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

* Progress on various files

* gfxprint stuff

* split some rodata, add iconv for rodata string parsing

* z_std_dma rodata

* 2 nonmatchings in gfxprint

* mtxuty-cvt ok

* more

* match a function in idle.c

* progress

* Cleanup

* Rename BgPolygon to CollisionPoly

* progress

* some effect stuff

* more effect progress

* updates

* made suggested changes

* z_effect_soft_sprite_old_init mostly ok

* remove old effects enum

* gamealloc.c OK

* added more files

* motor.c almost done

* motor.c OK

* updates

* migration of two files

* listalloc.c oK

* z_fcurve_data_skelanime split

* z_fcurve_data_skelanime.c decompiled

* more files split

* z_malloc.c OK

* contpfs.c OK

* fault.c rodata migrated

* migrated fault_drawer rodata

* update

* update preprocess.py

* renamed functions in z_skelanime

* started z_skelanime cleanup

* like halfway through fixing z_skelanime

* animation system updated to meet oot standards

* remove unused animation structs

* rename matrix structs to fit oot

* Add -woff 712

* fix diff_settings.py because i accidentally broke it before

* fixed merge conflict, doesn't match though

* It matches now

* Updates

* Fixed warnings...added gcc code syntax checking

* Remove gcc check, added in Tharo's PR

* warnings fixed (i think)

* fixed all warnings i think

* ok

* not sure what to do

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

* it matches if i do this

* remove comment

* accidentally put osPfsFreeBlocks in epilinkhandle.c

* memcmp -> bcmp

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

* format.sh

* MTXMODE_NEW and MTXMODE_APPLY to matrix functions

* Made suggested changes

* pragma sFaultDrawerFont instead of including in repo

* add some functions to functions.h

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

* Updated z_en_a_keep.c

* Missed suggestion in EnAObj_Destroy

* .

* update z_fcurve_Data_skelanime and z_skelanime with suggestions

* devmgr.c ok

* minor changes

* Addressed comments

* remove redundant file

* gfxp -> dlist in game.c

* updated actorfixer.py

* fixed warnings in z_malloc

* Change void* back to Actor*

* format

* Add the soft_sprit comments back

* Rename SV->Flex

* remove .common

* run format

* Update src/code/z_skelanime.c

* u32 channel

Co-authored-by: Lucas Shaw <lucas.shaw1123@gmail.com>
Co-authored-by: angie <angheloalf95@gmail.com>
Co-authored-by: Kenix3 <kenixwhisperwind@gmail.com>

161 files changed, 4045 insertions, 2926 deletions

diff --git a/src/boot_O1/viextendvstart.c b/src/boot_O1/viextendvstart.c
new file mode 100644
index 000000000..ce9f718d0
--- /dev/null
+++ b/src/boot_O1/viextendvstart.c
@@ -0,0 +1,5 @@
+#include "global.h"
+
+void osViExtendVStart(u32 a0) {
+    __additional_scanline = a0;
+}
diff --git a/src/boot_O2/__osMalloc.c b/src/boot_O2/__osMalloc.c
index 40572a59f..503c7c25a 100644
--- a/src/boot_O2/__osMalloc.c
+++ b/src/boot_O2/__osMalloc.c
@@ -45,7 +45,7 @@ ArenaNode* ArenaImpl_GetLastBlock(Arena* arena) {
     return last;
 }
 
-void __osMallocInit(Arena* arena, void* start, u32 size) {
+void __osMallocInit(Arena* arena, void* start, size_t size) {
     bzero(arena, sizeof(*arena));
     ArenaImpl_LockInit(arena);
     __osMallocAddBlock(arena, start, size);
@@ -91,7 +91,7 @@ u8 __osMallocIsInitalized(Arena* arena) {
     return arena->isInit;
 }
 
-void* __osMalloc(Arena* arena, u32 size) {
+void* __osMalloc(Arena* arena, size_t size) {
     ArenaNode* iter;
     ArenaNode* newNode;
     void* alloc;
@@ -134,7 +134,7 @@ void* __osMalloc(Arena* arena, u32 size) {
     return alloc;
 }
 
-void* __osMallocR(Arena* arena, u32 size) {
+void* __osMallocR(Arena* arena, size_t size) {
     ArenaNode* iter;
     ArenaNode* newNode;
     u32 blockSize;
@@ -219,7 +219,7 @@ end:
 
 #pragma GLOBAL_ASM("asm/non_matchings/boot/__osMalloc/__osRealloc.s")
 
-void __osAnalyzeArena(Arena* arena, u32* outMaxFree, u32* outFree, u32* outAlloc) {
+void __osAnalyzeArena(Arena* arena, size_t* outMaxFree, size_t* outFree, size_t* outAlloc) {
     ArenaNode* iter;
 
     ArenaImpl_Lock(arena);
diff --git a/src/boot_O2/__osMemset.c b/src/boot_O2/__osMemset.c
index 3a5469855..0c4172e9f 100644
--- a/src/boot_O2/__osMemset.c
+++ b/src/boot_O2/__osMemset.c
@@ -1,6 +1,6 @@
 #include "global.h"
 
-void* __osMemset(void* ptr, s32 val, u32 size) {
+void* __osMemset(void* ptr, s32 val, size_t size) {
     u8* dst = ptr;
     register s32 rem;
 
diff --git a/src/boot_O2/loadfragment2.c b/src/boot_O2/loadfragment2.c
index b9ea4533d..5c884be96 100644
--- a/src/boot_O2/loadfragment2.c
+++ b/src/boot_O2/loadfragment2.c
@@ -71,7 +71,7 @@ void Load2_Relocate(u32 allocatedVRamAddr, OverlayRelocationSection* overlayInfo
 s32 Load2_LoadOverlay(u32 vRomStart, u32 vRomEnd, u32 vRamStart, u32 vRamEnd, u32 allocatedVRamAddr) {
     int nbytes;
     u32 pad;
-    u32 size;
+    size_t size;
     void* end;
     OverlayRelocationSection* overlayInfo;
 
@@ -106,9 +106,9 @@ s32 Load2_LoadOverlay(u32 vRomStart, u32 vRomEnd, u32 vRamStart, u32 vRamEnd, u3
 #pragma GLOBAL_ASM("asm/non_matchings/boot/loadfragment2/Load2_LoadOverlay.s")
 #endif
 
-void* Load2_AllocateAndLoad(u32 vRomStart, u32 vRomEnd, u32 vRamStart, u32 vRamEnd) {
+void* Overlay_AllocateAndLoad(u32 vRomStart, u32 vRomEnd, u32 vRamStart, u32 vRamEnd) {
     void* allocatedVRamAddr;
-    u32 size;
+    size_t size;
 
     size = vRamEnd - vRamStart;
     allocatedVRamAddr = SystemArena_MallocR(size);
diff --git a/src/boot_O2/system_malloc.c b/src/boot_O2/system_malloc.c
index 61906ce42..ad2bb6345 100644
--- a/src/boot_O2/system_malloc.c
+++ b/src/boot_O2/system_malloc.c
@@ -2,15 +2,15 @@
 
 Arena gSystemArena;
 
-void* SystemArena_Malloc(u32 size) {
+void* SystemArena_Malloc(size_t size) {
     return __osMalloc(&gSystemArena, size);
 }
 
-void* SystemArena_MallocR(u32 size) {
+void* SystemArena_MallocR(size_t size) {
     return __osMallocR(&gSystemArena, size);
 }
 
-void* SystemArena_Realloc(void* oldPtr, u32 newSize) {
+void* SystemArena_Realloc(void* oldPtr, size_t newSize) {
     return __osRealloc(&gSystemArena, oldPtr, newSize);
 }
 
@@ -18,9 +18,9 @@ void SystemArena_Free(void* ptr) {
     __osFree(&gSystemArena, ptr);
 }
 
-void* SystemArena_Calloc(u32 elements, u32 size) {
+void* SystemArena_Calloc(u32 elements, size_t size) {
     void* ptr;
-    u32 totalSize = elements * size;
+    size_t totalSize = elements * size;
 
     ptr = __osMalloc(&gSystemArena, totalSize);
     if (ptr != NULL) {
@@ -29,7 +29,7 @@ void* SystemArena_Calloc(u32 elements, u32 size) {
     return ptr;
 }
 
-void SystemArena_AnalyzeArena(u32* maxFreeBlock, u32* bytesFree, u32* bytesAllocated) {
+void SystemArena_AnalyzeArena(size_t* maxFreeBlock, size_t* bytesFree, size_t* bytesAllocated) {
     __osAnalyzeArena(&gSystemArena, maxFreeBlock, bytesFree, bytesAllocated);
 }
 
@@ -37,7 +37,7 @@ u32 SystemArena_CheckArena(void) {
     return __osCheckArena(&gSystemArena);
 }
 
-void SystemArena_InitArena(void* start, u32 size) {
+void SystemArena_InitArena(void* start, size_t size) {
     __osMallocInit(&gSystemArena, start, size);
 }
 
diff --git a/src/boot_O2_g3/fault.c b/src/boot_O2_g3/fault.c
index 3cc3deb35..1851d21cb 100644
--- a/src/boot_O2_g3/fault.c
+++ b/src/boot_O2_g3/fault.c
@@ -1,7 +1,32 @@
+#include "ultra64.h"
 #include "global.h"
 #include "vt.h"
 
-#pragma GLOBAL_ASM("asm/non_matchings/boot/fault/D_800982B0.s")
+// data
+const char* sCpuExceptions[] = {
+    "Interrupt",
+    "TLB modification",
+    "TLB exception on load",
+    "TLB exception on store",
+    "Address error on load",
+    "Address error on store",
+    "Bus error on inst.",
+    "Bus error on data",
+    "System call exception",
+    "Breakpoint exception",
+    "Reserved instruction",
+    "Coprocessor unusable",
+    "Arithmetic overflow",
+    "Trap exception",
+    "Virtual coherency on inst.",
+    "Floating point exception",
+    "Watchpoint exception",
+    "Virtual coherency on data",
+};
+
+const char* sFpuExceptions[] = {
+    "Unimplemented operation", "Invalid operation", "Division by zero", "Overflow", "Underflow", "Inexact operation",
+};
 
 void Fault_SleepImpl(u32 duration) {
     u64 value = (duration * OS_CPU_COUNTER) / 1000ull;
@@ -79,7 +104,7 @@ void Fault_RemoveClient(FaultClient* client) {
     }
 }
 
-void Fault_AddAddrConvClient(FaultAddrConvClient* client, fault_address_converter_func callback, void* param) {
+void Fault_AddAddrConvClient(FaultAddrConvClient* client, FaultAddrConvFunc callback, void* param) {
     OSIntMask mask;
     u32 alreadyExists = 0;
 
@@ -269,9 +294,9 @@ void Fault_PrintFPCR(u32 value) {
     u32 flag = 0x20000;
 
     FaultDrawer_Printf("FPCSR:%08xH ", value);
-    for (i = 0; i < ARRAY_COUNT(sExceptionNames); i++) {
+    for (i = 0; i < ARRAY_COUNT(sFpuExceptions); i++) {
         if (value & flag) {
-            FaultDrawer_Printf("(%s)", sExceptionNames[i]);
+            FaultDrawer_Printf("(%s)", sFpuExceptions[i]);
             break;
         }
         flag >>= 1;
@@ -284,9 +309,9 @@ void osSyncPrintfFPCR(u32 value) {
     u32 flag = 0x20000;
 
     osSyncPrintf("FPCSR:%08xH  ", value);
-    for (i = 0; i < ARRAY_COUNT(sExceptionNames); i++) {
+    for (i = 0; i < ARRAY_COUNT(sFpuExceptions); i++) {
         if (value & flag) {
-            osSyncPrintf("(%s)\n", sExceptionNames[i]);
+            osSyncPrintf("(%s)\n", sFpuExceptions[i]);
             break;
         }
         flag >>= 1;
@@ -308,7 +333,7 @@ void Fault_PrintThreadContext(OSThread* t) {
     FaultDrawer_SetCursor(0x16, 0x14);
 
     ctx = &t->context;
-    FaultDrawer_Printf("THREAD:%d (%d:%s)\n", t->id, causeStrIdx, D_80096B80[causeStrIdx]);
+    FaultDrawer_Printf("THREAD:%d (%d:%s)\n", t->id, causeStrIdx, sCpuExceptions[causeStrIdx]);
     FaultDrawer_SetCharPad(-1, 0);
 
     FaultDrawer_Printf("PC:%08xH SR:%08xH VA:%08xH\n", (u32)ctx->pc, (u32)ctx->sr, (u32)ctx->badvaddr);
@@ -368,7 +393,7 @@ void osSyncPrintfThreadContext(OSThread* t) {
 
     ctx = &t->context;
     osSyncPrintf("\n");
-    osSyncPrintf("THREAD ID:%d (%d:%s)\n", t->id, causeStrIdx, D_80096B80[causeStrIdx]);
+    osSyncPrintf("THREAD ID:%d (%d:%s)\n", t->id, causeStrIdx, sCpuExceptions[causeStrIdx]);
 
     osSyncPrintf("PC:%08xH   SR:%08xH   VA:%08xH\n", (u32)ctx->pc, (u32)ctx->sr, (u32)ctx->badvaddr);
     osSyncPrintf("AT:%08xH   V0:%08xH   V1:%08xH\n", (u32)ctx->at, (u32)ctx->v0, (u32)ctx->v1);
@@ -444,7 +469,7 @@ void Fault_WaitForButtonCombo(void) {
     } while (!CHECK_BTN_ALL(input->cur.button, BTN_DLEFT | BTN_L | BTN_R | BTN_CRIGHT));
 }
 
-void Fault_DrawMemDumpPage(char* title, u32* addr, u32 param_3) {
+void Fault_DrawMemDumpPage(const char* title, u32* addr, u32 param_3) {
     u32* alignedAddr;
     u32* writeAddr;
     s32 y;
@@ -741,9 +766,9 @@ void Fault_SetOptionsFromController3(void) {
     }
 
     if (faultCustomOptions) {
-        graphPC = graphOSThread.context.pc;
-        graphRA = graphOSThread.context.ra;
-        graphSP = graphOSThread.context.sp;
+        graphPC = sGraphThread.context.pc;
+        graphRA = sGraphThread.context.ra;
+        graphSP = sGraphThread.context.sp;
         if (CHECK_BTN_ALL(input3->press.button, BTN_R)) {
             faultCopyToLog = !faultCopyToLog;
             FaultDrawer_SetOsSyncPrintfEnabled(faultCopyToLog);
diff --git a/src/boot_O2_g3/fault_drawer.c b/src/boot_O2_g3/fault_drawer.c
index 4e6518d14..949faadf1 100644
--- a/src/boot_O2_g3/fault_drawer.c
+++ b/src/boot_O2_g3/fault_drawer.c
@@ -1,6 +1,8 @@
 #include "global.h"
 #include "vt.h"
 
+extern const u32 sFaultDrawerFont[];
+
 FaultDrawer* sFaultDrawContext = &sFaultDrawerStruct;
 FaultDrawer sFaultDrawerDefault = {
     (u16*)0x803DA800,                   // fb - TODO map out buffers in this region and avoid hard-coded pointer
@@ -14,7 +16,7 @@ FaultDrawer sFaultDrawerDefault = {
     GPACK_RGBA5551(0, 0, 0, 0),         // backColor
     22,                                 // cursorX
     16,                                 // cursorY
-    (u32*)&sFaultDrawerFont,            // font
+    (u32*)sFaultDrawerFont,             // font
     8,                                  // charW
     8,                                  // charH
     0,                                  // charWPad
@@ -142,7 +144,7 @@ void FaultDrawer_FillScreen() {
 
 #pragma GLOBAL_ASM("asm/non_matchings/boot/fault_drawer/FaultDrawer_FormatStringFunc.s")
 
-#pragma GLOBAL_ASM("asm/non_matchings/boot/fault_drawer/D_80099080.s")
+const char D_80099080[] = "(null)";
 
 void FaultDrawer_VPrintf(const char* str, char* args) { // va_list
     _Printf((PrintCallback)FaultDrawer_FormatStringFunc, sFaultDrawContext, str, args);
diff --git a/src/boot_O2_g3/yaz0.c b/src/boot_O2_g3/yaz0.c
index bf42adf3f..094c0bb38 100644
--- a/src/boot_O2_g3/yaz0.c
+++ b/src/boot_O2_g3/yaz0.c
@@ -122,7 +122,7 @@ s32 Yaz0_DecompressImpl(u8* src, u8* dst) {
     return 0;
 }
 
-void Yaz0_Decompress(u32 romStart, void* dst, u32 size) {
+void Yaz0_Decompress(u32 romStart, void* dst, size_t size) {
     s32 status;
     u32 pad;
     char sp80[0x50];
diff --git a/src/boot_O2_g3/z_std_dma.c b/src/boot_O2_g3/z_std_dma.c
index 3a447b0e8..2903b488f 100644
--- a/src/boot_O2_g3/z_std_dma.c
+++ b/src/boot_O2_g3/z_std_dma.c
@@ -9,7 +9,7 @@ OSMesg sDmaMgrMsgs[32];
 OSThread sDmaMgrThread;
 u8 sDmaMgrStack[0x500];
 
-s32 DmaMgr_DMARomToRam(u32 rom, void* ram, u32 size) {
+s32 DmaMgr_DMARomToRam(u32 rom, void* ram, size_t size) {
     OSIoMesg ioMsg;
     OSMesgQueue queue;
     OSMesg msg[1];
@@ -111,7 +111,7 @@ const char* func_800809F4(u32 a0) {
 void DmaMgr_ProcessMsg(DmaRequest* req) {
     u32 vrom;
     void* ram;
-    u32 size;
+    size_t size;
     u32 romStart;
     u32 romSize;
     DmaEntry* dmaEntry;
@@ -172,7 +172,7 @@ void DmaMgr_ThreadEntry(void* a0) {
     }
 }
 
-s32 DmaMgr_SendRequestImpl(DmaRequest* request, void* vramStart, u32 vromStart, u32 size, UNK_TYPE4 unused,
+s32 DmaMgr_SendRequestImpl(DmaRequest* request, void* vramStart, u32 vromStart, size_t size, UNK_TYPE4 unused,
                            OSMesgQueue* queue, OSMesg msg) {
     if (gIrqMgrResetStatus >= 2) {
         return -2;
@@ -190,7 +190,7 @@ s32 DmaMgr_SendRequestImpl(DmaRequest* request, void* vramStart, u32 vromStart,
     return 0;
 }
 
-s32 DmaMgr_SendRequest0(void* vramStart, u32 vromStart, u32 size) {
+s32 DmaMgr_SendRequest0(void* vramStart, u32 vromStart, size_t size) {
     DmaRequest req;
     OSMesgQueue queue;
     OSMesg msg[1];
diff --git a/src/code/PreRender.c b/src/code/PreRender.c
index bdf4d326c..0afb1df68 100644
--- a/src/code/PreRender.c
+++ b/src/code/PreRender.c
@@ -17,7 +17,7 @@ void PreRender_SetValuesSave(PreRender* this, u32 width, u32 height, void* fbuf,
 
 void PreRender_Init(PreRender* this) {
     bzero(this, sizeof(PreRender));
-    func_80174AA0(&this->alloc);
+    ListAlloc_Init(&this->alloc);
 }
 
 /**
@@ -35,7 +35,7 @@ void PreRender_SetValues(PreRender* this, u32 width, u32 height, void* fbuf, voi
 }
 
 void PreRender_Destroy(PreRender* this) {
-    func_80174BA0(&this->alloc);
+    ListAlloc_FreeAll(&this->alloc);
 }
 
 void func_8016FDB8(PreRender* this, Gfx** gfxp, void* buf, void* bufSave, u32 arg4) {
diff --git a/src/code/TwoHeadArena.c b/src/code/TwoHeadArena.c
index b4262e3c6..83d5be3d1 100644
--- a/src/code/TwoHeadArena.c
+++ b/src/code/TwoHeadArena.c
@@ -12,7 +12,7 @@ void* THA_GetTail(TwoHeadArena* tha) {
     return tha->tail;
 }
 
-void* THA_AllocStart(TwoHeadArena* tha, u32 size) {
+void* THA_AllocStart(TwoHeadArena* tha, size_t size) {
     void* start = tha->head;
 
     tha->head = (u32)tha->head + size;
@@ -23,7 +23,7 @@ void* THA_AllocStart1(TwoHeadArena* tha) {
     return THA_AllocStart(tha, 1);
 }
 
-void* THA_AllocEnd(TwoHeadArena* tha, u32 size) {
+void* THA_AllocEnd(TwoHeadArena* tha, size_t size) {
     u32 mask;
 
     if (size >= 0x10) {
@@ -42,14 +42,14 @@ void* THA_AllocEnd(TwoHeadArena* tha, u32 size) {
     return tha->tail;
 }
 
-void* THA_AllocEndAlign16(TwoHeadArena* tha, u32 size) {
+void* THA_AllocEndAlign16(TwoHeadArena* tha, size_t size) {
     u32 mask = ~0xF;
 
     tha->tail = (((u32)tha->tail & mask) - size) & mask;
     return tha->tail;
 }
 
-void* THA_AllocEndAlign(TwoHeadArena* tha, u32 size, u32 mask) {
+void* THA_AllocEndAlign(TwoHeadArena* tha, size_t size, u32 mask) {
     tha->tail = (((u32)tha->tail & mask) - size) & mask;
     return tha->tail;
 }
@@ -67,7 +67,7 @@ void THA_Init(TwoHeadArena* tha) {
     tha->tail = (u32)tha->bufp + tha->size;
 }
 
-void THA_Ct(TwoHeadArena* tha, void* ptr, u32 size) {
+void THA_Ct(TwoHeadArena* tha, void* ptr, size_t size) {
     bzero(tha, sizeof(TwoHeadArena));
     tha->bufp = ptr;
     tha->size = size;
diff --git a/src/code/TwoHeadGfxArena.c b/src/code/TwoHeadGfxArena.c
index 81a3a383b..2f1629765 100644
--- a/src/code/TwoHeadGfxArena.c
+++ b/src/code/TwoHeadGfxArena.c
@@ -1,6 +1,6 @@
 #include "global.h"
 
-void THGA_Ct(TwoHeadGfxArena* thga, Gfx* start, u32 size) {
+void THGA_Ct(TwoHeadGfxArena* thga, Gfx* start, size_t size) {
     THA_Ct((TwoHeadArena*)thga, start, size);
 }
 
@@ -44,7 +44,7 @@ Gfx* THGA_AllocStart8Wrapper(TwoHeadGfxArena* thga) {
     return THGA_AllocStart8(thga);
 }
 
-Gfx* THGA_AllocEnd(TwoHeadGfxArena* thga, u32 size) {
+Gfx* THGA_AllocEnd(TwoHeadGfxArena* thga, size_t size) {
     return THA_AllocEnd((TwoHeadArena*)thga, size);
 }
 
diff --git a/src/code/code_800F23E0.c b/src/code/code_800F23E0.c
deleted file mode 100644
index 008a95db3..000000000
--- a/src/code/code_800F23E0.c
+++ /dev/null
@@ -1,5 +0,0 @@
-#include "global.h"
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/code_800F23E0/func_800F23E0.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/code_800F23E0/func_800F2478.s")
diff --git a/src/code/code_80122660.c b/src/code/code_80122660.c
deleted file mode 100644
index 7c0da2932..000000000
--- a/src/code/code_80122660.c
+++ /dev/null
@@ -1,5 +0,0 @@
-#include "global.h"
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/code_80122660/func_80122660.s")
-
-#pragma GLOBAL_ASM("asm/non_matchings/code/code_80122660/func_80122670.s")
diff --git a/src/code/game.c b/src/code/game.c
index eb26dee8a..a90fc7ac2 100644
--- a/src/code/game.c
+++ b/src/code/game.c
@@ -22,7 +22,7 @@ void Game_SetFramerateDivisor(GameState* gameState, s32 divisor) {
 }
 
 void GameState_SetFBFilter(Gfx** gfx, u32 arg1) {
-    Gfx* _gfx = *gfx;
+    Gfx* dlist = *gfx;
 
     if ((R_FB_FILTER_TYPE > 0) && (R_FB_FILTER_TYPE < 5)) {
         D_801F8010.type = R_FB_FILTER_TYPE;
@@ -30,7 +30,7 @@ void GameState_SetFBFilter(Gfx** gfx, u32 arg1) {
         D_801F8010.color.g = R_FB_FILTER_PRIM_COLOR(1);
         D_801F8010.color.b = R_FB_FILTER_PRIM_COLOR(2);
         D_801F8010.color.a = R_FB_FILTER_A;
-        func_80140D10(&D_801F8010, &_gfx, arg1);
+        func_80140D10(&D_801F8010, &dlist, arg1);
     } else {
         if ((R_FB_FILTER_TYPE == 5) || (R_FB_FILTER_TYPE == 6)) {
             D_801F8020.useRgba = (R_FB_FILTER_TYPE == 6);
@@ -42,7 +42,7 @@ void GameState_SetFBFilter(Gfx** gfx, u32 arg1) {
             D_801F8020.envColor.g = R_FB_FILTER_ENV_COLOR(1);
             D_801F8020.envColor.b = R_FB_FILTER_ENV_COLOR(2);
             D_801F8020.envColor.a = R_FB_FILTER_A;
-            func_80142100(&D_801F8020, &_gfx, arg1);
+            func_80142100(&D_801F8020, &dlist, arg1);
         } else {
             if (R_FB_FILTER_TYPE == 7) {
                 sMonoColors.unk_00 = 0;
@@ -54,27 +54,24 @@ void GameState_SetFBFilter(Gfx** gfx, u32 arg1) {
                 sMonoColors.envColor.g = R_FB_FILTER_ENV_COLOR(1);
                 sMonoColors.envColor.b = R_FB_FILTER_ENV_COLOR(2);
                 sMonoColors.envColor.a = R_FB_FILTER_A;
-                VisMono_Draw(&sMonoColors, &_gfx, arg1);
+                VisMono_Draw(&sMonoColors, &dlist, arg1);
             }
         }
     }
 
-    *gfx = _gfx;
+    *gfx = dlist;
 }
 
-void Game_Nop80173534(GameState* gamestate) {
-    ;
+void Game_Nop80173534(GameState* gameState) {
 }
 
-void GameState_Draw(GameState* gamestate, GraphicsContext* gfxCtx) {
+void GameState_Draw(GameState* gameState, GraphicsContext* gfxCtx) {
     Gfx* nextDisplayList;
     Gfx* polyOpa;
 
     OPEN_DISPS(gfxCtx);
 
-    polyOpa = POLY_OPA_DISP;
-    nextDisplayList = Graph_GfxPlusOne(POLY_OPA_DISP);
-
+    nextDisplayList = Graph_GfxPlusOne(polyOpa = POLY_OPA_DISP);
     gSPDisplayList(OVERLAY_DISP++, nextDisplayList);
 
     if (R_FB_FILTER_TYPE && R_FB_FILTER_ENV_COLOR(3) == 0) {
@@ -98,119 +95,123 @@ void GameState_Draw(GameState* gamestate, GraphicsContext* gfxCtx) {
 
     if (R_ENABLE_ARENA_DBG != 0) {
         SpeedMeter_DrawTimeEntries(&D_801F7FF0, gfxCtx);
-        SpeedMeter_DrawAllocEntries(&D_801F7FF0, gfxCtx, gamestate);
+        SpeedMeter_DrawAllocEntries(&D_801F7FF0, gfxCtx, gameState);
     }
 
     CLOSE_DISPS(gfxCtx);
 }
 
-void Game_ResetSegments(GraphicsContext* gfxCtx) {
-    gSPSegment(gfxCtx->polyOpa.p++, 0, 0);
-    gSPSegment(gfxCtx->polyOpa.p++, 0xF, gfxCtx->framebuffer);
-    gSPSegment(gfxCtx->polyXlu.p++, 0, 0);
-    gSPSegment(gfxCtx->polyXlu.p++, 0xF, gfxCtx->framebuffer);
-    gSPSegment(gfxCtx->overlay.p++, 0, 0);
-    gSPSegment(gfxCtx->overlay.p++, 0xF, gfxCtx->framebuffer);
+void GameState_SetFrameBuffer(GraphicsContext* gfxCtx) {
+    OPEN_DISPS(gfxCtx);
+
+    gSPSegment(POLY_OPA_DISP++, 0, NULL);
+    gSPSegment(POLY_OPA_DISP++, 0xF, gfxCtx->framebuffer);
+    gSPSegment(POLY_XLU_DISP++, 0, NULL);
+    gSPSegment(POLY_XLU_DISP++, 0xF, gfxCtx->framebuffer);
+    gSPSegment(OVERLAY_DISP++, 0, NULL);
+    gSPSegment(OVERLAY_DISP++, 0xF, gfxCtx->framebuffer);
+
+    CLOSE_DISPS(gfxCtx);
 }
 
 void func_801736DC(GraphicsContext* gfxCtx) {
     Gfx* nextDisplayList;
-    Gfx* _polyOpa;
+    Gfx* polyOpa;
+
+    OPEN_DISPS(gfxCtx);
 
-    nextDisplayList = Graph_GfxPlusOne(_polyOpa = gfxCtx->polyOpa.p);
-    gSPDisplayList(gfxCtx->overlay.p++, nextDisplayList);
+    nextDisplayList = Graph_GfxPlusOne(polyOpa = gfxCtx->polyOpa.p);
+    gSPDisplayList(OVERLAY_DISP++, nextDisplayList);
     gSPEndDisplayList(nextDisplayList++);
-    Graph_BranchDlist(_polyOpa, nextDisplayList);
+    Graph_BranchDlist(polyOpa, nextDisplayList);
+
+    POLY_OPA_DISP = nextDisplayList;
 
-    gfxCtx->polyOpa.p = nextDisplayList;
+    CLOSE_DISPS(gfxCtx);
 }
 
-void Game_UpdateInput(GameState* gamestate) {
-    Padmgr_GetInput(gamestate->input, 1);
+void Game_UpdateInput(GameState* gameState) {
+    Padmgr_GetInput(gameState->input, 1);
 }
 
-void Game_Update(GameState* gamestate) {
-    GraphicsContext* _gCtx;
-    _gCtx = gamestate->gfxCtx;
+void Game_Update(GameState* gameState) {
+    GraphicsContext* gfxCtx = gameState->gfxCtx;
 
-    Game_ResetSegments(gamestate->gfxCtx);
+    GameState_SetFrameBuffer(gameState->gfxCtx);
 
-    gamestate->main(gamestate);
+    gameState->main(gameState);
 
     if (R_PAUSE_MENU_MODE != 2) {
-        GameState_Draw(gamestate, _gCtx);
-        func_801736DC(_gCtx);
+        GameState_Draw(gameState, gfxCtx);
+        func_801736DC(gfxCtx);
     }
 }
 
-void Game_IncrementFrameCount(GameState* gamestate) {
-    Game_Nop80173534(gamestate);
-    gamestate->frames++;
+void Game_IncrementFrameCount(GameState* gameState) {
+    Game_Nop80173534(gameState);
+    gameState->frames++;
 }
 
-void Game_InitHeap(GameState* gamestate, u32 size) {
-    GameState* _ctx;
-    void* buf;
-
-    _ctx = gamestate;
-    buf = Gamealloc_Alloc(&_ctx->alloc, size);
+void GameState_InitArena(GameState* gameState, size_t size) {
+    GameAlloc* alloc = &gameState->alloc;
+    void* buf = GameAlloc_Malloc(alloc, size);
 
     if (buf) {
-        THA_Ct(&gamestate->heap, buf, size);
+        THA_Ct(&gameState->heap, buf, size);
         return;
     }
 
-    THA_Ct(&gamestate->heap, NULL, 0);
-    __assert("../game.c", 0x40B);
+    THA_Ct(&gameState->heap, NULL, 0);
+    __assert("../game.c", 1035);
 }
 
-void Game_ResizeHeap(GameState* gamestate, u32 size) {
+void GameState_Realloc(GameState* gameState, size_t size) {
     GameAlloc* alloc;
-    void* buf;
-    u32 systemMaxFree;
-    u32 bytesFree;
-    u32 bytesAllocated;
+    void* gameArena;
+    size_t systemMaxFree;
+    size_t bytesFree;
+    size_t bytesAllocated;
     void* heapStart;
 
-    heapStart = gamestate->heap.bufp;
-    alloc = &gamestate->alloc;
-    THA_Dt(&gamestate->heap);
-    Gamealloc_Free(alloc, heapStart);
+    heapStart = gameState->heap.bufp;
+    alloc = &gameState->alloc;
+    THA_Dt(&gameState->heap);
+    GameAlloc_Free(alloc, heapStart);
     SystemArena_AnalyzeArena(&systemMaxFree, &bytesFree, &bytesAllocated);
     size = ((systemMaxFree - (sizeof(ArenaNode))) < size) ? (0) : (size);
-    if (!size) {
+    if (size == 0) {
         size = systemMaxFree - (sizeof(ArenaNode));
     }
 
-    if ((buf = Gamealloc_Alloc(alloc, size)) != NULL) {
-        THA_Ct(&gamestate->heap, buf, size);
+    if ((gameArena = GameAlloc_Malloc(alloc, size)) != NULL) {
+        THA_Ct(&gameState->heap, gameArena, size);
     } else {
-        THA_Ct(&gamestate->heap, 0, 0);
-        __assert("../game.c", 0x432);
+        THA_Ct(&gameState->heap, 0, 0);
+        __assert("../game.c", 1074);
     }
 }
 
-void Game_StateInit(GameState* gamestate, GameStateFunc gameStateInit, GraphicsContext* gfxCtx) {
-    gamestate->gfxCtx = gfxCtx;
-    gamestate->frames = 0U;
-    gamestate->main = NULL;
-    gamestate->destroy = NULL;
-    gamestate->running = 1;
-    gfxCtx->unk274 = D_801FBB88;
+void GameState_Init(GameState* gameState, GameStateFunc init, GraphicsContext* gfxCtx) {
+    gameState->gfxCtx = gfxCtx;
+    gameState->frames = 0U;
+    gameState->main = NULL;
+    gameState->destroy = NULL;
+    gameState->running = 1;
+    gfxCtx->viMode = D_801FBB88;
     gfxCtx->viConfigFeatures = gViConfigFeatures;
     gfxCtx->viConfigXScale = gViConfigXScale;
     gfxCtx->viConfigYScale = gViConfigYScale;
-    gamestate->nextGameStateInit = NULL;
-    gamestate->nextGameStateSize = 0U;
+    gameState->nextGameStateInit = NULL;
+    gameState->nextGameStateSize = 0U;
 
     {
         s32 requiredScopeTemp;
 
-        Gamealloc_Init(&gamestate->alloc);
-        Game_InitHeap(gamestate, 0x100000);
-        Game_SetFramerateDivisor(gamestate, 3);
+        GameAlloc_Init(&gameState->alloc);
+        GameState_InitArena(gameState, 0x100000);
+        Game_SetFramerateDivisor(gameState, 3);
 
-        gameStateInit(gamestate);
+        init(gameState);
 
         func_80140CE0(&D_801F8010);
         func_801420C0(&D_801F8020);
@@ -219,17 +220,17 @@ void Game_StateInit(GameState* gamestate, GameStateFunc gameStateInit, GraphicsC
         func_801773A0(&D_801F7FF0);
         func_8013ED9C();
 
-        osSendMesg(&gamestate->gfxCtx->unk5C, NULL, 1);
+        osSendMesg(&gameState->gfxCtx->unk5C, NULL, 1);
     }
 }
 
-void Game_StateFini(GameState* gamestate) {
+void GameState_Destroy(GameState* gameState) {
     func_80172BC0();
     func_8019E014();
-    osRecvMesg(&gamestate->gfxCtx->unk5C, 0, 1);
+    osRecvMesg(&gameState->gfxCtx->unk5C, NULL, OS_MESG_BLOCK);
 
-    if (gamestate->destroy != 0) {
-        gamestate->destroy(gamestate);
+    if (gameState->destroy != NULL) {
+        gameState->destroy(gameState);
     }
 
     func_8013EDD0();
@@ -238,28 +239,28 @@ void Game_StateFini(GameState* gamestate) {
     func_801420F4(&D_801F8020);
     func_80141900(&sMonoColors);
     func_80140900(&D_801F8048);
-    THA_Dt(&gamestate->heap);
-    Gamealloc_FreeAll(&gamestate->alloc);
+    THA_Dt(&gameState->heap);
+    GameAlloc_Cleanup(&gameState->alloc);
 }
 
-GameStateFunc Game_GetNextStateInit(GameState* gamestate) {
-    return gamestate->nextGameStateInit;
+GameStateFunc GameState_GetNextStateInit(GameState* gameState) {
+    return gameState->nextGameStateInit;
 }
 
-u32 Game_GetNextStateSize(GameState* gamestate) {
-    return gamestate->nextGameStateSize;
+size_t Game_GetNextStateSize(GameState* gameState) {
+    return gameState->nextGameStateSize;
 }
 
-u32 Game_GetShouldContinue(GameState* gamestate) {
-    return gamestate->running;
+u32 GameState_IsRunning(GameState* gameState) {
+    return gameState->running;
 }
 
-s32 Game_GetHeapFreeSize(GameState* gamestate) {
-    return THA_GetSize(&gamestate->heap);
+s32 GameState_GetArenaSize(GameState* gameState) {
+    return THA_GetSize(&gameState->heap);
 }
 
-s32 func_80173B48(GameState* gamestate) {
-    s32 result;
-    result = OS_CYCLES_TO_NSEC(gamestate->framerateDivisor * sIrqMgrRetraceTime) - OS_CYCLES_TO_NSEC(D_801FBAF0);
+s32 func_80173B48(GameState* gameState) {
+    s32 result = OS_CYCLES_TO_NSEC(gameState->framerateDivisor * sIrqMgrRetraceTime) - OS_CYCLES_TO_NSEC(D_801FBAF0);
+
     return result;
 }
diff --git a/src/code/gamealloc.c b/src/code/gamealloc.c
index 34d595f79..541f9125b 100644
--- a/src/code/gamealloc.c
+++ b/src/code/gamealloc.c
@@ -1,11 +1,59 @@
 #include "global.h"
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/gamealloc/func_80173BF0.s")
+void GameAlloc_Log(GameAlloc* this) {
+    GameAllocEntry* iter;
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/gamealloc/Gamealloc_Alloc.s")
+    iter = this->base.next;
+    while (iter != &this->base) {
+        iter = iter->next;
+    }
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/gamealloc/Gamealloc_Free.s")
+void* GameAlloc_Malloc(GameAlloc* this, size_t size) {
+    GameAllocEntry* ptr = SystemArena_Malloc(size + sizeof(GameAllocEntry));
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/gamealloc/Gamealloc_FreeAll.s")
+    if (ptr != NULL) {
+        ptr->size = size;
+        ptr->prev = this->head;
+        this->head->next = ptr;
+        this->head = ptr;
+        ptr->next = &this->base;
+        this->base.prev = this->head;
+        return ptr + 1;
+    } else {
+        return NULL;
+    }
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/gamealloc/Gamealloc_Init.s")
+void GameAlloc_Free(GameAlloc* this, void* data) {
+    GameAllocEntry* ptr;
+
+    if (data != NULL) {
+        ptr = &((GameAllocEntry*)data)[-1];
+        ptr->prev->next = ptr->next;
+        ptr->next->prev = ptr->prev;
+        this->head = this->base.prev;
+        SystemArena_Free(ptr);
+    }
+}
+
+void GameAlloc_Cleanup(GameAlloc* this) {
+    GameAllocEntry* next = this->base.next;
+    GameAllocEntry* cur;
+
+    while (&this->base != next) {
+        cur = next;
+        next = next->next;
+        SystemArena_Free(cur);
+    }
+
+    this->head = &this->base;
+    this->base.next = &this->base;
+    this->base.prev = &this->base;
+}
+
+void GameAlloc_Init(GameAlloc* this) {
+    this->head = &this->base;
+    this->base.next = &this->base;
+    this->base.prev = &this->base;
+}
diff --git a/src/code/listalloc.c b/src/code/listalloc.c
index 3880806a1..da294a109 100644
--- a/src/code/listalloc.c
+++ b/src/code/listalloc.c
@@ -1,9 +1,62 @@
 #include "global.h"
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/listalloc/func_80174AA0.s")
+ListAlloc* ListAlloc_Init(ListAlloc* this) {
+    this->prev = NULL;
+    this->next = NULL;
+    return this;
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/listalloc/func_80174AB4.s")
+void* ListAlloc_Alloc(ListAlloc* this, size_t size) {
+    ListAlloc* ptr = SystemArena_Malloc(size + sizeof(ListAlloc));
+    ListAlloc* next;
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/listalloc/func_80174B20.s")
+    if (ptr == NULL) {
+        return NULL;
+    }
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/listalloc/func_80174BA0.s")
+    next = this->next;
+    if (next != NULL) {
+        next->next = ptr;
+    }
+
+    ptr->prev = next;
+    ptr->next = NULL;
+    this->next = ptr;
+
+    if (this->prev == NULL) {
+        this->prev = ptr;
+    }
+
+    return (u8*)ptr + sizeof(ListAlloc);
+}
+
+void ListAlloc_Free(ListAlloc* this, void* data) {
+    ListAlloc* ptr = &((ListAlloc*)data)[-1];
+
+    if (ptr->prev != NULL) {
+        ptr->prev->next = ptr->next;
+    }
+
+    if (ptr->next != NULL) {
+        ptr->next->prev = ptr->prev;
+    }
+
+    if (this->prev == ptr) {
+        this->prev = ptr->next;
+    }
+
+    if (this->next == ptr) {
+        this->next = ptr->prev;
+    }
+
+    SystemArena_Free(ptr);
+}
+
+void ListAlloc_FreeAll(ListAlloc* this) {
+    ListAlloc* iter = this->prev;
+
+    while (iter != NULL) {
+        ListAlloc_Free(this, (u8*)iter + sizeof(ListAlloc));
+        iter = this->prev;
+    }
+}
diff --git a/src/code/main.c b/src/code/main.c
index a2b859991..59ffb6a32 100644
--- a/src/code/main.c
+++ b/src/code/main.c
@@ -28,36 +28,36 @@ void Main(void* arg) {
 
     R_ENABLE_ARENA_DBG = 0;
 
-    osCreateMesgQueue(&siEventCallbackQueue, siEventCallbackBuffer, ARRAY_COUNT(siEventCallbackBuffer));
-    osSetEventMesg(OS_EVENT_SI, &siEventCallbackQueue, NULL);
+    osCreateMesgQueue(&sSiIntMsgQ, sSiIntMsgBuf, ARRAY_COUNT(sSiIntMsgBuf));
+    osSetEventMesg(OS_EVENT_SI, &sSiIntMsgQ, NULL);
 
-    osCreateMesgQueue(&mainIrqmgrCallbackQueue, mainIrqCallbackBuffer, ARRAY_COUNT(mainIrqCallbackBuffer));
+    osCreateMesgQueue(&irqMgrMsgQ, irqMgrMsgBuf, ARRAY_COUNT(irqMgrMsgBuf));
 
     StackCheck_Init(&schedStackEntry, schedStack, schedStack + sizeof(schedStack), 0, 0x100, "sched");
     Sched_Init(&gSchedContext, schedStack + sizeof(schedStack), Z_PRIORITY_SCHED, D_8009B290, 1, &gIrqMgr);
 
     CIC6105_AddRomInfoFaultPage();
 
-    IrqMgr_AddClient(&gIrqMgr, &mainIrqmgrCallbackNode, &mainIrqmgrCallbackQueue);
+    IrqMgr_AddClient(&gIrqMgr, &irqClient, &irqMgrMsgQ);
 
     StackCheck_Init(&audioStackEntry, audioStack, audioStack + sizeof(audioStack), 0, 0x100, "audio");
     AudioMgr_Init(&audioContext, audioStack + sizeof(audioStack), Z_PRIORITY_AUDIOMGR, 0xA, &gSchedContext, &gIrqMgr);
 
     StackCheck_Init(&padmgrStackEntry, padmgrStack, padmgrStack + sizeof(padmgrStack), 0, 0x100, "padmgr");
-    Padmgr_Start(&siEventCallbackQueue, &gIrqMgr, 7, Z_PRIORITY_PADMGR, padmgrStack + sizeof(padmgrStack));
+    PadMgr_Init(&sSiIntMsgQ, &gIrqMgr, 7, Z_PRIORITY_PADMGR, padmgrStack + sizeof(padmgrStack));
 
     AudioMgr_Unlock(&audioContext);
 
-    StackCheck_Init(&graphStackEntry, graphStack, graphStack + sizeof(graphStack), 0, 0x100, "graph");
-    osCreateThread(&graphOSThread, Z_THREAD_ID_GRAPH, Graph_ThreadEntry, arg, graphStack + sizeof(graphStack),
+    StackCheck_Init(&sGraphStackInfo, sGraphStack, sGraphStack + sizeof(sGraphStack), 0, 0x100, "graph");
+    osCreateThread(&sGraphThread, Z_THREAD_ID_GRAPH, Graph_ThreadEntry, arg, sGraphStack + sizeof(sGraphStack),
                    Z_PRIORITY_GRAPH);
-    osStartThread(&graphOSThread);
+    osStartThread(&sGraphThread);
 
     exit = false;
 
     while (!exit) {
         msg = NULL;
-        osRecvMesg(&mainIrqmgrCallbackQueue, (OSMesg)&msg, OS_MESG_BLOCK);
+        osRecvMesg(&irqMgrMsgQ, (OSMesg)&msg, OS_MESG_BLOCK);
         if (msg == NULL) {
             break;
         }
@@ -72,6 +72,6 @@ void Main(void* arg) {
         }
     }
 
-    IrqMgr_RemoveClient(&gIrqMgr, &mainIrqmgrCallbackNode);
-    osDestroyThread(&graphOSThread);
+    IrqMgr_RemoveClient(&gIrqMgr, &irqClient);
+    osDestroyThread(&sGraphThread);
 }
diff --git a/src/code/padmgr.c b/src/code/padmgr.c
index 65b9d0ff4..a8ef1db15 100644
--- a/src/code/padmgr.c
+++ b/src/code/padmgr.c
@@ -54,4 +54,4 @@
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/padmgr/Padmgr_ThreadEntry.s")
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/padmgr/Padmgr_Start.s")
+#pragma GLOBAL_ASM("asm/non_matchings/code/padmgr/PadMgr_Init.s")
diff --git a/src/code/sys_matrix.c b/src/code/sys_matrix.c
index cab2e563a..a4d5b9379 100644
--- a/src/code/sys_matrix.c
+++ b/src/code/sys_matrix.c
@@ -1,92 +1,92 @@
 #include "global.h"
 
-void SysMatrix_StateAlloc(GameState* gamestate) {
-    sMatrixStack = (MtxF*)THA_AllocEndAlign16(&gamestate->heap, 0x500);
+void Matrix_StateAlloc(GameState* gameState) {
+    sMatrixStack = (MtxF*)THA_AllocEndAlign16(&gameState->heap, 0x500);
     sCurrentMatrix = sMatrixStack;
 }
 
-void SysMatrix_StatePush(void) {
+void Matrix_StatePush(void) {
     MtxF* prev = sCurrentMatrix;
 
     sCurrentMatrix++;
     Matrix_MtxFCopy(sCurrentMatrix, prev);
 }
 
-void SysMatrix_StatePop(void) {
+void Matrix_StatePop(void) {
     sCurrentMatrix--;
 }
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/SysMatrix_CopyCurrentState.s")
+#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_CopyCurrentState.s")
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/SysMatrix_SetCurrentState.s")
+#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_SetCurrentState.s")
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/SysMatrix_GetCurrentState.s")
+#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_GetCurrentState.s")
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/SysMatrix_InsertMatrix.s")
+#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_InsertMatrix.s")
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/SysMatrix_InsertTranslation.s")
+#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_InsertTranslation.s")
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_Scale.s")
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/SysMatrix_InsertXRotation_s.s")
+#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_InsertXRotation_s.s")
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/SysMatrix_InsertXRotation_f.s")
+#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_InsertXRotation_f.s")
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/SysMatrix_RotateStateAroundXAxis.s")
+#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_RotateStateAroundXAxis.s")
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/SysMatrix_SetStateXRotation.s")
+#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_SetStateXRotation.s")
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_RotateY.s")
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/SysMatrix_InsertYRotation_f.s")
+#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_InsertYRotation_f.s")
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/SysMatrix_InsertZRotation_s.s")
+#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_InsertZRotation_s.s")
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/SysMatrix_InsertZRotation_f.s")
+#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_InsertZRotation_f.s")
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/SysMatrix_InsertRotation.s")
+#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_InsertRotation.s")
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/SysMatrix_RotateAndTranslateState.s")
+#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_JointPosition.s")
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/SysMatrix_SetStateRotationAndTranslation.s")
+#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_SetStateRotationAndTranslation.s")
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/SysMatrix_ToRSPMatrix.s")
+#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_ToRSPMatrix.s")
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/SysMatrix_GetStateAsRSPMatrix.s")
+#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_ToMtx.s")
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_NewMtx.s")
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/SysMatrix_AppendToPolyOpaDisp.s")
+#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_AppendToPolyOpaDisp.s")
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/SysMatrix_MultiplyVector3fByState.s")
+#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_MultiplyVector3fByState.s")
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/SysMatrix_GetStateTranslation.s")
+#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_GetStateTranslation.s")
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/SysMatrix_GetStateTranslationAndScaledX.s")
+#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_GetStateTranslationAndScaledX.s")
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/SysMatrix_GetStateTranslationAndScaledY.s")
+#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_GetStateTranslationAndScaledY.s")
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/SysMatrix_GetStateTranslationAndScaledZ.s")
+#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_GetStateTranslationAndScaledZ.s")
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/SysMatrix_MultiplyVector3fXZByCurrentState.s")
+#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_MultiplyVector3fXZByCurrentState.s")
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_MtxFCopy.s")
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/SysMatrix_FromRSPMatrix.s")
+#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_FromRSPMatrix.s")
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/SysMatrix_MultiplyVector3fByMatrix.s")
+#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_MultiplyVector3fByMatrix.s")
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/SysMatrix_TransposeXYZ.s")
+#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_TransposeXYZ.s")
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/SysMatrix_NormalizeXYZ.s")
+#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_NormalizeXYZ.s")
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/func_8018219C.s")
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/func_801822C4.s")
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/SysMatrix_InsertRotationAroundUnitVector_f.s")
+#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_InsertRotationAroundUnitVector_f.s")
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/SysMatrix_InsertRotationAroundUnitVector_s.s")
+#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_InsertRotationAroundUnitVector_s.s")
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/func_80182C90.s")
 
diff --git a/src/code/z_DLF.c b/src/code/z_DLF.c
index 1ae43c91d..688a5af15 100644
--- a/src/code/z_DLF.c
+++ b/src/code/z_DLF.c
@@ -1,5 +1,5 @@
 #include "global.h"
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_DLF/DLF_LoadGameState.s")
+#pragma GLOBAL_ASM("asm/non_matchings/code/z_DLF/Overlay_LoadGameState.s")
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_DLF/DLF_FreeGameState.s")
+#pragma GLOBAL_ASM("asm/non_matchings/code/z_DLF/Overlay_FreeGameState.s")
diff --git a/src/code/z_actor.c b/src/code/z_actor.c
index 2f1277057..8d87e539b 100644
--- a/src/code/z_actor.c
+++ b/src/code/z_actor.c
@@ -53,7 +53,7 @@ void ActorShadow_Draw(Actor* actor, Lights* lights, GlobalContext* globalCtx, Gf
             }
 
             func_800C0094(actor->floorPoly, actor->world.pos.x, actor->floorHeight, actor->world.pos.z, &mtx);
-            SysMatrix_SetCurrentState(&mtx);
+            Matrix_SetCurrentState(&mtx);
 
             if (dlist != D_04076BC0) {
                 Matrix_RotateY((f32)actor->shape.rot.y * (M_PI / 32768), MTXMODE_APPLY);
@@ -117,7 +117,7 @@ void func_800B40E0(GlobalContext* globalCtx, Light* light, MtxF* arg2, s32 arg3,
     sp58 = Math_FAtan2F(light->l.dir[0], light->l.dir[2]);
     arg6 *= (4.5f - (light->l.dir[1] * 0.035f));
     arg6 = (arg6 < 1.0f) ? 1.0f : arg6;
-    SysMatrix_SetCurrentState(arg2);
+    Matrix_SetCurrentState(arg2);
     Matrix_RotateY(sp58, MTXMODE_APPLY);
     Matrix_Scale(arg5, 1.0f, arg5 * arg6, MTXMODE_APPLY);
 
@@ -744,7 +744,7 @@ void Actor_FreeOverlay(ActorOverlay* entry) {
                 if ((entry->allocType & 1) != 0) {
                     entry->loadedRamAddr = NULL;
                 } else {
-                    zelda_free(ramAddr);
+                    ZeldaArena_Free(ramAddr);
                     entry->loadedRamAddr = NULL;
                 }
             }
diff --git a/src/code/z_actor_dlftbls.c b/src/code/z_actor_dlftbls.c
index 4165e4c9b..f33fcd538 100644
--- a/src/code/z_actor_dlftbls.c
+++ b/src/code/z_actor_dlftbls.c
@@ -736,7 +736,7 @@ void* ActorOverlayTable_FaultAddrConv(void* arg0, void* arg1) {
     s32 i;
     u8* ramStart;
     u8* ramEnd;
-    u32 size;
+    size_t size;
     u32 offset;
 
     for (i = 0; i < gMaxActorId; i++, overlayEntry++) {
diff --git a/src/code/z_collision_check.c b/src/code/z_collision_check.c
index 6ea0b2fcf..059fbce09 100644
--- a/src/code/z_collision_check.c
+++ b/src/code/z_collision_check.c
@@ -327,7 +327,7 @@ s32 Collider_FreeJntSph(GlobalContext* globalCtx, ColliderJntSph* collider) {
 
     collider->count = 0;
     if (collider->elements != NULL) {
-        zelda_free(collider->elements);
+        ZeldaArena_Free(collider->elements);
     }
     collider->elements = NULL;
     return 1;
@@ -359,7 +359,7 @@ s32 Collider_SetJntSphToActor(GlobalContext* globalCtx, ColliderJntSph* collider
 
     Collider_SetBaseToActor(globalCtx, &collider->base, &src->base);
     collider->count = src->count;
-    collider->elements = zelda_malloc(src->count * sizeof(ColliderJntSphElement));
+    collider->elements = ZeldaArena_Malloc(src->count * sizeof(ColliderJntSphElement));
 
     if (collider->elements == NULL) {
         collider->count = 0;
@@ -385,7 +385,7 @@ s32 Collider_SetJntSphAllocType1(GlobalContext* globalCtx, ColliderJntSph* spher
 
     Collider_SetBaseType1(globalCtx, &sphereGroup->base, actor, &src->base);
     sphereGroup->count = src->count;
-    sphereGroup->elements = zelda_malloc(src->count * sizeof(ColliderJntSphElement));
+    sphereGroup->elements = ZeldaArena_Malloc(src->count * sizeof(ColliderJntSphElement));
 
     if (sphereGroup->elements == NULL) {
         sphereGroup->count = 0;
@@ -681,7 +681,7 @@ s32 Collider_FreeTris(GlobalContext* globalCtx, ColliderTris* tris) {
 
     tris->count = 0;
     if (tris->elements != NULL) {
-        zelda_free(tris->elements);
+        ZeldaArena_Free(tris->elements);
     }
     tris->elements = NULL;
 
@@ -714,7 +714,7 @@ s32 Collider_SetTrisAllocType1(GlobalContext* globalCtx, ColliderTris* tris, Act
 
     Collider_SetBaseType1(globalCtx, &tris->base, actor, &src->base);
     tris->count = src->count;
-    tris->elements = zelda_malloc(tris->count * sizeof(ColliderTrisElement));
+    tris->elements = ZeldaArena_Malloc(tris->count * sizeof(ColliderTrisElement));
 
     if (tris->elements == NULL) {
         tris->count = 0;
@@ -3691,7 +3691,7 @@ void Collider_UpdateSpheres(s32 limb, ColliderJntSph* collider) {
             D_801EE1C0.x = collider->elements[i].dim.modelSphere.center.x;
             D_801EE1C0.y = collider->elements[i].dim.modelSphere.center.y;
             D_801EE1C0.z = collider->elements[i].dim.modelSphere.center.z;
-            SysMatrix_MultiplyVector3fByState(&D_801EE1C0, &D_801EE1D0);
+            Matrix_MultiplyVector3fByState(&D_801EE1C0, &D_801EE1D0);
             collider->elements[i].dim.worldSphere.center.x = D_801EE1D0.x;
             collider->elements[i].dim.worldSphere.center.y = D_801EE1D0.y;
             collider->elements[i].dim.worldSphere.center.z = D_801EE1D0.z;
@@ -3733,7 +3733,7 @@ void Collider_UpdateSphere(s32 limb, ColliderSphere* collider) {
         D_801EE1E0.x = collider->dim.modelSphere.center.x;
         D_801EE1E0.y = collider->dim.modelSphere.center.y;
         D_801EE1E0.z = collider->dim.modelSphere.center.z;
-        SysMatrix_MultiplyVector3fByState(&D_801EE1E0, &D_801EE1F0);
+        Matrix_MultiplyVector3fByState(&D_801EE1E0, &D_801EE1F0);
         collider->dim.worldSphere.center.x = D_801EE1F0.x;
         collider->dim.worldSphere.center.y = D_801EE1F0.y;
         collider->dim.worldSphere.center.z = D_801EE1F0.z;
diff --git a/src/code/z_eff_footmark.c b/src/code/z_eff_footmark.c
index ba2c79f71..d246aaffa 100644
--- a/src/code/z_eff_footmark.c
+++ b/src/code/z_eff_footmark.c
@@ -106,8 +106,8 @@ void EffFootmark_Draw(GlobalContext* globalCtx) {
 
     for (footmark = globalCtx->footprintInfo, i = 0; i < 100; i++, footmark++) {
         if (footmark->actor != NULL) {
-            SysMatrix_SetCurrentState(&footmark->displayMatrix);
-            Matrix_Scale(footmark->size * 0.00390625f * 0.7f, 1, footmark->size * 0.00390625f, 1);
+            Matrix_SetCurrentState(&footmark->displayMatrix);
+            Matrix_Scale(footmark->size * (1.0f / 0x100) * 0.7f, 1, footmark->size * (1.0f / 0x100), MTXMODE_APPLY);
 
             gSPMatrix(gfxCtx->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD);
 
diff --git a/src/code/z_effect_soft_sprite.c b/src/code/z_effect_soft_sprite.c
index 0ed19c050..47c2202f1 100644
--- a/src/code/z_effect_soft_sprite.c
+++ b/src/code/z_effect_soft_sprite.c
@@ -41,7 +41,7 @@ void EffectSS_Clear(GlobalContext* globalCtx) {
     for (i = 0; i < EFFECT_SS_MAX; i++) {
         addr = overlay->loadedRamAddr;
         if (addr != NULL) {
-            zelda_free(addr);
+            ZeldaArena_Free(addr);
         }
 
         overlay->loadedRamAddr = 0;
@@ -175,7 +175,7 @@ void EffectSs_Spawn(GlobalContext* globalCtx, s32 type, s32 priority, void* init
         initInfo = entry->initInfo;
     } else {
         if (entry->loadedRamAddr == NULL) {
-            entry->loadedRamAddr = zelda_mallocR(overlaySize);
+            entry->loadedRamAddr = ZeldaArena_MallocR(overlaySize);
 
             if (entry->loadedRamAddr == NULL) {
                 return;
diff --git a/src/code/z_effect_soft_sprite_old_init.c b/src/code/z_effect_soft_sprite_old_init.c
index aa461153c..cf27d2251 100644
--- a/src/code/z_effect_soft_sprite_old_init.c
+++ b/src/code/z_effect_soft_sprite_old_init.c
@@ -403,7 +403,7 @@ void EffectSsGSpk_SpawnSmall(GlobalContext* globalCtx, Actor* actor, Vec3f* pos,
 
 // EffectSsDFire Spawn Functions
 void EffectSsDFire_Spawn(GlobalContext* globalCtx, Vec3f* pos, Vec3f* velocity, Vec3f* accel, s16 scale, s16 scaleStep,
-                         s16 alpha, s16 fadeDelay, s16 life, s32 arg9) {
+                         s16 alpha, s16 fadeDelay, s16 arg8, s32 life) {
     EffectSsDFireInitParams initParams;
 
     Math_Vec3f_Copy(&initParams.pos, pos);
@@ -413,8 +413,8 @@ void EffectSsDFire_Spawn(GlobalContext* globalCtx, Vec3f* pos, Vec3f* velocity,
     initParams.scaleStep = scaleStep;
     initParams.alpha = alpha;
     initParams.fadeDelay = fadeDelay;
+    initParams.unk_2C = arg8;
     initParams.life = life;
-    initParams.unk_30 = arg9;
 
     EffectSs_Spawn(globalCtx, EFFECT_SS_D_FIRE, 128, &initParams);
 }
@@ -535,8 +535,8 @@ void EffectSsDtBubble_SpawnCustomColor(GlobalContext* globalCtx, Vec3f* pos, Vec
 /**
  * Spawn a single fragment
  *
- * Notes:
- *     - if a display list is not provided, D_0400C0D0 (wilted deku fragment) will be used as default
+ *  * Notes:
+ *     - if a display list is not provided, an unknown default will be used as default
  *     - the unused arg does not do anything, any value can be passed here
  *     - due to how life is implemented it is capped at 200. Any value over 200 is accepted, but the fragment will
  *       only live for 200 frames
@@ -960,6 +960,7 @@ void EffectSsExtra_Spawn(GlobalContext* globalCtx, Vec3f* pos, Vec3f* velocity,
 }
 
 // EffectSsDeadDb Spawn Functions
+
 void EffectSsDeadDb_Spawn(GlobalContext* globalCtx, Vec3f* pos, Vec3f* velocity, Vec3f* accel, Color_RGBA8* prim,
                           Color_RGBA8* env, s16 scale, s16 scaleStep, s32 unk) {
     EffectSsDeadDbInitParams initParams;
diff --git a/src/code/z_en_a_keep.c b/src/code/z_en_a_keep.c
index fbd323885..d5125d249 100644
--- a/src/code/z_en_a_keep.c
+++ b/src/code/z_en_a_keep.c
@@ -1,48 +1,57 @@
 #include "global.h"
 
-void EnAObj_Init(ActorEnAObj* this, GlobalContext* globalCtx) {
-    ActorEnAObj* s0 = (ActorEnAObj*)this;
-    s0->base.textId = ((s0->base.params >> 8) & 0xFF) | 0x300;
-    s0->base.params = (s0->base.params & 0xFF) - 9;
-    Actor_ProcessInitChain((Actor*)s0, &enAObjInitVar);
-    ActorShape_Init(&s0->base.shape, 0, (ActorShadowFunc)func_800B3FC0, 12);
-    Collider_InitAndSetCylinder(globalCtx, &s0->collision, (Actor*)s0, &enAObjCylinderInit);
-    Collider_UpdateCylinder((Actor*)s0, &s0->collision);
-    s0->base.colChkInfo.mass = 255;
-    s0->update = (ActorFunc)EnAObj_Update1;
+#define THIS ((EnAObj*)thisx)
+
+void EnAObj_Update1(EnAObj* this, GlobalContext* globalCtx);
+void EnAObj_Update2(EnAObj* this, GlobalContext* globalCtx);
+
+void EnAObj_Init(Actor* thisx, GlobalContext* globalCtx) {
+    EnAObj* this = THIS;
+
+    this->actor.textId = ((this->actor.params >> 8) & 0xFF) | 0x300;
+    this->actor.params = (this->actor.params & 0xFF) - 9;
+    Actor_ProcessInitChain(&this->actor, &enAObjInitVar);
+    ActorShape_Init(&this->actor.shape, 0, func_800B3FC0, 12);
+    Collider_InitAndSetCylinder(globalCtx, &this->collision, &this->actor, &enAObjCylinderInit);
+    Collider_UpdateCylinder(&this->actor, &this->collision);
+    this->actor.colChkInfo.mass = 255;
+    this->actionFunc = EnAObj_Update1;
 }
 
-void EnAObj_Destroy(ActorEnAObj* this, GlobalContext* globalCtx) {
-    ColliderCylinder* a2 = &this->collision;
-    Collider_DestroyCylinder(globalCtx, a2);
+void EnAObj_Destroy(Actor* thisx, GlobalContext* globalCtx) {
+    EnAObj* this = THIS;
+
+    Collider_DestroyCylinder(globalCtx, &this->collision);
 }
 
-void EnAObj_Update1(ActorEnAObj* this, GlobalContext* globalCtx) {
-    s16 v0;
-    s32 v1;
-    if (func_800B84D0((Actor*)this, globalCtx) != 0) {
-        this->update = (ActorFunc)EnAObj_Update2;
+void EnAObj_Update1(EnAObj* this, GlobalContext* globalCtx) {
+    s32 yawDiff;
+
+    if (func_800B84D0(&this->actor, globalCtx)) {
+        this->actionFunc = EnAObj_Update2;
     } else {
-        v0 = this->base.yawTowardsPlayer - this->base.shape.rot.y;
-        v1 = (v0 < 0) ? -v0 : v0;
-        if ((v1 < 10240) || ((this->base.params == 1) && (v1 > 22528))) {
-            func_800B863C((Actor*)this, globalCtx);
+        yawDiff = ABS_ALT((s16)(this->actor.yawTowardsPlayer - this->actor.shape.rot.y));
+
+        if ((yawDiff < 0x2800) || ((this->actor.params == 1) && (yawDiff > 0x5800))) {
+            func_800B863C(&this->actor, globalCtx);
         }
     }
 }
 
-void EnAObj_Update2(ActorEnAObj* this, GlobalContext* globalCtx) {
-    if (func_800B867C((Actor*)this, globalCtx) != 0) {
-        this->update = (ActorFunc)EnAObj_Update1;
+void EnAObj_Update2(EnAObj* this, GlobalContext* globalCtx) {
+    if (func_800B867C(&this->actor, globalCtx)) {
+        this->actionFunc = EnAObj_Update1;
     }
 }
 
-void EnAObj_Update(ActorEnAObj* this, GlobalContext* globalCtx) {
-    (this->update)((Actor*)this, (GlobalContext*)globalCtx);
-    Actor_SetHeight((Actor*)this, 45.0f);
-    CollisionCheck_SetOC(globalCtx, &globalCtx->colChkCtx, (Collider*)&this->collision);
+void EnAObj_Update(Actor* thisx, GlobalContext* globalCtx) {
+    EnAObj* this = THIS;
+
+    this->actionFunc(this, globalCtx);
+    Actor_SetHeight(&this->actor, 45.0f);
+    CollisionCheck_SetOC(globalCtx, &globalCtx->colChkCtx, &this->collision.base);
 }
 
-void EnAObj_Draw(ActorEnAObj* this, GlobalContext* globalCtx) {
-    func_800BDFC0(globalCtx, enAObjDisplayLists[this->base.params]);
+void EnAObj_Draw(Actor* thisx, GlobalContext* globalCtx) {
+    func_800BDFC0(globalCtx, enAObjDisplayLists[thisx->params]);
 }
diff --git a/src/code/z_en_item00.c b/src/code/z_en_item00.c
index 0a412c2da..acae2e0ce 100644
--- a/src/code/z_en_item00.c
+++ b/src/code/z_en_item00.c
@@ -660,7 +660,7 @@ void EnItem00_Draw(Actor* thisx, GlobalContext* globalCtx) {
                             this->unk152 = -2;
                         }
                     } else {
-                        Matrix_Scale(16.0f, 16.0f, 16.0f, 1);
+                        Matrix_Scale(16.0f, 16.0f, 16.0f, MTXMODE_APPLY);
                         GetItem_Draw(globalCtx, 8);
                     }
                     break;
@@ -785,7 +785,7 @@ void EnItem00_DrawHeartContainer(EnItem00* actor, GlobalContext* globalCtx) {
         OPEN_DISPS(globalCtx->state.gfxCtx);
 
         func_8012C2DC(globalCtx->state.gfxCtx);
-        Matrix_Scale(20.0f, 20.0f, 20.0f, 1);
+        Matrix_Scale(20.0f, 20.0f, 20.0f, MTXMODE_APPLY);
 
         gSPMatrix(POLY_XLU_DISP++, Matrix_NewMtx(globalCtx->state.gfxCtx), G_MTX_MODELVIEW | G_MTX_LOAD);
 
diff --git a/src/code/z_fcurve_data.c b/src/code/z_fcurve_data.c
new file mode 100644
index 000000000..a0bf887e1
--- /dev/null
+++ b/src/code/z_fcurve_data.c
@@ -0,0 +1,5 @@
+#include "global.h"
+
+#pragma GLOBAL_ASM("asm/non_matchings/code/z_fcurve_data/func_800F23E0.s")
+
+#pragma GLOBAL_ASM("asm/non_matchings/code/z_fcurve_data/func_800F2478.s")
diff --git a/src/code/z_fcurve_data_skelanime.c b/src/code/z_fcurve_data_skelanime.c
index 79439550d..c6ee50d87 100644
--- a/src/code/z_fcurve_data_skelanime.c
+++ b/src/code/z_fcurve_data_skelanime.c
@@ -1,15 +1,181 @@
 #include "global.h"
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_fcurve_data_skelanime/func_800F2620.s")
+void SkelCurve_Clear(SkelAnimeCurve* skelCurve) {
+    skelCurve->limbCount = 0;
+    skelCurve->limbList = NULL;
+    skelCurve->transUpdIdx = NULL;
+    skelCurve->animCurFrame = 0.0f;
+    skelCurve->animSpeed = 0.0f;
+    skelCurve->animFinalFrame = 0.0f;
+    skelCurve->unk0C = 0.0f;
+    skelCurve->transforms = NULL;
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_fcurve_data_skelanime/func_800F2650.s")
+s32 SkelCurve_Init(GlobalContext* globalCtx, SkelAnimeCurve* skelCurve, SkelCurveLimbList* limbListSeg,
+                   TransformUpdateIndex* transUpdIdx) {
+    SkelCurveLimb** limbs;
+    SkelCurveLimbList* limbList = (SkelCurveLimbList*)Lib_SegmentedToVirtual(limbListSeg);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_fcurve_data_skelanime/func_800F26C0.s")
+    skelCurve->limbCount = limbList->limbCount;
+    skelCurve->limbList = (SkelCurveLimb**)Lib_SegmentedToVirtual(limbList->limbs);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_fcurve_data_skelanime/func_800F26F0.s")
+    skelCurve->transforms = ZeldaArena_Malloc(sizeof(*skelCurve->transforms) * skelCurve->limbCount);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_fcurve_data_skelanime/func_800F2728.s")
+    do {
+        skelCurve->animCurFrame = 0.0f;
+    } while (0);
+    return 1;
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_fcurve_data_skelanime/func_800F29A0.s")
+void SkelCurve_Destroy(GlobalContext* globalCtx, SkelAnimeCurve* skelCurve) {
+    if (skelCurve->transforms != NULL) {
+        ZeldaArena_Free(skelCurve->transforms);
+    }
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_fcurve_data_skelanime/func_800F2CD8.s")
+void SkelCurve_SetAnim(SkelAnimeCurve* skelCurve, TransformUpdateIndex* transUpdIdx, f32 arg2, f32 animFinalFrame,
+                       f32 animCurFrame, f32 animSpeed) {
+    skelCurve->unk0C = arg2 - skelCurve->animSpeed;
+    skelCurve->animFinalFrame = animFinalFrame;
+    skelCurve->animCurFrame = animCurFrame;
+    skelCurve->animSpeed = animSpeed;
+    skelCurve->transUpdIdx = transUpdIdx;
+}
+
+#ifdef NON_MATCHING
+/* Should be functionally equivalent, also migrating rodata makes it a lot cleaner */
+s32 SkelCurve_Update(GlobalContext* globalCtx, SkelAnimeCurve* skelCurve) {
+    s16* transforms;
+    u8* transformRefIdx;
+    TransformUpdateIndex* transformIndex;
+    u16* transformCopyValues;
+    s32 i;
+    s32 ret = 0;
+    s32 k;
+    TransformData* transData;
+    f32 transformValue;
+    s32 j;
+
+    transformIndex = Lib_SegmentedToVirtual(skelCurve->transUpdIdx);
+    transformRefIdx = Lib_SegmentedToVirtual(transformIndex->refIndex);
+    transData = Lib_SegmentedToVirtual(transformIndex->transformData);
+    transformCopyValues = Lib_SegmentedToVirtual(transformIndex->copyValues);
+    transforms = (s16*)skelCurve->transforms;
+
+    skelCurve->animCurFrame += skelCurve->animSpeed * (globalCtx->state.framerateDivisor * 0.5f);
+
+    if ((skelCurve->animSpeed >= 0.0f && skelCurve->animCurFrame > skelCurve->animFinalFrame) ||
+        (skelCurve->animSpeed < 0.0f && skelCurve->animCurFrame < skelCurve->animFinalFrame)) {
+        skelCurve->animCurFrame = skelCurve->animFinalFrame;
+        ret = 1;
+    }
+
+    for (i = 0; i < skelCurve->limbCount; i++) {
+        for (j = 0; j < 3; j++) {
+            for (k = 0; k < 3; k++, transformRefIdx++, transforms++) {
+                if (*transformRefIdx == 0) {
+                    transformValue = *transformCopyValues;
+                    *transforms = transformValue;
+                    transformCopyValues++;
+                } else {
+                    transformValue = func_800F2478(skelCurve->animCurFrame, transData, *transformRefIdx);
+                    transData += *transformRefIdx;
+                    if (j == 0) {
+                        *transforms = transformValue * 1024.0f;
+                    } else if (j == 1) {
+                        *transforms = transformValue * (32768.0f / 180.0f);
+                    } else {
+                        *transforms = transformValue * 100.0f;
+                    }
+                }
+            }
+        }
+    }
+
+    return ret;
+}
+#else
+#pragma GLOBAL_ASM("asm/non_matchings/code/z_fcurve_data_skelanime/SkelCurve_Update.s")
+#endif
+
+void SkelCurve_DrawLimb(GlobalContext* globalCtx, s32 limbIndex, SkelAnimeCurve* skelCurve,
+                        OverrideCurveLimbDraw overrideLimbDraw, PostCurveLimbDraw postLimbDraw, s32 lod, Actor* thisx) {
+    SkelCurveLimb* limb = (SkelCurveLimb*)Lib_SegmentedToVirtual(skelCurve->limbList[limbIndex]);
+
+    OPEN_DISPS(globalCtx->state.gfxCtx);
+
+    Matrix_StatePush();
+
+    if (overrideLimbDraw == NULL ||
+        (overrideLimbDraw != NULL && overrideLimbDraw(globalCtx, skelCurve, limbIndex, thisx))) {
+        Vec3f scale;
+        Vec3s rot;
+        Vec3f pos;
+        Gfx* dList;
+        Vec3s* transform = (Vec3s*)&skelCurve->transforms[limbIndex];
+
+        scale.x = transform->x / 1024.0f;
+        scale.y = transform->y / 1024.0f;
+        scale.z = transform->z / 1024.0f;
+        transform++;
+        rot.x = transform->x;
+        rot.y = transform->y;
+        rot.z = transform->z;
+        transform++;
+        pos.x = transform->x;
+        pos.y = transform->y;
+        pos.z = transform->z;
+
+        Matrix_JointPosition(&pos, &rot);
+        Matrix_Scale(scale.x, scale.y, scale.z, MTXMODE_APPLY);
+
+        if (lod == 0) {
+            s32 pad1;
+
+            dList = limb->dList[0];
+            if (dList != NULL) {
+                gSPMatrix(POLY_OPA_DISP++, Matrix_NewMtx(globalCtx->state.gfxCtx),
+                          G_MTX_LOAD | G_MTX_NOPUSH | G_MTX_MODELVIEW);
+                gSPDisplayList(POLY_OPA_DISP++, dList);
+            }
+        } else if (lod == 1) {
+            s32 pad2;
+
+            dList = limb->dList[0];
+            if (dList != NULL) {
+                gSPMatrix(POLY_OPA_DISP++, Matrix_NewMtx(globalCtx->state.gfxCtx),
+                          G_MTX_LOAD | G_MTX_NOPUSH | G_MTX_MODELVIEW);
+                gSPDisplayList(POLY_OPA_DISP++, dList);
+            }
+            dList = limb->dList[1];
+            if (dList != NULL) {
+                gSPMatrix(POLY_XLU_DISP++, Matrix_NewMtx(globalCtx->state.gfxCtx),
+                          G_MTX_LOAD | G_MTX_NOPUSH | G_MTX_MODELVIEW);
+                gSPDisplayList(POLY_XLU_DISP++, dList);
+            }
+        }
+    }
+
+    if (postLimbDraw != NULL) {
+        postLimbDraw(globalCtx, skelCurve, limbIndex, thisx);
+    }
+
+    if (limb->firstChildIdx != LIMB_DONE) {
+        SkelCurve_DrawLimb(globalCtx, limb->firstChildIdx, skelCurve, overrideLimbDraw, postLimbDraw, lod, thisx);
+    }
+
+    Matrix_StatePop();
+
+    if (limb->nextLimbIdx != LIMB_DONE) {
+        SkelCurve_DrawLimb(globalCtx, limb->nextLimbIdx, skelCurve, overrideLimbDraw, postLimbDraw, lod, thisx);
+    }
+
+    CLOSE_DISPS(globalCtx->state.gfxCtx);
+}
+
+void SkelCurve_Draw(Actor* actor, GlobalContext* globalCtx, SkelAnimeCurve* skelCurve,
+                    OverrideCurveLimbDraw overrideLimbDraw, PostCurveLimbDraw postLimbDraw, s32 lod, Actor* thisx) {
+    if (skelCurve->transforms != NULL) {
+        SkelCurve_DrawLimb(globalCtx, 0, skelCurve, overrideLimbDraw, postLimbDraw, lod, thisx);
+    }
+}
diff --git a/src/code/z_lights.c b/src/code/z_lights.c
index 3e2e041b3..80d3f7131 100644
--- a/src/code/z_lights.c
+++ b/src/code/z_lights.c
@@ -432,7 +432,7 @@ void Lights_DrawGlow(GlobalContext* globalCtx) {
 
                     gDPSetPrimColor(dl++, 0, 0, params->color[0], params->color[1], params->color[2], 50);
 
-                    SysMatrix_InsertTranslation(params->x, params->y, params->z, 0);
+                    Matrix_InsertTranslation(params->x, params->y, params->z, MTXMODE_NEW);
                     Matrix_Scale(scale, scale, scale, MTXMODE_APPLY);
 
                     gSPMatrix(dl++, Matrix_NewMtx(globalCtx->state.gfxCtx),
diff --git a/src/code/z_malloc.c b/src/code/z_malloc.c
index f99519e9b..8d0bba44a 100644
--- a/src/code/z_malloc.c
+++ b/src/code/z_malloc.c
@@ -1,21 +1,54 @@
 #include "global.h"
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_malloc/zelda_malloc.s")
+void* ZeldaArena_Malloc(size_t size) {
+    void* ptr = __osMalloc(&sZeldaArena, size);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_malloc/zelda_mallocR.s")
+    return ptr;
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_malloc/zelda_realloc.s")
+void* ZeldaArena_MallocR(size_t size) {
+    void* ptr = __osMallocR(&sZeldaArena, size);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_malloc/zelda_free.s")
+    return ptr;
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_malloc/zelda_calloc.s")
+void* ZeldaArena_Realloc(void* ptr, size_t newSize) {
+    ptr = __osRealloc(&sZeldaArena, ptr, newSize);
+    return ptr;
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_malloc/MainHeap_AnalyzeArena.s")
+void ZeldaArena_Free(void* ptr) {
+    __osFree(&sZeldaArena, ptr);
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_malloc/MainHeap_Check.s")
+void* ZeldaArena_Calloc(u32 num, size_t size) {
+    void* ret;
+    u32 n = num * size;
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_malloc/MainHeap_Init.s")
+    ret = __osMalloc(&sZeldaArena, n);
+    if (ret != NULL) {
+        bzero(ret, n);
+    }
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_malloc/MainHeap_Cleanup.s")
+    return ret;
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_malloc/MainHeap_IsInitialized.s")
+void ZeldaArena_GetSizes(size_t* outMaxFree, size_t* outFree, size_t* outAlloc) {
+    __osAnalyzeArena(&sZeldaArena, outMaxFree, outFree, outAlloc);
+}
+
+void ZeldaArena_Check() {
+    __osCheckArena(&sZeldaArena);
+}
+
+void ZeldaArena_Init(void* start, size_t size) {
+    __osMallocInit(&sZeldaArena, start, size);
+}
+
+void ZeldaArena_Cleanup() {
+    __osMallocCleanup(&sZeldaArena);
+}
+
+u8 ZeldaArena_IsInitialized() {
+    return __osMallocIsInitalized(&sZeldaArena);
+}
diff --git a/src/code/z_pause.c b/src/code/z_pause.c
new file mode 100644
index 000000000..44be6238a
--- /dev/null
+++ b/src/code/z_pause.c
@@ -0,0 +1,5 @@
+#include "global.h"
+
+#pragma GLOBAL_ASM("asm/non_matchings/code/z_pause/func_80122660.s")
+
+#pragma GLOBAL_ASM("asm/non_matchings/code/z_pause/func_80122670.s")
diff --git a/src/code/z_room.c b/src/code/z_room.c
index 5f900ea87..5163f1f29 100644
--- a/src/code/z_room.c
+++ b/src/code/z_room.c
@@ -77,7 +77,7 @@ void Room_Init(GlobalContext* globalCtx, RoomContext* roomCtx) {
 
 #ifdef NON_MATCHING
 s32 Room_StartRoomTransition(GlobalContext* globalCtx, RoomContext* roomCtx, s32 index) {
-    u32 size;
+    size_t size;
 
     // XXX: this should use a branch-likely
     if (roomCtx->unk31 == 0) {
diff --git a/src/code/z_scene.c b/src/code/z_scene.c
index e77144528..b744af5d0 100644
--- a/src/code/z_scene.c
+++ b/src/code/z_scene.c
@@ -1,7 +1,7 @@
 #include "global.h"
 
 s32 Object_Spawn(ObjectContext* objectCtx, s16 id) {
-    u32 size;
+    size_t size;
 
     objectCtx->status[objectCtx->num].id = id;
     size = objectFileTable[id].vromEnd - objectFileTable[id].vromStart;
@@ -23,8 +23,8 @@ s32 Object_Spawn(ObjectContext* objectCtx, s16 id) {
     return objectCtx->num - 1;
 }
 
-void Object_InitBank(GameState* gamestate, ObjectContext* objectCtx) {
-    GlobalContext* globalCtx = (GlobalContext*)gamestate;
+void Object_InitBank(GameState* gameState, ObjectContext* objectCtx) {
+    GlobalContext* globalCtx = (GlobalContext*)gameState;
     s32 pad;
     u32 spaceSize;
     s32 i;
@@ -49,7 +49,7 @@ void Object_InitBank(GameState* gamestate, ObjectContext* objectCtx) {
     for (i = 0; i < OBJECT_EXCHANGE_BANK_MAX; i++) { objectCtx->status[i].id = 0; }
     // clang-format on
 
-    objectCtx->spaceStart = objectCtx->status[0].segment = THA_AllocEndAlign16(&gamestate->heap, spaceSize);
+    objectCtx->spaceStart = objectCtx->status[0].segment = THA_AllocEndAlign16(&gameState->heap, spaceSize);
     objectCtx->spaceEnd = (void*)((u32)objectCtx->spaceStart + spaceSize);
     objectCtx->mainKeepIndex = Object_Spawn(objectCtx, GAMEPLAY_KEEP);
 
@@ -60,7 +60,7 @@ void Object_UpdateBank(ObjectContext* objectCtx) {
     s32 i;
     ObjectStatus* status = &objectCtx->status[0];
     RomFile* objectFile;
-    u32 size;
+    size_t size;
 
     for (i = 0; i < objectCtx->num; i++) {
         if (status->id < 0) {
@@ -354,7 +354,7 @@ s32 Scene_LoadAreaTextures(GlobalContext* globalCtx, s32 fileIndex) {
         { SEGMENT_ROM_START(scene_texture_08), SEGMENT_ROM_END(scene_texture_08) },
     };
     u32 vromStart = sceneTextureFiles[fileIndex].vromStart;
-    u32 size = sceneTextureFiles[fileIndex].vromEnd - vromStart;
+    size_t size = sceneTextureFiles[fileIndex].vromEnd - vromStart;
 
     if (size != 0) {
         globalCtx->roomCtx.unk74 = THA_AllocEndAlign16(&globalCtx->state.heap, size);
diff --git a/src/code/z_skelanime.c b/src/code/z_skelanime.c
index 16428023a..4cd9734f6 100644
--- a/src/code/z_skelanime.c
+++ b/src/code/z_skelanime.c
@@ -1,63 +1,57 @@
 #include "global.h"
 
-s32 func_80136288(GlobalContext* globalCtx, SkelAnime* skelAnime);
-s32 func_8013631C(GlobalContext* globalCtx, SkelAnime* skelAnime);
-s32 func_8013702C(SkelAnime* skelAnime);
-s32 func_801370B0(SkelAnime* skelAnime);
-s32 func_8013713C(SkelAnime* skelAnime);
-void SkelAnime_ChangeAnimDefaultRepeat(SkelAnime* skelAnime, AnimationHeader* animationSeg);
-void func_80137748(SkelAnime* skelAnime, Vec3f* pos, s16 angle);
-void SkelAnime_ChangeLinkAnim(GlobalContext* globalCtx, SkelAnime* skelAnime,
-                              LinkAnimationHeader* linkAnimationHeaderSeg, f32 playbackSpeed, f32 frame, f32 frameCount,
-                              u8 animationMode, f32 transitionRate);
-void SkelAnime_CopyVec3s(SkelAnime* skelAnime, Vec3s* dst, Vec3s* src);
-void SkelAnime_LinkAnimetionLoaded(GlobalContext* globalCtx, AnimationEntryType0* entry);
-void SkelAnime_AnimationType1Loaded(GlobalContext* globalCtx, AnimationEntryType1* entry);
-void SkelAnime_AnimationType2Loaded(GlobalContext* globalCtx, AnimationEntryType2* entry);
-void SkelAnime_AnimationType3Loaded(GlobalContext* globalCtx, AnimationEntryType3* entry);
-void SkelAnime_AnimationType4Loaded(GlobalContext* globalCtx, AnimationEntryType4* entry);
-void SkelAnime_AnimationType5Loaded(GlobalContext* globalCtx, AnimationEntryType5* entry);
+#define ANIM_INTERP 1
+
+s32 LinkAnimation_Loop(GlobalContext* globalCtx, SkelAnime* skelAnime);
+s32 LinkAnimation_Once(GlobalContext* globalCtx, SkelAnime* skelAnime);
+s32 SkelAnime_LoopFull(SkelAnime* skelAnime);
+s32 SkelAnime_LoopPartial(SkelAnime* skelAnime);
+s32 SkelAnime_Once(SkelAnime* skelAnime);
+void Animation_PlayLoop(SkelAnime* skelAnime, AnimationHeader* animationSeg);
+void SkelAnime_UpdateTranslation(SkelAnime* skelAnime, Vec3f* pos, s16 angle);
+void LinkAnimation_Change(GlobalContext* globalCtx, SkelAnime* skelAnime, LinkAnimationHeader* linkAnimetionEntrySeg,
+                          f32 playbackSpeed, f32 frame, f32 frameCount, u8 animationMode, f32 transitionRate);
+void SkelAnime_CopyFrameTable(SkelAnime* skelAnime, Vec3s* dst, Vec3s* src);
 
 static AnimationEntryCallback sAnimationLoadDone[] = {
-    (AnimationEntryCallback)SkelAnime_LinkAnimetionLoaded,  (AnimationEntryCallback)SkelAnime_AnimationType1Loaded,
-    (AnimationEntryCallback)SkelAnime_AnimationType2Loaded, (AnimationEntryCallback)SkelAnime_AnimationType3Loaded,
-    (AnimationEntryCallback)SkelAnime_AnimationType4Loaded, (AnimationEntryCallback)SkelAnime_AnimationType5Loaded,
+    AnimationContext_LoadFrame, AnimationContext_CopyAll,   AnimationContext_Interp,
+    AnimationContext_CopyTrue,  AnimationContext_CopyFalse, AnimationContext_MoveActor,
 };
 
-s32 D_801F5AB0;
-s32 D_801F5AB4;
+s32 sAnimQueueFlags;
+s32 sDisableAnimQueueFlags;
 
 /*
  * Draws the limb at `limbIndex` with a level of detail display lists index by `dListIndex`
  */
-void SkelAnime_LodDrawLimb(GlobalContext* globalCtx, s32 limbIndex, void** skeleton, Vec3s* limbDrawTable,
-                           OverrideLimbDraw overrideLimbDraw, PostLimbDraw postLimbDraw, Actor* actor, s32 dListIndex) {
-    StandardLimb* limbEntry;
+void SkelAnime_DrawLimbLod(GlobalContext* globalCtx, s32 limbIndex, void** skeleton, Vec3s* jointTable,
+                           OverrideLimbDrawOpa overrideLimbDraw, PostLimbDrawOpa postLimbDraw, Actor* actor, s32 lod) {
+    LodLimb* limb;
     Gfx* dList;
     Vec3f pos;
     Vec3s rot;
-    GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    s32 pad;
 
-    SysMatrix_StatePush();
-    limbEntry = (StandardLimb*)Lib_SegmentedToVirtual(skeleton[limbIndex]);
+    OPEN_DISPS(globalCtx->state.gfxCtx);
+
+    Matrix_StatePush();
+    limb = (LodLimb*)Lib_SegmentedToVirtual(skeleton[limbIndex]);
     limbIndex++;
-    rot = limbDrawTable[limbIndex];
+    rot = jointTable[limbIndex];
 
-    pos.x = limbEntry->translation.x;
-    pos.y = limbEntry->translation.y;
-    pos.z = limbEntry->translation.z;
+    pos.x = limb->jointPos.x;
+    pos.y = limb->jointPos.y;
+    pos.z = limb->jointPos.z;
 
-    dList = limbEntry->displayLists[dListIndex];
+    dList = limb->dLists[lod];
     if ((overrideLimbDraw == NULL) || (overrideLimbDraw(globalCtx, limbIndex, &dList, &pos, &rot, actor) == 0)) {
-        SysMatrix_RotateAndTranslateState(&pos, &rot);
+        Matrix_JointPosition(&pos, &rot);
         if (dList != NULL) {
-            Gfx* polyTemp = gfxCtx->polyOpa.p;
+            Gfx* polyTemp = POLY_OPA_DISP;
 
-            gSPMatrix(polyTemp, Matrix_NewMtx(globalCtx->state.gfxCtx), G_MTX_LOAD);
+            gSPMatrix(&polyTemp[0], Matrix_NewMtx(globalCtx->state.gfxCtx), G_MTX_LOAD);
 
-            gSPDisplayList(polyTemp + 1, dList);
-            gfxCtx->polyOpa.p = polyTemp + 2;
+            gSPDisplayList(&polyTemp[1], dList);
+            POLY_OPA_DISP = &polyTemp[2];
         }
     }
 
@@ -65,58 +59,58 @@ void SkelAnime_LodDrawLimb(GlobalContext* globalCtx, s32 limbIndex, void** skele
         postLimbDraw(globalCtx, limbIndex, &dList, &rot, actor);
     }
 
-    if (limbEntry->firstChildIndex != LIMB_DONE) {
-        SkelAnime_LodDrawLimb(globalCtx, limbEntry->firstChildIndex, skeleton, limbDrawTable, overrideLimbDraw,
-                              postLimbDraw, actor, dListIndex);
+    if (limb->child != LIMB_DONE) {
+        SkelAnime_DrawLimbLod(globalCtx, limb->child, skeleton, jointTable, overrideLimbDraw, postLimbDraw, actor, lod);
     }
 
-    SysMatrix_StatePop();
+    Matrix_StatePop();
 
-    if (limbEntry->nextLimbIndex != LIMB_DONE) {
-        SkelAnime_LodDrawLimb(globalCtx, limbEntry->nextLimbIndex, skeleton, limbDrawTable, overrideLimbDraw,
-                              postLimbDraw, actor, dListIndex);
+    if (limb->sibling != LIMB_DONE) {
+        SkelAnime_DrawLimbLod(globalCtx, limb->sibling, skeleton, jointTable, overrideLimbDraw, postLimbDraw, actor,
+                              lod);
     }
+
+    CLOSE_DISPS(globalCtx->state.gfxCtx);
 }
 
-/*
- * Draws the Skeleton described by `skeleton` with a level of detail display list indexed by `dListIndex`
+/**
+ * Draw all limbs of type `LodLimb` in a given skeleton
+ * Near or far display list is specified via `lod`
  */
-void SkelAnime_LodDraw(GlobalContext* globalCtx, void** skeleton, Vec3s* limbDrawTable,
-                       OverrideLimbDraw overrideLimbDraw, PostLimbDraw postLimbDraw, Actor* actor, s32 dListIndex) {
-    StandardLimb* limbEntry;
+void SkelAnime_DrawLod(GlobalContext* globalCtx, void** skeleton, Vec3s* jointTable,
+                       OverrideLimbDrawOpa overrideLimbDraw, PostLimbDrawOpa postLimbDraw, Actor* actor, s32 lod) {
+    LodLimb* rootLimb;
     s32 pad;
     Gfx* dList;
     Vec3f pos;
     Vec3s rot;
-    GraphicsContext* gfxCtx;
-    s32 pad2;
 
     if (skeleton == NULL) {
         return;
     }
 
-    gfxCtx = globalCtx->state.gfxCtx;
+    OPEN_DISPS(globalCtx->state.gfxCtx);
 
-    SysMatrix_StatePush();
+    Matrix_StatePush();
 
-    limbEntry = (StandardLimb*)Lib_SegmentedToVirtual(skeleton[0]);
-    pos.x = limbDrawTable[0].x;
-    pos.y = limbDrawTable[0].y;
-    pos.z = limbDrawTable[0].z;
+    rootLimb = (LodLimb*)Lib_SegmentedToVirtual(skeleton[0]);
+    pos.x = jointTable[0].x;
+    pos.y = jointTable[0].y;
+    pos.z = jointTable[0].z;
 
-    rot = limbDrawTable[1];
-    dList = limbEntry->displayLists[dListIndex];
+    rot = jointTable[1];
+    dList = rootLimb->dLists[lod];
 
-    if ((overrideLimbDraw == NULL) || (overrideLimbDraw(globalCtx, 1, &dList, &pos, &rot, actor) == 0)) {
-        SysMatrix_RotateAndTranslateState(&pos, &rot);
+    if ((overrideLimbDraw == NULL) || !overrideLimbDraw(globalCtx, 1, &dList, &pos, &rot, actor)) {
+        Matrix_JointPosition(&pos, &rot);
         if (dList != NULL) {
-            Gfx* polyTemp = gfxCtx->polyOpa.p;
+            Gfx* polyTemp = POLY_OPA_DISP;
 
-            gSPMatrix(polyTemp, Matrix_NewMtx(globalCtx->state.gfxCtx), G_MTX_LOAD);
+            gSPMatrix(&polyTemp[0], Matrix_NewMtx(globalCtx->state.gfxCtx), G_MTX_LOAD);
 
-            gSPDisplayList(polyTemp + 1, dList);
+            gSPDisplayList(&polyTemp[1], dList);
 
-            gfxCtx->polyOpa.p = polyTemp + 2;
+            POLY_OPA_DISP = &polyTemp[2];
         }
     }
 
@@ -124,167 +118,169 @@ void SkelAnime_LodDraw(GlobalContext* globalCtx, void** skeleton, Vec3s* limbDra
         postLimbDraw(globalCtx, 1, &dList, &rot, actor);
     }
 
-    if (limbEntry->firstChildIndex != 0xFF) {
-        SkelAnime_LodDrawLimb(globalCtx, limbEntry->firstChildIndex, skeleton, limbDrawTable, overrideLimbDraw,
-                              postLimbDraw, actor, dListIndex);
+    if (rootLimb->child != LIMB_DONE) {
+        SkelAnime_DrawLimbLod(globalCtx, rootLimb->child, skeleton, jointTable, overrideLimbDraw, postLimbDraw, actor,
+                              lod);
     }
 
-    SysMatrix_StatePop();
+    Matrix_StatePop();
+
+    CLOSE_DISPS(globalCtx->state.gfxCtx);
 }
 
-/*
- * Draws the limb at `limbIndex` with a level of detail display lists index by `dListIndex`, Limb matrices come
- * from a dynamic allocation from the graph arena.
- */
-void SkelAnime_LodDrawLimbSV(GlobalContext* globalCtx, s32 limbIndex, void** skeleton, Vec3s* limbDrawTable,
-                             OverrideLimbDrawSV overrideLimbDraw, PostLimbDrawSV postLimbDraw, Actor* actor,
-                             s32 dListIndex, RSPMatrix** mtx) {
-    StandardLimb* limbEntry;
-    Gfx* dList[2];
+/**
+ * Draw a limb of type `LodLimb` contained within a flexible skeleton
+ * Near or far display list is specified via `lod`
+ */
+void SkelAnime_DrawFlexLimbLod(GlobalContext* globalCtx, s32 limbIndex, void** skeleton, Vec3s* jointTable,
+                               OverrideLimbDrawFlex overrideLimbDraw, PostLimbDrawFlex postLimbDraw, Actor* actor,
+                               s32 lod, Mtx** mtx) {
+    LodLimb* limb;
+    Gfx* newDList;
+    Gfx* limbDList;
     Vec3f pos;
     Vec3s rot;
-    GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    s32 pad;
 
-    SysMatrix_StatePush();
+    OPEN_DISPS(globalCtx->state.gfxCtx);
 
-    limbEntry = (StandardLimb*)Lib_SegmentedToVirtual(skeleton[limbIndex]);
+    Matrix_StatePush();
+
+    limb = (LodLimb*)Lib_SegmentedToVirtual(skeleton[limbIndex]);
     limbIndex++;
 
-    rot = limbDrawTable[limbIndex];
-
-    pos.x = limbEntry->translation.x;
-    pos.y = limbEntry->translation.y;
-    pos.z = limbEntry->translation.z;
-    // Double assignment here would not work.
-    dList[0] = limbEntry->displayLists[dListIndex];
-    dList[1] = dList[0];
-
-    if ((overrideLimbDraw == NULL) || (overrideLimbDraw(globalCtx, limbIndex, &dList[1], &pos, &rot, actor) == 0)) {
-        SysMatrix_RotateAndTranslateState(&pos, &rot);
-        if (dList[1] != NULL) {
-            SysMatrix_GetStateAsRSPMatrix(*mtx);
-            gSPMatrix(gfxCtx->polyOpa.p++, *mtx, G_MTX_LOAD);
-            gSPDisplayList(gfxCtx->polyOpa.p++, dList[1]);
+    rot = jointTable[limbIndex];
+
+    pos.x = limb->jointPos.x;
+    pos.y = limb->jointPos.y;
+    pos.z = limb->jointPos.z;
+
+    newDList = limbDList = limb->dLists[lod];
+
+    if ((overrideLimbDraw == NULL) || !overrideLimbDraw(globalCtx, limbIndex, &newDList, &pos, &rot, actor)) {
+        Matrix_JointPosition(&pos, &rot);
+        if (newDList != NULL) {
+            Matrix_ToMtx(*mtx);
+            gSPMatrix(POLY_OPA_DISP++, *mtx, G_MTX_LOAD);
+            gSPDisplayList(POLY_OPA_DISP++, newDList);
             (*mtx)++;
-        } else if (dList[0] != NULL) {
-            SysMatrix_GetStateAsRSPMatrix(*mtx);
+        } else if (limbDList != NULL) {
+            Matrix_ToMtx(*mtx);
             (*mtx)++;
         }
     }
 
     if (postLimbDraw != NULL) {
-        postLimbDraw(globalCtx, limbIndex, &dList[1], &dList[0], &rot, actor);
+        postLimbDraw(globalCtx, limbIndex, &newDList, &limbDList, &rot, actor);
     }
 
-    if (limbEntry->firstChildIndex != LIMB_DONE) {
-        SkelAnime_LodDrawLimbSV(globalCtx, limbEntry->firstChildIndex, skeleton, limbDrawTable, overrideLimbDraw,
-                                postLimbDraw, actor, dListIndex, mtx);
+    if (limb->child != LIMB_DONE) {
+        SkelAnime_DrawFlexLimbLod(globalCtx, limb->child, skeleton, jointTable, overrideLimbDraw, postLimbDraw, actor,
+                                  lod, mtx);
     }
 
-    SysMatrix_StatePop();
+    Matrix_StatePop();
 
-    if (limbEntry->nextLimbIndex != LIMB_DONE) {
-        SkelAnime_LodDrawLimbSV(globalCtx, limbEntry->nextLimbIndex, skeleton, limbDrawTable, overrideLimbDraw,
-                                postLimbDraw, actor, dListIndex, mtx);
+    if (limb->sibling != LIMB_DONE) {
+        SkelAnime_DrawFlexLimbLod(globalCtx, limb->sibling, skeleton, jointTable, overrideLimbDraw, postLimbDraw, actor,
+                                  lod, mtx);
     }
+
+    CLOSE_DISPS(globalCtx->state.gfxCtx);
 }
 
-/*
- * Draws the Skeleton described by `skeleton` with a level of detail display list indexed by `dListIndex`
- * Matricies for the limbs are dynamically allocted from the graph arena.  The dynamic allocation occurs
- * because the Skeleton is too large to be supported by the normal matrix stack.
- */
-void SkelAnime_LodDrawSV(GlobalContext* globalCtx, void** skeleton, Vec3s* limbDrawTable, s32 dListCount,
-                         OverrideLimbDrawSV overrideLimbDraw, PostLimbDrawSV postLimbDraw, Actor* actor,
-                         s32 dListIndex) {
-    StandardLimb* limbEntry;
+/**
+ * Draws all limbs of type `LodLimb` in a given flexible skeleton
+ * Limbs in a flexible skeleton have meshes that can stretch to line up with other limbs.
+ * An array of matrices is dynamically allocated so each limb can access any transform to ensure its meshes line up.
+ */
+void SkelAnime_DrawFlexLod(GlobalContext* globalCtx, void** skeleton, Vec3s* jointTable, s32 dListCount,
+                           OverrideLimbDrawFlex overrideLimbDraw, PostLimbDrawFlex postLimbDraw, Actor* actor,
+                           s32 lod) {
+    LodLimb* rootLimb;
     s32 pad;
-    Gfx* dList[2];
+    Gfx* newDList;
+    Gfx* limbDList;
     Vec3f pos;
     Vec3s rot;
-    RSPMatrix* mtx;
-    GraphicsContext* gfxCtx;
-    s32 pad2;
-
-    mtx = (RSPMatrix*)GRAPH_ALLOC(globalCtx->state.gfxCtx, ALIGN16(sizeof(RSPMatrix) * dListCount));
+    Mtx* mtx = (Mtx*)GRAPH_ALLOC(globalCtx->state.gfxCtx, ALIGN16(sizeof(Mtx) * dListCount));
 
     if (skeleton == NULL) {
         return;
     }
 
-    gfxCtx = globalCtx->state.gfxCtx;
+    OPEN_DISPS(globalCtx->state.gfxCtx);
 
-    gSPSegment(gfxCtx->polyOpa.p++, 0xD, mtx);
-    SysMatrix_StatePush();
+    gSPSegment(POLY_OPA_DISP++, 0xD, mtx);
+    Matrix_StatePush();
 
-    limbEntry = (StandardLimb*)Lib_SegmentedToVirtual(skeleton[0]);
-    pos.x = limbDrawTable[0].x;
-    pos.y = limbDrawTable[0].y;
-    pos.z = limbDrawTable[0].z;
+    rootLimb = (LodLimb*)Lib_SegmentedToVirtual(skeleton[0]);
+    pos.x = jointTable[0].x;
+    pos.y = jointTable[0].y;
+    pos.z = jointTable[0].z;
 
-    rot = limbDrawTable[1];
+    rot = jointTable[1];
 
-    dList[0] = limbEntry->displayLists[dListIndex];
-    dList[1] = dList[0];
+    newDList = limbDList = rootLimb->dLists[lod];
 
-    if ((overrideLimbDraw == NULL) || (overrideLimbDraw(globalCtx, 1, &dList[1], &pos, &rot, actor) == 0)) {
-        SysMatrix_RotateAndTranslateState(&pos, &rot);
-        if (dList[1] != NULL) {
-            Gfx* polyTemp = gfxCtx->polyOpa.p;
+    if ((overrideLimbDraw == NULL) || !overrideLimbDraw(globalCtx, 1, &newDList, &pos, &rot, actor)) {
+        Matrix_JointPosition(&pos, &rot);
+        if (newDList != NULL) {
+            Gfx* polyTemp = POLY_OPA_DISP;
 
-            gSPMatrix(polyTemp, SysMatrix_GetStateAsRSPMatrix(mtx), G_MTX_LOAD);
-            gSPDisplayList(polyTemp + 1, dList[1]);
-            gfxCtx->polyOpa.p = polyTemp + 2;
+            gSPMatrix(&polyTemp[0], Matrix_ToMtx(mtx), G_MTX_LOAD);
+            gSPDisplayList(&polyTemp[1], newDList);
+            POLY_OPA_DISP = &polyTemp[2];
             mtx++;
-        } else if (dList[0] != NULL) {
-            SysMatrix_GetStateAsRSPMatrix(mtx);
+        } else if (limbDList != NULL) {
+            Matrix_ToMtx(mtx);
             mtx++;
         }
     }
 
     if (postLimbDraw != NULL) {
-        postLimbDraw(globalCtx, 1, &dList[1], &dList[0], &rot, actor);
+        postLimbDraw(globalCtx, 1, &newDList, &limbDList, &rot, actor);
     }
 
-    if (limbEntry->firstChildIndex != LIMB_DONE) {
-        SkelAnime_LodDrawLimbSV(globalCtx, limbEntry->firstChildIndex, skeleton, limbDrawTable, overrideLimbDraw,
-                                postLimbDraw, actor, dListIndex, &mtx);
+    if (rootLimb->child != LIMB_DONE) {
+        SkelAnime_DrawFlexLimbLod(globalCtx, rootLimb->child, skeleton, jointTable, overrideLimbDraw, postLimbDraw,
+                                  actor, lod, &mtx);
     }
 
-    SysMatrix_StatePop();
+    Matrix_StatePop();
+
+    CLOSE_DISPS(globalCtx->state.gfxCtx);
 }
 
 /*
  * Draws the limb of the Skeleton `skeleton` at `limbIndex`
  */
-void SkelAnime_DrawLimb(GlobalContext* globalCtx, s32 limbIndex, void** skeleton, Vec3s* limbDrawTable,
-                        OverrideLimbDraw overrideLimbDraw, PostLimbDraw postLimbDraw, Actor* actor) {
-    StandardLimb* limbEntry;
+void SkelAnime_DrawLimbOpa(GlobalContext* globalCtx, s32 limbIndex, void** skeleton, Vec3s* jointTable,
+                           OverrideLimbDrawOpa overrideLimbDraw, PostLimbDrawOpa postLimbDraw, Actor* actor) {
+    StandardLimb* limb;
     Gfx* dList;
     Vec3f pos;
     Vec3s rot;
-    GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    s32 pad;
 
-    SysMatrix_StatePush();
+    OPEN_DISPS(globalCtx->state.gfxCtx);
 
-    limbEntry = (StandardLimb*)Lib_SegmentedToVirtual(skeleton[limbIndex]);
-    limbIndex++;
-    rot = limbDrawTable[limbIndex];
-    pos.x = limbEntry->translation.x;
-    pos.y = limbEntry->translation.y;
-    pos.z = limbEntry->translation.z;
-    dList = limbEntry->displayLists[0];
+    Matrix_StatePush();
 
-    if ((overrideLimbDraw == NULL) || (overrideLimbDraw(globalCtx, limbIndex, &dList, &pos, &rot, actor) == 0)) {
-        SysMatrix_RotateAndTranslateState(&pos, &rot);
+    limb = (StandardLimb*)Lib_SegmentedToVirtual(skeleton[limbIndex]);
+    limbIndex++;
+    rot = jointTable[limbIndex];
+    pos.x = limb->jointPos.x;
+    pos.y = limb->jointPos.y;
+    pos.z = limb->jointPos.z;
+    dList = limb->dList;
+
+    if ((overrideLimbDraw == NULL) || !overrideLimbDraw(globalCtx, limbIndex, &dList, &pos, &rot, actor)) {
+        Matrix_JointPosition(&pos, &rot);
         if (dList != NULL) {
-            Gfx* polyTemp = gfxCtx->polyOpa.p;
+            Gfx* polyTemp = POLY_OPA_DISP;
 
-            gSPMatrix(polyTemp, Matrix_NewMtx(globalCtx->state.gfxCtx), G_MTX_LOAD);
-            gSPDisplayList(polyTemp + 1, dList);
-            gfxCtx->polyOpa.p = polyTemp + 2;
+            gSPMatrix(&polyTemp[0], Matrix_NewMtx(globalCtx->state.gfxCtx), G_MTX_LOAD);
+            gSPDisplayList(&polyTemp[1], dList);
+            POLY_OPA_DISP = &polyTemp[2];
         }
     }
 
@@ -292,53 +288,54 @@ void SkelAnime_DrawLimb(GlobalContext* globalCtx, s32 limbIndex, void** skeleton
         postLimbDraw(globalCtx, limbIndex, &dList, &rot, actor);
     }
 
-    if (limbEntry->firstChildIndex != LIMB_DONE) {
-        SkelAnime_DrawLimb(globalCtx, limbEntry->firstChildIndex, skeleton, limbDrawTable, overrideLimbDraw,
-                           postLimbDraw, actor);
+    if (limb->child != LIMB_DONE) {
+        SkelAnime_DrawLimbOpa(globalCtx, limb->child, skeleton, jointTable, overrideLimbDraw, postLimbDraw, actor);
     }
 
-    SysMatrix_StatePop();
+    Matrix_StatePop();
 
-    if (limbEntry->nextLimbIndex != LIMB_DONE) {
-        SkelAnime_DrawLimb(globalCtx, limbEntry->nextLimbIndex, skeleton, limbDrawTable, overrideLimbDraw, postLimbDraw,
-                           actor);
+    if (limb->sibling != LIMB_DONE) {
+        SkelAnime_DrawLimbOpa(globalCtx, limb->sibling, skeleton, jointTable, overrideLimbDraw, postLimbDraw, actor);
     }
+
+    CLOSE_DISPS(globalCtx->state.gfxCtx);
 }
 
-void SkelAnime_Draw(GlobalContext* globalCtx, void** skeleton, Vec3s* limbDrawTable, OverrideLimbDraw overrideLimbDraw,
-                    PostLimbDraw postLimbDraw, Actor* actor) {
+/**
+ * Draw all limbs of type `StandardLimb` in a given skeleton to the polyOpa buffer
+ */
+void SkelAnime_DrawOpa(GlobalContext* globalCtx, void** skeleton, Vec3s* jointTable,
+                       OverrideLimbDrawOpa overrideLimbDraw, PostLimbDrawOpa postLimbDraw, Actor* actor) {
     StandardLimb* rootLimb;
     s32 pad;
     Gfx* dList;
     Vec3f pos;
     Vec3s rot;
-    GraphicsContext* gfxCtx;
-    s32 pad2;
 
     if (skeleton == NULL) {
         return;
     }
 
-    gfxCtx = globalCtx->state.gfxCtx;
+    OPEN_DISPS(globalCtx->state.gfxCtx);
 
-    SysMatrix_StatePush();
-    rootLimb = (StandardLimb*)Lib_SegmentedToVirtual(skeleton[0]);
+    Matrix_StatePush();
+    rootLimb = Lib_SegmentedToVirtual(skeleton[0]);
 
-    pos.x = limbDrawTable[0].x;
-    pos.y = limbDrawTable[0].y;
-    pos.z = limbDrawTable[0].z;
+    pos.x = jointTable[0].x;
+    pos.y = jointTable[0].y;
+    pos.z = jointTable[0].z;
 
-    rot = limbDrawTable[1];
-    dList = rootLimb->displayLists[0];
+    rot = jointTable[1];
+    dList = rootLimb->dList;
 
-    if ((overrideLimbDraw == NULL) || (overrideLimbDraw(globalCtx, 1, &dList, &pos, &rot, actor) == 0)) {
-        SysMatrix_RotateAndTranslateState(&pos, &rot);
+    if ((overrideLimbDraw == NULL) || !overrideLimbDraw(globalCtx, 1, &dList, &pos, &rot, actor)) {
+        Matrix_JointPosition(&pos, &rot);
         if (dList != NULL) {
-            Gfx* polyTemp = gfxCtx->polyOpa.p;
+            Gfx* polyTemp = POLY_OPA_DISP;
 
-            gSPMatrix(polyTemp, Matrix_NewMtx(globalCtx->state.gfxCtx), G_MTX_LOAD);
-            gSPDisplayList(polyTemp + 1, dList);
-            gfxCtx->polyOpa.p = polyTemp + 2;
+            gSPMatrix(&polyTemp[0], Matrix_NewMtx(globalCtx->state.gfxCtx), G_MTX_LOAD);
+            gSPDisplayList(&polyTemp[1], dList);
+            POLY_OPA_DISP = &polyTemp[2];
         }
     }
 
@@ -346,318 +343,333 @@ void SkelAnime_Draw(GlobalContext* globalCtx, void** skeleton, Vec3s* limbDrawTa
         postLimbDraw(globalCtx, 1, &dList, &rot, actor);
     }
 
-    if (rootLimb->firstChildIndex != LIMB_DONE) {
-        SkelAnime_DrawLimb(globalCtx, rootLimb->firstChildIndex, skeleton, limbDrawTable, overrideLimbDraw,
-                           postLimbDraw, actor);
+    if (rootLimb->child != LIMB_DONE) {
+        SkelAnime_DrawLimbOpa(globalCtx, rootLimb->child, skeleton, jointTable, overrideLimbDraw, postLimbDraw, actor);
     }
 
-    SysMatrix_StatePop();
+    Matrix_StatePop();
+
+    CLOSE_DISPS(globalCtx->state.gfxCtx);
 }
 
-void SkelAnime_DrawLimbSV(GlobalContext* globalCtx, s32 limbIndex, void** skeleton, Vec3s* limbDrawTable,
-                          OverrideLimbDraw overrideLimbDraw, PostLimbDraw postLimbDraw, Actor* actor,
-                          RSPMatrix** limbMatricies) {
-    StandardLimb* limbEntry;
-    Gfx* dList[2];
+void SkelAnime_DrawFlexLimbOpa(GlobalContext* globalCtx, s32 limbIndex, void** skeleton, Vec3s* jointTable,
+                               OverrideLimbDrawOpa overrideLimbDraw, PostLimbDrawOpa postLimbDraw, Actor* actor,
+                               Mtx** limbMatricies) {
+    StandardLimb* limb;
+    Gfx* newDList;
+    Gfx* limbDList;
     Vec3f pos;
     Vec3s rot;
-    GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    s32 pad;
 
-    SysMatrix_StatePush();
+    OPEN_DISPS(globalCtx->state.gfxCtx);
+
+    Matrix_StatePush();
 
-    limbEntry = (StandardLimb*)Lib_SegmentedToVirtual(skeleton[limbIndex]);
+    limb = Lib_SegmentedToVirtual(skeleton[limbIndex]);
     limbIndex++;
-    rot = limbDrawTable[limbIndex];
+    rot = jointTable[limbIndex];
 
-    pos.x = limbEntry->translation.x;
-    pos.y = limbEntry->translation.y;
-    pos.z = limbEntry->translation.z;
+    pos.x = limb->jointPos.x;
+    pos.y = limb->jointPos.y;
+    pos.z = limb->jointPos.z;
 
-    dList[0] = limbEntry->displayLists[0];
-    dList[1] = dList[0];
+    newDList = limbDList = limb->dList;
 
-    if ((overrideLimbDraw == NULL) || (overrideLimbDraw(globalCtx, limbIndex, &dList[1], &pos, &rot, actor) == 0)) {
-        SysMatrix_RotateAndTranslateState(&pos, &rot);
-        if (dList[1] != NULL) {
-            SysMatrix_GetStateAsRSPMatrix(*limbMatricies);
-            gSPMatrix(gfxCtx->polyOpa.p++, *limbMatricies, G_MTX_LOAD);
-            gSPDisplayList(gfxCtx->polyOpa.p++, dList[1]);
+    if ((overrideLimbDraw == NULL) || !overrideLimbDraw(globalCtx, limbIndex, &newDList, &pos, &rot, actor)) {
+        Matrix_JointPosition(&pos, &rot);
+        if (newDList != NULL) {
+            Matrix_ToMtx(*limbMatricies);
+            gSPMatrix(POLY_OPA_DISP++, *limbMatricies, G_MTX_LOAD);
+            gSPDisplayList(POLY_OPA_DISP++, newDList);
             (*limbMatricies)++;
-        } else if (dList[0] != NULL) {
-            SysMatrix_GetStateAsRSPMatrix(*limbMatricies);
+        } else if (limbDList != NULL) {
+            Matrix_ToMtx(*limbMatricies);
             (*limbMatricies)++;
         }
     }
 
     if (postLimbDraw != NULL) {
-        postLimbDraw(globalCtx, limbIndex, &dList[0], &rot, actor);
+        postLimbDraw(globalCtx, limbIndex, &limbDList, &rot, actor);
     }
 
-    if (limbEntry->firstChildIndex != LIMB_DONE) {
-        SkelAnime_DrawLimbSV(globalCtx, limbEntry->firstChildIndex, skeleton, limbDrawTable, overrideLimbDraw,
-                             postLimbDraw, actor, limbMatricies);
+    if (limb->child != LIMB_DONE) {
+        SkelAnime_DrawFlexLimbOpa(globalCtx, limb->child, skeleton, jointTable, overrideLimbDraw, postLimbDraw, actor,
+                                  limbMatricies);
     }
 
-    SysMatrix_StatePop();
+    Matrix_StatePop();
 
-    if (limbEntry->nextLimbIndex != LIMB_DONE) {
-        SkelAnime_DrawLimbSV(globalCtx, limbEntry->nextLimbIndex, skeleton, limbDrawTable, overrideLimbDraw,
-                             postLimbDraw, actor, limbMatricies);
+    if (limb->sibling != LIMB_DONE) {
+        SkelAnime_DrawFlexLimbOpa(globalCtx, limb->sibling, skeleton, jointTable, overrideLimbDraw, postLimbDraw, actor,
+                                  limbMatricies);
     }
+
+    CLOSE_DISPS(globalCtx->state.gfxCtx);
 }
 
-void SkelAnime_DrawSV(GlobalContext* globalCtx, void** skeleton, Vec3s* limbDrawTable, s32 dListCount,
-                      OverrideLimbDraw overrideLimbDraw, PostLimbDraw postLimbDraw, Actor* actor) {
-    StandardLimb* limbEntry;
+/**
+ * Draw all limbs of type `StandardLimb` in a given flexible skeleton to the polyOpa buffer
+ * Limbs in a flexible skeleton have meshes that can stretch to line up with other limbs.
+ * An array of matrices is dynamically allocated so each limb can access any transform to ensure its meshes line up.
+ */
+void SkelAnime_DrawFlexOpa(GlobalContext* globalCtx, void** skeleton, Vec3s* jointTable, s32 dListCount,
+                           OverrideLimbDrawOpa overrideLimbDraw, PostLimbDrawOpa postLimbDraw, Actor* actor) {
+    StandardLimb* rootLimb;
     s32 pad;
-    Gfx* dList[2];
+    Gfx* newDList;
+    Gfx* limbDList;
     Vec3f pos;
     Vec3s rot;
-    RSPMatrix* mtx;
-    GraphicsContext* gfxCtx;
-    s32 pad2;
-
-    mtx = (RSPMatrix*)GRAPH_ALLOC(globalCtx->state.gfxCtx, ALIGN16(sizeof(RSPMatrix) * dListCount));
+    Mtx* mtx = (Mtx*)GRAPH_ALLOC(globalCtx->state.gfxCtx, ALIGN16(sizeof(Mtx) * dListCount));
 
     if (skeleton == NULL) {
         return;
     }
 
-    gfxCtx = globalCtx->state.gfxCtx;
+    OPEN_DISPS(globalCtx->state.gfxCtx);
 
-    gSPSegment(gfxCtx->polyOpa.p++, 0xD, mtx);
+    gSPSegment(POLY_OPA_DISP++, 0xD, mtx);
 
-    SysMatrix_StatePush();
+    Matrix_StatePush();
 
-    limbEntry = (StandardLimb*)Lib_SegmentedToVirtual(skeleton[0]);
+    rootLimb = Lib_SegmentedToVirtual(skeleton[0]);
 
-    pos.x = limbDrawTable[0].x;
-    pos.y = limbDrawTable[0].y;
-    pos.z = limbDrawTable[0].z;
-    rot = limbDrawTable[1];
+    pos.x = jointTable[0].x;
+    pos.y = jointTable[0].y;
+    pos.z = jointTable[0].z;
+    rot = jointTable[1];
 
-    dList[0] = limbEntry->displayLists[0];
-    dList[1] = dList[0];
+    newDList = limbDList = rootLimb->dList;
 
-    if ((overrideLimbDraw == NULL) || (overrideLimbDraw(globalCtx, 1, &dList[1], &pos, &rot, actor) == 0)) {
-        SysMatrix_RotateAndTranslateState(&pos, &rot);
-        if (dList[1] != NULL) {
-            Gfx* polyTemp = gfxCtx->polyOpa.p;
+    if ((overrideLimbDraw == NULL) || !overrideLimbDraw(globalCtx, 1, &newDList, &pos, &rot, actor)) {
+        Matrix_JointPosition(&pos, &rot);
+        if (newDList != NULL) {
+            Gfx* polyTemp = POLY_OPA_DISP;
 
-            gSPMatrix(polyTemp, SysMatrix_GetStateAsRSPMatrix(mtx), G_MTX_LOAD);
-            gSPDisplayList(polyTemp + 1, dList[1]);
-            gfxCtx->polyOpa.p = polyTemp + 2;
+            gSPMatrix(&polyTemp[0], Matrix_ToMtx(mtx), G_MTX_LOAD);
+            gSPDisplayList(&polyTemp[1], newDList);
+            POLY_OPA_DISP = &polyTemp[2];
             mtx++;
         } else {
-            if (dList[0] != NULL) {
-                SysMatrix_GetStateAsRSPMatrix(mtx);
+            if (limbDList != NULL) {
+                Matrix_ToMtx(mtx);
                 mtx++;
             }
         }
     }
 
     if (postLimbDraw != NULL) {
-        postLimbDraw(globalCtx, 1, &dList[0], &rot, actor);
+        postLimbDraw(globalCtx, 1, &limbDList, &rot, actor);
     }
 
-    if (limbEntry->firstChildIndex != LIMB_DONE) {
-        SkelAnime_DrawLimbSV(globalCtx, limbEntry->firstChildIndex, skeleton, limbDrawTable, overrideLimbDraw,
-                             postLimbDraw, actor, &mtx);
+    if (rootLimb->child != LIMB_DONE) {
+        SkelAnime_DrawFlexLimbOpa(globalCtx, rootLimb->child, skeleton, jointTable, overrideLimbDraw, postLimbDraw,
+                                  actor, &mtx);
     }
 
-    SysMatrix_StatePop();
+    Matrix_StatePop();
+
+    CLOSE_DISPS(globalCtx->state.gfxCtx);
 }
 
-void func_80134148(GlobalContext* globalCtx, s32 limbIndex, void** skeleton, Vec3s* limbDrawTable,
-                   OverrideLimbDraw overrideLimbDraw, PostLimbDraw postLimbDraw, UnkActorDraw unkDraw, Actor* actor,
-                   RSPMatrix** mtx) {
-    StandardLimb* limbEntry;
-    Gfx* dList[2];
+void func_80134148(GlobalContext* globalCtx, s32 limbIndex, void** skeleton, Vec3s* jointTable,
+                   OverrideLimbDrawOpa overrideLimbDraw, PostLimbDrawOpa postLimbDraw, UnkActorDraw unkDraw,
+                   Actor* actor, Mtx** mtx) {
+    StandardLimb* limb;
+    Gfx* newDList;
+    Gfx* limbDList;
     Vec3f pos;
     Vec3s rot;
-    GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    s32 pad2;
 
-    SysMatrix_StatePush();
+    OPEN_DISPS(globalCtx->state.gfxCtx);
 
-    limbEntry = (StandardLimb*)Lib_SegmentedToVirtual(skeleton[limbIndex]);
+    Matrix_StatePush();
+
+    limb = (StandardLimb*)Lib_SegmentedToVirtual(skeleton[limbIndex]);
     limbIndex++;
 
-    rot = limbDrawTable[limbIndex];
-    pos.x = limbEntry->translation.x;
-    pos.y = limbEntry->translation.y;
-    pos.z = limbEntry->translation.z;
+    rot = jointTable[limbIndex];
+    pos.x = limb->jointPos.x;
+    pos.y = limb->jointPos.y;
+    pos.z = limb->jointPos.z;
+
+    newDList = limbDList = limb->dList;
 
-    dList[0] = limbEntry->displayLists[0];
-    dList[1] = dList[0];
+    if ((overrideLimbDraw == NULL) || !overrideLimbDraw(globalCtx, limbIndex, &newDList, &pos, &rot, actor)) {
+        Matrix_JointPosition(&pos, &rot);
+        Matrix_StatePush();
 
-    if ((overrideLimbDraw == NULL) || (overrideLimbDraw(globalCtx, limbIndex, &dList[1], &pos, &rot, actor) == 0)) {
-        SysMatrix_RotateAndTranslateState(&pos, &rot);
-        SysMatrix_StatePush();
+        //! @bug Does not check unkDraw is not NULL before calling it.
         unkDraw(globalCtx, limbIndex, actor);
-        if (dList[1] != NULL) {
-            Gfx* polyTemp = gfxCtx->polyOpa.p;
+        if (newDList != NULL) {
+            Gfx* polyTemp = POLY_OPA_DISP;
 
-            gSPMatrix(polyTemp, SysMatrix_GetStateAsRSPMatrix(*mtx), G_MTX_LOAD);
-            gSPDisplayList(polyTemp + 1, dList[1]);
-            gfxCtx->polyOpa.p = polyTemp + 2;
+            gSPMatrix(&polyTemp[0], Matrix_ToMtx(*mtx), G_MTX_LOAD);
+            gSPDisplayList(&polyTemp[1], newDList);
+            POLY_OPA_DISP = &polyTemp[2];
             (*mtx)++;
         } else {
-            if (dList[0] != NULL) {
-                SysMatrix_GetStateAsRSPMatrix(*mtx);
+            if (limbDList != NULL) {
+                Matrix_ToMtx(*mtx);
                 (*mtx)++;
             }
         }
-        SysMatrix_StatePop();
+        Matrix_StatePop();
     }
 
     if (postLimbDraw != NULL) {
-        postLimbDraw(globalCtx, limbIndex, &dList[0], &rot, actor);
+        postLimbDraw(globalCtx, limbIndex, &limbDList, &rot, actor);
     }
 
-    if (limbEntry->firstChildIndex != LIMB_DONE) {
-        func_80134148(globalCtx, limbEntry->firstChildIndex, skeleton, limbDrawTable, overrideLimbDraw, postLimbDraw,
-                      unkDraw, actor, mtx);
+    if (limb->child != LIMB_DONE) {
+        func_80134148(globalCtx, limb->child, skeleton, jointTable, overrideLimbDraw, postLimbDraw, unkDraw, actor,
+                      mtx);
     }
 
-    SysMatrix_StatePop();
+    Matrix_StatePop();
 
-    if (limbEntry->nextLimbIndex != LIMB_DONE) {
-        func_80134148(globalCtx, limbEntry->nextLimbIndex, skeleton, limbDrawTable, overrideLimbDraw, postLimbDraw,
-                      unkDraw, actor, mtx);
+    if (limb->sibling != LIMB_DONE) {
+        func_80134148(globalCtx, limb->sibling, skeleton, jointTable, overrideLimbDraw, postLimbDraw, unkDraw, actor,
+                      mtx);
     }
+
+    CLOSE_DISPS(globalCtx->state.gfxCtx);
 }
 
-void func_801343C0(GlobalContext* globalCtx, void** skeleton, Vec3s* limbDrawTable, s32 dListCount,
-                   OverrideLimbDraw overrideLimbDraw, PostLimbDraw postLimbDraw, UnkActorDraw unkDraw, Actor* actor) {
-    StandardLimb* limbEntry;
+void func_801343C0(GlobalContext* globalCtx, void** skeleton, Vec3s* jointTable, s32 dListCount,
+                   OverrideLimbDrawOpa overrideLimbDraw, PostLimbDrawOpa postLimbDraw, UnkActorDraw unkDraw,
+                   Actor* actor) {
+    StandardLimb* rootLimb;
     s32 pad;
-    Gfx* dList[2];
+    Gfx* newDList;
+    Gfx* limbDList;
     Vec3f pos;
     Vec3s rot;
-    RSPMatrix* mtx;
-    GraphicsContext* gfxCtx;
-    s32 pad2;
+    Mtx* mtx;
 
     if (skeleton == NULL) {
         return;
     }
 
-    gfxCtx = globalCtx->state.gfxCtx;
+    OPEN_DISPS(globalCtx->state.gfxCtx);
 
-    mtx = (RSPMatrix*)GRAPH_ALLOC(globalCtx->state.gfxCtx, ALIGN16(sizeof(RSPMatrix) * dListCount));
+    mtx = (Mtx*)GRAPH_ALLOC(globalCtx->state.gfxCtx, ALIGN16(sizeof(Mtx) * dListCount));
 
-    gSPSegment(gfxCtx->polyOpa.p++, 0xD, mtx);
+    gSPSegment(POLY_OPA_DISP++, 0xD, mtx);
 
-    SysMatrix_StatePush();
+    Matrix_StatePush();
+
+    rootLimb = (StandardLimb*)Lib_SegmentedToVirtual(skeleton[0]);
 
-    limbEntry = (StandardLimb*)Lib_SegmentedToVirtual(skeleton[0]);
+    pos.x = jointTable[0].x;
+    pos.y = jointTable[0].y;
+    pos.z = jointTable[0].z;
+    rot = jointTable[1];
 
-    pos.x = limbDrawTable[0].x;
-    pos.y = limbDrawTable[0].y;
-    pos.z = limbDrawTable[0].z;
-    rot = limbDrawTable[1];
+    newDList = limbDList = rootLimb->dList;
 
-    dList[0] = limbEntry->displayLists[0];
-    dList[1] = dList[0];
+    if ((overrideLimbDraw == NULL) || !overrideLimbDraw(globalCtx, 1, &newDList, &pos, &rot, actor)) {
+        Matrix_JointPosition(&pos, &rot);
+        Matrix_StatePush();
 
-    if ((overrideLimbDraw == NULL) || (overrideLimbDraw(globalCtx, 1, &dList[1], &pos, &rot, actor) == 0)) {
-        SysMatrix_RotateAndTranslateState(&pos, &rot);
-        SysMatrix_StatePush();
+        //! @bug Does not check unkDraw is not NULL before calling it.
         unkDraw(globalCtx, 1, actor);
-        if (dList[1] != NULL) {
-            Gfx* polyTemp = gfxCtx->polyOpa.p;
 
-            gSPMatrix(polyTemp, SysMatrix_GetStateAsRSPMatrix(mtx), G_MTX_LOAD);
-            gSPDisplayList(polyTemp + 1, dList[1]);
-            gfxCtx->polyOpa.p = polyTemp + 2;
+        if (newDList != NULL) {
+            Gfx* polyTemp = POLY_OPA_DISP;
+
+            gSPMatrix(&polyTemp[0], Matrix_ToMtx(mtx), G_MTX_LOAD);
+            gSPDisplayList(&polyTemp[1], newDList);
+            POLY_OPA_DISP = &polyTemp[2];
             mtx++;
         } else {
-            if (dList[0] != NULL) {
-                SysMatrix_GetStateAsRSPMatrix(mtx++);
+            if (limbDList != NULL) {
+                Matrix_ToMtx(mtx++);
             }
         }
-        SysMatrix_StatePop();
+        Matrix_StatePop();
     }
 
     if (postLimbDraw != NULL) {
-        postLimbDraw(globalCtx, 1, &dList[0], &rot, actor);
+        postLimbDraw(globalCtx, 1, &limbDList, &rot, actor);
     }
 
-    if (limbEntry->firstChildIndex != LIMB_DONE) {
-        func_80134148(globalCtx, limbEntry->firstChildIndex, skeleton, limbDrawTable, overrideLimbDraw, postLimbDraw,
-                      unkDraw, actor, &mtx);
+    if (rootLimb->child != LIMB_DONE) {
+        func_80134148(globalCtx, rootLimb->child, skeleton, jointTable, overrideLimbDraw, postLimbDraw, unkDraw, actor,
+                      &mtx);
     }
 
-    SysMatrix_StatePop();
+    Matrix_StatePop();
+
+    CLOSE_DISPS(globalCtx->state.gfxCtx);
 }
 
-/*
- * Copies the rotation values from the rotation value table, indexed by the rotation index table
- * When a rotation index is >= the animation limit, the output rotation value is copied from the frame's
- * rotation value list, otherwise it is copied from the initial rotation value list
- */
-void SkelAnime_AnimateFrame(AnimationHeader* animationSeg, s32 currentFrame, s32 limbCount, Vec3s* dst) {
-    AnimationHeader* animationHeader = Lib_SegmentedToVirtual(animationSeg);
-    JointIndex* index = Lib_SegmentedToVirtual(animationHeader->jointIndices);
-    AnimationRotationValue* rotationValueTable = Lib_SegmentedToVirtual(animationHeader->frameData);
-    AnimationRotationValue* frameRotationValueTable = &rotationValueTable[currentFrame];
+/**
+ * Copies frame data from the frame data table, indexed by the joint index table.
+ * Indices below staticIndexMax are copied from that entry in the static frame data table.
+ * Indices above staticIndexMax are offsets to a frame data array indexed by the frame.
+ */
+void SkelAnime_GetFrameData(AnimationHeader* animation, s32 frame, s32 limbCount, Vec3s* frameTable) {
+    AnimationHeader* animHeader = Lib_SegmentedToVirtual(animation);
+    JointIndex* jointIndices = Lib_SegmentedToVirtual(animHeader->jointIndices);
+    s16* frameData = Lib_SegmentedToVirtual(animHeader->frameData);
+    s16* dynamicData = &frameData[frame];
     s32 i;
-    u16 limit = animationHeader->staticIndexMax;
+    u16 staticIndexMax = animHeader->staticIndexMax;
 
     for (i = 0; i < limbCount; i++) {
         // Debug prints here, this is needed to prevent loop unrolling
         if (0) {
             if (0) {};
         }
-        dst->x = index->x >= limit ? frameRotationValueTable[index->x] : rotationValueTable[index->x];
-        dst->y = index->y >= limit ? frameRotationValueTable[index->y] : rotationValueTable[index->y];
-        dst->z = index->z >= limit ? frameRotationValueTable[index->z] : rotationValueTable[index->z];
-        index++, dst++;
+        frameTable->x = jointIndices->x >= staticIndexMax ? dynamicData[jointIndices->x] : frameData[jointIndices->x];
+        frameTable->y = jointIndices->y >= staticIndexMax ? dynamicData[jointIndices->y] : frameData[jointIndices->y];
+        frameTable->z = jointIndices->z >= staticIndexMax ? dynamicData[jointIndices->z] : frameData[jointIndices->z];
+        jointIndices++, frameTable++;
     }
 }
 
-s16 SkelAnime_GetTotalFrames(AnimationHeaderCommon* animationSeg) {
-    AnimationHeaderCommon* animation = Lib_SegmentedToVirtual(animationSeg);
-    return animation->frameCount;
+s16 Animation_GetLength(void* animation) {
+    AnimationHeaderCommon* common = Lib_SegmentedToVirtual(animation);
+
+    return common->frameCount;
 }
 
-s16 SkelAnime_GetFrameCount(AnimationHeaderCommon* animationSeg) {
-    AnimationHeaderCommon* animation = Lib_SegmentedToVirtual(animationSeg);
+s16 Animation_GetLastFrame(void* animation) {
+    AnimationHeaderCommon* common = Lib_SegmentedToVirtual(animation);
 
-    return (u16)animation->frameCount - 1;
+    return (u16)common->frameCount - 1;
 }
 
 /*
  * Draws the Skeleton `skeleton`'s limb at index `limbIndex`.  Appends all generated graphics commands to
  * `gfx`.  Returns a pointer to the next gfx to be appended to.
  */
-Gfx* SkelAnime_Draw2Limb(GlobalContext* globalCtx, s32 limbIndex, void** skeleton, Vec3s* limbDrawTable,
-                         OverrideLimbDraw2 overrideLimbDraw, PostLimbDraw2 postLimbDraw, Actor* actor, Gfx* gfx) {
-    StandardLimb* limbEntry;
+Gfx* SkelAnime_DrawLimb(GlobalContext* globalCtx, s32 limbIndex, void** skeleton, Vec3s* jointTable,
+                        OverrideLimbDraw overrideLimbDraw, PostLimbDraw postLimbDraw, Actor* actor, Gfx* gfx) {
+    StandardLimb* limb;
     Gfx* dList;
     Vec3f pos;
     Vec3s rot;
 
-    SysMatrix_StatePush();
+    Matrix_StatePush();
 
-    limbEntry = (StandardLimb*)Lib_SegmentedToVirtual(skeleton[limbIndex]);
+    limb = (StandardLimb*)Lib_SegmentedToVirtual(skeleton[limbIndex]);
     limbIndex++;
 
-    rot = limbDrawTable[limbIndex];
-    pos.x = limbEntry->translation.x;
-    pos.y = limbEntry->translation.y;
-    pos.z = limbEntry->translation.z;
+    rot = jointTable[limbIndex];
+    pos.x = limb->jointPos.x;
+    pos.y = limb->jointPos.y;
+    pos.z = limb->jointPos.z;
 
-    dList = limbEntry->displayLists[0];
+    dList = limb->dList;
 
-    if ((overrideLimbDraw == NULL) || (overrideLimbDraw(globalCtx, limbIndex, &dList, &pos, &rot, actor, &gfx) == 0)) {
-        SysMatrix_RotateAndTranslateState(&pos, &rot);
+    if ((overrideLimbDraw == NULL) || !overrideLimbDraw(globalCtx, limbIndex, &dList, &pos, &rot, actor, &gfx)) {
+        Matrix_JointPosition(&pos, &rot);
         if (dList != NULL) {
-            gSPMatrix(gfx, Matrix_NewMtx(globalCtx->state.gfxCtx), G_MTX_LOAD);
-            gSPDisplayList(gfx + 1, dList);
-            gfx = gfx + 2;
+            gSPMatrix(&gfx[0], Matrix_NewMtx(globalCtx->state.gfxCtx), G_MTX_LOAD);
+            gSPDisplayList(&gfx[1], dList);
+            gfx = &gfx[2];
         }
     }
 
@@ -665,16 +677,16 @@ Gfx* SkelAnime_Draw2Limb(GlobalContext* globalCtx, s32 limbIndex, void** skeleto
         postLimbDraw(globalCtx, limbIndex, &dList, &rot, actor, &gfx);
     }
 
-    if (limbEntry->firstChildIndex != LIMB_DONE) {
-        gfx = SkelAnime_Draw2Limb(globalCtx, limbEntry->firstChildIndex, skeleton, limbDrawTable, overrideLimbDraw,
-                                  postLimbDraw, actor, gfx);
+    if (limb->child != LIMB_DONE) {
+        gfx = SkelAnime_DrawLimb(globalCtx, limb->child, skeleton, jointTable, overrideLimbDraw, postLimbDraw, actor,
+                                 gfx);
     }
 
-    SysMatrix_StatePop();
+    Matrix_StatePop();
 
-    if (limbEntry->nextLimbIndex != LIMB_DONE) {
-        gfx = SkelAnime_Draw2Limb(globalCtx, limbEntry->nextLimbIndex, skeleton, limbDrawTable, overrideLimbDraw,
-                                  postLimbDraw, actor, gfx);
+    if (limb->sibling != LIMB_DONE) {
+        gfx = SkelAnime_DrawLimb(globalCtx, limb->sibling, skeleton, jointTable, overrideLimbDraw, postLimbDraw, actor,
+                                 gfx);
     }
 
     return gfx;
@@ -684,9 +696,9 @@ Gfx* SkelAnime_Draw2Limb(GlobalContext* globalCtx, s32 limbIndex, void** skeleto
  * Draws the Skeleton `skeleton`  Appends all generated graphics to `gfx`, and returns a pointer to the
  * next gfx to be appended to.
  */
-Gfx* SkelAnime_Draw2(GlobalContext* globalCtx, void** skeleton, Vec3s* limbDrawTable,
-                     OverrideLimbDraw2 overrideLimbDraw, PostLimbDraw2 postLimbDraw, Actor* actor, Gfx* gfx) {
-    StandardLimb* limbEntry;
+Gfx* SkelAnime_Draw(GlobalContext* globalCtx, void** skeleton, Vec3s* jointTable, OverrideLimbDraw overrideLimbDraw,
+                    PostLimbDraw postLimbDraw, Actor* actor, Gfx* gfx) {
+    StandardLimb* rootLimb;
     s32 pad;
     Gfx* dList;
     Vec3f pos;
@@ -696,23 +708,24 @@ Gfx* SkelAnime_Draw2(GlobalContext* globalCtx, void** skeleton, Vec3s* limbDrawT
         return NULL;
     }
 
-    SysMatrix_StatePush();
+    Matrix_StatePush();
+
+    rootLimb = (StandardLimb*)Lib_SegmentedToVirtual(skeleton[0]);
 
-    limbEntry = (StandardLimb*)Lib_SegmentedToVirtual(skeleton[0]);
+    pos.x = jointTable[0].x;
+    pos.y = jointTable[0].y;
+    pos.z = jointTable[0].z;
 
-    pos.x = limbDrawTable[0].x;
-    pos.y = limbDrawTable[0].y;
-    pos.z = limbDrawTable[0].z;
-    rot = limbDrawTable[1];
+    rot = jointTable[1];
 
-    dList = limbEntry->displayLists[0];
+    dList = rootLimb->dList;
 
-    if ((overrideLimbDraw == NULL) || (overrideLimbDraw(globalCtx, 1, &dList, &pos, &rot, actor, &gfx) == 0)) {
-        SysMatrix_RotateAndTranslateState(&pos, &rot);
+    if ((overrideLimbDraw == NULL) || !overrideLimbDraw(globalCtx, 1, &dList, &pos, &rot, actor, &gfx)) {
+        Matrix_JointPosition(&pos, &rot);
         if (dList != NULL) {
-            gSPMatrix(gfx, Matrix_NewMtx(globalCtx->state.gfxCtx), G_MTX_LOAD);
-            gSPDisplayList(gfx + 1, dList);
-            gfx = gfx + 2;
+            gSPMatrix(&gfx[0], Matrix_NewMtx(globalCtx->state.gfxCtx), G_MTX_LOAD);
+            gSPDisplayList(&gfx[1], dList);
+            gfx = &gfx[2];
         }
     }
 
@@ -720,202 +733,285 @@ Gfx* SkelAnime_Draw2(GlobalContext* globalCtx, void** skeleton, Vec3s* limbDrawT
         postLimbDraw(globalCtx, 1, &dList, &rot, actor, &gfx);
     }
 
-    if (limbEntry->firstChildIndex != LIMB_DONE) {
-        gfx = SkelAnime_Draw2Limb(globalCtx, limbEntry->firstChildIndex, skeleton, limbDrawTable, overrideLimbDraw,
-                                  postLimbDraw, actor, gfx);
+    if (rootLimb->child != LIMB_DONE) {
+        gfx = SkelAnime_DrawLimb(globalCtx, rootLimb->child, skeleton, jointTable, overrideLimbDraw, postLimbDraw,
+                                 actor, gfx);
     }
 
-    SysMatrix_StatePop();
+    Matrix_StatePop();
 
     return gfx;
 }
 
-/*
- * Draws the Skeleton `skeleton`  Appends all generated graphics to `gfx`, and returns a pointer to the
- * next gfx to be appended to.  Allocates matricies for display lists on the graph heap.
- */
-Gfx* SkelAnime_DrawLimbSV2(GlobalContext* globalCtx, s32 limbIndex, void** skeleton, Vec3s* limbDrawTable,
-                           OverrideLimbDraw2 overrideLimbDraw, PostLimbDraw2 postLimbDraw, Actor* actor,
-                           RSPMatrix** mtx, Gfx* gfx) {
-    StandardLimb* limbEntry;
-    Gfx* dList1;
-    Gfx* dList2;
+/**
+ * Draw a limb of type `StandardLimb` contained within a flexible skeleton to the specified display buffer
+ */
+Gfx* SkelAnime_DrawFlexLimb(GlobalContext* globalCtx, s32 limbIndex, void** skeleton, Vec3s* jointTable,
+                            OverrideLimbDraw overrideLimbDraw, PostLimbDraw postLimbDraw, Actor* actor, Mtx** mtx,
+                            Gfx* gfx) {
+    StandardLimb* limb;
+    Gfx* newDList;
+    Gfx* limbDList;
     Vec3f pos;
     Vec3s rot;
 
-    SysMatrix_StatePush();
+    Matrix_StatePush();
 
-    limbEntry = (StandardLimb*)Lib_SegmentedToVirtual(skeleton[limbIndex]);
+    limb = (StandardLimb*)Lib_SegmentedToVirtual(skeleton[limbIndex]);
     limbIndex++;
-    rot = limbDrawTable[limbIndex];
+    rot = jointTable[limbIndex];
 
-    pos.x = limbEntry->translation.x;
-    pos.y = limbEntry->translation.y;
-    pos.z = limbEntry->translation.z;
+    pos.x = limb->jointPos.x;
+    pos.y = limb->jointPos.y;
+    pos.z = limb->jointPos.z;
 
-    dList1 = dList2 = limbEntry->displayLists[0];
+    newDList = limbDList = limb->dList;
 
-    if ((overrideLimbDraw == NULL) || (overrideLimbDraw(globalCtx, limbIndex, &dList1, &pos, &rot, actor, &gfx) == 0)) {
-        SysMatrix_RotateAndTranslateState(&pos, &rot);
-        if (dList1 != NULL) {
-            gSPMatrix(gfx, SysMatrix_GetStateAsRSPMatrix(*mtx), G_MTX_LOAD);
-            gSPDisplayList(gfx + 1, dList1);
-            gfx = gfx + 2;
+    if ((overrideLimbDraw == NULL) || !overrideLimbDraw(globalCtx, limbIndex, &newDList, &pos, &rot, actor, &gfx)) {
+        Matrix_JointPosition(&pos, &rot);
+        if (newDList != NULL) {
+            gSPMatrix(&gfx[0], Matrix_ToMtx(*mtx), G_MTX_LOAD);
+            gSPDisplayList(&gfx[1], newDList);
+            gfx = &gfx[2];
             (*mtx)++;
         } else {
-            if (dList2 != NULL) {
-                SysMatrix_GetStateAsRSPMatrix(*mtx);
+            if (limbDList != NULL) {
+                Matrix_ToMtx(*mtx);
                 (*mtx)++;
             }
         }
     }
 
     if (postLimbDraw != NULL) {
-        postLimbDraw(globalCtx, limbIndex, &dList2, &rot, actor, &gfx);
+        postLimbDraw(globalCtx, limbIndex, &limbDList, &rot, actor, &gfx);
     }
 
-    if (limbEntry->firstChildIndex != LIMB_DONE) {
-        gfx = SkelAnime_DrawLimbSV2(globalCtx, limbEntry->firstChildIndex, skeleton, limbDrawTable, overrideLimbDraw,
-                                    postLimbDraw, actor, mtx, gfx);
+    if (limb->child != LIMB_DONE) {
+        gfx = SkelAnime_DrawFlexLimb(globalCtx, limb->child, skeleton, jointTable, overrideLimbDraw, postLimbDraw,
+                                     actor, mtx, gfx);
     }
 
-    SysMatrix_StatePop();
+    Matrix_StatePop();
 
-    if (limbEntry->nextLimbIndex != LIMB_DONE) {
-        gfx = SkelAnime_DrawLimbSV2(globalCtx, limbEntry->nextLimbIndex, skeleton, limbDrawTable, overrideLimbDraw,
-                                    postLimbDraw, actor, mtx, gfx);
+    if (limb->sibling != LIMB_DONE) {
+        gfx = SkelAnime_DrawFlexLimb(globalCtx, limb->sibling, skeleton, jointTable, overrideLimbDraw, postLimbDraw,
+                                     actor, mtx, gfx);
     }
 
     return gfx;
 }
 
-Gfx* SkelAnime_DrawSV2(GlobalContext* globalCtx, void** skeleton, Vec3s* limbDrawTable, s32 dListCount,
-                       OverrideLimbDraw2 overrideLimbDraw, PostLimbDraw2 postLimbDraw, Actor* actor, Gfx* gfx) {
-    StandardLimb* limbEntry;
+/**
+ * Draw all limbs of type `StandardLimb` in a given flexible skeleton to the specified display buffer
+ * Limbs in a flexible skeleton have meshes that can stretch to line up with other limbs.
+ * An array of matrices is dynamically allocated so each limb can access any transform to ensure its meshes line up.
+ */
+Gfx* SkelAnime_DrawFlex(GlobalContext* globalCtx, void** skeleton, Vec3s* jointTable, s32 dListCount,
+                        OverrideLimbDraw overrideLimbDraw, PostLimbDraw postLimbDraw, Actor* actor, Gfx* gfx) {
+    StandardLimb* rootLimb;
     s32 pad;
-    Gfx* dList1;
-    Gfx* dList2;
+    Gfx* newDList;
+    Gfx* limbDList;
     Vec3f pos;
     Vec3s rot;
-    RSPMatrix* mtx;
+    Mtx* mtx;
 
     if (skeleton == NULL) {
         return NULL;
     }
 
-    mtx = (RSPMatrix*)GRAPH_ALLOC(globalCtx->state.gfxCtx, ALIGN16(sizeof(RSPMatrix) * dListCount));
+    mtx = (Mtx*)GRAPH_ALLOC(globalCtx->state.gfxCtx, ALIGN16(sizeof(Mtx) * dListCount));
 
     gSPSegment(gfx++, 0xD, mtx);
 
-    SysMatrix_StatePush();
+    Matrix_StatePush();
 
-    limbEntry = (StandardLimb*)Lib_SegmentedToVirtual(skeleton[0]);
+    rootLimb = Lib_SegmentedToVirtual(skeleton[0]);
 
-    pos.x = limbDrawTable[0].x;
-    pos.y = limbDrawTable[0].y;
-    pos.z = limbDrawTable[0].z;
+    pos.x = jointTable[0].x;
+    pos.y = jointTable[0].y;
+    pos.z = jointTable[0].z;
 
-    rot = limbDrawTable[1];
+    rot = jointTable[1];
 
-    dList1 = dList2 = limbEntry->displayLists[0];
+    newDList = limbDList = rootLimb->dList;
 
-    if ((overrideLimbDraw == NULL) || (overrideLimbDraw(globalCtx, 1, &dList1, &pos, &rot, actor, &gfx) == 0)) {
-        SysMatrix_RotateAndTranslateState(&pos, &rot);
-        if (dList1 != NULL) {
-            gSPMatrix(gfx, SysMatrix_GetStateAsRSPMatrix(mtx), G_MTX_LOAD);
-            gSPDisplayList(gfx + 1, dList1);
-            gfx = gfx + 2;
+    if ((overrideLimbDraw == NULL) || !overrideLimbDraw(globalCtx, 1, &newDList, &pos, &rot, actor, &gfx)) {
+        Matrix_JointPosition(&pos, &rot);
+        if (newDList != NULL) {
+            gSPMatrix(&gfx[0], Matrix_ToMtx(mtx), G_MTX_LOAD);
+            gSPDisplayList(&gfx[1], newDList);
+            gfx = &gfx[2];
             mtx++;
         } else {
-            if (dList2 != NULL) {
-                SysMatrix_GetStateAsRSPMatrix(mtx);
+            if (limbDList != NULL) {
+                Matrix_ToMtx(mtx);
                 mtx++;
             }
         }
     }
 
     if (postLimbDraw != NULL) {
-        postLimbDraw(globalCtx, 1, &dList2, &rot, actor, &gfx);
+        postLimbDraw(globalCtx, 1, &limbDList, &rot, actor, &gfx);
     }
 
-    if (limbEntry->firstChildIndex != LIMB_DONE) {
-        gfx = SkelAnime_DrawLimbSV2(globalCtx, limbEntry->firstChildIndex, skeleton, limbDrawTable, overrideLimbDraw,
-                                    postLimbDraw, actor, &mtx, gfx);
+    if (rootLimb->child != LIMB_DONE) {
+        gfx = SkelAnime_DrawFlexLimb(globalCtx, rootLimb->child, skeleton, jointTable, overrideLimbDraw, postLimbDraw,
+                                     actor, &mtx, gfx);
     }
 
-    SysMatrix_StatePop();
+    Matrix_StatePop();
 
     return gfx;
 }
 
-// Function is unused.
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/func_80134FFC.s")
+/**
+ * Unpacks frame data for the animation at the given frame into frameTable
+ * Used by the legacy animation format
+ */
+#ifdef NON_MATCHING
+// equivalent, minor reordering
+s16 SkelAnime_GetFrameDataLegacy(LegacyAnimationHeader* animation, s32 frame, Vec3s* frameTable) {
+    LegacyAnimationHeader* animHeader = Lib_SegmentedToVirtual(animation);
+    s16 limbCount = animHeader->limbCount;
+    JointKey* key = Lib_SegmentedToVirtual(animHeader->jointKey);
+    s16* frameData = Lib_SegmentedToVirtual(animHeader->frameData);
+    s16* staticData = &frameData[0];
+    s16* dynamicData = &frameData[frame];
+    s32 i;
 
-s16 func_801353D4(AnimationHeaderCommon* animationSeg) {
-    AnimationHeaderCommon* animation = Lib_SegmentedToVirtual(animationSeg);
+    /**
+     *Equivalent to the following, but the compiler optimizes the loop in a way I can't replicate
+     */
+    /*
+         for(i = 0, frameTable++, key++; i < limbCount + 1; i++, key++, frameTable++) {
+             frameTable->x = frame < key->xMax ? dynamicData[key->x] : staticData[key->x];
+             frameTable->y = frame < key->yMax ? dynamicData[key->y] : staticData[key->y];
+             frameTable->z = frame < key->zMax ? dynamicData[key->z] : staticData[key->z];
+         }
+    */
+    frameTable->x = frame < key->xMax ? dynamicData[key->x] : staticData[key->x];
+    frameTable->y = frame < key->yMax ? dynamicData[key->y] : staticData[key->y];
+    frameTable->z = frame < key->zMax ? dynamicData[key->z] : staticData[key->z];
+
+    i = 1;
+    frameTable++;
+    key++;
+
+    if (limbCount & 1) {}
+
+    if (limbCount > 0) {
+        if (limbCount & 1) {
+            i++;
+            frameTable->x = frame < key->xMax ? dynamicData[key->x] : staticData[key->x];
+            frameTable->y = frame < key->yMax ? dynamicData[key->y] : staticData[key->y];
+            frameTable->z = frame < key->zMax ? dynamicData[key->z] : staticData[key->z];
+            key++;
+            frameTable++;
+            if (limbCount + 1 == i) {
+                goto ret;
+            }
+        }
+        do {
+            i += 2;
+            frameTable->x = frame < key->xMax ? dynamicData[key->x] : staticData[key->x];
+            frameTable->y = frame < key->yMax ? dynamicData[key->y] : staticData[key->y];
+            frameTable->z = frame < key->zMax ? dynamicData[key->z] : staticData[key->z];
+            key++;
+            frameTable++;
+            frameTable->x = frame < key->xMax ? dynamicData[key->x] : staticData[key->x];
+            frameTable->y = frame < key->yMax ? dynamicData[key->y] : staticData[key->y];
+            frameTable->z = frame < key->zMax ? dynamicData[key->z] : staticData[key->z];
+            key++;
+            frameTable++;
+        } while (i != limbCount + 1);
+    }
+
+ret:
+    return limbCount;
+}
+#else
+#pragma GLOBAL_ASM("asm/non_matchings/code/z_skelanime/SkelAnime_GetFrameData2.s")
+#endif
+
+/**
+ * Used by legacy animation format
+ */
+s16 Animation_GetLimbCount2(LegacyAnimationHeader* animation) {
+    LegacyAnimationHeader* animHeader = Lib_SegmentedToVirtual(animation);
 
-    return animation->unk02;
+    return animHeader->limbCount;
 }
 
-/*
- * Appears to be unused anywhere in the game.  Appears to be a clone of
- * SkelAnime_GetTotalFrames
+/**
+ * Used by legacy animation format
  */
-s16 SkelAnime_GetTotalFrames2(AnimationHeaderCommon* animationSeg) {
-    AnimationHeaderCommon* animation = Lib_SegmentedToVirtual(animationSeg);
+s16 Animation_GetLength2(LegacyAnimationHeader* animation) {
+    LegacyAnimationHeader* animHeader = Lib_SegmentedToVirtual(animation);
 
-    return animation->frameCount;
+    return animHeader->frameCount;
 }
 
-/*
- * Appears to be unused anywhere in the game.  Appears to be a clone of
- * SkelAnime_GetFrameCount
+/**
+ * Used by legacy animation format
  */
-s16 SkelAnime_GetFrameCount2(AnimationHeaderCommon* animationSeg) {
-    AnimationHeaderCommon* animation = Lib_SegmentedToVirtual(animationSeg);
+s16 Animation_GetLastFrame2(LegacyAnimationHeader* animation) {
+    AnimationHeaderCommon* animHeader = Lib_SegmentedToVirtual(animation);
 
-    return animation->frameCount - 1;
+    return animHeader->frameCount - 1;
 }
 
-void SkelAnime_InterpolateVec3s(s32 limbCount, Vec3s* dst, Vec3s* vec2, Vec3s* vec3, f32 unkf) {
+/**
+ * Linearly interpolates the start and tactoret frame tables with the given weight, putting the result in dst
+ */
+void SkelAnime_InterpFrameTable(s32 limbCount, Vec3s* dst, Vec3s* start, Vec3s* tactoret, f32 weight) {
     s32 i;
-    s16 dist;
-    s16 temp2;
-
-    if (unkf < 1.0f) {
-        for (i = 0; i < limbCount; i++, dst++, vec2++, vec3++) {
-            temp2 = vec2->x;
-            dist = vec3->x - temp2;
-            dst->x = (s16)(dist * unkf) + temp2;
-            temp2 = vec2->y;
-            dist = vec3->y - temp2;
-            dst->y = (s16)(dist * unkf) + temp2;
-            temp2 = vec2->z;
-            dist = vec3->z - temp2;
-            dst->z = (s16)(dist * unkf) + temp2;
+    s16 diff;
+    s16 base;
+
+    if (weight < 1.0f) {
+        for (i = 0; i < limbCount; i++, dst++, start++, tactoret++) {
+            base = start->x;
+            diff = tactoret->x - base;
+            dst->x = (s16)(diff * weight) + base;
+            base = start->y;
+            diff = tactoret->y - base;
+            dst->y = (s16)(diff * weight) + base;
+            base = start->z;
+            diff = tactoret->z - base;
+            dst->z = (s16)(diff * weight) + base;
         }
     } else {
-        for (i = 0; i < limbCount; i++, dst++, vec3++) {
-            dst->x = vec3->x;
-            dst->y = vec3->y;
-            dst->z = vec3->z;
+        for (i = 0; i < limbCount; i++, dst++, tactoret++) {
+            dst->x = tactoret->x;
+            dst->y = tactoret->y;
+            dst->z = tactoret->z;
         }
     }
 }
 
-void SkelAnime_AnimationCtxReset(AnimationContext* animationCtx) {
+/**
+ * Zeroes out the current request count
+ */
+void AnimationContext_Reset(AnimationContext* animationCtx) {
     animationCtx->animationCount = 0;
 }
 
-void func_801358D4(GlobalContext* globalCtx) {
-    D_801F5AB0 *= 2;
+/**
+ * Shifts the queue flag to the next queue
+ */
+void AnimationContext_SetNextQueue(GlobalContext* globalCtx) {
+    sAnimQueueFlags <<= 1;
 }
 
-void func_801358F4(GlobalContext* globalCtx) {
-    D_801F5AB4 |= D_801F5AB0;
+/**
+ * Disables the current animation queue. Only load and move actor requests will be processed for that queue.
+ */
+void AnimationContext_DisableQueue(GlobalContext* globalCtx) {
+    sDisableAnimQueueFlags |= sAnimQueueFlags;
 }
 
-AnimationEntry* SkelAnime_NextEntry(AnimationContext* animationCtx, AnimationType type) {
+AnimationEntry* AnimationContext_AddEntry(AnimationContext* animationCtx, AnimationType type) {
     AnimationEntry* entry;
     s16 index = animationCtx->animationCount;
 
@@ -929,807 +1025,991 @@ AnimationEntry* SkelAnime_NextEntry(AnimationContext* animationCtx, AnimationTyp
     return entry;
 }
 
-/*
- * The next 6 functions are coordinate with the AnimationType enum
+/**
+ * Requests loading frame data from the Link animation into frameTable
  */
-
-void SkelAnime_LoadLinkAnimetion(GlobalContext* globalCtx, LinkAnimationHeader* linkAnimetionSeg, s32 frame,
-                                 s32 limbCount, void* ram) {
-    AnimationEntry* entry;
-    LinkAnimationHeader* LinkAnimationHeader;
-    s32 pad;
-
-    entry = SkelAnime_NextEntry(&globalCtx->animationCtx, ANIMATION_LINKANIMETION);
+void AnimationContext_SetLoadFrame(GlobalContext* globalCtx, LinkAnimationHeader* animation, s32 frame, s32 limbCount,
+                                   Vec3s* frameTable) {
+    AnimationEntry* entry = AnimationContext_AddEntry(&globalCtx->animationCtx, ANIMATION_LINKANIMETION);
 
     if (entry != NULL) {
-        LinkAnimationHeader = Lib_SegmentedToVirtual(linkAnimetionSeg);
-        osCreateMesgQueue(&entry->types.type0.msgQueue, &entry->types.type0.msg, 1);
-        DmaMgr_SendRequestImpl(
-            &entry->types.type0.req, ram,
-            LINK_ANIMETION_OFFSET(LinkAnimationHeader->segment, (sizeof(Vec3s) * limbCount + 2) * frame),
-            sizeof(Vec3s) * limbCount + 2, 0, &entry->types.type0.msgQueue, NULL);
+        LinkAnimationHeader* linkAnimHeader = (LinkAnimationHeader*)Lib_SegmentedToVirtual(animation);
+        u32 ram = frameTable;
+
+        osCreateMesgQueue(&entry->data.load.msgQueue, &entry->data.load.msg, 1);
+        DmaMgr_SendRequestImpl(&entry->data.load.req, ram,
+                               LINK_ANIMETION_OFFSET(linkAnimHeader->segment, (sizeof(Vec3s) * limbCount + 2) * frame),
+                               sizeof(Vec3s) * limbCount + 2, 0, &entry->data.load.msgQueue, NULL);
     }
 }
 
-void SkelAnime_LoadAnimationType1(GlobalContext* globalCtx, s32 vecCount, Vec3s* dst, Vec3s* src) {
-    AnimationEntry* entry = SkelAnime_NextEntry(&globalCtx->animationCtx, ANIMATION_TYPE1);
+/**
+ * Requests copying all vectors from src frame table into dst frame table
+ */
+void AnimationContext_SetCopyAll(GlobalContext* globalCtx, s32 vecCount, Vec3s* dst, Vec3s* src) {
+    AnimationEntry* entry = AnimationContext_AddEntry(&globalCtx->animationCtx, ANIMENTRY_COPYALL);
 
     if (entry != NULL) {
-        entry->types.type1.unk00 = D_801F5AB0;
-        entry->types.type1.vecCount = vecCount;
-        entry->types.type1.dst = dst;
-        entry->types.type1.src = src;
+        entry->data.copy.queueFlag = sAnimQueueFlags;
+        entry->data.copy.vecCount = vecCount;
+        entry->data.copy.dst = dst;
+        entry->data.copy.src = src;
     }
 }
 
-void SkelAnime_LoadAnimationType2(GlobalContext* globalCtx, s32 limbCount, Vec3s* arg2, Vec3s* arg3, f32 arg4) {
-    AnimationEntry* entry = SkelAnime_NextEntry(&globalCtx->animationCtx, ANIMATION_TYPE2);
+/**
+ * Requests interpolating between base and mod frame tables with the given weight, placing the result in base
+ */
+void AnimationContext_SetInterp(GlobalContext* globalCtx, s32 vecCount, Vec3s* base, Vec3s* mod, f32 weight) {
+    AnimationEntry* entry = AnimationContext_AddEntry(&globalCtx->animationCtx, ANIMENTRY_INTERP);
 
     if (entry != NULL) {
-        entry->types.type2.unk00 = D_801F5AB0;
-        entry->types.type2.limbCount = limbCount;
-        entry->types.type2.unk04 = arg2;
-        entry->types.type2.unk08 = arg3;
-        entry->types.type2.unk0C = arg4;
+        entry->data.interp.queueFlag = sAnimQueueFlags;
+        entry->data.interp.vecCount = vecCount;
+        entry->data.interp.base = base;
+        entry->data.interp.mod = mod;
+        entry->data.interp.weight = weight;
     }
 }
 
-void SkelAnime_LoadAnimationType3(GlobalContext* globalCtx, s32 vecCount, Vec3s* dst, Vec3s* src, u8* index) {
-    AnimationEntry* entry = SkelAnime_NextEntry(&globalCtx->animationCtx, ANIMATION_TYPE3);
+/**
+ * Requests copying vectors from src frame table to dst frame table whose load flag is true
+ */
+void AnimationContext_SetCopyTrue(GlobalContext* globalCtx, s32 vecCount, Vec3s* dst, Vec3s* src, u8* copyFlag) {
+    AnimationEntry* entry = AnimationContext_AddEntry(&globalCtx->animationCtx, ANIMENTRY_COPYTRUE);
 
     if (entry != NULL) {
-        entry->types.type3.unk00 = D_801F5AB0;
-        entry->types.type3.vecCount = vecCount;
-        entry->types.type3.dst = dst;
-        entry->types.type3.src = src;
-        entry->types.type3.index = index;
+        entry->data.copy1.queueFlag = sAnimQueueFlags;
+        entry->data.copy1.vecCount = vecCount;
+        entry->data.copy1.dst = dst;
+        entry->data.copy1.src = src;
+        entry->data.copy1.copyFlag = copyFlag;
     }
 }
 
-void SkelAnime_LoadAnimationType4(GlobalContext* globalCtx, s32 vecCount, Vec3s* dst, Vec3s* src, u8* index) {
-    AnimationEntry* entry = SkelAnime_NextEntry(&globalCtx->animationCtx, ANIMATION_TYPE4);
+/**
+ * Requests copying vectors from src frame table to dst frame table whose load flag is false
+ */
+void AnimationContext_SetCopyFalse(GlobalContext* globalCtx, s32 vecCount, Vec3s* dst, Vec3s* src, u8* copyFlag) {
+    AnimationEntry* entry = AnimationContext_AddEntry(&globalCtx->animationCtx, ANIMENTRY_COPYFALSE);
 
     if (entry != NULL) {
-        entry->types.type4.unk00 = D_801F5AB0;
-        entry->types.type4.vecCount = vecCount;
-        entry->types.type4.dst = dst;
-        entry->types.type4.src = src;
-        entry->types.type4.index = index;
+        entry->data.copy0.queueFlag = sAnimQueueFlags;
+        entry->data.copy0.vecCount = vecCount;
+        entry->data.copy0.dst = dst;
+        entry->data.copy0.src = src;
+        entry->data.copy0.copyFlag = copyFlag;
     }
 }
 
-void SkelAnime_LoadAnimationType5(GlobalContext* globalCtx, Actor* actor, SkelAnime* skelAnime, f32 arg3) {
-    AnimationEntry* entry = SkelAnime_NextEntry(&globalCtx->animationCtx, ANIMATION_TYPE5);
+/**
+ * Requests moving an actor according to the translation of its root limb
+ */
+void AnimationContext_SetMoveActor(GlobalContext* globalCtx, Actor* actor, SkelAnime* skelAnime, f32 actor3) {
+    AnimationEntry* entry = AnimationContext_AddEntry(&globalCtx->animationCtx, ANIMENTRY_MOVEACTOR);
 
     if (entry != NULL) {
-        entry->types.type5.actor = actor;
-        entry->types.type5.skelAnime = skelAnime;
-        entry->types.type5.unk08 = arg3;
+        entry->data.move.actor = actor;
+        entry->data.move.skelAnime = skelAnime;
+        entry->data.move.unk08 = actor3;
     }
 }
 
-/* The next functions are callbacks to loading animations */
+/**
+ * Receives the request for Link's animation frame data
+ */
+void AnimationContext_LoadFrame(GlobalContext* globalCtx, AnimationEntryData* data) {
+    AnimEntryLoadFrame* entry = &data->load;
 
-void SkelAnime_LinkAnimetionLoaded(GlobalContext* globalCtx, AnimationEntryType0* entry) {
     osRecvMesg(&entry->msgQueue, NULL, OS_MESG_BLOCK);
 }
 
-void SkelAnime_AnimationType1Loaded(GlobalContext* globalCtx, AnimationEntryType1* entry) {
-    s32 i;
-    Vec3s* dst;
-    Vec3s* src;
-    AnimationEntryRaw* genericEntry = (AnimationEntryRaw*)entry;
+/**
+ * If the entry's queue is enabled, copies all vectors from src frame table to dst frame table
+ */
+void AnimationContext_CopyAll(GlobalContext* globalCtx, AnimationEntryData* data) {
+    AnimEntryCopyAll* entry = &data->copy;
 
-    if ((genericEntry->raw[0] & D_801F5AB4) != 0) {
-        return;
-    }
+    if (!(entry->queueFlag & sDisableAnimQueueFlags)) {
+        Vec3s* dst = entry->dst;
+        Vec3s* src = entry->src;
+        s32 i;
 
-    for (dst = entry->dst, src = entry->src, i = 0; i < genericEntry->raw[1]; i++) {
-        *dst++ = *src++;
+        for (i = 0; i < entry->vecCount; i++) {
+            *dst++ = *src++;
+        }
     }
 }
 
-void SkelAnime_AnimationType2Loaded(GlobalContext* globalCtx, AnimationEntryType2* entry) {
-    if ((entry->unk00 & D_801F5AB4) == 0) {
-        SkelAnime_InterpolateVec3s(entry->limbCount, entry->unk04, entry->unk04, entry->unk08, entry->unk0C);
+/**
+ * If the entry's queue is enabled, interpolates between the base and mod frame tables, placing the result in base
+ */
+void AnimationContext_Interp(GlobalContext* globalCtx, AnimationEntryData* data) {
+    AnimEntryInterp* entry = &data->interp;
+
+    if (!(entry->queueFlag & sDisableAnimQueueFlags)) {
+        SkelAnime_InterpFrameTable(entry->vecCount, entry->base, entry->base, entry->mod, entry->weight);
     }
 }
 
-void SkelAnime_AnimationType3Loaded(GlobalContext* globalCtx, AnimationEntryType3* entry) {
-    s32 i;
-    Vec3s* dst;
-    Vec3s* src;
-    u8* index;
-    AnimationEntryRaw* rawEntry = (AnimationEntryRaw*)entry;
-
-    if ((rawEntry->raw[0] & D_801F5AB4) == 0) {
-        for (dst = entry->dst, src = entry->src, index = entry->index, i = 0; i < rawEntry->raw[1]; i++, dst++, src++) {
-            if (*index++) {
+/**
+ * If the entry's queue is enabled, copies all vectors from src frame table to dst frame table whose copy flag is true
+ */
+void AnimationContext_CopyTrue(GlobalContext* globalCtx, AnimationEntryData* data) {
+    AnimEntryCopyTrue* entry = &data->copy1;
+
+    if (!(entry->queueFlag & sDisableAnimQueueFlags)) {
+        Vec3s* dst = entry->dst;
+        Vec3s* src = entry->src;
+        u8* copyFlag = entry->copyFlag;
+        s32 i;
+
+        for (i = 0; i < entry->vecCount; i++, dst++, src++) {
+            if (*copyFlag++) {
                 *dst = *src;
             }
         }
     }
 }
 
-void SkelAnime_AnimationType4Loaded(GlobalContext* globalCtx, AnimationEntryType4* entry) {
-    s32 i;
-    Vec3s* dst;
-    Vec3s* src;
-    u8* index;
-    AnimationEntryRaw* rawEntry = (AnimationEntryRaw*)entry;
-
-    if ((rawEntry->raw[0] & D_801F5AB4) == 0) {
-        for (dst = entry->dst, src = entry->src, index = entry->index, i = 0; i < rawEntry->raw[1]; i++, dst++, src++) {
-            if (*index++ < 1U) {
+/**
+ * If the entry's queue is enabled, copies all vectors from src frame table to dst frame table whose copy flag is false
+ */
+void AnimationContext_CopyFalse(GlobalContext* globalCtx, AnimationEntryData* data) {
+    AnimEntryCopyFalse* entry = &data->copy0;
+
+    if (!(entry->queueFlag & sDisableAnimQueueFlags)) {
+        Vec3s* dst = entry->dst;
+        Vec3s* src = entry->src;
+        u8* copyFlag = entry->copyFlag;
+        s32 i;
+
+        for (i = 0; i < entry->vecCount; i++, dst++, src++) {
+            if (!(*copyFlag++)) {
                 *dst = *src;
             }
         }
     }
 }
 
-void SkelAnime_AnimationType5Loaded(GlobalContext* globalCtx, AnimationEntryType5* entry) {
-    s32 pad;
+/**
+ * Moves an actor according to the translation of its root limb
+ */
+void AnimationContext_MoveActor(GlobalContext* globalCtx, AnimationEntryData* data) {
+    AnimEntryMoveActor* entry = &data->move;
     Actor* actor = entry->actor;
-    Vec3f pos;
+    Vec3f diff;
 
-    func_80137748(entry->skelAnime, &pos, actor->shape.rot.y);
-    actor->world.pos.x += (pos.x * actor->scale.x) * entry->unk08;
-    actor->world.pos.y += (pos.y * actor->scale.y) * entry->unk08;
-    actor->world.pos.z += (pos.z * actor->scale.z) * entry->unk08;
+    SkelAnime_UpdateTranslation(entry->skelAnime, &diff, actor->shape.rot.y);
+    actor->world.pos.x += diff.x * actor->scale.x * entry->unk08;
+    actor->world.pos.y += diff.y * actor->scale.y * entry->unk08;
+    actor->world.pos.z += diff.z * actor->scale.z * entry->unk08;
 }
 
-void func_80135EE8(GlobalContext* globalCtx, AnimationContext* animationCtx) {
+/**
+ * Performs all requests in the animation queue, then resets the queue flags.
+ */
+void AnimationContext_Update(GlobalContext* globalCtx, AnimationContext* animationCtx) {
     AnimationEntry* entry = animationCtx->entries;
 
     for (; animationCtx->animationCount != 0; entry++, animationCtx->animationCount--) {
-        sAnimationLoadDone[entry->type](globalCtx, &entry->types);
+        sAnimationLoadDone[entry->type](globalCtx, &entry->data);
     }
 
-    D_801F5AB0 = 1;
-    D_801F5AB4 = 0;
+    sAnimQueueFlags = 1;
+    sDisableAnimQueueFlags = 0;
 }
 
-void SkelAnime_InitLinkAnimetion(GlobalContext* globalCtx, SkelAnime* skelAnime, FlexSkeletonHeader* skeletonHeaderSeg,
-                                 LinkAnimationHeader* linkAnimationHeaderSeg, s32 flags, Vec3s* limbDrawTbl,
-                                 Vec3s* transitionDrawTbl, s32 limbBufCount) {
+/**
+ * Initializes a skeleton to be used with Link animations to a looping animation, dynamically allocating the frame
+ * tables if not given.
+ */
+void SkelAnime_InitLink(GlobalContext* globalCtx, SkelAnime* skelAnime, FlexSkeletonHeader* skeletonHeaderSeg,
+                        LinkAnimationHeader* animation, s32 flags, Vec3s* jointTable, Vec3s* morphTable,
+                        s32 limbBufCount) {
     FlexSkeletonHeader* skeletonHeader;
-    s32 headerCount;
+    s32 headerJointCount;
     s32 limbCount;
-    u32 allocSize;
+    size_t allocSize;
 
     skeletonHeader = Lib_SegmentedToVirtual(skeletonHeaderSeg);
-    headerCount = skeletonHeader->sh.limbCount;
+    headerJointCount = skeletonHeader->sh.limbCount;
     skelAnime->initFlags = flags;
-    limbCount = (flags & 2) ? headerCount : 1;
+    limbCount = (flags & 2) ? headerJointCount : 1;
 
     if (flags & 1) {
-        limbCount += headerCount;
+        limbCount += headerJointCount;
     }
 
     if (flags & 4) {
-        limbCount += headerCount;
+        limbCount += headerJointCount;
     }
 
     skelAnime->limbCount = limbCount;
     skelAnime->dListCount = skeletonHeader->dListCount;
-    skelAnime->skeleton = Lib_SegmentedToVirtual(skeletonHeader->sh.skeletonSeg);
+    skelAnime->skeleton = Lib_SegmentedToVirtual(skeletonHeader->sh.segment);
     allocSize = sizeof(Vec3s) * limbCount;
 
     if (flags & 8) {
         allocSize += 2;
     }
 
-    if (limbDrawTbl == NULL) {
-        skelAnime->limbDrawTbl = zelda_malloc(allocSize);
-        skelAnime->transitionDrawTbl = zelda_malloc(allocSize);
+    if (jointTable == NULL) {
+        skelAnime->jointTable = ZeldaArena_Malloc(allocSize);
+        skelAnime->morphTable = ZeldaArena_Malloc(allocSize);
     } else {
-        skelAnime->limbDrawTbl = (Vec3s*)ALIGN16((u32)limbDrawTbl);
-        skelAnime->transitionDrawTbl = (Vec3s*)ALIGN16((u32)transitionDrawTbl);
+        skelAnime->jointTable = (Vec3s*)ALIGN16((u32)jointTable);
+        skelAnime->morphTable = (Vec3s*)ALIGN16((u32)morphTable);
     }
 
-    SkelAnime_ChangeLinkAnim(globalCtx, skelAnime, linkAnimationHeaderSeg, 1.0f, 0.0f, 0.0f, 0, 0.0f);
+    LinkAnimation_Change(globalCtx, skelAnime, animation, 1.0f, 0.0f, 0.0f, ANIMMODE_LOOP, 0.0f);
 }
 
-void func_801360A8(SkelAnime* skelAnime) {
-    if (skelAnime->mode < 2) {
-        skelAnime->animUpdate = func_80136288;
+/**
+ * Sets the update function of a SkelAnime that uses Link animations based on its mode
+ */
+void LinkAnimation_SetUpdateFunction(SkelAnime* skelAnime) {
+    if (skelAnime->mode <= ANIMMODE_LOOP_INTERP) {
+        skelAnime->update = LinkAnimation_Loop;
     } else {
-        skelAnime->animUpdate = func_8013631C;
+        skelAnime->update = LinkAnimation_Once;
     }
-    skelAnime->transCurrentFrame = 0.0f;
+    skelAnime->morphWeight = 0.0f;
 }
 
-s32 func_801360E0(GlobalContext* globalCtx, SkelAnime* skelAnime) {
-    return skelAnime->animUpdate(globalCtx, skelAnime);
+/**
+ * Advances the current Link animation and updates all frame tables. If the animation plays once, returns true when it
+ * finishes.
+ */
+s32 LinkAnimation_Update(GlobalContext* globalCtx, SkelAnime* skelAnime) {
+    return skelAnime->update(globalCtx, skelAnime);
 }
 
-s32 func_80136104(GlobalContext* globalCtx, SkelAnime* skelAnime) {
-    f32 prevUnk28 = skelAnime->transCurrentFrame;
+/**
+ * Requests an interpolation between the pose in jointTable to the one in morphTable, advancing the morph but not the
+ * animation frame
+ */
+s32 LinkAnimation_Morph(GlobalContext* globalCtx, SkelAnime* skelAnime) {
+    f32 prevMorphWeight = skelAnime->morphWeight;
     f32 updateRate = (s32)globalCtx->state.framerateDivisor * 0.5f;
 
-    skelAnime->transCurrentFrame -= skelAnime->transitionStep * updateRate;
-    if (skelAnime->transCurrentFrame <= 0.0f) {
-        func_801360A8(skelAnime);
+    skelAnime->morphWeight -= skelAnime->morphRate * updateRate;
+    if (skelAnime->morphWeight <= 0.0f) {
+        LinkAnimation_SetUpdateFunction(skelAnime);
     }
 
-    SkelAnime_LoadAnimationType2(globalCtx, skelAnime->limbCount, skelAnime->limbDrawTbl, skelAnime->transitionDrawTbl,
-                                 1.0f - (skelAnime->transCurrentFrame / prevUnk28));
+    AnimationContext_SetInterp(globalCtx, skelAnime->limbCount, skelAnime->jointTable, skelAnime->morphTable,
+                               1.0f - (skelAnime->morphWeight / prevMorphWeight));
     return 0;
 }
 
-void func_801361BC(GlobalContext* globalCtx, SkelAnime* skelAnime) {
-    SkelAnime_LoadLinkAnimetion(globalCtx, skelAnime->linkAnimetionSeg, skelAnime->animCurrentFrame,
-                                skelAnime->limbCount, skelAnime->limbDrawTbl);
-    if (skelAnime->transCurrentFrame != 0) {
+/**
+ * Requests a load of the next frame of a Link animation, advances the morph, and requests an interpolation between
+ * jointTable and morphTable
+ */
+void LinkAnimation_AnimateFrame(GlobalContext* globalCtx, SkelAnime* skelAnime) {
+    AnimationContext_SetLoadFrame(globalCtx, skelAnime->animation, skelAnime->curFrame, skelAnime->limbCount,
+                                  skelAnime->jointTable);
+    if (skelAnime->morphWeight != 0) {
         f32 updateRate = (s32)globalCtx->state.framerateDivisor * 0.5f;
-        skelAnime->transCurrentFrame -= skelAnime->transitionStep * updateRate;
-        if (skelAnime->transCurrentFrame <= 0.0f) {
-            skelAnime->transCurrentFrame = 0.0f;
+        skelAnime->morphWeight -= skelAnime->morphRate * updateRate;
+        if (skelAnime->morphWeight <= 0.0f) {
+            skelAnime->morphWeight = 0.0f;
         } else {
-            SkelAnime_LoadAnimationType2(globalCtx, skelAnime->limbCount, skelAnime->limbDrawTbl,
-                                         skelAnime->transitionDrawTbl, skelAnime->transCurrentFrame);
+            AnimationContext_SetInterp(globalCtx, skelAnime->limbCount, skelAnime->jointTable, skelAnime->morphTable,
+                                       skelAnime->morphWeight);
         }
     }
 }
 
-s32 func_80136288(GlobalContext* globalCtx, SkelAnime* skelAnime) {
+/**
+ * Advances a Link animation that loops over its full length
+ */
+s32 LinkAnimation_Loop(GlobalContext* globalCtx, SkelAnime* skelAnime) {
     f32 updateRate = (s32)globalCtx->state.framerateDivisor * 0.5f;
 
-    skelAnime->animCurrentFrame += skelAnime->animPlaybackSpeed * updateRate;
-    if (skelAnime->animCurrentFrame < 0.0f) {
-        skelAnime->animCurrentFrame += skelAnime->totalFrames;
-    } else if (skelAnime->totalFrames <= skelAnime->animCurrentFrame) {
-        skelAnime->animCurrentFrame -= skelAnime->totalFrames;
+    skelAnime->curFrame += skelAnime->playSpeed * updateRate;
+    if (skelAnime->curFrame < 0.0f) {
+        skelAnime->curFrame += skelAnime->animLength;
+    } else if (skelAnime->animLength <= skelAnime->curFrame) {
+        skelAnime->curFrame -= skelAnime->animLength;
     }
-    func_801361BC(globalCtx, skelAnime);
+    LinkAnimation_AnimateFrame(globalCtx, skelAnime);
     return 0;
 }
 
-s32 func_8013631C(GlobalContext* globalCtx, SkelAnime* skelAnime) {
+/**
+ * Advances a Link animation that stops at endFrame and returns true when it is reached.
+ */
+s32 LinkAnimation_Once(GlobalContext* globalCtx, SkelAnime* skelAnime) {
     f32 updateRate = (s32)globalCtx->state.framerateDivisor * 0.5f;
 
-    if (skelAnime->animCurrentFrame == skelAnime->animFrameCount) {
-        func_801361BC(globalCtx, skelAnime);
+    if (skelAnime->curFrame == skelAnime->endFrame) {
+        LinkAnimation_AnimateFrame(globalCtx, skelAnime);
         return 1;
     }
 
-    skelAnime->animCurrentFrame += skelAnime->animPlaybackSpeed * updateRate;
+    skelAnime->curFrame += skelAnime->playSpeed * updateRate;
 
-    if (((skelAnime->animCurrentFrame - skelAnime->animFrameCount) * skelAnime->animPlaybackSpeed) > 0.0f) {
-        skelAnime->animCurrentFrame = skelAnime->animFrameCount;
+    if (((skelAnime->curFrame - skelAnime->endFrame) * skelAnime->playSpeed) > 0.0f) {
+        skelAnime->curFrame = skelAnime->endFrame;
     } else {
-        if (skelAnime->animCurrentFrame < 0.0f) {
-            skelAnime->animCurrentFrame += skelAnime->totalFrames;
-        } else if (skelAnime->totalFrames <= skelAnime->animCurrentFrame) {
-            skelAnime->animCurrentFrame -= skelAnime->totalFrames;
+        if (skelAnime->curFrame < 0.0f) {
+            skelAnime->curFrame += skelAnime->animLength;
+        } else if (skelAnime->animLength <= skelAnime->curFrame) {
+            skelAnime->curFrame -= skelAnime->animLength;
         }
     }
-    func_801361BC(globalCtx, skelAnime);
+    LinkAnimation_AnimateFrame(globalCtx, skelAnime);
     return 0;
 }
 
-void SkelAnime_SetTransition(GlobalContext* globalCtx, SkelAnime* skelAnime, f32 transitionRate) {
-    skelAnime->transCurrentFrame = 1.0f;
-    skelAnime->transitionStep = 1.0f / transitionRate;
+/**
+ * Sets a new morph and resets the morph weight for the current animation.
+ */
+void Animation_SetMorph(GlobalContext* globalCtx, SkelAnime* skelAnime, f32 morphFrames) {
+    skelAnime->morphWeight = 1.0f;
+    skelAnime->morphRate = 1.0f / morphFrames;
 }
 
-void SkelAnime_ChangeLinkAnim(GlobalContext* globalCtx, SkelAnime* skelAnime,
-                              LinkAnimationHeader* linkAnimationHeaderSeg, f32 playbackSpeed, f32 frame, f32 frameCount,
-                              u8 animationMode, f32 transitionRate) {
-    skelAnime->mode = animationMode;
-    if ((transitionRate != 0.0f) &&
-        ((linkAnimationHeaderSeg != skelAnime->linkAnimetionSeg) || (frame != skelAnime->animCurrentFrame))) {
-        if (transitionRate < 0) {
-            func_801360A8(skelAnime);
-            SkelAnime_CopyVec3s(skelAnime, skelAnime->transitionDrawTbl, skelAnime->limbDrawTbl);
-            transitionRate = -transitionRate;
+/**
+ * General way to set a new Link animation, allowing choice of playback speed, start frame, end frame, play mode, and
+ * number of transition frames. Positive morph frames morph from the current pose to the start pose of the new
+ * animation, then start the new animation. Negative morph frames start the new animation immediately, modified by the
+ * pose immediately before the animation change.
+ */
+void LinkAnimation_Change(GlobalContext* globalCtx, SkelAnime* skelAnime, LinkAnimationHeader* animation, f32 playSpeed,
+                          f32 startFrame, f32 endFrame, u8 mode, f32 morphFrames) {
+    skelAnime->mode = mode;
+    if ((morphFrames != 0.0f) && ((animation != skelAnime->animation) || (startFrame != skelAnime->curFrame))) {
+        if (morphFrames < 0) {
+            LinkAnimation_SetUpdateFunction(skelAnime);
+            SkelAnime_CopyFrameTable(skelAnime, skelAnime->morphTable, skelAnime->jointTable);
+            morphFrames = -morphFrames;
         } else {
-            skelAnime->animUpdate = func_80136104;
-            SkelAnime_LoadLinkAnimetion(globalCtx, linkAnimationHeaderSeg, (s32)frame, skelAnime->limbCount,
-                                        skelAnime->transitionDrawTbl);
+            skelAnime->update = LinkAnimation_Morph;
+            AnimationContext_SetLoadFrame(globalCtx, animation, (s32)startFrame, skelAnime->limbCount,
+                                          skelAnime->morphTable);
         }
-        skelAnime->transCurrentFrame = 1.0f;
-        skelAnime->transitionStep = 1.0f / transitionRate;
+        skelAnime->morphWeight = 1.0f;
+        skelAnime->morphRate = 1.0f / morphFrames;
     } else {
-        func_801360A8(skelAnime);
-        SkelAnime_LoadLinkAnimetion(globalCtx, linkAnimationHeaderSeg, (s32)frame, skelAnime->limbCount,
-                                    skelAnime->limbDrawTbl);
-        skelAnime->transCurrentFrame = 0.0f;
+        LinkAnimation_SetUpdateFunction(skelAnime);
+        AnimationContext_SetLoadFrame(globalCtx, animation, (s32)startFrame, skelAnime->limbCount,
+                                      skelAnime->jointTable);
+        skelAnime->morphWeight = 0.0f;
     }
 
-    skelAnime->linkAnimetionSeg = linkAnimationHeaderSeg;
-    skelAnime->animCurrentFrame = 0.0f;
-    skelAnime->initialFrame = frame;
-    skelAnime->animCurrentFrame = frame;
-    skelAnime->animFrameCount = frameCount;
-    skelAnime->totalFrames = SkelAnime_GetTotalFrames(&linkAnimationHeaderSeg->common);
-    skelAnime->animPlaybackSpeed = playbackSpeed;
+    skelAnime->animation = animation;
+    skelAnime->curFrame = 0.0f;
+    skelAnime->startFrame = startFrame;
+    skelAnime->curFrame = startFrame;
+    skelAnime->endFrame = endFrame;
+    skelAnime->animLength = Animation_GetLength(animation);
+    skelAnime->playSpeed = playSpeed;
 }
 
-void SkelAnime_ChangeLinkAnimDefaultStop(GlobalContext* globalCtx, SkelAnime* skelAnime,
-                                         LinkAnimationHeader* linkAnimationHeaderSeg) {
-    SkelAnime_ChangeLinkAnim(globalCtx, skelAnime, linkAnimationHeaderSeg, 1.0f, 0.0f,
-                             SkelAnime_GetFrameCount(&linkAnimationHeaderSeg->common), 2, 0.0f);
+/**
+ * Immediately changes to a Link animation that plays once at the default speed.
+ */
+void LinkAnimation_PlayOnce(GlobalContext* globalCtx, SkelAnime* skelAnime, LinkAnimationHeader* animation) {
+    LinkAnimation_Change(globalCtx, skelAnime, animation, 1.0f, 0.0f, Animation_GetLastFrame(&animation->common),
+                         ANIMMODE_ONCE, 0.0f);
 }
 
-void SkelAnime_ChangeLinkAnimPlaybackStop(GlobalContext* globalCtx, SkelAnime* skelAnime,
-                                          LinkAnimationHeader* linkAnimationHeaderSeg, f32 playbackSpeed) {
-    SkelAnime_ChangeLinkAnim(globalCtx, skelAnime, linkAnimationHeaderSeg, playbackSpeed, 0.0f,
-                             SkelAnime_GetFrameCount(&linkAnimationHeaderSeg->common), 2, 0.0f);
+/**
+ * Immediately changes to a Link animation that plays once at the specified speed.
+ */
+void LinkAnimation_PlayOnceSetSpeed(GlobalContext* globalCtx, SkelAnime* skelAnime, LinkAnimationHeader* animation,
+                                    f32 playSpeed) {
+    LinkAnimation_Change(globalCtx, skelAnime, animation, playSpeed, 0.0f, Animation_GetLastFrame(&animation->common),
+                         ANIMMODE_ONCE, 0.0f);
 }
 
-void SkelAnime_ChangeLinkAnimDefaultRepeat(GlobalContext* globalCtx, SkelAnime* skelAnime,
-                                           LinkAnimationHeader* linkAnimationHeaderSeg) {
-    SkelAnime_ChangeLinkAnim(globalCtx, skelAnime, linkAnimationHeaderSeg, 1.0f, 0.0f,
-                             SkelAnime_GetFrameCount(&linkAnimationHeaderSeg->common), 0, 0.0f);
+/**
+ * Immediately changes to a Link animation that loops at the default speed.
+ */
+void LinkAnimation_PlayLoop(GlobalContext* globalCtx, SkelAnime* skelAnime, LinkAnimationHeader* animation) {
+    LinkAnimation_Change(globalCtx, skelAnime, animation, 1.0f, 0.0f, Animation_GetLastFrame(&animation->common),
+                         ANIMMODE_LOOP, 0.0f);
 }
 
-void SkelAnime_ChangeLinkAnimPlaybackRepeat(GlobalContext* globalCtx, SkelAnime* skelAnime,
-                                            LinkAnimationHeader* linkAnimationHeaderSeg, f32 playbackSpeed) {
-    SkelAnime_ChangeLinkAnim(globalCtx, skelAnime, linkAnimationHeaderSeg, playbackSpeed, 0.0f,
-                             SkelAnime_GetFrameCount(&linkAnimationHeaderSeg->common), 0, 0.0f);
+/**
+ * Immediately changes to a Link animation that loops at the specified speed.
+ */
+void LinkAnimation_PlayLoopSetSpeed(GlobalContext* globalCtx, SkelAnime* skelAnime, LinkAnimationHeader* animation,
+                                    f32 playSpeed) {
+    LinkAnimation_Change(globalCtx, skelAnime, animation, playSpeed, 0.0f, Animation_GetLastFrame(&animation->common),
+                         ANIMMODE_LOOP, 0.0f);
 }
 
-void func_8013670C(GlobalContext* globalCtx, SkelAnime* skelAnime) {
-    SkelAnime_LoadAnimationType1(globalCtx, skelAnime->limbCount, skelAnime->transitionDrawTbl, skelAnime->limbDrawTbl);
+/**
+ * Requests copying jointTable to morphTable
+ */
+void LinkAnimation_CopyJointToMorph(GlobalContext* globalCtx, SkelAnime* skelAnime) {
+    AnimationContext_SetCopyAll(globalCtx, skelAnime->limbCount, skelAnime->morphTable, skelAnime->jointTable);
 }
 
-void func_8013673C(GlobalContext* globalCtx, SkelAnime* skelAnime) {
-    SkelAnime_LoadAnimationType1(globalCtx, skelAnime->limbCount, skelAnime->limbDrawTbl, skelAnime->transitionDrawTbl);
+/**
+ * Requests copying morphTable to jointTable
+ */
+void LinkAnimation_CopyMorphToJoint(GlobalContext* globalCtx, SkelAnime* skelAnime) {
+    AnimationContext_SetCopyAll(globalCtx, skelAnime->limbCount, skelAnime->jointTable, skelAnime->morphTable);
 }
 
-void func_8013676C(GlobalContext* globalCtx, SkelAnime* skelAnime, LinkAnimationHeader* linkAnimationHeaderSeg,
-                   f32 frame) {
-    SkelAnime_LoadLinkAnimetion(globalCtx, linkAnimationHeaderSeg, (s32)frame, skelAnime->limbCount,
-                                skelAnime->transitionDrawTbl);
+/**
+ * Requests loading frame data from the Link animation into morphTable
+ */
+void LinkAnimation_LoadToMorph(GlobalContext* globalCtx, SkelAnime* skelAnime, LinkAnimationHeader* animation,
+                               f32 frame) {
+    AnimationContext_SetLoadFrame(globalCtx, animation, (s32)frame, skelAnime->limbCount, skelAnime->morphTable);
 }
 
-void func_801367B0(GlobalContext* globalCtx, SkelAnime* skelAnime, LinkAnimationHeader* linkAnimationHeaderSeg,
-                   f32 frame) {
-    SkelAnime_LoadLinkAnimetion(globalCtx, linkAnimationHeaderSeg, (s32)frame, skelAnime->limbCount,
-                                skelAnime->limbDrawTbl);
+/**
+ * Requests loading frame data from the Link animation into jointTable
+ */
+void LinkAnimation_LoadToJoint(GlobalContext* globalCtx, SkelAnime* skelAnime, LinkAnimationHeader* animation,
+                               f32 frame) {
+    AnimationContext_SetLoadFrame(globalCtx, animation, (s32)frame, skelAnime->limbCount, skelAnime->jointTable);
 }
 
-void func_801367F4(GlobalContext* globalCtx, SkelAnime* skelAnime, f32 frame) {
-    SkelAnime_LoadAnimationType2(globalCtx, skelAnime->limbCount, skelAnime->limbDrawTbl, skelAnime->transitionDrawTbl,
-                                 frame);
+/**
+ * Requests interpolating between jointTable and morphTable, placing the result in jointTable
+ */
+void LinkAnimation_InterpJointMorph(GlobalContext* globalCtx, SkelAnime* skelAnime, f32 weight) {
+    AnimationContext_SetInterp(globalCtx, skelAnime->limbCount, skelAnime->jointTable, skelAnime->morphTable, weight);
 }
 
-void func_8013682C(GlobalContext* globalCtx, SkelAnime* skelAnime, LinkAnimationHeader* linkAnimationHeaderSeg,
-                   f32 transitionFrame, LinkAnimationHeader* LinkAnimationHeaderSeg2, f32 frame, f32 transitionRate,
-                   Vec3s* limbDrawTbl) {
-    Vec3s* alignedLimbDrawTbl;
-    SkelAnime_LoadLinkAnimetion(globalCtx, linkAnimationHeaderSeg, (s32)transitionFrame, skelAnime->limbCount,
-                                skelAnime->limbDrawTbl);
+/**
+ * Requests loading frame data from the Link animations and blending them, placing the result in jointTable
+ */
+void LinkAnimation_BlendToJoint(GlobalContext* globalCtx, SkelAnime* skelAnime, LinkAnimationHeader* animation1,
+                                f32 frame1, LinkAnimationHeader* animation2, f32 frame2, f32 blendWeight,
+                                Vec3s* blendTable) {
+    Vec3s* alignedBlendTable;
+
+    AnimationContext_SetLoadFrame(globalCtx, animation1, (s32)frame1, skelAnime->limbCount, skelAnime->jointTable);
 
-    alignedLimbDrawTbl = (Vec3s*)ALIGN16((u32)limbDrawTbl);
+    alignedBlendTable = (Vec3s*)ALIGN16((u32)blendTable);
 
-    SkelAnime_LoadLinkAnimetion(globalCtx, LinkAnimationHeaderSeg2, (s32)frame, skelAnime->limbCount,
-                                alignedLimbDrawTbl);
-    SkelAnime_LoadAnimationType2(globalCtx, skelAnime->limbCount, skelAnime->limbDrawTbl, alignedLimbDrawTbl,
-                                 transitionRate);
+    AnimationContext_SetLoadFrame(globalCtx, animation2, (s32)frame2, skelAnime->limbCount, alignedBlendTable);
+    AnimationContext_SetInterp(globalCtx, skelAnime->limbCount, skelAnime->jointTable, alignedBlendTable, blendWeight);
 }
 
-void func_801368CC(GlobalContext* globalCtx, SkelAnime* skelAnime, LinkAnimationHeader* linkAnimationHeaderSeg,
-                   f32 transitionFrame, LinkAnimationHeader* LinkAnimationHeaderSeg2, f32 frame, f32 transitionRate,
-                   Vec3s* limbDrawTbl) {
-    Vec3s* alignedLimbDrawTbl;
+/**
+ * Requests loading frame data from the Link animations and blending them, placing the result in morphTable
+ */
+void LinkAnimation_BlendToMorph(GlobalContext* globalCtx, SkelAnime* skelAnime, LinkAnimationHeader* animation1,
+                                f32 frame1, LinkAnimationHeader* animation2, f32 frame2, f32 blendWeight,
+                                Vec3s* blendTable) {
+    Vec3s* alignedBlendTable;
 
-    SkelAnime_LoadLinkAnimetion(globalCtx, linkAnimationHeaderSeg, (s32)transitionFrame, skelAnime->limbCount,
-                                skelAnime->transitionDrawTbl);
+    AnimationContext_SetLoadFrame(globalCtx, animation1, (s32)frame1, skelAnime->limbCount, skelAnime->morphTable);
 
-    alignedLimbDrawTbl = (Vec3s*)ALIGN16((u32)limbDrawTbl);
+    alignedBlendTable = (Vec3s*)ALIGN16((u32)blendTable);
 
-    SkelAnime_LoadLinkAnimetion(globalCtx, LinkAnimationHeaderSeg2, (s32)frame, skelAnime->limbCount,
-                                alignedLimbDrawTbl);
-    SkelAnime_LoadAnimationType2(globalCtx, skelAnime->limbCount, skelAnime->transitionDrawTbl, alignedLimbDrawTbl,
-                                 transitionRate);
+    AnimationContext_SetLoadFrame(globalCtx, animation2, (s32)frame2, skelAnime->limbCount, alignedBlendTable);
+    AnimationContext_SetInterp(globalCtx, skelAnime->limbCount, skelAnime->morphTable, alignedBlendTable, blendWeight);
 }
 
-void SkelAnime_SetModeStop(SkelAnime* skelAnime) {
-    skelAnime->mode = 2;
-    func_801360A8(skelAnime);
+/**
+ * Changes a looping animation to one that stops at the end.
+ */
+void LinkAnimation_EndLoop(SkelAnime* skelAnime) {
+    skelAnime->mode = ANIMMODE_ONCE;
+    LinkAnimation_SetUpdateFunction(skelAnime);
 }
 
-s32 func_80136990(SkelAnime* skelAnime, f32 arg1, f32 updateRate) {
+/**
+ * Checks if the current frame is after frame and the previous frame was before it.
+ */
+s32 Animation_OnFrameImpl(SkelAnime* skelAnime, f32 frame, f32 updateRate) {
     f32 updateSpeed;
-    f32 temp_f12;
+    f32 curFrameDiff;
     f32 nextFrame;
 
-    updateSpeed = skelAnime->animPlaybackSpeed * updateRate;
-    nextFrame = skelAnime->animCurrentFrame - updateSpeed;
+    updateSpeed = skelAnime->playSpeed * updateRate;
+    nextFrame = skelAnime->curFrame - updateSpeed;
     if (nextFrame < 0.0f) {
-        nextFrame += skelAnime->totalFrames;
-    } else if (skelAnime->totalFrames <= nextFrame) {
-        nextFrame -= skelAnime->totalFrames;
+        nextFrame += skelAnime->animLength;
+    } else if (skelAnime->animLength <= nextFrame) {
+        nextFrame -= skelAnime->animLength;
     }
 
-    if ((arg1 == 0.0f) && (updateSpeed > 0.0f)) {
-        arg1 = skelAnime->totalFrames;
+    if ((frame == 0.0f) && (updateSpeed > 0.0f)) {
+        frame = skelAnime->animLength;
     }
 
-    temp_f12 = (nextFrame + updateSpeed) - arg1;
-    if ((0.0f <= (temp_f12 * updateSpeed)) && (((temp_f12 - updateSpeed) * updateSpeed) < 0.0f)) {
-        return 1;
+    curFrameDiff = (nextFrame + updateSpeed) - frame;
+    if ((0.0f <= (curFrameDiff * updateSpeed)) && (((curFrameDiff - updateSpeed) * updateSpeed) < 0.0f)) {
+        return true;
     }
-    return 0;
+    return false;
 }
 
-s32 func_80136A48(SkelAnime* skelAnime, f32 arg1) {
+/**
+ * Checks if the current Link animation has reached the specified frame
+ */
+s32 LinkAnimation_OnFrame(SkelAnime* skelAnime, f32 frame) {
     f32 updateRate = gFramerateDivisorHalf;
 
-    return func_80136990(skelAnime, arg1, updateRate);
+    return Animation_OnFrameImpl(skelAnime, frame, updateRate);
 }
 
+/**
+ * Initializes a normal skeleton to a looping animation, dynamically allocating the frame tables if not provided.
+ */
 void SkelAnime_Init(GlobalContext* globalCtx, SkelAnime* skelAnime, SkeletonHeader* skeletonHeaderSeg,
-                    AnimationHeader* animationSeg, Vec3s* limbDrawTbl, Vec3s* transitionDrawTable, s32 limbCount) {
+                    AnimationHeader* animation, Vec3s* jointTable, Vec3s* morphTable, s32 limbCount) {
     SkeletonHeader* skeletonHeader;
 
     skeletonHeader = Lib_SegmentedToVirtual(skeletonHeaderSeg);
     skelAnime->limbCount = skeletonHeader->limbCount + 1;
-    skelAnime->skeleton = Lib_SegmentedToVirtual(skeletonHeader->skeletonSeg);
-    if (limbDrawTbl == NULL) {
-        skelAnime->limbDrawTbl = zelda_malloc(sizeof(*skelAnime->limbDrawTbl) * skelAnime->limbCount);
-        skelAnime->transitionDrawTbl = zelda_malloc(sizeof(*skelAnime->transitionDrawTbl) * skelAnime->limbCount);
+    skelAnime->skeleton = Lib_SegmentedToVirtual(skeletonHeader->segment);
+    if (jointTable == NULL) {
+        skelAnime->jointTable = ZeldaArena_Malloc(sizeof(*skelAnime->jointTable) * skelAnime->limbCount);
+        skelAnime->morphTable = ZeldaArena_Malloc(sizeof(*skelAnime->morphTable) * skelAnime->limbCount);
     } else {
-        skelAnime->limbDrawTbl = limbDrawTbl;
-        skelAnime->transitionDrawTbl = transitionDrawTable;
+        skelAnime->jointTable = jointTable;
+        skelAnime->morphTable = morphTable;
     }
 
-    if (animationSeg != NULL) {
-        SkelAnime_ChangeAnimDefaultRepeat(skelAnime, animationSeg);
+    if (animation != NULL) {
+        Animation_PlayLoop(skelAnime, animation);
     }
 }
 
-void SkelAnime_InitSV(GlobalContext* globalCtx, SkelAnime* skelAnime, FlexSkeletonHeader* skeletonHeaderSeg,
-                      AnimationHeader* animationSeg, Vec3s* limbDrawTbl, Vec3s* transitionDrawTable, s32 limbCount) {
+/**
+ * Initializes a flex skeleton to a looping animation, dynamically allocating the frame tables if not given.
+ */
+void SkelAnime_InitFlex(GlobalContext* globalCtx, SkelAnime* skelAnime, FlexSkeletonHeader* skeletonHeaderSeg,
+                        AnimationHeader* animation, Vec3s* jointTable, Vec3s* morphTable, s32 limbCount) {
     FlexSkeletonHeader* skeletonHeader;
 
     skeletonHeader = Lib_SegmentedToVirtual(skeletonHeaderSeg);
     skelAnime->limbCount = skeletonHeader->sh.limbCount + 1;
     skelAnime->dListCount = skeletonHeader->dListCount;
-    skelAnime->skeleton = Lib_SegmentedToVirtual(skeletonHeader->sh.skeletonSeg);
+    skelAnime->skeleton = Lib_SegmentedToVirtual(skeletonHeader->sh.segment);
 
-    if (limbDrawTbl == NULL) {
-        skelAnime->limbDrawTbl = zelda_malloc(sizeof(*skelAnime->limbDrawTbl) * skelAnime->limbCount);
+    if (jointTable == NULL) {
+        skelAnime->jointTable = ZeldaArena_Malloc(sizeof(*skelAnime->jointTable) * skelAnime->limbCount);
 
-        skelAnime->transitionDrawTbl = zelda_malloc(sizeof(*skelAnime->transitionDrawTbl) * skelAnime->limbCount);
+        skelAnime->morphTable = ZeldaArena_Malloc(sizeof(*skelAnime->morphTable) * skelAnime->limbCount);
     } else {
-        skelAnime->limbDrawTbl = limbDrawTbl;
-        skelAnime->transitionDrawTbl = transitionDrawTable;
+        skelAnime->jointTable = jointTable;
+        skelAnime->morphTable = morphTable;
     }
 
-    if (animationSeg != NULL) {
-        SkelAnime_ChangeAnimDefaultRepeat(skelAnime, animationSeg);
+    if (animation != NULL) {
+        Animation_PlayLoop(skelAnime, animation);
     }
 }
 
+/**
+ * Initializes a skeleton with SkinLimbs to a looping animation, dynamically allocating the frame tables.
+ */
 void SkelAnime_InitSkin(GlobalContext* globalCtx, SkelAnime* skelAnime, SkeletonHeader* skeletonHeaderSeg,
-                        AnimationHeader* animationSeg) {
+                        AnimationHeader* animation) {
     SkeletonHeader* skeletonHeader;
 
     skeletonHeader = Lib_SegmentedToVirtual(skeletonHeaderSeg);
     skelAnime->limbCount = skeletonHeader->limbCount + 1;
-    skelAnime->skeleton = Lib_SegmentedToVirtual(skeletonHeader->skeletonSeg);
-    skelAnime->limbDrawTbl = zelda_malloc(sizeof(*skelAnime->limbDrawTbl) * skelAnime->limbCount);
-    skelAnime->transitionDrawTbl = zelda_malloc(sizeof(*skelAnime->transitionDrawTbl) * skelAnime->limbCount);
+    skelAnime->skeleton = Lib_SegmentedToVirtual(skeletonHeader->segment);
+    skelAnime->jointTable = ZeldaArena_Malloc(sizeof(*skelAnime->jointTable) * skelAnime->limbCount);
+    skelAnime->morphTable = ZeldaArena_Malloc(sizeof(*skelAnime->morphTable) * skelAnime->limbCount);
 
     // Debug prints here, required to match.
     if (1) {};
 
-    if (animationSeg != NULL) {
-        SkelAnime_ChangeAnimDefaultRepeat(skelAnime, animationSeg);
+    if (animation != NULL) {
+        Animation_PlayLoop(skelAnime, animation);
     }
 }
 
-void func_80136C84(SkelAnime* skelAnime) {
-    if (skelAnime->mode < 2) {
-        skelAnime->animUpdate = func_8013702C;
-    } else if (skelAnime->mode < 4) {
-        skelAnime->animUpdate = func_8013713C;
+/**
+ * Sets the SkelAnime's update function based on its current mode.
+ */
+void SkelAnime_SetUpdate(SkelAnime* skelAnime) {
+    if (skelAnime->mode <= ANIMMODE_LOOP_INTERP) {
+        skelAnime->update = SkelAnime_LoopFull;
+    } else if (skelAnime->mode <= ANIMMODE_ONCE_INTERP) {
+        skelAnime->update = SkelAnime_Once;
     } else {
-        skelAnime->animUpdate = func_801370B0;
+        skelAnime->update = SkelAnime_LoopPartial;
     }
 }
 
-s32 SkelAnime_FrameUpdateMatrix(SkelAnime* skelAnime) {
-    return skelAnime->animUpdate(skelAnime);
+/**
+ * Advances the current animation and updates all frame tables. If the animation plays once, returns true when it
+ * finishes.
+ */
+s32 SkelAnime_Update(SkelAnime* skelAnime) {
+    return skelAnime->update(skelAnime);
 }
 
-s32 func_80136CF4(SkelAnime* skelAnime) {
-    f32 prevUnk28 = skelAnime->transCurrentFrame;
+/**
+ * Morphs from the pose in jointTable to the one in morphTable, advancing the morph but not the animation frame
+ */
+s32 SkelAnime_Morph(SkelAnime* skelAnime) {
+    f32 prevMorphWeight = skelAnime->morphWeight;
     f32 updateRate = gFramerateDivisorThird;
 
-    skelAnime->transCurrentFrame -= skelAnime->transitionStep * updateRate;
-    if (skelAnime->transCurrentFrame <= 0.0f) {
-        func_80136C84(skelAnime);
-        skelAnime->transCurrentFrame = 0.0f;
+    skelAnime->morphWeight -= skelAnime->morphRate * updateRate;
+    if (skelAnime->morphWeight <= 0.0f) {
+        SkelAnime_SetUpdate(skelAnime);
+        skelAnime->morphWeight = 0.0f;
     }
-    SkelAnime_InterpolateVec3s(skelAnime->limbCount, skelAnime->limbDrawTbl, skelAnime->limbDrawTbl,
-                               skelAnime->transitionDrawTbl, 1.0f - (skelAnime->transCurrentFrame / prevUnk28));
+    SkelAnime_InterpFrameTable(skelAnime->limbCount, skelAnime->jointTable, skelAnime->jointTable,
+                               skelAnime->morphTable, 1.0f - (skelAnime->morphWeight / prevMorphWeight));
     return 0;
 }
 
-s32 func_80136D98(SkelAnime* skelAnime) {
-    s16 temp_a2 = (s16)(skelAnime->transCurrentFrame * 16384.0f);
-    s16 temp_a1;
-    f32 sp28;
-    f32 phi_f2;
+/**
+ * Performs a tapered morph from the pose in jointTable to the one in morphTable, advancing the morph but not the
+ * animation frame
+ */
+s32 SkelAnime_MorphTaper(SkelAnime* skelAnime) {
+    s16 prevPhase = skelAnime->morphWeight * 0x4000;
+    s16 curPhase;
+    f32 prevWeight;
+    f32 curWeight;
     f32 updateRate = gFramerateDivisorThird;
 
-    skelAnime->transCurrentFrame -= skelAnime->transitionStep * updateRate;
-    if (skelAnime->transCurrentFrame <= 0.0f) {
-        func_80136C84(skelAnime);
-        skelAnime->transCurrentFrame = 0.0f;
+    skelAnime->morphWeight -= skelAnime->morphRate * updateRate;
+    if (skelAnime->morphWeight <= 0.0f) {
+        SkelAnime_SetUpdate(skelAnime);
+        skelAnime->morphWeight = 0.0f;
     }
-    temp_a1 = (s16)(skelAnime->transCurrentFrame * 16384.0f);
-    if (skelAnime->unk03 < 0) {
-        sp28 = 1.0f - Math_CosS(temp_a2);
-        phi_f2 = 1.0f - Math_CosS(temp_a1);
+    curPhase = skelAnime->morphWeight * 0x4000;
+    if (skelAnime->taper < 0) {
+        prevWeight = 1.0f - Math_CosS(prevPhase);
+        curWeight = 1.0f - Math_CosS(curPhase);
     } else {
-        sp28 = Math_SinS(temp_a2);
-        phi_f2 = Math_SinS(temp_a1);
+        prevWeight = Math_SinS(prevPhase);
+        curWeight = Math_SinS(curPhase);
     }
-    if (phi_f2 != 0.0f) {
-        phi_f2 /= sp28;
+    if (curWeight != 0.0f) {
+        curWeight /= prevWeight;
     } else {
-        phi_f2 = 0.0f;
+        curWeight = 0.0f;
     }
-    SkelAnime_InterpolateVec3s(skelAnime->limbCount, skelAnime->limbDrawTbl, skelAnime->limbDrawTbl,
-                               skelAnime->transitionDrawTbl, 1.0f - phi_f2);
+    SkelAnime_InterpFrameTable(skelAnime->limbCount, skelAnime->jointTable, skelAnime->jointTable,
+                               skelAnime->morphTable, 1.0f - curWeight);
     return 0;
 }
 
-void func_80136F04(SkelAnime* skelAnime) {
-    s32 t;
-    s32 pad[2];
-    Vec3s sp38[98];
-    f32 temp_f10;
-    f32 temp_f2;
-
-    SkelAnime_AnimateFrame(skelAnime->animCurrentSeg, skelAnime->animCurrentFrame, skelAnime->limbCount,
-                           skelAnime->limbDrawTbl);
-    if (skelAnime->mode & 0x1) {
-        t = (s32)skelAnime->animCurrentFrame;
-        temp_f10 = t;
-        temp_f2 = skelAnime->animCurrentFrame - temp_f10;
-        t++;
-        if (t >= (s32)skelAnime->totalFrames) {
-            t = 0;
+/**
+ * Gets frame data for the current frame as modified by morphTable and advances the morph
+ */
+void SkelAnime_AnimateFrame(SkelAnime* skelAnime) {
+    Vec3s nextjointTable[100];
+
+    SkelAnime_GetFrameData(skelAnime->animation, skelAnime->curFrame, skelAnime->limbCount, skelAnime->jointTable);
+    if (skelAnime->mode & ANIM_INTERP) {
+        s32 frame = skelAnime->curFrame;
+        f32 partialFrame = skelAnime->curFrame - frame;
+
+        if (++frame >= (s32)skelAnime->animLength) {
+            frame = 0;
         }
-        SkelAnime_AnimateFrame(skelAnime->animCurrentSeg, t, skelAnime->limbCount, sp38);
-        SkelAnime_InterpolateVec3s(skelAnime->limbCount, skelAnime->limbDrawTbl, skelAnime->limbDrawTbl, sp38, temp_f2);
+        SkelAnime_GetFrameData(skelAnime->animation, frame, skelAnime->limbCount, nextjointTable);
+        SkelAnime_InterpFrameTable(skelAnime->limbCount, skelAnime->jointTable, skelAnime->jointTable, nextjointTable,
+                                   partialFrame);
     }
-    if (skelAnime->transCurrentFrame != 0) {
+    if (skelAnime->morphWeight != 0) {
         f32 updateRate = gFramerateDivisorThird;
-        skelAnime->transCurrentFrame -= skelAnime->transitionStep * updateRate;
-        if (skelAnime->transCurrentFrame <= 0.0f) {
-            skelAnime->transCurrentFrame = 0.0f;
-            return;
+
+        skelAnime->morphWeight -= skelAnime->morphRate * updateRate;
+        if (skelAnime->morphWeight <= 0.0f) {
+            skelAnime->morphWeight = 0.0f;
+        } else {
+            SkelAnime_InterpFrameTable(skelAnime->limbCount, skelAnime->jointTable, skelAnime->jointTable,
+                                       skelAnime->morphTable, skelAnime->morphWeight);
         }
-        SkelAnime_InterpolateVec3s(skelAnime->limbCount, skelAnime->limbDrawTbl, skelAnime->limbDrawTbl,
-                                   skelAnime->transitionDrawTbl, skelAnime->transCurrentFrame);
     }
 }
-
-s32 func_8013702C(SkelAnime* skelAnime) {
+/**
+ * Advances an animation that loops over its full length and updates the frame tables
+ */
+s32 SkelAnime_LoopFull(SkelAnime* skelAnime) {
     f32 updateRate = gFramerateDivisorThird;
 
-    skelAnime->animCurrentFrame += skelAnime->animPlaybackSpeed * updateRate;
-    if (skelAnime->animCurrentFrame < 0.0f) {
-        skelAnime->animCurrentFrame += skelAnime->totalFrames;
-    } else if (skelAnime->totalFrames <= skelAnime->animCurrentFrame) {
-        skelAnime->animCurrentFrame -= skelAnime->totalFrames;
+    skelAnime->curFrame += skelAnime->playSpeed * updateRate;
+    if (skelAnime->curFrame < 0.0f) {
+        skelAnime->curFrame += skelAnime->animLength;
+    } else if (skelAnime->animLength <= skelAnime->curFrame) {
+        skelAnime->curFrame -= skelAnime->animLength;
     }
 
-    func_80136F04(skelAnime);
+    SkelAnime_AnimateFrame(skelAnime);
     return 0;
 }
 
-s32 func_801370B0(SkelAnime* skelAnime) {
+/**
+ * Advances an animation that loops over part of its length and updates the frame tables
+ */
+s32 SkelAnime_LoopPartial(SkelAnime* skelAnime) {
     f32 updateRate = gFramerateDivisorThird;
 
-    skelAnime->animCurrentFrame += skelAnime->animPlaybackSpeed * updateRate;
-    if (skelAnime->animCurrentFrame < skelAnime->initialFrame) {
-        skelAnime->animCurrentFrame =
-            (skelAnime->animCurrentFrame - skelAnime->initialFrame) + skelAnime->animFrameCount;
-    } else if (skelAnime->animFrameCount <= skelAnime->animCurrentFrame) {
-        skelAnime->animCurrentFrame =
-            (skelAnime->animCurrentFrame - skelAnime->animFrameCount) + skelAnime->initialFrame;
+    skelAnime->curFrame += skelAnime->playSpeed * updateRate;
+    if (skelAnime->curFrame < skelAnime->startFrame) {
+        skelAnime->curFrame = (skelAnime->curFrame - skelAnime->startFrame) + skelAnime->endFrame;
+    } else if (skelAnime->endFrame <= skelAnime->curFrame) {
+        skelAnime->curFrame = (skelAnime->curFrame - skelAnime->endFrame) + skelAnime->startFrame;
     }
 
-    func_80136F04(skelAnime);
+    SkelAnime_AnimateFrame(skelAnime);
     return 0;
 }
 
-s32 func_8013713C(SkelAnime* skelAnime) {
+/**
+ * Advances an animation that stops at endFrame and returns true when it is reached.
+ */
+s32 SkelAnime_Once(SkelAnime* skelAnime) {
     f32 updateRate = gFramerateDivisorThird;
 
-    if (skelAnime->animCurrentFrame == skelAnime->animFrameCount) {
-        SkelAnime_AnimateFrame(skelAnime->animCurrentSeg, (s32)skelAnime->animCurrentFrame, skelAnime->limbCount,
-                               skelAnime->limbDrawTbl);
-        func_80136F04(skelAnime);
+    if (skelAnime->curFrame == skelAnime->endFrame) {
+        SkelAnime_GetFrameData(skelAnime->animation, skelAnime->curFrame, skelAnime->limbCount, skelAnime->jointTable);
+        SkelAnime_AnimateFrame(skelAnime);
         return 1;
     }
 
-    skelAnime->animCurrentFrame += skelAnime->animPlaybackSpeed * updateRate;
-    if (((skelAnime->animCurrentFrame - skelAnime->animFrameCount) * skelAnime->animPlaybackSpeed) > 0.0f) {
-        skelAnime->animCurrentFrame = skelAnime->animFrameCount;
+    skelAnime->curFrame += skelAnime->playSpeed * updateRate;
+    if (((skelAnime->curFrame - skelAnime->endFrame) * skelAnime->playSpeed) > 0.0f) {
+        skelAnime->curFrame = skelAnime->endFrame;
     } else {
-        if (skelAnime->animCurrentFrame < 0.0f) {
-            skelAnime->animCurrentFrame += skelAnime->totalFrames;
+        if (skelAnime->curFrame < 0.0f) {
+            skelAnime->curFrame += skelAnime->animLength;
         } else {
-            if (skelAnime->totalFrames <= skelAnime->animCurrentFrame) {
-                skelAnime->animCurrentFrame -= skelAnime->totalFrames;
+            if (skelAnime->animLength <= skelAnime->curFrame) {
+                skelAnime->curFrame -= skelAnime->animLength;
             }
         }
     }
-    func_80136F04(skelAnime);
+    SkelAnime_AnimateFrame(skelAnime);
     return 0;
 }
 
-void SkelAnime_ChangeAnimImpl(SkelAnime* skelAnime, AnimationHeader* animationSeg, f32 playbackSpeed, f32 frame,
-                              f32 frameCount, u8 animationType, f32 transitionRate, s8 unk2) {
-    skelAnime->mode = animationType;
-    if ((transitionRate != 0.0f) &&
-        ((animationSeg != skelAnime->animCurrentSeg) || (frame != skelAnime->animCurrentFrame))) {
-        if (transitionRate < 0) {
-            func_80136C84(skelAnime);
-            SkelAnime_CopyVec3s(skelAnime, skelAnime->transitionDrawTbl, skelAnime->limbDrawTbl);
-            transitionRate = -transitionRate;
+/**
+ * Fully general way to set a new animation, allowing choice of playback speed, start frame, end frame, play mode,
+ * number of transition frames, and tapering of the transition. Positive morph frames morph from the current pose to the
+ * start pose of the new animation, then start the new animation. Negative morph frames start the new animation
+ * immediately, modified by the pose immediately before the animation change.
+ */
+void Animation_ChangeImpl(SkelAnime* skelAnime, AnimationHeader* animation, f32 playSpeed, f32 startFrame, f32 endFrame,
+                          u8 mode, f32 morphFrames, s8 taper) {
+    skelAnime->mode = mode;
+    if ((morphFrames != 0.0f) && ((animation != skelAnime->animation) || (startFrame != skelAnime->curFrame))) {
+        if (morphFrames < 0) {
+            SkelAnime_SetUpdate(skelAnime);
+            SkelAnime_CopyFrameTable(skelAnime, skelAnime->morphTable, skelAnime->jointTable);
+            morphFrames = -morphFrames;
         } else {
-            if (unk2 != 0) {
-                skelAnime->animUpdate = func_80136D98;
-                skelAnime->unk03 = unk2;
+            if (taper != ANIMTAPER_NONE) {
+                skelAnime->update = SkelAnime_MorphTaper;
+                skelAnime->taper = taper;
             } else {
-                skelAnime->animUpdate = func_80136CF4;
+                skelAnime->update = SkelAnime_Morph;
             }
-            SkelAnime_AnimateFrame(animationSeg, frame, skelAnime->limbCount, skelAnime->transitionDrawTbl);
+            SkelAnime_GetFrameData(animation, startFrame, skelAnime->limbCount, skelAnime->morphTable);
         }
-        skelAnime->transCurrentFrame = 1.0f;
-        skelAnime->transitionStep = 1.0f / transitionRate;
+        skelAnime->morphWeight = 1.0f;
+        skelAnime->morphRate = 1.0f / morphFrames;
     } else {
-        func_80136C84(skelAnime);
-        SkelAnime_AnimateFrame(animationSeg, frame, skelAnime->limbCount, skelAnime->limbDrawTbl);
-        skelAnime->transCurrentFrame = 0.0f;
+        SkelAnime_SetUpdate(skelAnime);
+        SkelAnime_GetFrameData(animation, startFrame, skelAnime->limbCount, skelAnime->jointTable);
+        skelAnime->morphWeight = 0.0f;
     }
 
-    skelAnime->animCurrentSeg = animationSeg;
-    skelAnime->initialFrame = frame;
-    skelAnime->animFrameCount = frameCount;
-    skelAnime->totalFrames = SkelAnime_GetTotalFrames(&animationSeg->common);
-    if (skelAnime->mode >= 4) {
-        skelAnime->animCurrentFrame = 0.0f;
+    skelAnime->animation = animation;
+    skelAnime->startFrame = startFrame;
+    skelAnime->endFrame = endFrame;
+    skelAnime->animLength = Animation_GetLength(&animation->common);
+    if (skelAnime->mode >= ANIMMODE_LOOP_PARTIAL) {
+        skelAnime->curFrame = 0.0f;
     } else {
-        skelAnime->animCurrentFrame = frame;
-        if (skelAnime->mode < 2) {
-            skelAnime->animFrameCount = skelAnime->totalFrames - 1.0f;
+        skelAnime->curFrame = startFrame;
+        if (skelAnime->mode <= ANIMMODE_LOOP_INTERP) {
+            skelAnime->endFrame = skelAnime->animLength - 1.0f;
         }
     }
-    skelAnime->animPlaybackSpeed = playbackSpeed;
+    skelAnime->playSpeed = playSpeed;
 }
 
-void SkelAnime_ChangeAnim(SkelAnime* skelAnime, AnimationHeader* animationSeg, f32 playbackSpeed, f32 frame,
-                          f32 frameCount, u8 mode, f32 transitionRate) {
-    SkelAnime_ChangeAnimImpl(skelAnime, animationSeg, playbackSpeed, frame, frameCount, mode, transitionRate, 0);
+/**
+ * General way to set a new animation, allowing choice of playback speed, start frame, end frame, play mode, and number
+ * of transition frames. Positive morph frames morph from the current pose to the start pose of the new animation, then
+ * start the new animation. Negative morph frames start the new animation immediately, modified by the pose immediately
+ * before the animation change.
+ */
+void Animation_Change(SkelAnime* skelAnime, AnimationHeader* animation, f32 playSpeed, f32 startFrame, f32 endFrame,
+                      u8 mode, f32 morphFrames) {
+    Animation_ChangeImpl(skelAnime, animation, playSpeed, startFrame, endFrame, mode, morphFrames, ANIMTAPER_NONE);
 }
 
-void SkelAnime_ChangeAnimDefaultStop(SkelAnime* skelAnime, AnimationHeader* animationSeg) {
-    SkelAnime_ChangeAnim(skelAnime, animationSeg, 1.0f, 0.0f, SkelAnime_GetFrameCount(&animationSeg->common), 2, 0.0f);
+/**
+ * Immediately changes to an animation that plays once at the default speed.
+ */
+void Animation_PlayOnce(SkelAnime* skelAnime, AnimationHeader* animation) {
+    Animation_Change(skelAnime, animation, 1.0f, 0.0f, Animation_GetLastFrame(&animation->common), ANIMMODE_ONCE, 0.0f);
 }
 
-void SkelAnime_ChangeAnimTransitionStop(SkelAnime* skelAnime, AnimationHeader* animationSeg, f32 transitionRate) {
-    SkelAnime_ChangeAnim(skelAnime, animationSeg, 1.0f, 0, SkelAnime_GetFrameCount(&animationSeg->common), 2,
-                         transitionRate);
+/**
+ * Smoothly transitions to an animation that plays once at the default speed.
+ * Positive morph frames morph from the current pose to the start pose of the new animation, then start the new
+ * animation. Negative morph frames start the new animation immediately, modified by the pose immediately before the
+ * animation change.
+ */
+void Animation_MorphToPlayOnce(SkelAnime* skelAnime, AnimationHeader* animationSeg, f32 morphFrames) {
+    Animation_Change(skelAnime, animationSeg, 1.0f, 0, Animation_GetLastFrame(&animationSeg->common), ANIMMODE_ONCE,
+                     morphFrames);
 }
 
-void SkelAnime_ChangeAnimPlaybackStop(SkelAnime* skelAnime, AnimationHeader* animationSeg, f32 playbackSpeed) {
-    SkelAnime_ChangeAnim(skelAnime, animationSeg, playbackSpeed, 0.0f, SkelAnime_GetFrameCount(&animationSeg->common),
-                         2, 0.0f);
+/**
+ * Immediately changes to an animation that plays once at the specified speed.
+ */
+void Animation_PlayOnceSetSpeed(SkelAnime* skelAnime, AnimationHeader* animation, f32 playSpeed) {
+    Animation_Change(skelAnime, animation, playSpeed, 0.0f, Animation_GetLastFrame(&animation->common), ANIMMODE_ONCE,
+                     0.0f);
 }
 
-void SkelAnime_ChangeAnimDefaultRepeat(SkelAnime* skelAnime, AnimationHeader* animationSeg) {
-    SkelAnime_ChangeAnim(skelAnime, animationSeg, 1.0f, 0.0f, SkelAnime_GetFrameCount(&animationSeg->common), 0, 0.0f);
+/**
+ * Immediately changes to an animation that loops at the default.
+ */
+void Animation_PlayLoop(SkelAnime* skelAnime, AnimationHeader* animation) {
+    Animation_Change(skelAnime, animation, 1.0f, 0.0f, Animation_GetLastFrame(&animation->common), ANIMMODE_LOOP, 0.0f);
 }
 
-void SkelAnime_ChangeAnimTransitionRepeat(SkelAnime* skelAnime, AnimationHeader* animationSeg, f32 transitionRate) {
-    SkelAnime_ChangeAnim(skelAnime, animationSeg, 1.0f, 0.0f, 0.0f, 0, transitionRate);
+/**
+ * Smoothly transitions to a looping animation, specifying the number of frames for the transition.
+ * Positive morph frames morph from the current pose to the start pose of the new animation, then start the new
+ * animation. Negative morph frames start the new animation immediately, modified by the pose immediately before the
+ * animation change.
+ */
+void Animation_MorphToLoop(SkelAnime* skelAnime, AnimationHeader* animation, f32 morphFrames) {
+    Animation_Change(skelAnime, animation, 1.0f, 0.0f, 0.0f, ANIMMODE_LOOP, morphFrames);
 }
 
-void SkelAnime_ChangeAnimPlaybackRepeat(SkelAnime* skelAnime, AnimationHeader* animationSeg, f32 playbackSpeed) {
-    SkelAnime_ChangeAnim(skelAnime, animationSeg, playbackSpeed, 0.0f, SkelAnime_GetFrameCount(&animationSeg->common),
-                         0, 0.0f);
+/**
+ * Immediately changes to an animation that loops at the specified speed.
+ */
+void Animation_PlayLoopSetSpeed(SkelAnime* skelAnime, AnimationHeader* animation, f32 playbackSpeed) {
+    Animation_Change(skelAnime, animation, playbackSpeed, 0.0f, Animation_GetLastFrame(&animation->common),
+                     ANIMMODE_LOOP, 0.0f);
 }
 
-void SkelAnime_AnimSetStop(SkelAnime* skelAnime) {
-    skelAnime->mode = 2;
-    skelAnime->animFrameCount = skelAnime->totalFrames;
-    func_80136C84(skelAnime);
+/**
+ * Changes a looping animation to one that stops at the end. Unused
+ */
+void Animation_EndLoop(SkelAnime* skelAnime) {
+    skelAnime->mode = ANIMMODE_ONCE;
+    skelAnime->endFrame = skelAnime->animLength;
+    SkelAnime_SetUpdate(skelAnime);
 }
 
-void SkelAnime_AnimReverse(SkelAnime* skelAnime) {
-    f32 initialFrame = skelAnime->initialFrame;
+/**
+ * Reverses the current animation.
+ */
+void Animation_Reverse(SkelAnime* skelAnime) {
+    f32 startFrame = skelAnime->startFrame;
 
-    skelAnime->initialFrame = skelAnime->animFrameCount;
-    skelAnime->animPlaybackSpeed = -skelAnime->animPlaybackSpeed;
-    skelAnime->animFrameCount = initialFrame;
+    skelAnime->startFrame = skelAnime->endFrame;
+    skelAnime->playSpeed = -skelAnime->playSpeed;
+    skelAnime->endFrame = startFrame;
 }
 
-void func_80137674(SkelAnime* skelAnime, Vec3s* dst, Vec3s* src, u8* index) {
+/**
+ * Copies the src frame table to the dst frame table if copyFlag for that limb is true.
+ */
+void SkelAnime_CopyFrameTableTrue(SkelAnime* skelAnime, Vec3s* dst, Vec3s* src, u8* copyFlag) {
     s32 i;
 
     for (i = 0; i < skelAnime->limbCount; i++, dst++, src++) {
-        if (*index++) {
+        if (*copyFlag++) {
             *dst = *src;
         }
     }
 }
 
-void func_801376DC(SkelAnime* skelAnime, Vec3s* dst, Vec3s* src, u8* arg3) {
+/**
+ * Copies the src frame table to the dst frame table if copyFlag for that limb is false.
+ */
+void SkelAnime_CopyFrameTableFalse(SkelAnime* skelAnime, Vec3s* dst, Vec3s* src, u8* copyFlag) {
     s32 i;
 
     for (i = 0; i < skelAnime->limbCount; i++, dst++, src++) {
-        if (*arg3++ < 1U) {
+        if (!*copyFlag++) {
             *dst = *src;
         }
     }
 }
 
-/*
- * Moves `pos` backwards on the xz plane from `angle`
+/**
+ * Updates translation of the root limb and calculates `pos`, the difference between
+ * the old and new positions of the root limb as rotated by `angle`. Used to allow
+ * animations to change an actor's position.
  */
-void func_80137748(SkelAnime* skelAnime, Vec3f* pos, s16 angle) {
+void SkelAnime_UpdateTranslation(SkelAnime* skelAnime, Vec3f* diff, s16 angle) {
     f32 x;
     f32 z;
     f32 sin;
     f32 cos;
 
-    if (skelAnime->flags & 0x10) {
-        pos->z = 0.0f;
-        pos->x = 0.0f;
+    if (skelAnime->moveFlags & ANIM_FLAG_NOMOVE) {
+        diff->z = 0.0f;
+        diff->x = 0.0f;
     } else {
         // `angle` rotation around y axis.
-        x = skelAnime->limbDrawTbl->x - skelAnime->prevFramePos.x;
-        z = skelAnime->limbDrawTbl->z - skelAnime->prevFramePos.z;
+        x = skelAnime->jointTable->x - skelAnime->prevTransl.x;
+        z = skelAnime->jointTable->z - skelAnime->prevTransl.z;
         sin = Math_SinS(angle);
         cos = Math_CosS(angle);
-        pos->x = x * cos + z * sin;
-        pos->z = z * cos - x * sin;
+        diff->x = x * cos + z * sin;
+        diff->z = z * cos - x * sin;
     }
 
-    skelAnime->prevFramePos.x = skelAnime->limbDrawTbl->x;
-    skelAnime->limbDrawTbl->x = skelAnime->unk3E.x;
-    skelAnime->prevFramePos.z = skelAnime->limbDrawTbl->z;
-    skelAnime->limbDrawTbl->z = skelAnime->unk3E.z;
-    if (skelAnime->flags & ANIM_FLAG_UPDATEXZ) {
-        if (skelAnime->flags & ANIM_FLAG_UPDATEY) {
-            pos->y = 0.0f;
+    skelAnime->prevTransl.x = skelAnime->jointTable->x;
+    skelAnime->jointTable->x = skelAnime->baseTransl.x;
+    skelAnime->prevTransl.z = skelAnime->jointTable->z;
+    skelAnime->jointTable->z = skelAnime->baseTransl.z;
+    if (skelAnime->moveFlags & ANIM_FLAG_UPDATEY) {
+        if (skelAnime->moveFlags & ANIM_FLAG_NOMOVE) {
+            diff->y = 0.0f;
         } else {
-            pos->y = skelAnime->limbDrawTbl->y - skelAnime->prevFramePos.y;
+            diff->y = skelAnime->jointTable->y - skelAnime->prevTransl.y;
         }
-        skelAnime->prevFramePos.y = skelAnime->limbDrawTbl->y;
-        skelAnime->limbDrawTbl->y = skelAnime->unk3E.y;
+        skelAnime->prevTransl.y = skelAnime->jointTable->y;
+        skelAnime->jointTable->y = skelAnime->baseTransl.y;
     } else {
-        pos->y = 0.0f;
-        skelAnime->prevFramePos.y = skelAnime->limbDrawTbl->y;
+        diff->y = 0.0f;
+        skelAnime->prevTransl.y = skelAnime->jointTable->y;
     }
-    skelAnime->flags &= ~ANIM_FLAG_UPDATEY;
+    skelAnime->moveFlags &= ~ANIM_FLAG_NOMOVE;
 }
 
-s32 func_801378B8(SkelAnime* skelAnime, f32 arg1) {
-    return func_80136990(skelAnime, arg1, 1.0f);
+/**
+ * Checks if the current animation is at the specified frame
+ */
+s32 Animation_OnFrame(SkelAnime* skelAnime, f32 frame) {
+    return Animation_OnFrameImpl(skelAnime, frame, 1.0f);
 }
 
+/**
+ * Frees the frame tables for a skelAnime with dynamically allocated tables.
+ */
 void SkelAnime_Free(SkelAnime* skelAnime, GlobalContext* globalCtx) {
-    if (skelAnime->limbDrawTbl != NULL) {
-        zelda_free(skelAnime->limbDrawTbl);
+    if (skelAnime->jointTable != NULL) {
+        ZeldaArena_Free(skelAnime->jointTable);
     }
 
-    if (skelAnime->transitionDrawTbl != NULL) {
-        zelda_free(skelAnime->transitionDrawTbl);
+    if (skelAnime->morphTable != NULL) {
+        ZeldaArena_Free(skelAnime->morphTable);
     }
 }
 
-void SkelAnime_CopyVec3s(SkelAnime* skelAnime, Vec3s* dst, Vec3s* src) {
+/**
+ * Copies the src frame table to the dst frame table.
+ */
+void SkelAnime_CopyFrameTable(SkelAnime* skelAnime, Vec3s* dst, Vec3s* src) {
     bcopy(src, dst, sizeof(Vec3s) * skelAnime->limbCount);
 }
diff --git a/src/code/z_view.c b/src/code/z_view.c
index 034f045b1..c325fd563 100644
--- a/src/code/z_view.c
+++ b/src/code/z_view.c
@@ -237,7 +237,7 @@ s32 View_SetQuake(View* view, Vec3f rot, Vec3f scale, f32 speed) {
     return 1;
 }
 
-s32 View_StepQuake(View* view, RSPMatrix* matrix) {
+s32 View_StepQuake(View* view, Mtx* matrix) {
     MtxF mf;
 
     if (view->quakeSpeed == 0.0f) {
@@ -256,16 +256,16 @@ s32 View_StepQuake(View* view, RSPMatrix* matrix) {
         view->currQuakeScale.z += ((view->quakeScale.z - view->currQuakeScale.z) * view->quakeSpeed);
     }
 
-    SysMatrix_FromRSPMatrix(matrix, &mf);
-    SysMatrix_SetCurrentState(&mf);
-    SysMatrix_RotateStateAroundXAxis(view->currQuakeRot.x);
-    SysMatrix_InsertYRotation_f(view->currQuakeRot.y, 1);
-    SysMatrix_InsertZRotation_f(view->currQuakeRot.z, 1);
-    Matrix_Scale(view->currQuakeScale.x, view->currQuakeScale.y, view->currQuakeScale.z, 1);
-    SysMatrix_InsertZRotation_f(-view->currQuakeRot.z, 1);
-    SysMatrix_InsertYRotation_f(-view->currQuakeRot.y, 1);
-    SysMatrix_RotateStateAroundXAxis(-view->currQuakeRot.x);
-    SysMatrix_GetStateAsRSPMatrix(matrix);
+    Matrix_FromRSPMatrix(matrix, &mf);
+    Matrix_SetCurrentState(&mf);
+    Matrix_RotateStateAroundXAxis(view->currQuakeRot.x);
+    Matrix_InsertYRotation_f(view->currQuakeRot.y, 1);
+    Matrix_InsertZRotation_f(view->currQuakeRot.z, 1);
+    Matrix_Scale(view->currQuakeScale.x, view->currQuakeScale.y, view->currQuakeScale.z, MTXMODE_APPLY);
+    Matrix_InsertZRotation_f(-view->currQuakeRot.z, 1);
+    Matrix_InsertYRotation_f(-view->currQuakeRot.y, 1);
+    Matrix_RotateStateAroundXAxis(-view->currQuakeRot.x);
+    Matrix_ToMtx(matrix);
 
     return 1;
 }
@@ -310,7 +310,7 @@ s32 View_RenderToPerspectiveMatrix(View* view) {
     guPerspective(projection, &view->normal, view->fovy, aspect, view->zNear, view->zFar, view->scale);
     view->projection = *projection;
     //! @bug: This cast of `projection` is invalid
-    View_StepQuake(view, (RSPMatrix*)projection);
+    View_StepQuake(view, (Mtx*)projection);
 
     gSPPerspNormalize(POLY_OPA_DISP++, view->normal);
     gSPMatrix(POLY_OPA_DISP++, projection, G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_PROJECTION);
diff --git a/src/code/z_vr_box.c b/src/code/z_vr_box.c
index 1fca4801d..9e949beac 100644
--- a/src/code/z_vr_box.c
+++ b/src/code/z_vr_box.c
@@ -35,9 +35,9 @@ void func_80143148(SkyboxContext* skyboxCtx, s32 arg1) {
     }
 }
 
-void func_801431E8(GameState* gamestate, SkyboxContext* skyboxCtx, s16 skyType) {
-    GlobalContext* globalCtx = (GlobalContext*)gamestate;
-    u32 size;
+void func_801431E8(GameState* gameState, SkyboxContext* skyboxCtx, s16 skyType) {
+    GlobalContext* globalCtx = (GlobalContext*)gameState;
+    size_t size;
     void* offset;
     s32 pad;
 
@@ -82,7 +82,7 @@ void func_801431E8(GameState* gamestate, SkyboxContext* skyboxCtx, s16 skyType)
 }
 
 void func_80143324(GlobalContext* globalCtx, SkyboxContext* skyboxCtx, s16 skyType) {
-    u32 size;
+    size_t size;
 
     if (1) {}
 
@@ -133,22 +133,22 @@ void func_80143324(GlobalContext* globalCtx, SkyboxContext* skyboxCtx, s16 skyTy
     }
 }
 
-void func_801434E4(GameState* gamestate, SkyboxContext* skyboxCtx, s16 skyType) {
+void func_801434E4(GameState* gameState, SkyboxContext* skyboxCtx, s16 skyType) {
     skyboxCtx->skyboxShouldDraw = 0;
     skyboxCtx->rotX = skyboxCtx->rotY = skyboxCtx->rotZ = 0.0f;
 
-    func_801431E8(gamestate, skyboxCtx, skyType);
+    func_801431E8(gameState, skyboxCtx, skyType);
 
     if (skyType != 0) {
-        skyboxCtx->unk17C = THA_AllocEndAlign16(&gamestate->heap, 0x3840);
+        skyboxCtx->unk17C = THA_AllocEndAlign16(&gameState->heap, 0x3840);
 
         if (skyType == 5) {
             // Allocate enough space for the vertices for a 6 sided skybox (cube)
-            skyboxCtx->roomVtx = THA_AllocEndAlign16(&gamestate->heap, sizeof(Vtx) * 32 * 6);
+            skyboxCtx->roomVtx = THA_AllocEndAlign16(&gameState->heap, sizeof(Vtx) * 32 * 6);
             func_80143148(skyboxCtx, 6);
         } else {
             // Allocate enough space for the vertices for a 5 sided skybox (bottom is missing)
-            skyboxCtx->roomVtx = THA_AllocEndAlign16(&gamestate->heap, sizeof(Vtx) * 32 * 5);
+            skyboxCtx->roomVtx = THA_AllocEndAlign16(&gameState->heap, sizeof(Vtx) * 32 * 5);
             func_80143148(skyboxCtx, 5);
         }
     }
diff --git a/src/libultra/io/contpfs.c b/src/libultra/io/contpfs.c
index b5e6e0288..42009674f 100644
--- a/src/libultra/io/contpfs.c
+++ b/src/libultra/io/contpfs.c
@@ -1,15 +1,308 @@
+#include "ultra64.h"
 #include "global.h"
 
-#pragma GLOBAL_ASM("asm/non_matchings/boot/contpfs/__osSumcalc.s")
+u16 __osSumcalc(u8* ptr, s32 length) {
+    s32 i;
+    u32 sum = 0;
+    u8* temp = ptr;
 
-#pragma GLOBAL_ASM("asm/non_matchings/boot/contpfs/__osIdCheckSum.s")
+    for (i = 0; i < length; i++) {
+        sum += *temp++;
+    }
+    return sum & 0xFFFF;
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/boot/contpfs/__osRepairPackId.s")
+s32 __osIdCheckSum(u16* ptr, u16* checkSum, u16* idSum) {
+    u16 data = 0;
+    u32 i;
 
-#pragma GLOBAL_ASM("asm/non_matchings/boot/contpfs/__osCheckPackId.s")
+    *checkSum = *idSum = 0;
+    for (i = 0; i < ((sizeof(__OSPackId) - sizeof(u32)) / sizeof(u8)); i += 2) {
+        data = *((u16*)((u32)ptr + i));
+        *checkSum += data;
+        *idSum += ~data;
+    }
+    return 0;
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/boot/contpfs/__osGetId.s")
+s32 __osRepairPackId(OSPfs* pfs, __OSPackId* badid, __OSPackId* newid) {
+    s32 ret = 0;
+    u8 temp[BLOCKSIZE];
+    u8 comp[BLOCKSIZE];
+    u8 mask = 0;
+    s32 i, j = 0;
+    u16 index[4];
 
-#pragma GLOBAL_ASM("asm/non_matchings/boot/contpfs/__osCheckId.s")
+    newid->repaired = 0xFFFFFFFF;
+    newid->random = osGetCount();
+    newid->serialMid = badid->serialMid;
+    newid->serialLow = badid->serialLow;
 
-#pragma GLOBAL_ASM("asm/non_matchings/boot/contpfs/__osPfsRWInode.s")
+    if ((pfs->activebank != 0) && ((ret = __osPfsSelectBank(pfs, 0)) != 0)) {
+        return ret;
+    }
+
+    do {
+        if ((ret = __osPfsSelectBank(pfs, j)) != 0) {
+            return ret;
+        }
+
+        if ((ret = __osContRamRead(pfs->queue, pfs->channel, 0, temp)) != 0) {
+            return ret;
+        }
+        temp[0] = j | 0x80;
+        for (i = 1; i < BLOCKSIZE; i++) {
+            temp[i] = ~temp[i];
+        }
+
+        if ((ret = __osContRamWrite(pfs->queue, pfs->channel, 0, temp, 0)) != 0) {
+            return ret;
+        }
+        if ((ret = __osContRamRead(pfs->queue, pfs->channel, 0, comp)) != 0) {
+            return (ret);
+        }
+        for (i = 0; i < BLOCKSIZE; i++) {
+            if (comp[i] != temp[i]) {
+                break;
+            }
+        }
+        if (i != BLOCKSIZE) {
+            break;
+        }
+
+        if (j > 0) {
+            if ((ret = __osPfsSelectBank(pfs, 0)) != 0) {
+                return ret;
+            }
+            if ((ret = __osContRamRead(pfs->queue, pfs->channel, 0, temp)) != 0) {
+                return ret;
+            }
+            if (temp[0] != 0x80) {
+                break;
+            }
+        }
+
+        j++;
+    } while (j < PFS_MAX_BANKS);
+
+    if ((pfs->activebank != 0) && (ret = __osPfsSelectBank(pfs, 0)) != 0) {
+        return ret;
+    }
+
+    mask = (j > 0) ? 1 : 0;
+    newid->deviceid = (badid->deviceid & 0xFFFE) | mask;
+    newid->banks = j;
+    newid->version = badid->version;
+    __osIdCheckSum((u16*)newid, &newid->checksum, &newid->invertedChecksum);
+
+    index[0] = PFS_ID_0AREA;
+    index[1] = PFS_ID_1AREA;
+    index[2] = PFS_ID_2AREA;
+    index[3] = PFS_ID_3AREA;
+    for (i = 0; i < 4; i++) {
+        if ((ret = __osContRamWrite(pfs->queue, pfs->channel, index[i], (u8*)newid, PFS_FORCE)) != 0) {
+            return ret;
+        }
+    }
+    if ((ret = __osContRamRead(pfs->queue, pfs->channel, PFS_ID_0AREA, temp)) != 0) {
+        return ret;
+    }
+    for (i = 0; i < BLOCKSIZE; i++) {
+        if (temp[i] != *(u8*)((s32)newid + i)) {
+            return PFS_ERR_DEVICE;
+        }
+    }
+    return 0;
+}
+
+s32 __osCheckPackId(OSPfs* pfs, __OSPackId* check) {
+    u16 index[4];
+    s32 ret = 0;
+    u16 sum;
+    u16 idSum;
+    s32 i;
+    s32 j;
+
+    if ((pfs->activebank != 0) && (ret = __osPfsSelectBank(pfs, 0)) != 0) {
+        return ret;
+    }
+
+    index[0] = PFS_ID_0AREA;
+    index[1] = PFS_ID_1AREA;
+    index[2] = PFS_ID_2AREA;
+    index[3] = PFS_ID_3AREA;
+    for (i = 1; i < 4; i++) {
+        if ((ret = __osContRamRead(pfs->queue, pfs->channel, index[i], (u8*)check)) != 0) {
+            return ret;
+        }
+        __osIdCheckSum((u16*)check, &sum, &idSum);
+        if ((check->checksum == sum) && (check->invertedChecksum == idSum)) {
+            break;
+        }
+    }
+    if (i == 4) {
+        return PFS_ERR_ID_FATAL;
+    }
+
+    for (j = 0; j < 4; j++) {
+        if (j != i) {
+            if ((ret = __osContRamWrite(pfs->queue, pfs->channel, index[j], (u8*)check, PFS_FORCE)) != 0) {
+                return ret;
+            }
+        }
+    }
+    return 0;
+}
+
+s32 __osGetId(OSPfs* pfs) {
+    u16 sum;
+    u16 isum;
+    u8 temp[BLOCKSIZE];
+    __OSPackId* id;
+    __OSPackId newid;
+    s32 ret;
+
+    if (pfs->activebank != 0) {
+        if ((ret = __osPfsSelectBank(pfs, 0)) != 0) {
+            return ret;
+        }
+    }
+
+    if ((ret = __osContRamRead(pfs->queue, pfs->channel, PFS_ID_0AREA, temp)) != 0) {
+        return ret;
+    }
+
+    __osIdCheckSum((u16*)temp, &sum, &isum);
+    id = (__OSPackId*)temp;
+    if ((id->checksum != sum) || (id->invertedChecksum != isum)) {
+        if ((ret = __osCheckPackId(pfs, id)) == PFS_ERR_ID_FATAL) {
+            ret = __osRepairPackId(pfs, id, &newid);
+            if (ret) {
+                return ret;
+            }
+            id = &newid;
+        } else if (ret != 0) {
+            return ret;
+        }
+    }
+
+    if ((id->deviceid & 0x01) == 0) {
+        ret = __osRepairPackId(pfs, id, &newid);
+        if (ret) {
+            return ret;
+        }
+        id = &newid;
+        if ((id->deviceid & 0x01) == 0) {
+            return PFS_ERR_DEVICE;
+        }
+    }
+
+    bcopy(id, pfs->id, BLOCKSIZE);
+
+    if (0) {}
+
+    pfs->version = id->version;
+
+    pfs->banks = id->banks;
+    pfs->inodeStartPage = 1 + DEF_DIR_PAGES + (2 * pfs->banks);
+    pfs->dir_size = DEF_DIR_PAGES * PFS_ONE_PAGE;
+    pfs->inode_table = 1 * PFS_ONE_PAGE;
+    pfs->minode_table = (1 + pfs->banks) * PFS_ONE_PAGE;
+    pfs->dir_table = pfs->minode_table + (pfs->banks * PFS_ONE_PAGE);
+
+    if ((ret = __osContRamRead(pfs->queue, pfs->channel, PFS_LABEL_AREA, pfs->label)) != 0) {
+        return ret;
+    }
+
+    return 0;
+}
+
+s32 __osCheckId(OSPfs* pfs) {
+    u8 temp[BLOCKSIZE];
+    s32 ret;
+
+    if (pfs->activebank != 0) {
+        ret = __osPfsSelectBank(pfs, 0);
+        if (ret == PFS_ERR_NEW_PACK) {
+            ret = __osPfsSelectBank(pfs, 0);
+        }
+        if (ret != 0) {
+            return ret;
+        }
+    }
+
+    if ((ret = __osContRamRead(pfs->queue, pfs->channel, PFS_ID_0AREA, temp)) != 0) {
+        if (ret != PFS_ERR_NEW_PACK) {
+            return ret;
+        }
+        if ((ret = __osContRamRead(pfs->queue, pfs->channel, PFS_ID_0AREA, temp)) != 0) {
+            return ret;
+        }
+    }
+
+    if (bcmp(pfs->id, temp, BLOCKSIZE) != 0) {
+        return PFS_ERR_NEW_PACK;
+    }
+
+    return 0;
+}
+
+s32 __osPfsRWInode(OSPfs* pfs, __OSInode* inode, u8 flag, u8 bank) {
+    u8 sum;
+    s32 j;
+    s32 ret;
+    s32 offset;
+    u8* addr;
+
+    if (flag == PFS_READ && bank == __osPfsInodeCacheBank && (pfs->channel == __osPfsInodeCacheChannel)) {
+        bcopy(&__osPfsInodeCache, inode, sizeof(__OSInode));
+        return 0;
+    }
+
+    if ((pfs->activebank != 0) && (ret = __osPfsSelectBank(pfs, 0)) != 0) {
+        return ret;
+    }
+
+    offset = ((bank > 0) ? 1 : pfs->inodeStartPage);
+
+    if (flag == PFS_WRITE) {
+        inode->inodePage[0].inode_t.page =
+            __osSumcalc((u8*)(inode->inodePage + offset), (PFS_INODE_SIZE_PER_PAGE - offset) * 2);
+    }
+
+    for (j = 0; j < PFS_ONE_PAGE; j++) {
+        addr = (u8*)(((u8*)inode) + (j * BLOCKSIZE));
+        if (flag == PFS_WRITE) {
+            ret = __osContRamWrite(pfs->queue, pfs->channel, pfs->inode_table + (bank * PFS_ONE_PAGE) + j, addr, 0);
+            ret = __osContRamWrite(pfs->queue, pfs->channel, pfs->minode_table + (bank * PFS_ONE_PAGE) + j, addr, 0);
+        } else {
+            ret = __osContRamRead(pfs->queue, pfs->channel, pfs->inode_table + (bank * PFS_ONE_PAGE) + j, addr);
+        }
+        if (ret) {
+            return ret;
+        }
+    }
+
+    if (flag == PFS_READ) {
+        sum = __osSumcalc((u8*)(inode->inodePage + offset), (PFS_INODE_SIZE_PER_PAGE - offset) * 2);
+        if (sum != inode->inodePage[0].inode_t.page) {
+            for (j = 0; j < PFS_ONE_PAGE; j++) {
+                addr = (u8*)(((u8*)inode) + (j * BLOCKSIZE));
+                ret = __osContRamRead(pfs->queue, pfs->channel, pfs->minode_table + (bank * PFS_ONE_PAGE) + j, addr);
+            }
+            sum = __osSumcalc((u8*)(inode->inodePage + offset), (PFS_INODE_SIZE_PER_PAGE - offset) * 2);
+            if (sum != inode->inodePage[0].inode_t.page) {
+                return PFS_ERR_INCONSISTENT;
+            }
+            for (j = 0; j < PFS_ONE_PAGE; j++) {
+                addr = (u8*)(((u8*)inode) + (j * BLOCKSIZE));
+                ret = __osContRamWrite(pfs->queue, pfs->channel, pfs->inode_table + (bank * PFS_ONE_PAGE) + j, addr, 0);
+            }
+        }
+    }
+    __osPfsInodeCacheBank = bank;
+    bcopy(inode, &__osPfsInodeCache, sizeof(__OSInode));
+    __osPfsInodeCacheChannel = pfs->channel;
+
+    return 0;
+}
diff --git a/src/libultra/io/devmgr.c b/src/libultra/io/devmgr.c
index 0a5d7e0bb..c0f69c456 100644
--- a/src/libultra/io/devmgr.c
+++ b/src/libultra/io/devmgr.c
@@ -1,3 +1,104 @@
 #include "global.h"
 
-#pragma GLOBAL_ASM("asm/non_matchings/boot/devmgr/__osDevMgrMain.s")
+void __osDevMgrMain(void* arg) {
+    OSIoMesg* ioMesg;
+    OSMesg sp70;
+    OSMesg sp6C; // "dummy"
+    s32 ret;
+    OSDevMgr* devMgr;
+    s32 msgVar = 0;
+
+    devMgr = (OSDevMgr*)arg;
+    ioMesg = NULL;
+    ret = 0;
+
+    while (true) {
+        osRecvMesg(devMgr->cmdQueue, (OSMesg)&ioMesg, OS_MESG_BLOCK);
+        if ((ioMesg->piHandle != NULL) && (ioMesg->piHandle->type == 2) &&
+            ((ioMesg->piHandle->transferInfo.cmdType == OS_READ) ||
+             (ioMesg->piHandle->transferInfo.cmdType == OS_WRITE))) {
+            __OSBlockInfo* block;
+            __OSTranxInfo* transfer;
+
+            transfer = &ioMesg->piHandle->transferInfo;
+            block = &transfer->block[transfer->blockNum];
+            transfer->sectorNum = -1;
+            if (transfer->transferMode != 3) {
+                block->dramAddr = (void*)((u32)block->dramAddr - block->sectorSize);
+            }
+
+            if ((transfer->transferMode == 2) && (ioMesg->piHandle->transferInfo.cmdType == OS_READ)) {
+                msgVar = 1;
+            } else {
+                msgVar = 0;
+            }
+
+            osRecvMesg(devMgr->acsQueue, &sp6C, OS_MESG_BLOCK);
+            __osResetGlobalIntMask(0x00100401);
+            __osEPiRawWriteIo(ioMesg->piHandle, 0x05000510, transfer->bmCtlShadow | 0x80000000);
+
+        label:
+            osRecvMesg(devMgr->evtQueue, &sp70, OS_MESG_BLOCK);
+            transfer = &ioMesg->piHandle->transferInfo;
+            block = &transfer->block[transfer->blockNum];
+            if (block->errStatus == 0x1D) {
+                u32 status;
+
+                __osEPiRawWriteIo(ioMesg->piHandle, 0x05000510, transfer->bmCtlShadow | 0x10000000);
+                __osEPiRawWriteIo(ioMesg->piHandle, 0x05000510, transfer->bmCtlShadow);
+                __osEPiRawReadIo(ioMesg->piHandle, 0x05000508, &status);
+                if (status & 0x02000000) {
+                    __osEPiRawWriteIo(ioMesg->piHandle, 0x05000510, transfer->bmCtlShadow | 0x1000000);
+                }
+                block->errStatus = 4;
+                HW_REG(PI_STATUS_REG, u32) = PI_STATUS_CLEAR_INTR;
+                __osSetGlobalIntMask(0x00100C01);
+            }
+            osSendMesg(ioMesg->hdr.retQueue, (OSMesg)ioMesg, OS_MESG_NOBLOCK);
+
+            if ((msgVar == 1) && (ioMesg->piHandle->transferInfo.block[0].errStatus == 0)) {
+                msgVar = 0;
+                goto label;
+            }
+
+            osSendMesg(devMgr->acsQueue, NULL, OS_MESG_NOBLOCK);
+            if (ioMesg->piHandle->transferInfo.blockNum == 1) {
+                osYieldThread();
+            }
+        } else {
+            switch (ioMesg->hdr.type) {
+                case 11:
+                    osRecvMesg(devMgr->acsQueue, &sp6C, OS_MESG_BLOCK);
+                    ret = devMgr->piDmaCallback(OS_READ, ioMesg->devAddr, ioMesg->dramAddr, ioMesg->size);
+                    break;
+                case 12:
+                    osRecvMesg(devMgr->acsQueue, &sp6C, OS_MESG_BLOCK);
+                    ret = devMgr->piDmaCallback(OS_WRITE, ioMesg->devAddr, ioMesg->dramAddr, ioMesg->size);
+                    break;
+                case 15:
+                    osRecvMesg(devMgr->acsQueue, &sp6C, OS_MESG_BLOCK);
+                    ret = devMgr->epiDmaCallback(ioMesg->piHandle, OS_READ, ioMesg->devAddr, ioMesg->dramAddr,
+                                                 ioMesg->size);
+                    break;
+                case 16:
+                    osRecvMesg(devMgr->acsQueue, &sp6C, OS_MESG_BLOCK);
+                    ret = devMgr->epiDmaCallback(ioMesg->piHandle, OS_WRITE, ioMesg->devAddr, ioMesg->dramAddr,
+                                                 ioMesg->size);
+                    break;
+                case 10:
+                    osSendMesg(ioMesg->hdr.retQueue, ioMesg, OS_MESG_NOBLOCK);
+                    ret = -1;
+                    break;
+                default:
+                    ret = -1;
+                    break;
+            }
+
+            if (ret == 0) {
+                osRecvMesg(devMgr->evtQueue, &sp70, OS_MESG_BLOCK);
+                osSendMesg(ioMesg->hdr.retQueue, ioMesg, OS_MESG_NOBLOCK);
+                osSendMesg(devMgr->acsQueue, NULL, OS_MESG_NOBLOCK);
+            }
+        }
+    }
+}
diff --git a/src/libultra/io/epilinkhandle.c b/src/libultra/io/epilinkhandle.c
index 59efbc66e..bedd6d71c 100644
--- a/src/libultra/io/epilinkhandle.c
+++ b/src/libultra/io/epilinkhandle.c
@@ -1,3 +1,12 @@
 #include "global.h"
 
-#pragma GLOBAL_ASM("asm/non_matchings/boot/epilinkhandle/osEPiLinkHandle.s")
+s32 osEPiLinkHandle(OSPiHandle* handle) {
+    u32 saveMask = __osDisableInt();
+
+    handle->next = __osPiTable;
+    __osPiTable = handle;
+
+    __osRestoreInt(saveMask);
+
+    return 0;
+}
diff --git a/src/libultra/io/epirawdma.c b/src/libultra/io/epirawdma.c
index e6ee17d5f..f9e2e0f97 100644
--- a/src/libultra/io/epirawdma.c
+++ b/src/libultra/io/epirawdma.c
@@ -1,3 +1,3 @@
 #include "global.h"
 
-#pragma GLOBAL_ASM("asm/non_matchings/boot/epirawdma/osEPiRawStartDma.s")
+#pragma GLOBAL_ASM("asm/non_matchings/boot/epirawdma/__osEPiRawStartDma.s")
diff --git a/src/libultra/io/epirawread.c b/src/libultra/io/epirawread.c
index 0a175189e..e910cee4d 100644
--- a/src/libultra/io/epirawread.c
+++ b/src/libultra/io/epirawread.c
@@ -1,3 +1,3 @@
 #include "global.h"
 
-#pragma GLOBAL_ASM("asm/non_matchings/boot/epirawread/osEPiRawReadIo.s")
+#pragma GLOBAL_ASM("asm/non_matchings/boot/epirawread/__osEPiRawReadIo.s")
diff --git a/src/libultra/io/motor.c b/src/libultra/io/motor.c
new file mode 100644
index 000000000..25254c61b
--- /dev/null
+++ b/src/libultra/io/motor.c
@@ -0,0 +1,120 @@
+#include "ultra64.h"
+#include "global.h"
+
+#define BANK_ADDR 0x400
+#define MOTOR_ID 0x80
+
+s32 __osPfsSelectBank(OSPfs* pfs, u8 bank);
+
+s32 osSetRumble(OSPfs* pfs, u32 vibrate) {
+    s32 i;
+    s32 ret;
+    u8* buf = (u8*)&osPifBuffers[pfs->channel];
+
+    if (!(pfs->status & 8)) {
+        return 5;
+    }
+
+    __osSiGetAccess();
+    osPifBuffers[pfs->channel].pifstatus = 1;
+    buf += pfs->channel;
+    for (i = 0; i < BLOCKSIZE; i++) {
+        ((__OSContRamReadFormat*)buf)->data[i] = vibrate;
+    }
+
+    __osContLastCmd = CONT_CMD_END;
+    __osSiRawStartDma(OS_WRITE, &osPifBuffers[pfs->channel]);
+    osRecvMesg(pfs->queue, NULL, OS_MESG_BLOCK);
+    __osSiRawStartDma(OS_READ, &osPifBuffers[pfs->channel]);
+    osRecvMesg(pfs->queue, NULL, OS_MESG_BLOCK);
+
+    ret = ((__OSContRamReadFormat*)buf)->rxsize & 0xC0;
+    if (!ret) {
+        if (!vibrate) {
+            if (((__OSContRamReadFormat*)buf)->datacrc != 0) {
+                ret = PFS_ERR_CONTRFAIL;
+            }
+        } else {
+            if (((__OSContRamReadFormat*)buf)->datacrc != 0xEB) {
+                ret = PFS_ERR_CONTRFAIL;
+            }
+        }
+    }
+
+    __osSiRelAccess();
+
+    return ret;
+}
+void osSetUpMempakWrite(u32 channel, OSPifRam* buf) {
+    u8* bufptr = (u8*)buf;
+    __OSContRamReadFormat mempakwr;
+    u32 i;
+
+    mempakwr.dummy = 0xFF;
+    mempakwr.txsize = 0x23;
+    mempakwr.rxsize = 1;
+    mempakwr.cmd = 3; // write mempak
+    mempakwr.hi = 0x600 >> 3;
+    mempakwr.lo = (u8)(__osContAddressCrc(0x600) | (0x600 << 5));
+
+    if (channel != 0) {
+        for (i = 0; i < channel; i++) {
+            *bufptr++ = 0;
+        }
+    }
+
+    *(__OSContRamReadFormat*)bufptr = mempakwr;
+    bufptr += sizeof(mempakwr);
+    *bufptr = 0xFE;
+}
+
+s32 osProbeRumblePak(OSMesgQueue* ctrlrqueue, OSPfs* pfs, u32 channel) {
+    s32 ret;
+    u8 sp24[BLOCKSIZE];
+
+    pfs->queue = ctrlrqueue;
+    pfs->channel = channel;
+    pfs->activebank = 0xFF;
+    pfs->status = 0;
+
+    ret = __osPfsSelectBank(pfs, 0xFE);
+    if (ret == 2) {
+        ret = __osPfsSelectBank(pfs, MOTOR_ID);
+    }
+    if (ret != 0) {
+        return ret;
+    }
+    ret = __osContRamRead(ctrlrqueue, channel, 0x400, sp24);
+    if (ret == 2) {
+        ret = 4; // "Controller pack communication error"
+    }
+    if (ret != 0) {
+        return ret;
+    }
+    if (sp24[BLOCKSIZE - 1] == 0xFE) {
+        return 0xB;
+    }
+    ret = __osPfsSelectBank(pfs, MOTOR_ID);
+    if (ret == 2) {
+        ret = 4; // "Controller pack communication error"
+    }
+    if (ret != 0) {
+        return ret;
+    }
+    ret = __osContRamRead(ctrlrqueue, channel, BANK_ADDR, sp24);
+    if (ret == 2) {
+        ret = 4; // "Controller pack communication error"
+    }
+    if (ret != 0) {
+        return ret;
+    }
+    if (sp24[BLOCKSIZE - 1] != MOTOR_ID) {
+        return 0xB;
+    }
+    if ((pfs->status & PFS_MOTOR_INITIALIZED) == 0) {
+        osSetUpMempakWrite(channel, &osPifBuffers[channel]);
+    }
+    pfs->status = PFS_MOTOR_INITIALIZED;
+
+    return 0; // "Recognized rumble pak"
+}
diff --git a/src/libultra/io/pimgr.c b/src/libultra/io/pimgr.c
index f5081c050..74b1075a1 100644
--- a/src/libultra/io/pimgr.c
+++ b/src/libultra/io/pimgr.c
@@ -31,9 +31,9 @@ void osCreatePiManager(OSPri pri, OSMesgQueue* cmdQ, OSMesg* cmdBuf, s32 cmdMsgC
         __osPiDevMgr.cmdQueue = cmdQ;
         __osPiDevMgr.evtQueue = &D_8009E3D0;
         __osPiDevMgr.acsQueue = &__osPiAccessQueue;
-        __osPiDevMgr.piDmaCallback = osPiRawStartDma;
-        __osPiDevMgr.epiDmaCallback = osEPiRawStartDma;
-        osCreateThread(&D_8009D220, 0, __osDevMgrMain, &__osPiDevMgr, &piManagerStack[0x1000], pri);
+        __osPiDevMgr.piDmaCallback = __osPiRawStartDma;
+        __osPiDevMgr.epiDmaCallback = __osEPiRawStartDma;
+        osCreateThread(&D_8009D220, 0, __osDevMgrMain, (void*)&__osPiDevMgr, &piManagerStack[4096], pri);
         osStartThread(&D_8009D220);
         __osRestoreInt(savedMask);
         if (oldPri != -1) {
diff --git a/src/libultra/io/pirawdma.c b/src/libultra/io/pirawdma.c
index b133fadf5..242a91c24 100644
--- a/src/libultra/io/pirawdma.c
+++ b/src/libultra/io/pirawdma.c
@@ -1,6 +1,6 @@
 #include "global.h"
 
-s32 osPiRawStartDma(s32 direction, u32 devAddr, void* dramAddr, u32 size) {
+s32 __osPiRawStartDma(s32 direction, u32 devAddr, void* dramAddr, size_t size) {
     register int stat;
 
     stat = *(vu32*)0xA4600010;
diff --git a/src/libultra/io/sprawdma.c b/src/libultra/io/sprawdma.c
index 01e944c5f..95395a29d 100644
--- a/src/libultra/io/sprawdma.c
+++ b/src/libultra/io/sprawdma.c
@@ -1,6 +1,6 @@
 #include "global.h"
 
-s32 __osSpRawStartDma(s32 direction, void* devAddr, void* dramAddr, u32 size) {
+s32 __osSpRawStartDma(s32 direction, void* devAddr, void* dramAddr, size_t size) {
     if (__osSpDeviceBusy() != 0) {
         return -1;
     }
diff --git a/src/libultra/libc/string.c b/src/libultra/libc/string.c
index 5f085f677..b23bf564d 100644
--- a/src/libultra/libc/string.c
+++ b/src/libultra/libc/string.c
@@ -1,4 +1,4 @@
-#include "string.h"
+#include "global.h"
 
 const char* strchr(const char* s, int c) {
     const unsigned char ch = c;
diff --git a/src/overlays/actors/ovl_Arms_Hook/z_arms_hook.c b/src/overlays/actors/ovl_Arms_Hook/z_arms_hook.c
index 4f9b88118..62bac2109 100644
--- a/src/overlays/actors/ovl_Arms_Hook/z_arms_hook.c
+++ b/src/overlays/actors/ovl_Arms_Hook/z_arms_hook.c
@@ -300,14 +300,14 @@ void ArmsHook_Draw(Actor* thisx, GlobalContext* globalCtx) {
         OPEN_DISPS(globalCtx->state.gfxCtx);
 
         if ((ArmsHook_Shoot != this->actionFunc) || (this->timer <= 0)) {
-            SysMatrix_MultiplyVector3fByState(&D_808C1C10, &this->unk1E0);
-            SysMatrix_MultiplyVector3fByState(&D_808C1C28, &sp5C);
-            SysMatrix_MultiplyVector3fByState(&D_808C1C34, &sp50);
+            Matrix_MultiplyVector3fByState(&D_808C1C10, &this->unk1E0);
+            Matrix_MultiplyVector3fByState(&D_808C1C28, &sp5C);
+            Matrix_MultiplyVector3fByState(&D_808C1C34, &sp50);
             this->unk1C4 = 0;
         } else {
-            SysMatrix_MultiplyVector3fByState(&D_808C1C1C, &this->unk1E0);
-            SysMatrix_MultiplyVector3fByState(&D_808C1C40, &sp5C);
-            SysMatrix_MultiplyVector3fByState(&D_808C1C4C, &sp50);
+            Matrix_MultiplyVector3fByState(&D_808C1C1C, &this->unk1E0);
+            Matrix_MultiplyVector3fByState(&D_808C1C40, &sp5C);
+            Matrix_MultiplyVector3fByState(&D_808C1C4C, &sp50);
         }
         func_80126440(globalCtx, &this->collider.base, &this->unk1C4, &sp5C, &sp50);
         func_8012C28C(globalCtx->state.gfxCtx);
@@ -315,13 +315,13 @@ void ArmsHook_Draw(Actor* thisx, GlobalContext* globalCtx) {
 
         gSPMatrix(POLY_OPA_DISP++, Matrix_NewMtx(globalCtx->state.gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
         gSPDisplayList(POLY_OPA_DISP++, D_0601D960);
-        SysMatrix_InsertTranslation(this->actor.world.pos.x, this->actor.world.pos.y, this->actor.world.pos.z,
-                                    MTXMODE_NEW);
+        Matrix_InsertTranslation(this->actor.world.pos.x, this->actor.world.pos.y, this->actor.world.pos.z,
+                                 MTXMODE_NEW);
         Math_Vec3f_Diff(&player->rightHandWorld.pos, &this->actor.world.pos, &sp68);
         sp48 = SQXZ(sp68);
         sp4C = sqrtf(SQXZ(sp68));
         Matrix_RotateY(Math_Atan2S(sp68.x, sp68.z), MTXMODE_APPLY);
-        SysMatrix_InsertXRotation_s(Math_Atan2S(-sp68.y, sp4C), MTXMODE_APPLY);
+        Matrix_InsertXRotation_s(Math_Atan2S(-sp68.y, sp4C), MTXMODE_APPLY);
         f0 = sqrtf(SQ(sp68.y) + sp48);
         Matrix_Scale(0.015f, 0.015f, f0 * 0.01f, MTXMODE_APPLY);
         gSPMatrix(POLY_OPA_DISP++, Matrix_NewMtx(globalCtx->state.gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
diff --git a/src/overlays/actors/ovl_Arrow_Ice/z_arrow_ice.c b/src/overlays/actors/ovl_Arrow_Ice/z_arrow_ice.c
index 9d61ca292..ed513eef3 100644
--- a/src/overlays/actors/ovl_Arrow_Ice/z_arrow_ice.c
+++ b/src/overlays/actors/ovl_Arrow_Ice/z_arrow_ice.c
@@ -200,11 +200,10 @@ void ArrowIce_Draw(Actor* thisx, GlobalContext* globalCtx) {
 
         OPEN_DISPS(globalCtx->state.gfxCtx);
 
-        SysMatrix_InsertTranslation(transform->world.pos.x, transform->world.pos.y, transform->world.pos.z,
-                                    MTXMODE_NEW);
+        Matrix_InsertTranslation(transform->world.pos.x, transform->world.pos.y, transform->world.pos.z, MTXMODE_NEW);
         Matrix_RotateY(transform->shape.rot.y, MTXMODE_APPLY);
-        SysMatrix_InsertXRotation_s(transform->shape.rot.x, MTXMODE_APPLY);
-        SysMatrix_InsertZRotation_s(transform->shape.rot.z, MTXMODE_APPLY);
+        Matrix_InsertXRotation_s(transform->shape.rot.x, MTXMODE_APPLY);
+        Matrix_InsertZRotation_s(transform->shape.rot.z, MTXMODE_APPLY);
         Matrix_Scale(0.01f, 0.01f, 0.01f, MTXMODE_APPLY);
 
         // Draw blue effect over the screen when arrow hits
@@ -222,14 +221,14 @@ void ArrowIce_Draw(Actor* thisx, GlobalContext* globalCtx) {
         func_8012C2DC(globalCtx->state.gfxCtx);
         gDPSetPrimColor(POLY_XLU_DISP++, 0x80, 0x80, 170, 255, 255, (s32)(this->alpha * 0.5f) & 0xFF);
         gDPSetEnvColor(POLY_XLU_DISP++, 0, 0, 255, 128);
-        SysMatrix_InsertRotation(0x4000, 0, 0, MTXMODE_APPLY);
+        Matrix_InsertRotation(0x4000, 0, 0, MTXMODE_APPLY);
         if (this->timer != 0) {
-            SysMatrix_InsertTranslation(0.0f, 0.0f, 0.0f, MTXMODE_APPLY);
+            Matrix_InsertTranslation(0.0f, 0.0f, 0.0f, MTXMODE_APPLY);
         } else {
-            SysMatrix_InsertTranslation(0.0f, 1500.0f, 0.0f, MTXMODE_APPLY);
+            Matrix_InsertTranslation(0.0f, 1500.0f, 0.0f, MTXMODE_APPLY);
         }
         Matrix_Scale(this->radius * 0.2f, this->height * 3.0f, this->radius * 0.2f, MTXMODE_APPLY);
-        SysMatrix_InsertTranslation(0.0f, -700.0f, 0.0f, MTXMODE_APPLY);
+        Matrix_InsertTranslation(0.0f, -700.0f, 0.0f, MTXMODE_APPLY);
         gSPMatrix(POLY_XLU_DISP++, Matrix_NewMtx(globalCtx->state.gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
         gSPDisplayList(POLY_XLU_DISP++, sIceArrowDL);
         gSPDisplayList(POLY_XLU_DISP++,
diff --git a/src/overlays/actors/ovl_Bg_Ctower_Gear/z_bg_ctower_gear.c b/src/overlays/actors/ovl_Bg_Ctower_Gear/z_bg_ctower_gear.c
index c2554ec61..18b8a343c 100644
--- a/src/overlays/actors/ovl_Bg_Ctower_Gear/z_bg_ctower_gear.c
+++ b/src/overlays/actors/ovl_Bg_Ctower_Gear/z_bg_ctower_gear.c
@@ -90,14 +90,14 @@ void BgCtowerGear_Splash(BgCtowerGear* this, GlobalContext* globalCtx) {
     rotZ = this->dyna.actor.shape.rot.z & 0x1FFF;
     if ((flags != 0) && (rotZ < 0x1B58) && (rotZ >= 0x1388)) {
         Matrix_RotateY(this->dyna.actor.home.rot.y, 0);
-        SysMatrix_InsertXRotation_s(this->dyna.actor.home.rot.x, 1);
-        SysMatrix_InsertZRotation_s(this->dyna.actor.home.rot.z, 1);
+        Matrix_InsertXRotation_s(this->dyna.actor.home.rot.x, 1);
+        Matrix_InsertZRotation_s(this->dyna.actor.home.rot.z, 1);
         for (i = 0; i < 4; i++) {
             if ((u32)Rand_Next() >= 0x40000000) {
                 splashOffset.x = D_80AD3270[i].x - (Rand_ZeroOne() * 30.0f);
                 splashOffset.y = D_80AD3270[i].y;
                 splashOffset.z = D_80AD3270[i].z;
-                SysMatrix_MultiplyVector3fByState(&splashOffset, &splashSpawnPos);
+                Matrix_MultiplyVector3fByState(&splashOffset, &splashSpawnPos);
                 splashSpawnPos.x += this->dyna.actor.world.pos.x + ((Rand_ZeroOne() * 20.0f) - 10.0f);
                 splashSpawnPos.y += this->dyna.actor.world.pos.y;
                 splashSpawnPos.z += this->dyna.actor.world.pos.z + ((Rand_ZeroOne() * 20.0f) - 10.0f);
@@ -108,14 +108,14 @@ void BgCtowerGear_Splash(BgCtowerGear* this, GlobalContext* globalCtx) {
     if ((rotZ < 0x1F4) && (rotZ >= 0)) {
         if (flags != 0) {
             Matrix_RotateY(this->dyna.actor.home.rot.y, 0);
-            SysMatrix_InsertXRotation_s(this->dyna.actor.home.rot.x, 1);
-            SysMatrix_InsertZRotation_s(this->dyna.actor.home.rot.z, 1);
+            Matrix_InsertXRotation_s(this->dyna.actor.home.rot.x, 1);
+            Matrix_InsertZRotation_s(this->dyna.actor.home.rot.z, 1);
             for (i = 0; i < 3; i++) {
                 for (j = 0; j < 2; j++) {
                     splashOffset.x = D_80AD32A0[i].x + (Rand_ZeroOne() * 10.0f);
                     splashOffset.y = D_80AD32A0[i].y;
                     splashOffset.z = D_80AD32A0[i].z;
-                    SysMatrix_MultiplyVector3fByState(&splashOffset, &splashSpawnPos);
+                    Matrix_MultiplyVector3fByState(&splashOffset, &splashSpawnPos);
                     splashSpawnPos.x += this->dyna.actor.world.pos.x + ((Rand_ZeroOne() * 20.0f) - 10.0f);
                     splashSpawnPos.y += this->dyna.actor.world.pos.y;
                     splashSpawnPos.z += this->dyna.actor.world.pos.z + ((Rand_ZeroOne() * 20.0f) - 10.0f);
diff --git a/src/overlays/actors/ovl_Bg_Haka_Tomb/z_bg_haka_tomb.c b/src/overlays/actors/ovl_Bg_Haka_Tomb/z_bg_haka_tomb.c
index 9a6d2348b..34ad8fb1f 100644
--- a/src/overlays/actors/ovl_Bg_Haka_Tomb/z_bg_haka_tomb.c
+++ b/src/overlays/actors/ovl_Bg_Haka_Tomb/z_bg_haka_tomb.c
@@ -116,9 +116,9 @@ void BgHakaTomb_Update(Actor* thisx, GlobalContext* globalCtx) {
 
     this->actionFunc(this, globalCtx);
     Matrix_RotateY(this->dyna.actor.world.rot.y, MTXMODE_NEW);
-    SysMatrix_InsertXRotation_s(this->dyna.actor.world.rot.x, MTXMODE_APPLY);
-    SysMatrix_InsertZRotation_s(this->dyna.actor.world.rot.z, MTXMODE_APPLY);
-    SysMatrix_MultiplyVector3fByState(&D_80BD68A4, &vec);
+    Matrix_InsertXRotation_s(this->dyna.actor.world.rot.x, MTXMODE_APPLY);
+    Matrix_InsertZRotation_s(this->dyna.actor.world.rot.z, MTXMODE_APPLY);
+    Matrix_MultiplyVector3fByState(&D_80BD68A4, &vec);
     Math_Vec3f_Sum(&this->dyna.actor.world.pos, &vec, &this->dyna.actor.focus.pos);
 }
 
diff --git a/src/overlays/actors/ovl_Bg_Hakugin_Post/z_bg_hakugin_post.c b/src/overlays/actors/ovl_Bg_Hakugin_Post/z_bg_hakugin_post.c
index 691cf9992..453bd919c 100644
--- a/src/overlays/actors/ovl_Bg_Hakugin_Post/z_bg_hakugin_post.c
+++ b/src/overlays/actors/ovl_Bg_Hakugin_Post/z_bg_hakugin_post.c
@@ -234,7 +234,7 @@ BgHakuginPostUnkStruct1* func_80A9B32C(BgHakuginPostUnkStruct* unkStruct, BgHaku
 }
 
 void func_80A9B384(Vec3f* arg0) {
-    MtxF* matrix = SysMatrix_GetCurrentState();
+    MtxF* matrix = Matrix_GetCurrentState();
 
     matrix->mf[3][0] = arg0->x;
     matrix->mf[3][1] = arg0->y;
@@ -1013,8 +1013,8 @@ void func_80A9D61C(Actor* thisx, GlobalContext* globalCtx) {
     OPEN_DISPS(globalCtx->state.gfxCtx);
 
     func_8012C28C(globalCtx->state.gfxCtx);
-    SysMatrix_SetStateRotationAndTranslation(this->dyna.actor.world.pos.x, this->dyna.actor.world.pos.y,
-                                             this->dyna.actor.world.pos.z, &this->dyna.actor.shape.rot);
+    Matrix_SetStateRotationAndTranslation(this->dyna.actor.world.pos.x, this->dyna.actor.world.pos.y,
+                                          this->dyna.actor.world.pos.z, &this->dyna.actor.shape.rot);
     Matrix_Scale(0.1f, 0.1f, 0.1f, MTXMODE_APPLY);
 
     for (i = 0; i < D_80A9E028.count; i++) {
@@ -1035,8 +1035,8 @@ void func_80A9D61C(Actor* thisx, GlobalContext* globalCtx) {
         for (i = 0; i < ARRAY_COUNT(D_80A9E028.unk_02A4); i++) {
             unkStruct2 = &D_80A9E028.unk_02A4[i];
             if (unkStruct2->unk_2C > 0) {
-                SysMatrix_SetStateRotationAndTranslation(unkStruct2->unk_04.x, unkStruct2->unk_04.y,
-                                                         unkStruct2->unk_04.z, &unkStruct2->unk_20);
+                Matrix_SetStateRotationAndTranslation(unkStruct2->unk_04.x, unkStruct2->unk_04.y, unkStruct2->unk_04.z,
+                                                      &unkStruct2->unk_20);
                 Matrix_Scale(unkStruct2->unk_00, unkStruct2->unk_00, unkStruct2->unk_00, MTXMODE_APPLY);
 
                 gSPMatrix(POLY_OPA_DISP++, Matrix_NewMtx(globalCtx->state.gfxCtx),
diff --git a/src/overlays/actors/ovl_Bg_Kin2_Fence/z_bg_kin2_fence.c b/src/overlays/actors/ovl_Bg_Kin2_Fence/z_bg_kin2_fence.c
index a9ce12ce9..2d1fb8ca2 100644
--- a/src/overlays/actors/ovl_Bg_Kin2_Fence/z_bg_kin2_fence.c
+++ b/src/overlays/actors/ovl_Bg_Kin2_Fence/z_bg_kin2_fence.c
@@ -138,11 +138,11 @@ void BgKin2Fence_SpawnEyeSparkles(BgKin2Fence* this, GlobalContext* globalCtx, s
     Vec3f sp58;
     s32 pad[2];
 
-    SysMatrix_SetStateRotationAndTranslation(this->dyna.actor.world.pos.x, this->dyna.actor.world.pos.y,
-                                             this->dyna.actor.world.pos.z, &this->dyna.actor.shape.rot);
+    Matrix_SetStateRotationAndTranslation(this->dyna.actor.world.pos.x, this->dyna.actor.world.pos.y,
+                                          this->dyna.actor.world.pos.z, &this->dyna.actor.shape.rot);
 
     for (i = 0; i < 2; i++) {
-        SysMatrix_MultiplyVector3fByState(&eyeSparkleSpawnPositions[mask][i], &sp58);
+        Matrix_MultiplyVector3fByState(&eyeSparkleSpawnPositions[mask][i], &sp58);
         EffectSsKiraKira_SpawnDispersed(globalCtx, &sp58, &D_801D15B0, &D_801D15B0, &primColor, &envColor, 6000, -10);
     }
 }
@@ -156,9 +156,9 @@ void BgKin2Fence_Init(Actor* thisx, GlobalContext* globalCtx) {
     BgCheck3_LoadMesh(globalCtx, &this->dyna, &D_06000908);
     Collider_InitJntSph(globalCtx, &this->collider);
     Collider_SetJntSph(globalCtx, &this->collider, &this->dyna.actor, &sJntSphInit, this->colliderElements);
-    SysMatrix_SetStateRotationAndTranslation(this->dyna.actor.world.pos.x, this->dyna.actor.world.pos.y,
-                                             this->dyna.actor.world.pos.z, &this->dyna.actor.shape.rot);
-    Matrix_Scale(this->dyna.actor.scale.x, this->dyna.actor.scale.y, this->dyna.actor.scale.z, 1);
+    Matrix_SetStateRotationAndTranslation(this->dyna.actor.world.pos.x, this->dyna.actor.world.pos.y,
+                                          this->dyna.actor.world.pos.z, &this->dyna.actor.shape.rot);
+    Matrix_Scale(this->dyna.actor.scale.x, this->dyna.actor.scale.y, this->dyna.actor.scale.z, MTXMODE_APPLY);
 
     for (i = 0; i < 4; i++) {
         Collider_UpdateSpheres(i, &this->collider);
diff --git a/src/overlays/actors/ovl_Dm_Nb/z_dm_nb.c b/src/overlays/actors/ovl_Dm_Nb/z_dm_nb.c
index 2b7492754..1e36f9e29 100644
--- a/src/overlays/actors/ovl_Dm_Nb/z_dm_nb.c
+++ b/src/overlays/actors/ovl_Dm_Nb/z_dm_nb.c
@@ -72,7 +72,7 @@ void DmNb_Init(Actor* thisx, GlobalContext* globalCtx) {
     DmNb* this = THIS;
 
     ActorShape_Init(&this->actor.shape, 0.0f, NULL, 0.0f);
-    SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_06008C40, NULL, this->limbDrawTable, this->transitionDrawTable, 8);
+    SkelAnime_InitFlex(globalCtx, &this->skelAnime, &D_06008C40, NULL, this->jointTable, this->morphTable, 8);
     this->unk1F0 = -1;
     func_80C1DED0(this, 0);
     this->actor.flags &= ~1;
@@ -87,17 +87,17 @@ void DmNb_Update(Actor* thisx, GlobalContext* globalCtx) {
     DmNb* this = THIS;
 
     this->actionFunc(this, globalCtx);
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
-    Actor_UpdateBgCheckInfo(globalCtx, &this->actor, 30.0f, 12.0f, 0.0f, 0x4);
+    SkelAnime_Update(&this->skelAnime);
+    Actor_UpdateBgCheckInfo(globalCtx, &this->actor, 30.0f, 12.0f, 0.0f, 4);
 }
 
-void DmNb_UnkActorDraw(GlobalContext* globalCtx, s32 limbIndex, Actor* actor) {
+void DmNb_UnkActorDraw(GlobalContext* globalCtx, s32 limbIndex, Actor* thisx) {
 }
 
 void DmNb_Draw(Actor* thisx, GlobalContext* globalCtx) {
     DmNb* this = THIS;
 
     func_8012C5B0(globalCtx->state.gfxCtx);
-    func_801343C0(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl, this->skelAnime.dListCount, NULL,
+    func_801343C0(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable, this->skelAnime.dListCount, NULL,
                   NULL, DmNb_UnkActorDraw, &this->actor);
 }
diff --git a/src/overlays/actors/ovl_Dm_Nb/z_dm_nb.h b/src/overlays/actors/ovl_Dm_Nb/z_dm_nb.h
index f31d0c3de..a417ea070 100644
--- a/src/overlays/actors/ovl_Dm_Nb/z_dm_nb.h
+++ b/src/overlays/actors/ovl_Dm_Nb/z_dm_nb.h
@@ -11,8 +11,8 @@ typedef struct DmNb {
     /* 0x000 */ Actor actor;
     /* 0x144 */ SkelAnime skelAnime;
     /* 0x188 */ DmNbActionFunc actionFunc;
-    /* 0x18C */ Vec3s limbDrawTable[8];
-    /* 0x1BC */ Vec3s transitionDrawTable[8];
+    /* 0x18C */ Vec3s jointTable[8];
+    /* 0x1BC */ Vec3s morphTable[8];
     /* 0x1EC */ u8 unk1EC;
     /* 0x1F0 */ s32 unk1F0;
     /* 0x1F4 */ s32 unk1F4;
diff --git a/src/overlays/actors/ovl_Dm_Sa/z_dm_sa.c b/src/overlays/actors/ovl_Dm_Sa/z_dm_sa.c
index b5ddf40a0..02101b113 100644
--- a/src/overlays/actors/ovl_Dm_Sa/z_dm_sa.c
+++ b/src/overlays/actors/ovl_Dm_Sa/z_dm_sa.c
@@ -33,12 +33,12 @@ void func_80A2E960(SkelAnime* arg0, ActorAnimationEntry* animations, u16 index)
     animations += index;
 
     if (animations->frameCount < 0.0f) {
-        frameCount = SkelAnime_GetFrameCount(&animations->animation->common);
+        frameCount = Animation_GetLastFrame(animations->animation);
     } else {
         frameCount = animations->frameCount;
     }
-    SkelAnime_ChangeAnim(arg0, animations->animation, animations->playSpeed, animations->startFrame, frameCount,
-                         animations->mode, animations->morphFrames);
+    Animation_Change(arg0, animations->animation, animations->playSpeed, animations->startFrame, frameCount,
+                     animations->mode, animations->morphFrames);
 }
 
 void DmSa_Init(Actor* thisx, GlobalContext* globalCtx) {
@@ -48,7 +48,7 @@ void DmSa_Init(Actor* thisx, GlobalContext* globalCtx) {
     this->alpha = 0xFF;
     this->actor.targetArrowOffset = 3000.0f;
     ActorShape_Init(&this->actor.shape, 0.0f, func_800B3FC0, 24.0f);
-    SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_06013328, NULL, 0, 0, 0);
+    SkelAnime_InitFlex(globalCtx, &this->skelAnime, &D_06013328, NULL, 0, 0, 0);
     func_80A2E960(&this->skelAnime, D_80A2ED00, 0);
     Actor_SetScale(&this->actor, 0.01f);
     this->actionFunc = DmSa_DoNothing;
@@ -63,7 +63,7 @@ void DmSa_DoNothing(DmSa* this, GlobalContext* globalCtx) {
 void DmSa_Update(Actor* thisx, GlobalContext* globalCtx) {
     DmSa* this = THIS;
 
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     this->alpha += 0;
     this->actionFunc(this, globalCtx);
 }
@@ -114,7 +114,7 @@ void DmSa_Draw(Actor* thisx, GlobalContext* globalCtx) {
         gSPSegment(POLY_OPA_DISP++, 0x0C, func_80A2EBB0(globalCtx->state.gfxCtx, this->alpha));
     }
 
-    func_801343C0(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl, this->skelAnime.dListCount,
+    func_801343C0(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable, this->skelAnime.dListCount,
                   func_80A2EB10, func_80A2EB2C, func_80A2EB44, &this->actor);
 
     CLOSE_DISPS(globalCtx->state.gfxCtx);
diff --git a/src/overlays/actors/ovl_Eff_Dust/z_eff_dust.c b/src/overlays/actors/ovl_Eff_Dust/z_eff_dust.c
index bfb2cc728..3ca55d7b8 100644
--- a/src/overlays/actors/ovl_Eff_Dust/z_eff_dust.c
+++ b/src/overlays/actors/ovl_Eff_Dust/z_eff_dust.c
@@ -281,14 +281,14 @@ void func_80919768(Actor* thisx, GlobalContext* globalCtx2) {
     for (i = 0; i < ARRAY_COUNT(this->distanceTraveled); i++) {
         if (*distanceTraveled < 1.0f) {
             aux = 1.0f - SQ(*distanceTraveled);
-            SysMatrix_InsertTranslation(thisx->world.pos.x, thisx->world.pos.y, thisx->world.pos.z, MTXMODE_NEW);
+            Matrix_InsertTranslation(thisx->world.pos.x, thisx->world.pos.y, thisx->world.pos.z, MTXMODE_NEW);
             Matrix_RotateY(sp92, MTXMODE_APPLY);
-            SysMatrix_InsertTranslation(initialPositions->x * ((this->dx * aux) + (1.0f - this->dx)),
-                                        initialPositions->y * ((this->dy * aux) + (1.0f - this->dy)),
-                                        initialPositions->z * ((this->dz * aux) + (1.0f - this->dz)), MTXMODE_APPLY);
-            Matrix_Scale(this->scalingFactor, this->scalingFactor, this->scalingFactor, 1);
+            Matrix_InsertTranslation(initialPositions->x * ((this->dx * aux) + (1.0f - this->dx)),
+                                     initialPositions->y * ((this->dy * aux) + (1.0f - this->dy)),
+                                     initialPositions->z * ((this->dz * aux) + (1.0f - this->dz)), MTXMODE_APPLY);
+            Matrix_Scale(this->scalingFactor, this->scalingFactor, this->scalingFactor, MTXMODE_APPLY);
 
-            SysMatrix_NormalizeXYZ(&globalCtx->mf_187FC);
+            Matrix_NormalizeXYZ(&globalCtx->mf_187FC);
 
             gSPMatrix(POLY_XLU_DISP++, Matrix_NewMtx(gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
 
@@ -337,15 +337,15 @@ void func_809199FC(Actor* thisx, GlobalContext* globalCtx2) {
             gDPSetPrimColor(POLY_XLU_DISP++, 0, 0, 255, 255, 255, (*distanceTraveled * 255.0f));
 
             aux = 1.0f - SQ(*distanceTraveled);
-            SysMatrix_InsertMatrix(&player->mf_CC4, MTXMODE_NEW);
-            SysMatrix_InsertTranslation(initialPositions->x * ((this->dx * aux) + (1.0f - this->dx)),
-                                        (initialPositions->y * (1.0f - *distanceTraveled)) + 320.0f,
-                                        (initialPositions->z * (1.0f - *distanceTraveled)) + -20.0f, MTXMODE_APPLY);
+            Matrix_InsertMatrix(&player->mf_CC4, MTXMODE_NEW);
+            Matrix_InsertTranslation(initialPositions->x * ((this->dx * aux) + (1.0f - this->dx)),
+                                     (initialPositions->y * (1.0f - *distanceTraveled)) + 320.0f,
+                                     (initialPositions->z * (1.0f - *distanceTraveled)) + -20.0f, MTXMODE_APPLY);
 
             Matrix_Scale(*distanceTraveled * this->scalingFactor, *distanceTraveled * this->scalingFactor,
                          *distanceTraveled * this->scalingFactor, MTXMODE_APPLY);
 
-            SysMatrix_NormalizeXYZ(&globalCtx->mf_187FC);
+            Matrix_NormalizeXYZ(&globalCtx->mf_187FC);
 
             gSPMatrix(POLY_XLU_DISP++, Matrix_NewMtx(gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
             gSPClearGeometryMode(POLY_XLU_DISP++, G_FOG | G_LIGHTING);
diff --git a/src/overlays/actors/ovl_En_Baisen/z_en_baisen.c b/src/overlays/actors/ovl_En_Baisen/z_en_baisen.c
index b054b20e8..d9bb0f9fc 100644
--- a/src/overlays/actors/ovl_En_Baisen/z_en_baisen.c
+++ b/src/overlays/actors/ovl_En_Baisen/z_en_baisen.c
@@ -69,7 +69,7 @@ void EnBaisen_Init(Actor* thisx, GlobalContext* globalCtx) {
     EnBaisen* this = THIS;
 
     ActorShape_Init(&this->actor.shape, 0.0f, func_800B3FC0, 25.0f);
-    SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_06007908, &D_060011C0, this->jointTable, this->morphTable, 20);
+    SkelAnime_InitFlex(globalCtx, &this->skelAnime, &D_06007908, &D_060011C0, this->jointTable, this->morphTable, 20);
     this->actor.colChkInfo.mass = MASS_IMMOVABLE;
     this->paramCopy = this->actor.params;
     if (this->actor.params == 0) {
@@ -103,9 +103,9 @@ void EnBaisen_Destroy(Actor* thisx, GlobalContext* globalCtx) {
 
 void EnBaisen_ChangeAnimation(EnBaisen* this, s32 animIndex) {
     this->animIndex = animIndex;
-    this->frameCount = SkelAnime_GetFrameCount(&D_80BE8E4C[animIndex]->common);
-    SkelAnime_ChangeAnim(&this->skelAnime, D_80BE8E4C[this->animIndex], 1.0f, 0.0f, this->frameCount,
-                         animModes[this->animIndex], -10.0f);
+    this->frameCount = Animation_GetLastFrame(D_80BE8E4C[animIndex]);
+    Animation_Change(&this->skelAnime, D_80BE8E4C[this->animIndex], 1.0f, 0.0f, this->frameCount,
+                     animModes[this->animIndex], -10.0f);
 }
 
 void func_80BE871C(EnBaisen* this) {
@@ -201,7 +201,7 @@ void func_80BE89D8(EnBaisen* this, GlobalContext* globalCtx) {
     }
     if ((globalCtx->msgCtx.unk11F04 == 0x2AC6) || (globalCtx->msgCtx.unk11F04 == 0x2AC7) ||
         (globalCtx->msgCtx.unk11F04 == 0x2AC8)) {
-        this->skelAnime.animPlaybackSpeed = 0.0f;
+        this->skelAnime.playSpeed = 0.0f;
         this->unk29E = this->actor.yawTowardsPlayer;
     }
     if (this->unk2AC == 2) { // Note: This variable is only ever set to 1.
@@ -244,7 +244,7 @@ void EnBaisen_Update(Actor* thisx, GlobalContext* globalCtx) {
     s32 pad;
     EnBaisen* this = THIS;
 
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     if (this->unusedCounter != 0) {
         this->unusedCounter--;
     }
@@ -284,6 +284,6 @@ void EnBaisen_Draw(Actor* thisx, GlobalContext* globalCtx) {
     EnBaisen* this = THIS;
 
     func_8012C28C(globalCtx->state.gfxCtx);
-    SkelAnime_DrawSV(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl, this->skelAnime.dListCount,
-                     EnBaisen_OverrideLimbDraw, NULL, &this->actor);
+    SkelAnime_DrawFlexOpa(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable, this->skelAnime.dListCount,
+                          EnBaisen_OverrideLimbDraw, NULL, &this->actor);
 }
diff --git a/src/overlays/actors/ovl_En_Bigpo/z_en_bigpo.c b/src/overlays/actors/ovl_En_Bigpo/z_en_bigpo.c
index a639a10b8..2cb90b98d 100644
--- a/src/overlays/actors/ovl_En_Bigpo/z_en_bigpo.c
+++ b/src/overlays/actors/ovl_En_Bigpo/z_en_bigpo.c
@@ -74,8 +74,6 @@ void EnBigpo_WaitingForDampe(EnBigpo* this, GlobalContext* globalCtx);
 void EnBigpo_RevealedFireGrowing(EnBigpo* this, GlobalContext* globalCtx);
 
 // draw funcs
-void EnBigpo_PostLimbDraw(struct GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3s* rot, struct Actor* actor,
-                          Gfx** gfx);
 void EnBigpo_DrawMainBigpo(Actor* thisx, GlobalContext* globalCtx);
 void EnBigpo_DrawScoopSoul(Actor* thisx, GlobalContext* globalCtx);
 void EnBigpo_DrawLantern(Actor* thisx, GlobalContext* globalCtx);
@@ -404,7 +402,7 @@ void EnBigpo_SpawnCutsceneStage4(EnBigpo* this, GlobalContext* globalCtx) {
  *          big poe starts to visibly appear
  */
 void EnBigpo_SpawnCutsceneStage5(EnBigpo* this) {
-    SkelAnime_ChangeAnimDefaultRepeat(&this->skelAnime, &D_06001360);
+    Animation_PlayLoop(&this->skelAnime, &D_06001360);
     this->actor.draw = EnBigpo_DrawMainBigpo;
     Actor_SetScale(&this->actor, 0.014f);
     Audio_PlayActorSound2(&this->actor, NA_SE_EN_STALKIDS_APPEAR);
@@ -419,7 +417,7 @@ void EnBigpo_SpawnCutsceneStage6(EnBigpo* this, GlobalContext* globalCtx) {
     s32 i;
     s32 alphaPlus; // color alpha + 10
 
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     this->actor.shape.rot.y += this->rotVelocity;
     alphaPlus = this->mainColor.a + 10; // decrease transparency
     func_80B61914(this);
@@ -466,7 +464,7 @@ void EnBigpo_SpawnCutsceneStage8(EnBigpo* this, GlobalContext* globalCtx) {
     Actor* dampe;
     Camera* subCam;
 
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     this->idleTimer--;
     if (this->idleTimer == 0) {
         subCam = Play_GetCamera(globalCtx, this->cutsceneSubCamId);
@@ -518,7 +516,7 @@ void EnBigpo_SetupWarpIn(EnBigpo* this, GlobalContext* globalCtx) {
     s16 randomYaw = (Rand_Next() >> 0x14) + this->actor.yawTowardsPlayer;
 
     Audio_PlayActorSound2(&this->actor, NA_SE_EN_STALKIDS_APPEAR);
-    SkelAnime_ChangeAnimDefaultRepeat(&this->skelAnime, &D_06001360);
+    Animation_PlayLoop(&this->skelAnime, &D_06001360);
     this->rotVelocity = 0x2000;
     this->actor.world.pos.x = (Math_SinS(randomYaw) * distance) + player->actor.world.pos.x;
     this->actor.world.pos.z = (Math_CosS(randomYaw) * distance) + player->actor.world.pos.z;
@@ -545,7 +543,7 @@ void EnBigpo_WarpingIn(EnBigpo* this, GlobalContext* globalCtx) {
 }
 
 void EnBigpo_SetupIdleFlying(EnBigpo* this) {
-    SkelAnime_ChangeAnimTransitionRepeat(&this->skelAnime, &D_06000924, -5.0f);
+    Animation_MorphToLoop(&this->skelAnime, &D_06000924, -5.0f);
     // if poe missed attack, idle 4 seconds, otherwise its reappearing: attack immediately
     this->idleTimer = (this->actionFunc == EnBigpo_SpinningDown) ? 80 : 0;
     this->hoverHeightCycleTimer = 40;
@@ -561,7 +559,7 @@ void EnBigpo_SetupIdleFlying(EnBigpo* this) {
 void EnBigpo_IdleFlying(EnBigpo* this, GlobalContext* globalCtx) {
     Player* player = GET_PLAYER(globalCtx);
 
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     DECR(this->idleTimer);
 
     // flight position calculations
@@ -596,7 +594,7 @@ void EnBigpo_SetupSpinUp(EnBigpo* this) {
 }
 
 void EnBigpo_SpinningUp(EnBigpo* this, GlobalContext* globalCtx) {
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     this->rotVelocity += 0x200;
     EnBigpo_UpdateSpin(this);
     if (this->rotVelocity >= 0x3C00) {
@@ -614,7 +612,7 @@ void EnBigpo_SpinAttack(EnBigpo* this, GlobalContext* globalCtx) {
     Player* player = GET_PLAYER(globalCtx);
     s16 yawDiff;
 
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     Math_StepToF(&this->actor.speedXZ, 10.0f, 1.0f);
     Math_SmoothStepToF(&this->actor.world.pos.y, player->actor.world.pos.y, 0.3f, 7.5f, 1.0f);
     EnBigpo_UpdateSpin(this);
@@ -638,7 +636,7 @@ void EnBigpo_SetupSpinDown(EnBigpo* this) {
 void EnBigpo_SpinningDown(EnBigpo* this, GlobalContext* globalCtx) {
     Player* player = GET_PLAYER(globalCtx);
 
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     Math_SmoothStepToF(&this->actor.world.pos.y, player->actor.world.pos.y + 100.0f, 0.3f, 5.0f, 1.0f);
     Math_StepToF(&this->actor.speedXZ, 0.0f, 0.2f);
     if (Math_ScaledStepToS(&this->rotVelocity, 0, 0x200)) {
@@ -656,7 +654,7 @@ void EnBigpo_SpinningDown(EnBigpo* this, GlobalContext* globalCtx) {
  * called by EnBigpo_ApplyDamage
  */
 void EnBigpo_HitStun(EnBigpo* this) {
-    SkelAnime_ChangeAnimTransitionStop(&this->skelAnime, &D_06000454, -6.0f);
+    Animation_MorphToPlayOnce(&this->skelAnime, &D_06000454, -6.0f);
     func_800BCB70(&this->actor, 0x4000, 0xFF, 0, 0x10);
     this->collider.base.acFlags &= ~AC_ON;
     func_800BE504(&this->actor, &this->collider);
@@ -669,7 +667,7 @@ void EnBigpo_HitStun(EnBigpo* this) {
  */
 void EnBigpo_CheckHealth(EnBigpo* this, GlobalContext* globalCtx) {
     Math_StepToF(&this->actor.speedXZ, 0.0f, 0.5f);
-    if (SkelAnime_FrameUpdateMatrix(&this->skelAnime)) {
+    if (SkelAnime_Update(&this->skelAnime)) {
         if (this->actor.colChkInfo.health == 0) {
             EnBigpo_SetupDeath(this);
         } else {
@@ -1231,8 +1229,8 @@ void EnBigpo_UpdateFire(Actor* thisx, GlobalContext* globalCtx) {
     this->actionFunc(this, globalCtx);
 }
 
-s32 EnBigpo_OverrideLimbDraw(struct GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3f* pos, Vec3s* rot,
-                             struct Actor* actor, Gfx** gfx) {
+s32 EnBigpo_OverrideLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3f* pos, Vec3s* rot, Actor* actor,
+                             Gfx** gfx) {
     EnBigpo* this = (EnBigpo*)actor;
     // not fully invisible
     if (!(this->mainColor.a != 0 && limbIndex != 7) ||
@@ -1259,36 +1257,37 @@ void EnBigpo_PostLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList,
 
     if (limbIndex == 7) {
         // we scale the vec3f... then do nothing with it?
-        SysMatrix_GetStateTranslationAndScaledY(1400.0f, &unusedVec);
+        Matrix_GetStateTranslationAndScaledY(1400.0f, &unusedVec);
         if ((this->actionFunc == EnBigpo_BurnAwayDeath) && (this->idleTimer > 18)) {
-            if (actor->scale.x != 0.0f) {
-                Matrix_Scale(0.014f / actor->scale.x, 0.014f / actor->scale.x, 0.014f / actor->scale.x, 1);
+            if (this->actor.scale.x != 0.0f) {
+                Matrix_Scale(0.014f / this->actor.scale.x, 0.014f / this->actor.scale.x, 0.014f / this->actor.scale.x,
+                             1);
             }
         }
-        SysMatrix_CopyCurrentState(&this->drawMtxF);
+        Matrix_CopyCurrentState(&this->drawMtxF);
     }
 
     limbByte = D_80B65078[limbIndex];
     if (limbByte != -1) {
         if (limbByte < 3) {
-            SysMatrix_GetStateTranslation(&this->limbPos[limbByte]);
+            Matrix_GetStateTranslation(&this->limbPos[limbByte]);
             return;
         }
         if (limbByte == 3) {
-            SysMatrix_GetStateTranslationAndScaledX(3000.0f, &this->limbPos[limbByte]);
+            Matrix_GetStateTranslationAndScaledX(3000.0f, &this->limbPos[limbByte]);
             return;
         }
         if (limbByte == 4) {
-            SysMatrix_GetStateTranslationAndScaledY(-2000.0f, &this->limbPos[limbByte]);
+            Matrix_GetStateTranslationAndScaledY(-2000.0f, &this->limbPos[limbByte]);
             return;
         }
 
         v2ptr = &this->limbPos[limbByte + 1];
         v1ptr = D_80B65084;
-        SysMatrix_GetStateTranslationAndScaledX(-4000.0f, &this->limbPos[limbByte]);
+        Matrix_GetStateTranslationAndScaledX(-4000.0f, &this->limbPos[limbByte]);
 
         for (i = limbByte + 1; i < ARRAY_COUNT(this->limbPos); i++) {
-            SysMatrix_MultiplyVector3fByState(v1ptr, v2ptr);
+            Matrix_MultiplyVector3fByState(v1ptr, v2ptr);
             v2ptr++;
             v1ptr++;
         }
@@ -1310,8 +1309,8 @@ void EnBigpo_DrawMainBigpo(Actor* thisx, GlobalContext* globalCtx) {
         gSPSegment(&dispHead[2], 0x08,
                    Gfx_EnvColor(globalCtx->state.gfxCtx, this->mainColor.r, this->mainColor.g, this->mainColor.b,
                                 this->mainColor.a));
-        POLY_OPA_DISP = SkelAnime_Draw2(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl,
-                                        EnBigpo_OverrideLimbDraw, EnBigpo_PostLimbDraw, &this->actor, &dispHead[3]);
+        POLY_OPA_DISP = SkelAnime_Draw(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable,
+                                       EnBigpo_OverrideLimbDraw, EnBigpo_PostLimbDraw, &this->actor, &dispHead[3]);
 
     } else {
         dispHead = POLY_XLU_DISP;
@@ -1320,15 +1319,15 @@ void EnBigpo_DrawMainBigpo(Actor* thisx, GlobalContext* globalCtx) {
         gSPSegment(&dispHead[2], 0x08,
                    Gfx_EnvColor(globalCtx->state.gfxCtx, this->mainColor.r, this->mainColor.g, this->mainColor.b,
                                 this->mainColor.a));
-        POLY_XLU_DISP = SkelAnime_Draw2(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl,
-                                        EnBigpo_OverrideLimbDraw, EnBigpo_PostLimbDraw, &this->actor, &dispHead[3]);
+        POLY_XLU_DISP = SkelAnime_Draw(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable,
+                                       EnBigpo_OverrideLimbDraw, EnBigpo_PostLimbDraw, &this->actor, &dispHead[3]);
     }
 
     // 71.428566f might be 500/7 context unknown
     func_800BE680(globalCtx, &this->actor, this->limbPos, 9, this->actor.scale.x * 71.428566f * this->unk220, 0,
                   this->unk21C, 0x14);
 
-    SysMatrix_SetCurrentState(&this->drawMtxF);
+    Matrix_SetCurrentState(&this->drawMtxF);
     EnBigpo_DrawLantern(&this->actor, globalCtx);
     if (this->actionFunc == EnBigpo_SpawnCutsceneStage6) {
         EnBigpo_DrawCircleFlames(&this->actor, globalCtx);
@@ -1404,7 +1403,7 @@ void EnBigpo_DrawLantern(Actor* thisx, GlobalContext* globalCtx) {
 
         gSPSegment(&dispHead[1], 0x0A, Gfx_EnvColor(globalCtx->state.gfxCtx, 160, 0, 255, this->mainColor.a));
 
-        SysMatrix_GetStateTranslationAndScaledY(1400.0f, &vec2);
+        Matrix_GetStateTranslationAndScaledY(1400.0f, &vec2);
         Lights_PointGlowSetInfo(&this->fires[0].info, vec2.x + vec1.x, vec2.y + vec1.y, vec2.z + vec1.z,
                                 this->lanternColor.r, this->lanternColor.g, this->lanternColor.b, this->lanternColor.a);
 
@@ -1433,7 +1432,7 @@ void EnBigpo_DrawCircleFlames(Actor* thisx, GlobalContext* globalCtx) {
     MtxF* mtfxPtr;
     s32 i;
 
-    mtfxPtr = SysMatrix_GetCurrentState();
+    mtfxPtr = Matrix_GetCurrentState();
     OPEN_DISPS(globalCtx->state.gfxCtx);
 
     func_8012C2DC(globalCtx->state.gfxCtx);
diff --git a/src/overlays/actors/ovl_En_Bji_01/z_en_bji_01.c b/src/overlays/actors/ovl_En_Bji_01/z_en_bji_01.c
index 5cce23a9c..45370609b 100644
--- a/src/overlays/actors/ovl_En_Bji_01/z_en_bji_01.c
+++ b/src/overlays/actors/ovl_En_Bji_01/z_en_bji_01.c
@@ -26,9 +26,8 @@ void func_809CD6C0(EnBji01* this, GlobalContext* globalCtx);
 void func_809CD70C(EnBji01* this, GlobalContext* globalCtx);
 void func_809CD77C(EnBji01* this, GlobalContext* globalCtx);
 
-s32 EnBji01_OverrideLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3f* pos, Vec3s* rot,
-                             Actor* actor);
-void EnBji01_PostLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3s* rot, Actor* actor);
+s32 EnBji01_OverrideLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3f* pos, Vec3s* rot, Actor* arg);
+void EnBji01_PostLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3s* rot, Actor* arg);
 
 extern AnimationHeader D_06000FDC;
 extern AnimationHeader D_06005B58;
@@ -297,7 +296,7 @@ void EnBji01_DialogueHandler(EnBji01* this, GlobalContext* globalCtx) {
             func_809CCE98(this, globalCtx);
             break;
     }
-    if ((this->animationIndex == 3) && (this->skelAnime.animCurrentFrame == this->skelAnime.animFrameCount)) {
+    if ((this->animationIndex == 3) && (this->skelAnime.curFrame == this->skelAnime.endFrame)) {
         func_8013E1C8(&this->skelAnime, D_809CDC7C, 2, &this->animationIndex);
     }
 }
@@ -339,8 +338,8 @@ void EnBji01_Init(Actor* thisx, GlobalContext* globalCtx) {
     EnBji01* this = THIS;
 
     ActorShape_Init(&this->actor.shape, 0.0f, func_800B3FC0, 30.0f);
-    SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_0600578C, &D_06000FDC, this->jointTable, this->morphTable,
-                     BJI_LIMB_MAX);
+    SkelAnime_InitFlex(globalCtx, &this->skelAnime, &D_0600578C, &D_06000FDC, this->jointTable, this->morphTable,
+                       BJI_LIMB_MAX);
     Collider_InitAndSetCylinder(globalCtx, &this->collider, &this->actor, &sCylinderInit);
 
     this->actor.colChkInfo.mass = MASS_IMMOVABLE;
@@ -386,7 +385,7 @@ void EnBji01_Update(Actor* thisx, GlobalContext* globalCtx) {
 
     this->actionFunc(this, globalCtx);
     Actor_UpdateBgCheckInfo(globalCtx, (Actor*)this, 0.0f, 0.0f, 0.0f, 4U);
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
 
     if (this->blinkTimer-- <= 0) {
         if (--this->blinkSeqIndex < 0) {
@@ -438,7 +437,7 @@ void EnBji01_PostLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList,
         sp20.x += temp_f4 * 0.1f;
         sp20.y += temp_f4 * 0.1f;
         sp20.z += temp_f4 * 0.1f;
-        SysMatrix_MultiplyVector3fByState(&sp20, &this->actor.focus.pos);
+        Matrix_MultiplyVector3fByState(&sp20, &this->actor.focus.pos);
     }
 }
 
@@ -449,7 +448,7 @@ void EnBji01_Draw(Actor* thisx, GlobalContext* globalCtx) {
     OPEN_DISPS(globalCtx->state.gfxCtx);
     func_8012C28C(globalCtx->state.gfxCtx);
     gSPSegment(POLY_OPA_DISP++, 0x08, Lib_SegmentedToVirtual(sEyeTextures[this->eyeTexIndex]));
-    SkelAnime_DrawSV(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl, this->skelAnime.dListCount,
-                     EnBji01_OverrideLimbDraw, EnBji01_PostLimbDraw, &this->actor);
+    SkelAnime_DrawFlexOpa(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable, this->skelAnime.dListCount,
+                          EnBji01_OverrideLimbDraw, EnBji01_PostLimbDraw, &this->actor);
     CLOSE_DISPS(globalCtx->state.gfxCtx);
 }
diff --git a/src/overlays/actors/ovl_En_Bu/z_en_bu.c b/src/overlays/actors/ovl_En_Bu/z_en_bu.c
index ad001d6e0..8a7d39086 100644
--- a/src/overlays/actors/ovl_En_Bu/z_en_bu.c
+++ b/src/overlays/actors/ovl_En_Bu/z_en_bu.c
@@ -47,11 +47,11 @@ void EnBu_Draw(Actor* thisx, GlobalContext* globalCtx) {
 
     OPEN_DISPS(globalCtx->state.gfxCtx);
 
-    SysMatrix_InsertTranslation(this->actor.world.pos.x, this->actor.world.pos.y, this->actor.world.pos.z, 0);
-    SysMatrix_InsertZRotation_s(this->actor.shape.rot.z, 1);
+    Matrix_InsertTranslation(this->actor.world.pos.x, this->actor.world.pos.y, this->actor.world.pos.z, MTXMODE_NEW);
+    Matrix_InsertZRotation_s(this->actor.shape.rot.z, 1);
     Matrix_RotateY(this->actor.shape.rot.y, 1);
-    SysMatrix_InsertXRotation_s(this->actor.shape.rot.x, 1);
-    Matrix_Scale(0.01f, 0.01f, 0.01f, 1);
+    Matrix_InsertXRotation_s(this->actor.shape.rot.x, 1);
+    Matrix_Scale(0.01f, 0.01f, 0.01f, MTXMODE_APPLY);
     gSPMatrix(POLY_OPA_DISP++, Matrix_NewMtx(globalCtx->state.gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
     gSPDisplayList(POLY_OPA_DISP++, this->displayListPtr);
 
diff --git a/src/overlays/actors/ovl_En_Cha/z_en_cha.c b/src/overlays/actors/ovl_En_Cha/z_en_cha.c
index 1df7f22e1..9a1280c29 100644
--- a/src/overlays/actors/ovl_En_Cha/z_en_cha.c
+++ b/src/overlays/actors/ovl_En_Cha/z_en_cha.c
@@ -118,7 +118,7 @@ void EnCha_Draw(Actor* thisx, GlobalContext* globalCtx) {
     EnCha* this = THIS;
 
     func_800BDFC0(globalCtx, D_06000710);
-    SysMatrix_InsertTranslation(-1094.0f, 4950.0f, 9.0f, 1);
-    SysMatrix_InsertXRotation_s(this->actor.home.rot.x, 1);
+    Matrix_InsertTranslation(-1094.0f, 4950.0f, 9.0f, MTXMODE_APPLY);
+    Matrix_InsertXRotation_s(this->actor.home.rot.x, 1);
     func_800BDFC0(globalCtx, D_06000958);
 }
diff --git a/src/overlays/actors/ovl_En_Clear_Tag/z_en_clear_tag.c b/src/overlays/actors/ovl_En_Clear_Tag/z_en_clear_tag.c
index e0c520f9f..b7ad8e6f3 100644
--- a/src/overlays/actors/ovl_En_Clear_Tag/z_en_clear_tag.c
+++ b/src/overlays/actors/ovl_En_Clear_Tag/z_en_clear_tag.c
@@ -416,9 +416,9 @@ void EnClearTag_Init(Actor* thisx, GlobalContext* globalCtx) {
                 for (i = 0; i < 54; i++) {
                     lightRayMaxScale =
                         sLightRayMaxScale[thisx->params] + Rand_ZeroFloat(sLightRayMaxScale[thisx->params]);
-                    SysMatrix_InsertYRotation_f(Rand_ZeroFloat(M_PI * 2), 0);
-                    SysMatrix_RotateStateAroundXAxis(Rand_ZeroFloat(M_PI * 2));
-                    SysMatrix_GetStateTranslationAndScaledZ(lightRayMaxScale, &vel);
+                    Matrix_InsertYRotation_f(Rand_ZeroFloat(M_PI * 2), 0);
+                    Matrix_RotateStateAroundXAxis(Rand_ZeroFloat(M_PI * 2));
+                    Matrix_GetStateTranslationAndScaledZ(lightRayMaxScale, &vel);
                     accel.x = vel.x * -0.03f;
                     accel.y = vel.y * -0.03f;
                     accel.z = vel.z * -0.03f;
@@ -489,9 +489,9 @@ void EnClearTag_Init(Actor* thisx, GlobalContext* globalCtx) {
             pos = this->actor.world.pos;
             for (i = 0; i < 44; i++) {
                 lightRayMaxScale = sLightRayMaxScale[thisx->params] + Rand_ZeroFloat(sLightRayMaxScale[thisx->params]);
-                SysMatrix_InsertYRotation_f(Rand_ZeroFloat(2 * M_PI), 0);
-                SysMatrix_RotateStateAroundXAxis(Rand_ZeroFloat(2 * M_PI));
-                SysMatrix_GetStateTranslationAndScaledZ(lightRayMaxScale, &vel);
+                Matrix_InsertYRotation_f(Rand_ZeroFloat(2 * M_PI), 0);
+                Matrix_RotateStateAroundXAxis(Rand_ZeroFloat(2 * M_PI));
+                Matrix_GetStateTranslationAndScaledZ(lightRayMaxScale, &vel);
                 accel.x = vel.x * -0.03f;
                 accel.y = vel.y * -0.03f;
                 accel.z = vel.z * -0.03f;
@@ -798,10 +798,10 @@ void EnClearTag_DrawEffects(Actor* thisx, GlobalContext* globalCtx) {
             }
 
             // Draw the debris effect.
-            SysMatrix_InsertTranslation(effect->position.x, effect->position.y, effect->position.z, MTXMODE_NEW);
+            Matrix_InsertTranslation(effect->position.x, effect->position.y, effect->position.z, MTXMODE_NEW);
             Matrix_Scale(effect->scale, effect->scale, effect->scale, MTXMODE_APPLY);
-            SysMatrix_InsertYRotation_f(effect->rotationY, MTXMODE_APPLY);
-            SysMatrix_RotateStateAroundXAxis(effect->rotationX);
+            Matrix_InsertYRotation_f(effect->rotationY, MTXMODE_APPLY);
+            Matrix_RotateStateAroundXAxis(effect->rotationX);
             gSPMatrix(POLY_OPA_DISP++, Matrix_NewMtx(gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
             gSPDisplayList(POLY_OPA_DISP++, gClearTagDebrisEffectDL);
         }
@@ -817,7 +817,7 @@ void EnClearTag_DrawEffects(Actor* thisx, GlobalContext* globalCtx) {
                 gDPSetEnvColor(POLY_XLU_DISP++, 255, 255, 255, (s8)effect->primColor.a);
                 gDPSetPrimColor(POLY_XLU_DISP++, 0, 0, 255, 255, 255, (s8)effect->primColor.a);
                 func_800C0094(this->actor.floorPoly, effect->position.x, effect->position.y, effect->position.z, &mtxF);
-                SysMatrix_SetCurrentState(&mtxF);
+                Matrix_SetCurrentState(&mtxF);
                 Matrix_Scale(effect->scale, 1.0f, effect->scale, MTXMODE_APPLY);
                 gSPMatrix(POLY_XLU_DISP++, Matrix_NewMtx(gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
                 gSPDisplayList(POLY_XLU_DISP++, D_04030100);
@@ -842,7 +842,7 @@ void EnClearTag_DrawEffects(Actor* thisx, GlobalContext* globalCtx) {
                 gDPSetPrimColor(POLY_XLU_DISP++, 0, 0, 255, 255, 200, (s8)(effect->primColor.a * 0.7f));
                 func_800C0094(this->actor.floorPoly, effect->position.x, this->actor.floorHeight, effect->position.z,
                               &mtxF);
-                SysMatrix_SetCurrentState(&mtxF);
+                Matrix_SetCurrentState(&mtxF);
                 Matrix_Scale(effect->scale * 3.0f, 1.0f, effect->scale * 3.0f, MTXMODE_APPLY);
                 gSPMatrix(POLY_XLU_DISP++, Matrix_NewMtx(gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
                 gSPDisplayList(POLY_XLU_DISP++, gClearTagFlashEffectGroundDL);
@@ -870,10 +870,10 @@ void EnClearTag_DrawEffects(Actor* thisx, GlobalContext* globalCtx) {
             gSPSegment(
                 POLY_XLU_DISP++, 0x08,
                 Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 0, -effect->actionTimer * 5, 32, 64, 1, 0, 0, 32, 32));
-            SysMatrix_InsertTranslation(effect->position.x, effect->position.y, effect->position.z, MTXMODE_NEW);
-            SysMatrix_NormalizeXYZ(&globalCtx->mf_187FC);
+            Matrix_InsertTranslation(effect->position.x, effect->position.y, effect->position.z, MTXMODE_NEW);
+            Matrix_NormalizeXYZ(&globalCtx->mf_187FC);
             Matrix_Scale(effect->smokeScaleX * effect->scale, effect->smokeScaleY * effect->scale, 1.0f, MTXMODE_APPLY);
-            SysMatrix_InsertTranslation(0.0f, 20.0f, 0.0f, MTXMODE_APPLY);
+            Matrix_InsertTranslation(0.0f, 20.0f, 0.0f, MTXMODE_APPLY);
             gSPMatrix(POLY_XLU_DISP++, Matrix_NewMtx(gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
             gSPDisplayList(POLY_XLU_DISP++, gClearTagFireEffectDL);
         }
@@ -896,8 +896,8 @@ void EnClearTag_DrawEffects(Actor* thisx, GlobalContext* globalCtx) {
             gSPSegment(
                 POLY_XLU_DISP++, 0x08,
                 Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 0, -effect->actionTimer * 15, 32, 64, 1, 0, 0, 32, 32));
-            SysMatrix_InsertTranslation(effect->position.x, effect->position.y, effect->position.z, MTXMODE_NEW);
-            SysMatrix_NormalizeXYZ(&globalCtx->mf_187FC);
+            Matrix_InsertTranslation(effect->position.x, effect->position.y, effect->position.z, MTXMODE_NEW);
+            Matrix_NormalizeXYZ(&globalCtx->mf_187FC);
             Matrix_Scale(effect->scale, effect->scale, 1.0f, MTXMODE_APPLY);
             gSPMatrix(POLY_XLU_DISP++, Matrix_NewMtx(gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
             gSPDisplayList(POLY_XLU_DISP++, gClearTagFireEffectDL);
@@ -918,8 +918,8 @@ void EnClearTag_DrawEffects(Actor* thisx, GlobalContext* globalCtx) {
 
             // Draw the flash billboard effect.
             gDPSetPrimColor(POLY_XLU_DISP++, 0, 0, 255, 255, 200, (s8)effect->primColor.a);
-            SysMatrix_InsertTranslation(effect->position.x, effect->position.y, effect->position.z, MTXMODE_NEW);
-            SysMatrix_NormalizeXYZ(&globalCtx->mf_187FC);
+            Matrix_InsertTranslation(effect->position.x, effect->position.y, effect->position.z, MTXMODE_NEW);
+            Matrix_NormalizeXYZ(&globalCtx->mf_187FC);
             Matrix_Scale(2.0f * effect->scale, 2.0f * effect->scale, 1.0f, MTXMODE_APPLY);
             gSPMatrix(POLY_XLU_DISP++, Matrix_NewMtx(gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
             gSPDisplayList(POLY_XLU_DISP++, gClearTagFlashEffectDL);
@@ -943,12 +943,12 @@ void EnClearTag_DrawEffects(Actor* thisx, GlobalContext* globalCtx) {
             // Draw the light ray effect.
             gDPSetPrimColor(POLY_XLU_DISP++, 0, 0, (u8)effect->primColor.r, (u8)effect->primColor.g,
                             (u8)effect->primColor.b, (u8)effect->primColor.a);
-            SysMatrix_InsertTranslation(effect->position.x, effect->position.y, effect->position.z, MTXMODE_NEW);
-            SysMatrix_InsertYRotation_f(effect->rotationY, MTXMODE_APPLY);
-            SysMatrix_RotateStateAroundXAxis(effect->rotationX);
-            SysMatrix_InsertZRotation_f(effect->rotationZ, MTXMODE_APPLY);
+            Matrix_InsertTranslation(effect->position.x, effect->position.y, effect->position.z, MTXMODE_NEW);
+            Matrix_InsertYRotation_f(effect->rotationY, MTXMODE_APPLY);
+            Matrix_RotateStateAroundXAxis(effect->rotationX);
+            Matrix_InsertZRotation_f(effect->rotationZ, MTXMODE_APPLY);
             Matrix_Scale(effect->scale * 0.5f, effect->scale * 0.5f, effect->maxScale * effect->scale, MTXMODE_APPLY);
-            SysMatrix_RotateStateAroundXAxis(M_PI / 2);
+            Matrix_RotateStateAroundXAxis(M_PI / 2);
             gSPMatrix(POLY_XLU_DISP++, Matrix_NewMtx(gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
             gSPDisplayList(POLY_XLU_DISP++, gClearTagLightRayEffectDL);
         }
@@ -968,8 +968,8 @@ void EnClearTag_DrawEffects(Actor* thisx, GlobalContext* globalCtx) {
 
             // Apply material 16 times along a circle to give the appearance of a splash
             for (j = 0; j < 16; j++) {
-                SysMatrix_InsertYRotation_f(2.0f * (j * M_PI) * (1.0f / 16.0f), MTXMODE_NEW);
-                SysMatrix_GetStateTranslationAndScaledZ(effect->maxScale, &vec);
+                Matrix_InsertYRotation_f(2.0f * (j * M_PI) * (1.0f / 16.0f), MTXMODE_NEW);
+                Matrix_GetStateTranslationAndScaledZ(effect->maxScale, &vec);
                 /**
                  * Get the water surface at point (`x`, `ySurface`, `z`). `ySurface` doubles as position y input
                  * returns true if point is within the xz boundaries of an active water box, else false
@@ -980,10 +980,10 @@ void EnClearTag_DrawEffects(Actor* thisx, GlobalContext* globalCtx) {
                                   &ySurface, &waterBox)) {
                     if ((effect->position.y - ySurface) < 200.0f) {
                         // Draw the splash effect.
-                        SysMatrix_InsertTranslation(effect->position.x + vec.x, ySurface, effect->position.z + vec.z,
-                                                    MTXMODE_NEW);
-                        SysMatrix_InsertYRotation_f(2.0f * (j * M_PI) * (1.0f / 16.0f), MTXMODE_APPLY);
-                        SysMatrix_RotateStateAroundXAxis(effect->rotationX);
+                        Matrix_InsertTranslation(effect->position.x + vec.x, ySurface, effect->position.z + vec.z,
+                                                 MTXMODE_NEW);
+                        Matrix_InsertYRotation_f(2.0f * (j * M_PI) * (1.0f / 16.0f), MTXMODE_APPLY);
+                        Matrix_RotateStateAroundXAxis(effect->rotationX);
                         Matrix_Scale(effect->scale, effect->scale, effect->scale, MTXMODE_APPLY);
                         gSPMatrix(POLY_XLU_DISP++, Matrix_NewMtx(gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
                         gSPDisplayList(POLY_XLU_DISP++, D_0403A0F0);
diff --git a/src/overlays/actors/ovl_En_Dai/z_en_dai.c b/src/overlays/actors/ovl_En_Dai/z_en_dai.c
index 2bb487064..fb917742c 100644
--- a/src/overlays/actors/ovl_En_Dai/z_en_dai.c
+++ b/src/overlays/actors/ovl_En_Dai/z_en_dai.c
@@ -91,7 +91,7 @@ void func_80B3E168(EnDaiParticle* particle, GlobalContext* globalCtx2) {
                 isDisplayListSet = true;
             }
 
-            SysMatrix_StatePush();
+            Matrix_StatePush();
 
             alpha = (particle->unk_02 / (f32)particle->unk_01);
             alpha *= 255.0f;
@@ -102,15 +102,15 @@ void func_80B3E168(EnDaiParticle* particle, GlobalContext* globalCtx2) {
                        Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, (particle->unk_02 + (i * 3)) * 3,
                                         (particle->unk_02 + (i * 3)) * 15, 0x20, 0x40, 1, 0, 0, 0x20, 0x20));
 
-            SysMatrix_InsertTranslation(particle->unk_10.x, particle->unk_10.y, particle->unk_10.z, MTXMODE_NEW);
-            SysMatrix_NormalizeXYZ(&globalCtx->mf_187FC);
+            Matrix_InsertTranslation(particle->unk_10.x, particle->unk_10.y, particle->unk_10.z, MTXMODE_NEW);
+            Matrix_NormalizeXYZ(&globalCtx->mf_187FC);
             Matrix_Scale(particle->unk_34, particle->unk_34, 1.0f, MTXMODE_APPLY);
 
             gSPMatrix(POLY_XLU_DISP++, Matrix_NewMtx(globalCtx->state.gfxCtx),
                       G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
             gSPDisplayList(POLY_XLU_DISP++, D_060002E8);
 
-            SysMatrix_StatePop();
+            Matrix_StatePop();
         }
     }
 
@@ -280,8 +280,7 @@ s16 func_80B3E8BC(EnDai* this, s32 arg1) {
     }
 
     while (i < end) {
-        if ((D_80B3FCB4[i] <= this->skelAnime.animCurrentFrame) &&
-            (D_80B3FCE4[i] >= this->skelAnime.animCurrentFrame)) {
+        if ((D_80B3FCB4[i] <= this->skelAnime.curFrame) && (D_80B3FCE4[i] >= this->skelAnime.curFrame)) {
             return D_80B3FD14[i];
         }
         i++;
@@ -297,7 +296,7 @@ s32 func_80B3E96C(EnDai* this, GlobalContext* globalCtx) {
     Vec3f sp50;
 
     if ((DECR(this->unk_1DA) == 0) &&
-        ((this->unk_1DC == 0) || func_801378B8(&this->skelAnime, this->skelAnime.animFrameCount))) {
+        ((this->unk_1DC == 0) || Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame))) {
         switch (this->unk_1DC) {
             case 0:
                 func_80B3E5DC(this, 2);
@@ -373,10 +372,10 @@ s32 func_80B3EC84(EnDai* this) {
     s32 ret = false;
 
     for (i = 0; i < ARRAY_COUNT(D_80B3FD6C); i++) {
-        if ((this->unk_1DC == D_80B3FD6C[i]) && (D_80B3FD2C[i] < this->skelAnime.animCurrentFrame) &&
-            (D_80B3FD4C[i] >= this->skelAnime.animCurrentFrame)) {
-            func_80B3EC10(D_80B3FD2C[i], D_80B3FD7C[i], D_80B3FD4C[i], D_80B3FD7C[i + 1],
-                          this->skelAnime.animCurrentFrame, &this->unk_1F0);
+        if ((this->unk_1DC == D_80B3FD6C[i]) && (D_80B3FD2C[i] < this->skelAnime.curFrame) &&
+            (D_80B3FD4C[i] >= this->skelAnime.curFrame)) {
+            func_80B3EC10(D_80B3FD2C[i], D_80B3FD7C[i], D_80B3FD4C[i], D_80B3FD7C[i + 1], this->skelAnime.curFrame,
+                          &this->unk_1F0);
             ret = true;
             break;
         }
@@ -400,10 +399,10 @@ s32 func_80B3ED88(EnDai* this) {
     s32 ret = false;
 
     for (i = 0; i < ARRAY_COUNT(D_80B3FE00); i++) {
-        if ((this->unk_1DC == D_80B3FE00[i]) && (D_80B3FDE8[i] < this->skelAnime.animCurrentFrame) &&
-            (D_80B3FDF4[i] >= this->skelAnime.animCurrentFrame)) {
-            func_80B3EC10(D_80B3FDE8[i], D_80B3FE08[i], D_80B3FDF4[i], D_80B3FE08[i + 1],
-                          this->skelAnime.animCurrentFrame, &this->unk_1FC);
+        if ((this->unk_1DC == D_80B3FE00[i]) && (D_80B3FDE8[i] < this->skelAnime.curFrame) &&
+            (D_80B3FDF4[i] >= this->skelAnime.curFrame)) {
+            func_80B3EC10(D_80B3FDE8[i], D_80B3FE08[i], D_80B3FDF4[i], D_80B3FE08[i + 1], this->skelAnime.curFrame,
+                          &this->unk_1FC);
             ret = true;
             break;
         }
@@ -496,24 +495,24 @@ void func_80B3F044(EnDai* this, GlobalContext* globalCtx) {
             if (globalCtx->csCtx.frames == 360) {
                 Audio_PlayActorSound2(&this->actor, NA_SE_EN_DAIGOLON_SLEEP3 - SFX_FLAG);
             }
-            if (func_801378B8(&this->skelAnime, 43.0f)) {
+            if (Animation_OnFrame(&this->skelAnime, 43.0f)) {
                 Audio_PlayActorSound2(&this->actor, NA_SE_EV_GORON_BOUND_1);
             }
             this->unk_1D6 = func_80B3E8BC(this, this->unk_1CC);
             break;
 
         case 3:
-            if (func_801378B8(&this->skelAnime, 6.0f)) {
+            if (Animation_OnFrame(&this->skelAnime, 6.0f)) {
                 Audio_PlayActorSound2(&this->actor, NA_SE_EN_DAIGOLON_SLEEP1);
             }
             this->unk_1D6 = func_80B3E8BC(this, this->unk_1CC);
             break;
 
         case 4:
-            if (func_801378B8(&this->skelAnime, 30.0f)) {
+            if (Animation_OnFrame(&this->skelAnime, 30.0f)) {
                 Audio_PlayActorSound2(&this->actor, NA_SE_EN_DAIGOLON_SLEEP2);
             }
-            if (func_801378B8(&this->skelAnime, 35.0f)) {
+            if (Animation_OnFrame(&this->skelAnime, 35.0f)) {
                 Audio_PlayActorSound2(&this->actor, NA_SE_EV_GORON_BOUND_0);
             }
             this->unk_1D6 = func_80B3E8BC(this, this->unk_1CC);
@@ -527,7 +526,7 @@ void EnDai_Init(Actor* thisx, GlobalContext* globalCtx) {
     EnDai* this = THIS;
 
     ActorShape_Init(&this->actor.shape, 0.0f, func_800B3FC0, 0.0f);
-    SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_060130D0, NULL, this->jointTable, this->morphTable, 19);
+    SkelAnime_InitFlex(globalCtx, &this->skelAnime, &D_060130D0, NULL, this->jointTable, this->morphTable, 19);
     this->unk_A70 = -1;
     func_80B3E5DC(this, 0);
     Actor_SetScale(&this->actor, 0.2f);
@@ -567,13 +566,13 @@ void EnDai_Update(Actor* thisx, GlobalContext* globalCtx) {
 
     if (!func_80B3E7C8(this, globalCtx) && func_80B3E69C(this, globalCtx)) {
         func_80B3F044(this, globalCtx);
-        SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+        SkelAnime_Update(&this->skelAnime);
         func_80B3E834(this);
         func_80B3E460(this);
     } else {
         this->actionFunc(this, globalCtx);
         if (!(player->stateFlags2 & 0x8000000)) {
-            SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+            SkelAnime_Update(&this->skelAnime);
             func_80B3E834(this);
             if (!(this->unk_1CE & 0x200)) {
                 func_8013C964(&this->actor, globalCtx, 0.0f, 0.0f, 0, this->unk_1CE & 7);
@@ -592,7 +591,7 @@ s32 func_80B3F598(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3f* p
     }
 
     if (limbIndex == 11) {
-        SysMatrix_MultiplyVector3fByState(&D_801D15B0, &this->unk_1E4);
+        Matrix_MultiplyVector3fByState(&D_801D15B0, &this->unk_1E4);
     }
 
     if (limbIndex == 10) {
@@ -614,15 +613,15 @@ void func_80B3F614(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3s*
             D_80B3FE4C.x = sREG(0);
             D_80B3FE4C.y = sREG(1);
             D_80B3FE4C.z = sREG(2);
-            SysMatrix_MultiplyVector3fByState(&D_80B3FE4C, &this->actor.focus.pos);
+            Matrix_MultiplyVector3fByState(&D_80B3FE4C, &this->actor.focus.pos);
             Math_Vec3s_Copy(&this->actor.focus.rot, &this->actor.world.rot);
-            SysMatrix_CopyCurrentState(&sp24);
+            Matrix_CopyCurrentState(&sp24);
             func_8018219C(&sp24, &sp64, 0);
             this->unk_1D4 = BINANG_SUB(sp64.y, 0x4000);
             break;
 
         case 10:
-            SysMatrix_CopyCurrentState(&this->unk_18C);
+            Matrix_CopyCurrentState(&this->unk_18C);
             break;
     }
 }
@@ -671,10 +670,10 @@ void func_80B3F78C(EnDai* this, GlobalContext* globalCtx) {
     gSPSegment(POLY_XLU_DISP++, 0x08, Lib_SegmentedToVirtual(D_80B3FE58[this->unk_1D6]));
 
     POLY_XLU_DISP =
-        func_8013AB00(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl, this->skelAnime.dListCount,
+        func_8013AB00(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable, this->skelAnime.dListCount,
                       func_80B3F598, func_80B3F614, func_80B3F6EC, &this->actor, POLY_XLU_DISP);
     if (this->unk_1CE & 0x40) {
-        SysMatrix_SetCurrentState(&this->unk_18C);
+        Matrix_SetCurrentState(&this->unk_18C);
 
         gSPMatrix(POLY_XLU_DISP++, Matrix_NewMtx(globalCtx->state.gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
         gSPDisplayList(POLY_XLU_DISP++, D_0600C538);
@@ -703,9 +702,9 @@ void func_80B3F920(EnDai* this, GlobalContext* globalCtx) {
         gSPSegment(POLY_OPA_DISP++, 0x08, Lib_SegmentedToVirtual(D_80B3FE70[this->unk_1D6]));
 
         POLY_OPA_DISP =
-            func_8013AB00(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl, this->skelAnime.dListCount,
+            func_8013AB00(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable, this->skelAnime.dListCount,
                           func_80B3F598, func_80B3F614, func_80B3F6EC, &this->actor, POLY_OPA_DISP);
-        SysMatrix_SetCurrentState(&this->unk_18C);
+        Matrix_SetCurrentState(&this->unk_18C);
 
         gSPMatrix(POLY_OPA_DISP++, Matrix_NewMtx(globalCtx->state.gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
         gSPDisplayList(POLY_OPA_DISP++, D_0600C538);
@@ -722,9 +721,9 @@ void func_80B3F920(EnDai* this, GlobalContext* globalCtx) {
         gSPSegment(POLY_XLU_DISP++, 0x08, Lib_SegmentedToVirtual(D_80B3FE70[this->unk_1D6]));
 
         POLY_XLU_DISP =
-            func_8013AB00(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl, this->skelAnime.dListCount,
+            func_8013AB00(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable, this->skelAnime.dListCount,
                           func_80B3F598, func_80B3F614, func_80B3F6EC, &this->actor, POLY_XLU_DISP);
-        SysMatrix_SetCurrentState(&this->unk_18C);
+        Matrix_SetCurrentState(&this->unk_18C);
 
         gSPMatrix(POLY_XLU_DISP++, Matrix_NewMtx(globalCtx->state.gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
         gSPDisplayList(POLY_XLU_DISP++, D_0600C538);
diff --git a/src/overlays/actors/ovl_En_Daiku/z_en_daiku.c b/src/overlays/actors/ovl_En_Daiku/z_en_daiku.c
index c07c78398..40eac8099 100644
--- a/src/overlays/actors/ovl_En_Daiku/z_en_daiku.c
+++ b/src/overlays/actors/ovl_En_Daiku/z_en_daiku.c
@@ -108,18 +108,18 @@ void EnDaiku_Init(Actor* thisx, GlobalContext* globalCtx) {
             this->unk_27E = this->unk_278 * 4 + 4;
 
         case ENDAIKU_PARAMS_FF_1:
-            SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_0600A850, &D_06002FA0, this->jointTable, this->morphTable,
-                             17);
+            SkelAnime_InitFlex(globalCtx, &this->skelAnime, &D_0600A850, &D_06002FA0, this->jointTable,
+                               this->morphTable, 17);
             break;
 
         case ENDAIKU_PARAMS_FF_2:
-            SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_0600A850, &D_0600B690, this->jointTable, this->morphTable,
-                             17);
+            SkelAnime_InitFlex(globalCtx, &this->skelAnime, &D_0600A850, &D_0600B690, this->jointTable,
+                               this->morphTable, 17);
             break;
 
         case ENDAIKU_PARAMS_FF_3:
-            SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_0600A850, &D_06001114, this->jointTable, this->morphTable,
-                             17);
+            SkelAnime_InitFlex(globalCtx, &this->skelAnime, &D_0600A850, &D_06001114, this->jointTable,
+                               this->morphTable, 17);
             break;
     }
 
@@ -141,8 +141,8 @@ void func_8094373C(EnDaiku* this, s32 arg1) {
         0, 0, 0, 0, 2, 0, 0, 2, 2,
     };
 
-    this->unk_284 = SkelAnime_GetFrameCount(&D_809440A4[arg1]->common);
-    SkelAnime_ChangeAnim(&this->skelAnime, D_809440A4[arg1], 1.0f, 0.0f, this->unk_284, D_809440C8[arg1], -4.0f);
+    this->unk_284 = Animation_GetLastFrame(D_809440A4[arg1]);
+    Animation_Change(&this->skelAnime, D_809440A4[arg1], 1.0f, 0.0f, this->unk_284, D_809440C8[arg1], -4.0f);
 }
 
 void func_809437C8(EnDaiku* this) {
@@ -179,7 +179,7 @@ void func_80943820(EnDaiku* this) {
 }
 
 void func_809438F8(EnDaiku* this, GlobalContext* globalCtx) {
-    f32 currentFrame = this->skelAnime.animCurrentFrame;
+    f32 currentFrame = this->skelAnime.curFrame;
     s32 pad;
     s32 day = gSaveContext.day - 1;
     s32 pad2;
@@ -245,7 +245,7 @@ void func_80943BC0(EnDaiku* this) {
 }
 
 void func_80943BDC(EnDaiku* this, GlobalContext* globalCtx) {
-    f32 currentFrame = this->skelAnime.animCurrentFrame;
+    f32 currentFrame = this->skelAnime.curFrame;
 
     if ((this->unk_278 == ENDAIKU_PARAMS_FF_2) && (this->unk_284 <= currentFrame)) {
         if (Rand_ZeroOne() < 0.5f) {
@@ -266,7 +266,7 @@ void EnDaiku_Update(Actor* thisx, GlobalContext* globalCtx) {
     s32 pad;
 
     if (this->unk_27E == 0) {
-        SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+        SkelAnime_Update(&this->skelAnime);
     }
 
     if ((this->unk_278 == ENDAIKU_PARAMS_FF_0) && (gSaveContext.day == 3) && (gSaveContext.isNight)) {
@@ -353,8 +353,8 @@ void EnDaiku_Draw(Actor* thisx, GlobalContext* globalCtx) {
             break;
     }
 
-    SkelAnime_DrawSV(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl, this->skelAnime.dListCount,
-                     func_80943E18, func_80943E60, &this->actor);
+    SkelAnime_DrawFlexOpa(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable, this->skelAnime.dListCount,
+                          func_80943E18, func_80943E60, &this->actor);
 
     CLOSE_DISPS(globalCtx->state.gfxCtx);
 }
diff --git a/src/overlays/actors/ovl_En_Daiku2/z_en_daiku2.c b/src/overlays/actors/ovl_En_Daiku2/z_en_daiku2.c
index 9e34154a2..daa159788 100644
--- a/src/overlays/actors/ovl_En_Daiku2/z_en_daiku2.c
+++ b/src/overlays/actors/ovl_En_Daiku2/z_en_daiku2.c
@@ -96,7 +96,7 @@ void EnDaiku2_Init(Actor* thisx, GlobalContext* globalCtx) {
 
     this->actor.colChkInfo.mass = MASS_IMMOVABLE;
     ActorShape_Init(&this->actor.shape, 0.0f, func_800B3FC0, 40.0f);
-    SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_0600A850, &D_06002FA0, this->jointTable, this->morphTable, 17);
+    SkelAnime_InitFlex(globalCtx, &this->skelAnime, &D_0600A850, &D_06002FA0, this->jointTable, this->morphTable, 17);
     this->actor.targetMode = 0;
     Collider_InitAndSetCylinder(globalCtx, &this->collider, &this->actor, &sCylinderInit);
     this->unk_278 = ENDAIKU2_GET_7F(&this->actor);
@@ -144,12 +144,12 @@ void func_80BE6408(EnDaiku2* this, s32 arg1) {
     f32 sp34 = 1.0f;
 
     this->unk_276 = arg1;
-    this->unk_284 = SkelAnime_GetFrameCount(&sAnimations[this->unk_276]->common);
+    this->unk_284 = Animation_GetLastFrame(sAnimations[this->unk_276]);
     if (this->unk_276 == 3) {
         sp34 = 2.0f;
     }
-    SkelAnime_ChangeAnim(&this->skelAnime, sAnimations[this->unk_276], sp34, 0.0f, this->unk_284,
-                         D_80BE7958[this->unk_276], -4.0f);
+    Animation_Change(&this->skelAnime, sAnimations[this->unk_276], sp34, 0.0f, this->unk_284, D_80BE7958[this->unk_276],
+                     -4.0f);
 }
 
 s32 func_80BE64C0(EnDaiku2* this, GlobalContext* globalCtx) {
@@ -212,7 +212,7 @@ void func_80BE65B4(EnDaiku2* this, GlobalContext* globalCtx) {
 }
 
 void func_80BE66E4(EnDaiku2* this, GlobalContext* globalCtx) {
-    f32 sp9C = this->skelAnime.animCurrentFrame;
+    f32 sp9C = this->skelAnime.curFrame;
     s32 sp98 = gSaveContext.day - 1;
     s32 i;
     Vec3f sp88;
@@ -244,7 +244,7 @@ void func_80BE66E4(EnDaiku2* this, GlobalContext* globalCtx) {
     }
 
     func_800B8614(&this->actor, globalCtx, 80.0f);
-    if ((this->unk_276 == 8) && func_801378B8(&this->skelAnime, 6.0f)) {
+    if ((this->unk_276 == 8) && Animation_OnFrame(&this->skelAnime, 6.0f)) {
         Audio_PlayActorSound2(&this->actor, NA_SE_EV_ROCK_BROKEN);
 
         for (i = 0; i < 10; i++) {
@@ -274,8 +274,8 @@ void func_80BE66E4(EnDaiku2* this, GlobalContext* globalCtx) {
             if ((this->unk_276 == 5) || (this->unk_276 == 9)) {
                 func_80BE6408(this, 10);
             } else if ((this->unk_276 == 10) && (this->unk_284 <= sp9C)) {
-                this->unk_284 = SkelAnime_GetFrameCount(&D_06002134.common);
-                SkelAnime_ChangeAnim(&this->skelAnime, &D_06002134, -1.0f, this->unk_284, 0.0f, 2, -4.0f);
+                this->unk_284 = Animation_GetLastFrame(&D_06002134);
+                Animation_Change(&this->skelAnime, &D_06002134, -1.0f, this->unk_284, 0.0f, 2, -4.0f);
                 this->unk_276 = 11;
             } else if ((this->unk_276 == 11) && (sp9C <= 0.0f)) {
                 func_80BE6408(this, 8);
@@ -371,7 +371,7 @@ void func_80BE6EB0(EnDaiku2* this) {
 }
 
 void func_80BE6EF0(EnDaiku2* this, GlobalContext* globalCtx) {
-    f32 sp5C = this->skelAnime.animCurrentFrame;
+    f32 sp5C = this->skelAnime.curFrame;
     s32 pad[4];
     Vec3f sp40;
     s16 var;
@@ -440,7 +440,7 @@ void func_80BE71A0(EnDaiku2* this) {
 }
 
 void func_80BE71D8(EnDaiku2* this, GlobalContext* globalCtx) {
-    f32 currentFrame = this->skelAnime.animCurrentFrame;
+    f32 currentFrame = this->skelAnime.curFrame;
 
     if (func_80BE64C0(this, globalCtx)) {
         func_80BE6CFC(this);
@@ -457,7 +457,7 @@ void EnDaiku2_Update(Actor* thisx, GlobalContext* globalCtx) {
     EnDaiku2* this = THIS;
     s32 pad;
 
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     this->actionFunc(this, globalCtx);
     this->actor.shape.rot.y = this->actor.world.rot.y;
     Actor_SetHeight(&this->actor, 65.0f);
@@ -496,8 +496,8 @@ void EnDaiku2_Draw(Actor* thisx, GlobalContext* globalCtx) {
 
     func_8012C28C(globalCtx->state.gfxCtx);
     gDPSetEnvColor(POLY_OPA_DISP++, 245, 155, 0, 255);
-    SkelAnime_DrawSV(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl, this->skelAnime.dListCount, NULL,
-                     EnDaiku2_PostLimbDraw, &this->actor);
+    SkelAnime_DrawFlexOpa(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable, this->skelAnime.dListCount,
+                          NULL, EnDaiku2_PostLimbDraw, &this->actor);
     func_80BE7718(this, globalCtx);
 
     CLOSE_DISPS(globalCtx->state.gfxCtx);
@@ -561,17 +561,17 @@ void func_80BE7718(EnDaiku2* this, GlobalContext* globalCtx) {
 
         for (i = 0; i < ARRAY_COUNT(this->particles); i++, particle++) {
             if (particle->isEnabled) {
-                SysMatrix_StatePush();
-                SysMatrix_InsertTranslation(particle->unk_04.x, particle->unk_04.y, particle->unk_04.z, MTXMODE_NEW);
-                SysMatrix_InsertXRotation_s(particle->unk_28.x, MTXMODE_APPLY);
+                Matrix_StatePush();
+                Matrix_InsertTranslation(particle->unk_04.x, particle->unk_04.y, particle->unk_04.z, MTXMODE_NEW);
+                Matrix_InsertXRotation_s(particle->unk_28.x, MTXMODE_APPLY);
                 Matrix_RotateY(particle->unk_28.y, MTXMODE_APPLY);
-                SysMatrix_InsertZRotation_s(particle->unk_28.z, MTXMODE_APPLY);
+                Matrix_InsertZRotation_s(particle->unk_28.z, MTXMODE_APPLY);
                 Matrix_Scale(particle->unk_30, particle->unk_30, particle->unk_30, MTXMODE_APPLY);
 
                 gSPMatrix(POLY_OPA_DISP++, Matrix_NewMtx(gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
                 gSPDisplayList(POLY_OPA_DISP++, D_060009E0);
 
-                SysMatrix_StatePop();
+                Matrix_StatePop();
             }
         }
     }
diff --git a/src/overlays/actors/ovl_En_Dekunuts/z_en_dekunuts.c b/src/overlays/actors/ovl_En_Dekunuts/z_en_dekunuts.c
index 69042a822..39acd872d 100644
--- a/src/overlays/actors/ovl_En_Dekunuts/z_en_dekunuts.c
+++ b/src/overlays/actors/ovl_En_Dekunuts/z_en_dekunuts.c
@@ -178,7 +178,7 @@ void func_808BD3B4(EnDekunuts* this, GlobalContext* globalCtx) {
 }
 
 void func_808BD428(EnDekunuts* this) {
-    SkelAnime_ChangeAnimPlaybackStop(&this->skelAnime, &D_06003180, 0.0f);
+    Animation_PlayOnceSetSpeed(&this->skelAnime, &D_06003180, 0.0f);
     this->unk_190 = Rand_S16Offset(100, 50);
     this->collider.dim.height = 5;
     Math_Vec3f_Copy(&this->actor.world.pos, &this->actor.home.pos);
@@ -189,7 +189,7 @@ void func_808BD428(EnDekunuts* this) {
 void func_808BD49C(EnDekunuts* this, GlobalContext* globalCtx) {
     s32 phi_v1 = false;
 
-    if (this->skelAnime.animPlaybackSpeed < 0.5f) {
+    if (this->skelAnime.playSpeed < 0.5f) {
         phi_v1 = true;
     }
 
@@ -197,18 +197,18 @@ void func_808BD49C(EnDekunuts* this, GlobalContext* globalCtx) {
         this->unk_190--;
     }
 
-    if (func_801378B8(&this->skelAnime, 9.0f)) {
+    if (Animation_OnFrame(&this->skelAnime, 9.0f)) {
         this->collider.base.acFlags |= AC_ON;
-    } else if (func_801378B8(&this->skelAnime, 8.0f)) {
+    } else if (Animation_OnFrame(&this->skelAnime, 8.0f)) {
         Audio_PlayActorSound2(&this->actor, NA_SE_EN_NUTS_UP);
     }
 
-    this->collider.dim.height = (s32)((CLAMP(this->skelAnime.animCurrentFrame, 9.0f, 12.0f) - 9.0f) * 9.0f) + 5;
+    this->collider.dim.height = (s32)((CLAMP(this->skelAnime.curFrame, 9.0f, 12.0f) - 9.0f) * 9.0f) + 5;
 
     if (!phi_v1 && (this->actor.params == ENDEKUNUTS_GET_FF00_0) &&
         (Player_GetMask(globalCtx) != PLAYER_MASK_STONE_MASK) && (this->actor.xzDistToPlayer < 120.0f)) {
         func_808BDC9C(this);
-    } else if (SkelAnime_FrameUpdateMatrix(&this->skelAnime)) {
+    } else if (SkelAnime_Update(&this->skelAnime)) {
         if (((this->unk_190 == 0) && (this->actor.xzDistToPlayer > 320.0f)) ||
             (Player_GetMask(globalCtx) == PLAYER_MASK_STONE_MASK)) {
             func_808BD78C(this);
@@ -228,19 +228,19 @@ void func_808BD49C(EnDekunuts* this, GlobalContext* globalCtx) {
          ((this->actor.params == ENDEKUNUTS_GET_FF00_2) && (this->actor.yDistToPlayer > -60.0f)) ||
          (this->actor.params == ENDEKUNUTS_GET_FF00_1)) &&
         ((this->unk_190 == 0) || (this->actor.xzDistToPlayer < 480.0f))) {
-        this->skelAnime.animPlaybackSpeed = 1.0f;
+        this->skelAnime.playSpeed = 1.0f;
     }
 }
 
 void func_808BD78C(EnDekunuts* this) {
-    SkelAnime_ChangeAnimDefaultRepeat(&this->skelAnime, &D_06002FA4);
+    Animation_PlayLoop(&this->skelAnime, &D_06002FA4);
     this->unk_190 = 2;
     this->actionFunc = func_808BD7D4;
 }
 
 void func_808BD7D4(EnDekunuts* this, GlobalContext* globalCtx) {
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
-    if (func_801378B8(&this->skelAnime, 0.0f)) {
+    SkelAnime_Update(&this->skelAnime);
+    if (Animation_OnFrame(&this->skelAnime, 0.0f)) {
         if (this->unk_190 != 0) {
             this->unk_190--;
         }
@@ -253,7 +253,7 @@ void func_808BD7D4(EnDekunuts* this, GlobalContext* globalCtx) {
 }
 
 void func_808BD870(EnDekunuts* this) {
-    SkelAnime_ChangeAnimTransitionRepeat(&this->skelAnime, &D_0600326C, -3.0f);
+    Animation_MorphToLoop(&this->skelAnime, &D_0600326C, -3.0f);
     if (this->actionFunc == func_808BDA4C) {
         this->unk_190 = 4098;
     } else {
@@ -263,8 +263,8 @@ void func_808BD870(EnDekunuts* this) {
 }
 
 void func_808BD8D8(EnDekunuts* this, GlobalContext* globalCtx) {
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
-    if (func_801378B8(&this->skelAnime, 0.0f)) {
+    SkelAnime_Update(&this->skelAnime);
+    if (Animation_OnFrame(&this->skelAnime, 0.0f)) {
         if (this->unk_190 != 0) {
             this->unk_190--;
         }
@@ -292,7 +292,7 @@ void func_808BD8D8(EnDekunuts* this, GlobalContext* globalCtx) {
 }
 
 void func_808BDA08(EnDekunuts* this) {
-    SkelAnime_ChangeAnimDefaultStop(&this->skelAnime, &D_06000168);
+    Animation_PlayOnce(&this->skelAnime, &D_06000168);
     this->unk_190 = this->unk_194;
     this->actionFunc = func_808BDA4C;
 }
@@ -314,17 +314,17 @@ void func_808BDA4C(EnDekunuts* this, GlobalContext* globalCtx) {
         sp58.y = player->actor.world.pos.y + 40.0f;
         pitch = Actor_PitchToPoint(&this->actor, &sp58);
         pitch = CLAMP(pitch, -0x3800, -0x2000);
-        if (this->skelAnime.animCurrentFrame < 7.0f) {
+        if (this->skelAnime.curFrame < 7.0f) {
             Math_ScaledStepToS(&this->actor.world.rot.x, pitch, 0x800);
         } else {
             Math_ScaledStepToS(&this->actor.world.rot.x, 0, 0x800);
         }
     }
 
-    if (SkelAnime_FrameUpdateMatrix(&this->skelAnime)) {
+    if (SkelAnime_Update(&this->skelAnime)) {
         this->actor.world.rot.x = 0;
         func_808BD870(this);
-    } else if (func_801378B8(&this->skelAnime, 7.0f)) {
+    } else if (Animation_OnFrame(&this->skelAnime, 7.0f)) {
         val = Math_CosS(this->actor.world.rot.x) * 15.0f;
         pos.x = (Math_SinS(this->actor.shape.rot.y) * val) + this->actor.world.pos.x;
         pos.y = (this->actor.world.pos.y + 12.0f) - (Math_SinS(this->actor.world.rot.x) * 15.0f);
@@ -335,8 +335,8 @@ void func_808BDA4C(EnDekunuts* this, GlobalContext* globalCtx) {
                         this->actor.world.rot.x, this->actor.shape.rot.y, 0, params) != NULL) {
             Audio_PlayActorSound2(&this->actor, NA_SE_EN_NUTS_THROW);
         }
-    } else if ((this->unk_190 >= 2) && func_801378B8(&this->skelAnime, 12.0f)) {
-        SkelAnime_ChangeAnimTransitionStop(&this->skelAnime, &D_06000168, -3.0f);
+    } else if ((this->unk_190 >= 2) && Animation_OnFrame(&this->skelAnime, 12.0f)) {
+        Animation_MorphToPlayOnce(&this->skelAnime, &D_06000168, -3.0f);
         if (this->unk_190 != 0) {
             this->unk_190--;
         }
@@ -344,14 +344,14 @@ void func_808BDA4C(EnDekunuts* this, GlobalContext* globalCtx) {
 }
 
 void func_808BDC9C(EnDekunuts* this) {
-    SkelAnime_ChangeAnimTransitionStop(&this->skelAnime, &D_06002A5C, -5.0f);
+    Animation_MorphToPlayOnce(&this->skelAnime, &D_06002A5C, -5.0f);
     this->unk_190 = 0;
     Audio_PlayActorSound2(&this->actor, NA_SE_EN_NUTS_DOWN);
     this->actionFunc = func_808BDD54;
 }
 
 void func_808BDCF0(EnDekunuts* this) {
-    SkelAnime_ChangeAnimTransitionStop(&this->skelAnime, &D_06002A5C, -5.0f);
+    Animation_MorphToPlayOnce(&this->skelAnime, &D_06002A5C, -5.0f);
     this->collider.base.acFlags &= ~AC_ON;
     this->unk_190 = 80;
     Audio_PlayActorSound2(&this->actor, NA_SE_EN_NUTS_DOWN);
@@ -359,7 +359,7 @@ void func_808BDCF0(EnDekunuts* this) {
 }
 
 void func_808BDD54(EnDekunuts* this, GlobalContext* globalCtx) {
-    if (SkelAnime_FrameUpdateMatrix(&this->skelAnime)) {
+    if (SkelAnime_Update(&this->skelAnime)) {
         if (this->unk_190 != 0) {
             this->unk_190--;
         }
@@ -368,10 +368,10 @@ void func_808BDD54(EnDekunuts* this, GlobalContext* globalCtx) {
             func_808BD428(this);
         }
     } else {
-        this->collider.dim.height = (s32)((3.0f - CLAMP(this->skelAnime.animCurrentFrame, 1.0f, 3.0f)) * 12.0f) + 5;
+        this->collider.dim.height = (s32)((3.0f - CLAMP(this->skelAnime.curFrame, 1.0f, 3.0f)) * 12.0f) + 5;
     }
 
-    if (func_801378B8(&this->skelAnime, 4.0f)) {
+    if (Animation_OnFrame(&this->skelAnime, 4.0f)) {
         this->collider.base.acFlags &= ~AC_ON;
     }
     Math_ApproachF(&this->actor.world.pos.x, this->actor.home.pos.x, 0.5f, 3.0f);
@@ -379,7 +379,7 @@ void func_808BDD54(EnDekunuts* this, GlobalContext* globalCtx) {
 }
 
 void func_808BDE7C(EnDekunuts* this) {
-    SkelAnime_ChangeAnimTransitionStop(&this->skelAnime, &D_06002DD4, -3.0f);
+    Animation_MorphToPlayOnce(&this->skelAnime, &D_06002DD4, -3.0f);
     this->collider.dim.height = 37;
     this->actor.colChkInfo.mass = 50;
     Audio_PlayActorSound2(&this->actor, NA_SE_EN_NUTS_DAMAGE);
@@ -390,7 +390,7 @@ void func_808BDE7C(EnDekunuts* this) {
 }
 
 void func_808BDEF8(EnDekunuts* this, GlobalContext* globalCtx) {
-    if (SkelAnime_FrameUpdateMatrix(&this->skelAnime)) {
+    if (SkelAnime_Update(&this->skelAnime)) {
         this->unk_192 = BINANG_ROT180(this->actor.yawTowardsPlayer);
         this->unk_18D = 3;
         func_808BDF60(this);
@@ -399,7 +399,7 @@ void func_808BDEF8(EnDekunuts* this, GlobalContext* globalCtx) {
 }
 
 void func_808BDF60(EnDekunuts* this) {
-    SkelAnime_ChangeAnimDefaultRepeat(&this->skelAnime, &D_06003780);
+    Animation_PlayLoop(&this->skelAnime, &D_06003780);
     this->unk_190 = 2;
     this->unk_18C = 0;
     this->collider.base.acFlags |= AC_ON;
@@ -410,8 +410,8 @@ void func_808BDFB8(EnDekunuts* this, GlobalContext* globalCtx) {
     s16 yaw;
     s16 yaw2;
 
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
-    if (func_801378B8(&this->skelAnime, 0.0f)) {
+    SkelAnime_Update(&this->skelAnime);
+    if (Animation_OnFrame(&this->skelAnime, 0.0f)) {
         if (this->unk_190 != 0) {
             this->unk_190--;
         }
@@ -456,7 +456,7 @@ void func_808BDFB8(EnDekunuts* this, GlobalContext* globalCtx) {
 }
 
 void func_808BE1CC(EnDekunuts* this) {
-    SkelAnime_ChangeAnimDefaultRepeat(&this->skelAnime, &D_060033E4);
+    Animation_PlayLoop(&this->skelAnime, &D_060033E4);
     this->unk_190 = 3;
     this->actor.speedXZ = 0.0f;
     if (this->unk_18D != 0) {
@@ -466,8 +466,8 @@ void func_808BE1CC(EnDekunuts* this) {
 }
 
 void func_808BE22C(EnDekunuts* this, GlobalContext* globalCtx) {
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
-    if (func_801378B8(&this->skelAnime, 0.0f)) {
+    SkelAnime_Update(&this->skelAnime);
+    if (Animation_OnFrame(&this->skelAnime, 0.0f)) {
         if (this->unk_190 != 0) {
             this->unk_190--;
         }
@@ -479,7 +479,7 @@ void func_808BE22C(EnDekunuts* this, GlobalContext* globalCtx) {
 }
 
 void func_808BE294(EnDekunuts* this, s32 arg1) {
-    SkelAnime_ChangeAnimTransitionStop(&this->skelAnime, &D_0600259C, -3.0f);
+    Animation_MorphToPlayOnce(&this->skelAnime, &D_0600259C, -3.0f);
     if (this->actor.params == ENDEKUNUTS_GET_FF00_0) {
         this->actor.speedXZ = 10.0f;
         if (arg1 != 0) {
@@ -492,12 +492,12 @@ void func_808BE294(EnDekunuts* this, s32 arg1) {
     this->actionFunc = func_808BE358;
     Audio_PlayActorSound2(&this->actor, NA_SE_EN_NUTS_DAMAGE);
     Audio_PlayActorSound2(&this->actor, NA_SE_EN_CUTBODY);
-    func_800BCB70(&this->actor, 0x4000, 255, 0, SkelAnime_GetFrameCount(&D_0600259C.common));
+    func_800BCB70(&this->actor, 0x4000, 255, 0, Animation_GetLastFrame(&D_0600259C));
 }
 
 void func_808BE358(EnDekunuts* this, GlobalContext* globalCtx) {
     Math_StepToF(&this->actor.speedXZ, 0.0f, 1.0f);
-    if (SkelAnime_FrameUpdateMatrix(&this->skelAnime)) {
+    if (SkelAnime_Update(&this->skelAnime)) {
         func_808BE484(this);
     }
 }
@@ -531,7 +531,7 @@ void func_808BE3FC(EnDekunuts* this, GlobalContext* globalCtx) {
 }
 
 void func_808BE484(EnDekunuts* this) {
-    SkelAnime_ChangeAnimDefaultStop(&this->skelAnime, &D_06002BD4);
+    Animation_PlayOnce(&this->skelAnime, &D_06002BD4);
     this->actionFunc = func_808BE4D4;
     this->actor.speedXZ = 0.0f;
     Audio_PlayActorSound2(&this->actor, NA_SE_EN_NUTS_DEAD);
@@ -543,7 +543,7 @@ void func_808BE4D4(EnDekunuts* this, GlobalContext* globalCtx) {
     s32 pad;
     Vec3f sp40;
 
-    if (SkelAnime_FrameUpdateMatrix(&this->skelAnime)) {
+    if (SkelAnime_Update(&this->skelAnime)) {
         sp40.x = this->actor.world.pos.x;
         sp40.y = this->actor.world.pos.y + 18.0f;
         sp40.z = this->actor.world.pos.z;
@@ -560,12 +560,12 @@ void func_808BE4D4(EnDekunuts* this, GlobalContext* globalCtx) {
 }
 
 void func_808BE680(EnDekunuts* this) {
-    SkelAnime_ChangeAnimTransitionRepeat(&this->skelAnime, &D_0600326C, -3.0f);
+    Animation_MorphToLoop(&this->skelAnime, &D_0600326C, -3.0f);
     this->actionFunc = func_808BE6C4;
 }
 
 void func_808BE6C4(EnDekunuts* this, GlobalContext* globalCtx) {
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     if (Player_GetMask(globalCtx) != PLAYER_MASK_STONE_MASK) {
         Math_ApproachS(&this->actor.shape.rot.y, this->actor.yawTowardsPlayer, 2, 0xE38);
     }
@@ -678,7 +678,7 @@ s32 func_808BEBD0(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3f* p
 
     if (this->actionFunc == func_808BDA4C) {
         if (limbIndex == 5) {
-            currentFrame = this->skelAnime.animCurrentFrame;
+            currentFrame = this->skelAnime.curFrame;
             if (currentFrame <= 6.0f) {
                 arg2 = 1.0f - (currentFrame * 0.0833f);
                 arg1 = (currentFrame * 0.1167f) + 1.0f;
@@ -719,30 +719,30 @@ void func_808BED30(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3s*
 
     if (value != -1) {
         if (value < 3) {
-            SysMatrix_GetStateTranslationAndScaledX(1000.0f, &this->unk_21C[value]);
+            Matrix_GetStateTranslationAndScaledX(1000.0f, &this->unk_21C[value]);
         } else {
-            SysMatrix_GetStateTranslation(&this->unk_21C[value]);
+            Matrix_GetStateTranslation(&this->unk_21C[value]);
             ptr1 = &D_808BEFA4[0];
             ptr2 = &this->unk_21C[value + 1];
             for (i = value + 1; i < ARRAY_COUNT(this->unk_21C); i++) {
-                SysMatrix_MultiplyVector3fByState(ptr1, ptr2);
+                Matrix_MultiplyVector3fByState(ptr1, ptr2);
                 ptr1++, ptr2++;
             }
         }
     }
 
     if (limbIndex == 2) {
-        SysMatrix_GetStateTranslation(&this->actor.focus.pos);
+        Matrix_GetStateTranslation(&this->actor.focus.pos);
     }
 }
 
 void EnDekunuts_Draw(Actor* thisx, GlobalContext* globalCtx) {
     EnDekunuts* this = THIS;
 
-    SkelAnime_Draw(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl, func_808BEBD0, func_808BED30,
-                   &this->actor);
-    SysMatrix_SetStateRotationAndTranslation(this->actor.home.pos.x, this->actor.home.pos.y, this->actor.home.pos.z,
-                                             &this->actor.home.rot);
+    SkelAnime_DrawOpa(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable, func_808BEBD0, func_808BED30,
+                      &this->actor);
+    Matrix_SetStateRotationAndTranslation(this->actor.home.pos.x, this->actor.home.pos.y, this->actor.home.pos.z,
+                                          &this->actor.home.rot);
     Matrix_Scale(this->actor.scale.x, this->actor.scale.y, this->actor.scale.z, MTXMODE_APPLY);
     if (this->actor.colorFilterTimer != 0) {
         func_800AE5A0(globalCtx);
diff --git a/src/overlays/actors/ovl_En_Dg/z_en_dg.c b/src/overlays/actors/ovl_En_Dg/z_en_dg.c
index cf3337c0a..c0c17367d 100644
--- a/src/overlays/actors/ovl_En_Dg/z_en_dg.c
+++ b/src/overlays/actors/ovl_En_Dg/z_en_dg.c
@@ -157,13 +157,13 @@ void func_80989140(SkelAnime* skelAnime, ActorAnimationEntryS arg1[], s32 arg2)
 
     arg1 += arg2;
     if (arg1->frameCount < 0) {
-        frameCount = SkelAnime_GetFrameCount(&arg1->animationSeg->common);
+        frameCount = Animation_GetLastFrame(arg1->animationSeg);
     } else {
         frameCount = arg1->frameCount;
     }
 
-    SkelAnime_ChangeAnim(skelAnime, arg1->animationSeg, arg1->playbackSpeed + (BREG(88) * 0.1f), arg1->frame,
-                         frameCount, arg1->mode, arg1->transitionRate);
+    Animation_Change(skelAnime, arg1->animationSeg, arg1->playbackSpeed + (BREG(88) * 0.1f), arg1->frame, frameCount,
+                     arg1->mode, arg1->transitionRate);
 }
 
 void func_80989204(EnDg* this, GlobalContext* globalCtx) {
@@ -294,7 +294,7 @@ void func_80989674(EnDg* this, GlobalContext* globalCtx) {
 }
 
 void func_80989864(EnDg* this, GlobalContext* globalCtx) {
-    s16 frame = this->skelAnime.animCurrentFrame;
+    s16 frame = this->skelAnime.curFrame;
     s16 mod = (this->actor.speedXZ > 6.0f) ? 2 : 3;
     Vec3f sp38;
 
@@ -307,31 +307,31 @@ void func_80989864(EnDg* this, GlobalContext* globalCtx) {
 }
 
 void func_80989974(EnDg* this) {
-    if (func_801378B8(&this->skelAnime, 1.0f) || func_801378B8(&this->skelAnime, 7.0f)) {
+    if (Animation_OnFrame(&this->skelAnime, 1.0f) || Animation_OnFrame(&this->skelAnime, 7.0f)) {
         Audio_PlayActorSound2(&this->actor, NA_SE_EV_MONKEY_WALK);
     }
 }
 
 void func_809899C8(EnDg* this, f32 arg1) {
-    if (func_801378B8(&this->skelAnime, arg1)) {
+    if (Animation_OnFrame(&this->skelAnime, arg1)) {
         Audio_PlayActorSound2(&this->actor, NA_SE_EV_SMALL_DOG_BARK);
     }
 }
 
 void func_80989A08(EnDg* this, f32 arg1) {
-    if (func_801378B8(&this->skelAnime, arg1)) {
+    if (Animation_OnFrame(&this->skelAnime, arg1)) {
         Audio_PlayActorSound2(&this->actor, NA_SE_EV_SMALL_DOG_ANG_BARK);
     }
 }
 
 void func_80989A48(EnDg* this) {
-    if (func_801378B8(&this->skelAnime, 23.0f) || func_801378B8(&this->skelAnime, 28.0f)) {
+    if (Animation_OnFrame(&this->skelAnime, 23.0f) || Animation_OnFrame(&this->skelAnime, 28.0f)) {
         Audio_PlayActorSound2(&this->actor, NA_SE_EV_SMALL_DOG_WHINE);
     }
 }
 
 void func_80989A9C(EnDg* this, f32 arg1) {
-    if (func_801378B8(&this->skelAnime, arg1)) {
+    if (Animation_OnFrame(&this->skelAnime, arg1)) {
         Audio_PlayActorSound2(&this->actor, NA_SE_EV_SMALL_DOG_GROAN);
     }
 }
@@ -657,9 +657,9 @@ void func_8098A70C(EnDg* this, GlobalContext* globalCtx) {
 
     Actor_SetVelocityAndMoveYRotationAndGravity(&this->actor);
     func_80989974(this);
-    if (func_801378B8(&this->skelAnime, 3.0f)) {
+    if (Animation_OnFrame(&this->skelAnime, 3.0f)) {
         Audio_PlayActorSound2(&this->actor, NA_SE_EV_SMALL_DOG_CRY);
-    } else if (func_801378B8(&this->skelAnime, 6.0f)) {
+    } else if (Animation_OnFrame(&this->skelAnime, 6.0f)) {
         Audio_PlayActorSound2(&this->actor, NA_SE_EV_MONKEY_WALK);
     }
 }
@@ -689,7 +689,7 @@ void func_8098A938(EnDg* this, GlobalContext* globalCtx) {
     this->actor.world.rot.y = this->actor.shape.rot.y;
     if (this->actor.xzDistToPlayer < 70.0f) {
         Math_ApproachZeroF(&this->actor.speedXZ, 0.2f, 1.0f);
-        if (func_801378B8(&this->skelAnime, 7.0f)) {
+        if (Animation_OnFrame(&this->skelAnime, 7.0f)) {
             s16 y = ABS_ALT(player->actor.shape.rot.y - this->actor.shape.rot.y);
 
             this->unk_28E = 20;
@@ -751,7 +751,7 @@ void func_8098AB48(EnDg* this, GlobalContext* globalCtx) {
 }
 
 void func_8098AC34(EnDg* this, GlobalContext* globalCtx) {
-    s16 sp26 = this->skelAnime.animCurrentFrame;
+    s16 sp26 = this->skelAnime.curFrame;
 
     if ((this->actor.xyzDistToPlayerSq < 800.0f) && (this->collider.base.atFlags & AT_BOUNCED)) {
         this->unk_28E = 60;
@@ -772,13 +772,13 @@ void func_8098AC34(EnDg* this, GlobalContext* globalCtx) {
     }
 
     if (sp26 < 9) {
-        if (func_801378B8(&this->skelAnime, 0.0f)) {
+        if (Animation_OnFrame(&this->skelAnime, 0.0f)) {
             sAnimations[14].playbackSpeed = randPlusMinusPoint5Scaled(1.0f) + 3.0f;
         }
         func_80989864(this, globalCtx);
     } else {
         this->unk_280 |= 2;
-        if (func_801378B8(&this->skelAnime, 9.0f)) {
+        if (Animation_OnFrame(&this->skelAnime, 9.0f)) {
             f32 rand = randPlusMinusPoint5Scaled(1.5f);
 
             sAnimations[14].playbackSpeed = 1.2f;
@@ -1116,7 +1116,7 @@ void EnDg_Init(Actor* thisx, GlobalContext* globalCtx) {
     s32 pad;
 
     ActorShape_Init(&this->actor.shape, 0.0f, func_800B3FC0, 24.0f);
-    SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_060080F0, NULL, this->jointTable, this->morphTable, 13);
+    SkelAnime_InitFlex(globalCtx, &this->skelAnime, &D_060080F0, NULL, this->jointTable, this->morphTable, 13);
     Collider_InitCylinder(globalCtx, &this->collider);
     Collider_SetCylinder(globalCtx, &this->collider, &this->actor, &sCylinderInit);
     CollisionCheck_SetInfo2(&this->actor.colChkInfo, &sDamageTable, &sColChkInfoInit);
@@ -1170,7 +1170,7 @@ void EnDg_Update(Actor* thisx, GlobalContext* globalCtx) {
         func_8098933C(this, &sp28);
         Math_ApproachF(&this->unk_294.x, sp28.x, 0.2f, 0.1f);
         Math_ApproachF(&this->unk_294.z, sp28.z, 0.2f, 0.1f);
-        SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+        SkelAnime_Update(&this->skelAnime);
     }
 }
 
@@ -1185,9 +1185,9 @@ void func_8098BFD4(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3s*
     if (limbIndex == 5) {
         if (this->actionFunc == func_8098BBEC) {
             sp20.x = 5000.0f;
-            SysMatrix_MultiplyVector3fByState(&sp20, &this->actor.focus.pos);
+            Matrix_MultiplyVector3fByState(&sp20, &this->actor.focus.pos);
         } else if (this->actionFunc != func_8098BC54) {
-            SysMatrix_MultiplyVector3fByState(&sp20, &this->actor.focus.pos);
+            Matrix_MultiplyVector3fByState(&sp20, &this->actor.focus.pos);
         }
     }
 }
@@ -1225,13 +1225,13 @@ void EnDg_Draw(Actor* thisx, GlobalContext* globalCtx) {
             break;
     }
 
-    SysMatrix_InsertTranslation(this->actor.world.pos.x, this->actor.world.pos.y, this->actor.world.pos.z, MTXMODE_NEW);
-    SysMatrix_RotateStateAroundXAxis(this->unk_294.x);
-    SysMatrix_InsertZRotation_f(this->unk_294.z, MTXMODE_APPLY);
+    Matrix_InsertTranslation(this->actor.world.pos.x, this->actor.world.pos.y, this->actor.world.pos.z, MTXMODE_NEW);
+    Matrix_RotateStateAroundXAxis(this->unk_294.x);
+    Matrix_InsertZRotation_f(this->unk_294.z, MTXMODE_APPLY);
     Matrix_RotateY(this->actor.shape.rot.y, MTXMODE_APPLY);
     Matrix_Scale(this->actor.scale.x, this->actor.scale.y, this->actor.scale.z, MTXMODE_APPLY);
-    SkelAnime_DrawSV(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl, this->skelAnime.dListCount,
-                     func_8098BFB8, func_8098BFD4, &this->actor);
+    SkelAnime_DrawFlexOpa(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable, this->skelAnime.dListCount,
+                          func_8098BFB8, func_8098BFD4, &this->actor);
 
     CLOSE_DISPS(globalCtx->state.gfxCtx);
 }
diff --git a/src/overlays/actors/ovl_En_Dinofos/z_en_dinofos.c b/src/overlays/actors/ovl_En_Dinofos/z_en_dinofos.c
index cf6a959b4..8670600fe 100644
--- a/src/overlays/actors/ovl_En_Dinofos/z_en_dinofos.c
+++ b/src/overlays/actors/ovl_En_Dinofos/z_en_dinofos.c
@@ -293,7 +293,7 @@ void EnDinofos_Init(Actor* thisx, GlobalContext* globalCtx) {
                               this->colliderJntSphElement);
     Collider_InitAndSetQuad(globalCtx, &this->colliderQuad, &this->actor, &sQuadInit);
     CollisionCheck_SetInfo(&this->actor.colChkInfo, &sDamageTable, &sColChkInfoInit);
-    SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_06009570, &D_06002E40, this->jointTable, this->morphTable, 21);
+    SkelAnime_InitFlex(globalCtx, &this->skelAnime, &D_06009570, &D_06002E40, this->jointTable, this->morphTable, 21);
 
     if (D_8089E364 == 0) {
         for (i = 0; i < ARRAY_COUNT(D_8089E33C); i++) {
@@ -483,8 +483,8 @@ void func_8089B100(EnDinofos* this, GlobalContext* globalCtx) {
     Player* player = GET_PLAYER(globalCtx);
     Vec3f sp3C;
 
-    SkelAnime_ChangeAnim(&this->skelAnime, &D_06001CCC, 1.0f, SkelAnime_GetFrameCount(&D_06001CCC.common),
-                         SkelAnime_GetFrameCount(&D_06001CCC.common), 2, 0.0f);
+    Animation_Change(&this->skelAnime, &D_06001CCC, 1.0f, Animation_GetLastFrame(&D_06001CCC),
+                     Animation_GetLastFrame(&D_06001CCC), 2, 0.0f);
     func_800BE33C(&camera->eye, &camera->at, &this->unk_29A, 1);
     Math_Vec3f_Diff(&this->actor.world.pos, &player->actor.world.pos, &sp3C);
     this->unk_2BC.x = player->actor.world.pos.x + (0.4f * sp3C.x);
@@ -549,7 +549,7 @@ void func_8089B4A4(EnDinofos* this) {
     if (this->unk_290 < 10) {
         func_801A2E54(0x38);
     }
-    SkelAnime_ChangeAnimDefaultStop(&this->skelAnime, &D_0600C974);
+    Animation_PlayOnce(&this->skelAnime, &D_0600C974);
     this->unk_2BC.x = (Math_SinS(this->actor.shape.rot.y + 0x200) * 123.0f) + this->actor.world.pos.x;
     this->unk_2BC.y = this->actor.floorHeight + 11.0f;
     this->unk_2BC.z = (Math_CosS(this->actor.shape.rot.y + 0x200) * 123.0f) + this->actor.world.pos.z;
@@ -567,38 +567,38 @@ void func_8089B580(EnDinofos* this, GlobalContext* globalCtx) {
         Play_CameraSetAtEye(globalCtx, this->camId, &this->actor.focus.pos, &camera->eye);
     }
 
-    if (this->skelAnime.animCurrentFrame > 35.0f) {
-        if ((globalCtx->sceneNum == SCENE_MITURIN) && func_801378B8(&this->skelAnime, 38.0f)) {
+    if (this->skelAnime.curFrame > 35.0f) {
+        if ((globalCtx->sceneNum == SCENE_MITURIN) && Animation_OnFrame(&this->skelAnime, 38.0f)) {
             globalCtx->envCtx.unk_C3 = 11;
         }
 
         Math_Vec3f_StepTo(&camera->eye, &this->unk_2BC, 10.0f);
         Play_CameraSetAtEye(globalCtx, this->camId, &this->actor.focus.pos, &camera->eye);
-        if (this->skelAnime.animCurrentFrame <= 55.0f) {
+        if (this->skelAnime.curFrame <= 55.0f) {
             func_800B9010(&this->actor, NA_SE_EN_DODO_J_FIRE - SFX_FLAG);
         }
     }
 
-    if ((globalCtx->sceneNum == SCENE_MITURIN) && func_801378B8(&this->skelAnime, 55.0f)) {
+    if ((globalCtx->sceneNum == SCENE_MITURIN) && Animation_OnFrame(&this->skelAnime, 55.0f)) {
         globalCtx->envCtx.unk_C3 = 0xFF;
     }
 
-    if (SkelAnime_FrameUpdateMatrix(&this->skelAnime)) {
+    if (SkelAnime_Update(&this->skelAnime)) {
         func_8089B6E8(this);
     }
 }
 
 void func_8089B6E8(EnDinofos* this) {
-    SkelAnime_ChangeAnimTransitionStop(&this->skelAnime, &D_06009B70, -3.0f);
+    Animation_MorphToPlayOnce(&this->skelAnime, &D_06009B70, -3.0f);
     this->actionFunc = func_8089B72C;
 }
 
 void func_8089B72C(EnDinofos* this, GlobalContext* globalCtx) {
-    if (func_801378B8(&this->skelAnime, 2.0f)) {
+    if (Animation_OnFrame(&this->skelAnime, 2.0f)) {
         Audio_PlayActorSound2(&this->actor, NA_SE_EN_RIZA_ATTACK);
     }
 
-    if (SkelAnime_FrameUpdateMatrix(&this->skelAnime)) {
+    if (SkelAnime_Update(&this->skelAnime)) {
         func_8089ABF4(this, globalCtx);
         this->actor.flags &= ~0x00100000;
         this->actor.cutscene = -1;
@@ -607,7 +607,7 @@ void func_8089B72C(EnDinofos* this, GlobalContext* globalCtx) {
 }
 
 void func_8089B7B0(EnDinofos* this) {
-    SkelAnime_ChangeAnimTransitionRepeat(&this->skelAnime, &D_06002E40, -4.0f);
+    Animation_MorphToLoop(&this->skelAnime, &D_06002E40, -4.0f);
     this->unk_290 = (s32)Rand_ZeroFloat(20.0f) + 40;
     this->unk_292 = 30;
     this->actor.speedXZ = 0.0f;
@@ -617,7 +617,7 @@ void func_8089B7B0(EnDinofos* this) {
 }
 
 void func_8089B834(EnDinofos* this, GlobalContext* globalCtx) {
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     if (this->unk_292 != 0) {
         this->unk_292--;
     } else if (func_8089A968(this)) {
@@ -635,7 +635,7 @@ void func_8089B8B0(EnDinofos* this, GlobalContext* globalCtx) {
     f32 phi_f0;
 
     if (this->actionFunc != func_8089B98C) {
-        SkelAnime_ChangeAnimTransitionRepeat(&this->skelAnime, &D_06000580, -4.0f);
+        Animation_MorphToLoop(&this->skelAnime, &D_06000580, -4.0f);
         if (func_800BC5EC(globalCtx, &this->actor)) {
             phi_f0 = 170.0f;
         } else {
@@ -656,7 +656,7 @@ void func_8089B8B0(EnDinofos* this, GlobalContext* globalCtx) {
 void func_8089B98C(EnDinofos* this, GlobalContext* globalCtx) {
     f32 phi_f0;
 
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     if (!func_8089AE00(this, globalCtx)) {
         if (func_800BC5EC(globalCtx, &this->actor)) {
             phi_f0 = 170.0f;
@@ -682,7 +682,7 @@ void func_8089B98C(EnDinofos* this, GlobalContext* globalCtx) {
             func_8089A9B0(this, globalCtx);
         }
 
-        if (func_801378B8(&this->skelAnime, 0.0f) || func_801378B8(&this->skelAnime, 6.0f)) {
+        if (Animation_OnFrame(&this->skelAnime, 0.0f) || Animation_OnFrame(&this->skelAnime, 6.0f)) {
             Audio_PlayActorSound2(&this->actor, NA_SE_EN_RIZA_WALK);
         }
     }
@@ -690,7 +690,7 @@ void func_8089B98C(EnDinofos* this, GlobalContext* globalCtx) {
 
 void func_8089BAC0(EnDinofos* this) {
     if (this->actionFunc != func_8089BB60) {
-        SkelAnime_ChangeAnimTransitionRepeat(&this->skelAnime, &D_06000580, -4.0f);
+        Animation_MorphToLoop(&this->skelAnime, &D_06000580, -4.0f);
         this->actor.speedXZ = 0.0f;
     }
     if (BINANG_SUB(this->actor.yawTowardsPlayer, this->actor.shape.rot.y) > 0) {
@@ -704,7 +704,7 @@ void func_8089BAC0(EnDinofos* this) {
 }
 
 void func_8089BB60(EnDinofos* this, GlobalContext* globalCtx) {
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     if (Math_ScaledStepToS(&this->actor.shape.rot.y, this->unk_28C, 0x400)) {
         func_8089A9B0(this, globalCtx);
     }
@@ -729,10 +729,10 @@ void func_8089BBB4(EnDinofos* this, GlobalContext* globalCtx) {
         }
 
         if (this->actionFunc == func_8089D1E0) {
-            this->skelAnime.animPlaybackSpeed = this->actor.speedXZ * 0.166666671634f;
+            this->skelAnime.playSpeed = this->actor.speedXZ * 0.166666671634f;
         } else {
-            SkelAnime_ChangeAnim(&this->skelAnime, &D_0600D62C, this->actor.speedXZ * 0.166666671634f, 0.0f, 0.0f, 0,
-                                 -4.0f);
+            Animation_Change(&this->skelAnime, &D_0600D62C, this->actor.speedXZ * 0.166666671634f, 0.0f, 0.0f, 0,
+                             -4.0f);
         }
 
         this->actor.world.rot.y = BINANG_ADD(this->actor.shape.rot.y, 0x4000);
@@ -776,9 +776,9 @@ void func_8089BD28(EnDinofos* this, GlobalContext* globalCtx) {
         }
 
         if (this->actor.speedXZ > 0.0f) {
-            this->skelAnime.animPlaybackSpeed = 1.0f;
+            this->skelAnime.playSpeed = 1.0f;
         } else {
-            this->skelAnime.animPlaybackSpeed = -1.0f;
+            this->skelAnime.playSpeed = -1.0f;
         }
 
         this->actor.world.rot.y = BINANG_ADD(this->actor.shape.rot.y, 0x4000);
@@ -796,14 +796,14 @@ void func_8089BD28(EnDinofos* this, GlobalContext* globalCtx) {
 
         this->actor.world.pos.x += Math_SinS(this->actor.shape.rot.y) * this->unk_2A4;
         this->actor.world.pos.z += Math_CosS(this->actor.shape.rot.y) * this->unk_2A4;
-        SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+        SkelAnime_Update(&this->skelAnime);
         if (this->unk_292 != 0) {
             this->unk_292--;
         } else {
             func_8089A9B0(this, globalCtx);
         }
 
-        if (func_801378B8(&this->skelAnime, 0.0f) || func_801378B8(&this->skelAnime, 5.0f)) {
+        if (Animation_OnFrame(&this->skelAnime, 0.0f) || Animation_OnFrame(&this->skelAnime, 5.0f)) {
             Audio_PlayActorSound2(&this->actor, NA_SE_EN_RIZA_WALK);
         }
     }
@@ -811,10 +811,10 @@ void func_8089BD28(EnDinofos* this, GlobalContext* globalCtx) {
 
 void func_8089C024(EnDinofos* this, s32 arg1) {
     if (arg1 == 0) {
-        SkelAnime_ChangeAnimTransitionStop(&this->skelAnime, &D_06001CCC, 2.0f);
+        Animation_MorphToPlayOnce(&this->skelAnime, &D_06001CCC, 2.0f);
         func_8089AD70(this);
     } else {
-        SkelAnime_ChangeAnimTransitionStop(&this->skelAnime, &D_06001CCC, -1.0f);
+        Animation_MorphToPlayOnce(&this->skelAnime, &D_06001CCC, -1.0f);
         if ((arg1 == 2) || (arg1 == 3)) {
             this->colliderJntSph.base.acFlags &= ~AC_ON;
             func_8089AD70(this);
@@ -830,8 +830,8 @@ void func_8089C024(EnDinofos* this, s32 arg1) {
 void func_8089C0DC(EnDinofos* this, GlobalContext* globalCtx) {
     Math_ScaledStepToS(&this->actor.shape.rot.y, this->actor.yawTowardsPlayer, 0x1000);
     this->actor.world.rot.y = this->actor.shape.rot.y;
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
-    if (func_801378B8(&this->skelAnime, 1.0f)) {
+    SkelAnime_Update(&this->skelAnime);
+    if (Animation_OnFrame(&this->skelAnime, 1.0f)) {
         if (this->unk_290 == 3) {
             func_8089C244(this);
         } else {
@@ -858,7 +858,7 @@ void func_8089C164(EnDinofos* this) {
 }
 
 void func_8089C1F8(EnDinofos* this, GlobalContext* globalCtx) {
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     if (this->actor.bgCheckFlags & 1) {
         func_8089C398(this);
     }
@@ -875,13 +875,13 @@ void func_8089C244(EnDinofos* this) {
 }
 
 void func_8089C2A8(EnDinofos* this, GlobalContext* globalCtx) {
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     this->unk_290++;
     Math_ScaledStepToS(&this->actor.shape.rot.y, this->actor.yawTowardsPlayer, 0x1800);
-    if ((this->actor.velocity.y < 0.0f) && (this->skelAnime.animCurrentSeg == &D_06001CCC)) {
+    if ((this->actor.velocity.y < 0.0f) && (this->skelAnime.animation == &D_06001CCC)) {
         this->colliderQuad.base.atFlags |= AT_ON;
         this->colliderJntSph.base.acFlags |= AC_ON;
-        SkelAnime_ChangeAnim(&this->skelAnime, &D_060025B4, 1.0f, 7.0f, 13.0f, 2, -2.0f);
+        Animation_Change(&this->skelAnime, &D_060025B4, 1.0f, 7.0f, 13.0f, 2, -2.0f);
     }
 
     if (this->actor.bgCheckFlags & 1) {
@@ -892,9 +892,9 @@ void func_8089C2A8(EnDinofos* this, GlobalContext* globalCtx) {
 
 void func_8089C398(EnDinofos* this) {
     if (this->actionFunc != func_8089C2A8) {
-        SkelAnime_ChangeAnimDefaultStop(&this->skelAnime, &D_06000AF0);
+        Animation_PlayOnce(&this->skelAnime, &D_06000AF0);
     } else {
-        this->skelAnime.animFrameCount = SkelAnime_GetFrameCount(&D_060025B4.common);
+        this->skelAnime.endFrame = Animation_GetLastFrame(&D_060025B4);
     }
 
     if (this->actor.speedXZ < 0.0f) {
@@ -910,7 +910,7 @@ void func_8089C398(EnDinofos* this) {
 }
 
 void func_8089C44C(EnDinofos* this, GlobalContext* globalCtx) {
-    if (SkelAnime_FrameUpdateMatrix(&this->skelAnime)) {
+    if (SkelAnime_Update(&this->skelAnime)) {
         if ((this->unk_290 == 1) && (this->actor.xzDistToPlayer < 280.0f) && func_8089A968(this) &&
             (Rand_ZeroOne() < 0.6f)) {
             func_8089CA14(this);
@@ -921,7 +921,7 @@ void func_8089C44C(EnDinofos* this, GlobalContext* globalCtx) {
 }
 
 void func_8089C4F8(EnDinofos* this) {
-    SkelAnime_ChangeAnimDefaultStop(&this->skelAnime, &D_060025B4);
+    Animation_PlayOnce(&this->skelAnime, &D_060025B4);
     this->colliderQuad.base.atFlags &= ~AT_BOUNCED;
     Audio_PlayActorSound2(&this->actor, NA_SE_EN_RIZA_CRY);
     this->unk_290 = 0;
@@ -935,24 +935,24 @@ void func_8089C56C(EnDinofos* this, GlobalContext* globalCtx) {
     this->unk_290++;
     Math_ScaledStepToS(&this->actor.shape.rot.y, this->actor.yawTowardsPlayer, 0x800);
     this->actor.world.rot.y = this->actor.shape.rot.y;
-    if (SkelAnime_FrameUpdateMatrix(&this->skelAnime)) {
+    if (SkelAnime_Update(&this->skelAnime)) {
         func_800A8514(Effect_GetParams(this->unk_2A0));
         this->colliderQuad.base.atFlags &= ~AT_ON;
         func_8089A9B0(this, globalCtx);
-    } else if (func_801378B8(&this->skelAnime, 7.0f)) {
+    } else if (Animation_OnFrame(&this->skelAnime, 7.0f)) {
         this->colliderQuad.base.atFlags |= AT_ON;
         func_8089AD70(this);
-    } else if (func_801378B8(&this->skelAnime, 13.0f)) {
+    } else if (Animation_OnFrame(&this->skelAnime, 13.0f)) {
         this->colliderQuad.base.atFlags &= ~AT_ON;
-    } else if (func_801378B8(&this->skelAnime, 11.0f)) {
+    } else if (Animation_OnFrame(&this->skelAnime, 11.0f)) {
         Audio_PlayActorSound2(&this->actor, NA_SE_EN_RIZA_ATTACK);
-    } else if (this->skelAnime.animCurrentFrame < 7.0f) {
+    } else if (this->skelAnime.curFrame < 7.0f) {
         func_8089AE00(this, globalCtx);
     }
 }
 
 void func_8089C690(EnDinofos* this) {
-    SkelAnime_ChangeAnim(&this->skelAnime, &D_060025B4, -1.0f, this->skelAnime.animCurrentFrame, 0.0f, 2, 0.0f);
+    Animation_Change(&this->skelAnime, &D_060025B4, -1.0f, this->skelAnime.curFrame, 0.0f, 2, 0.0f);
     this->colliderQuad.base.atFlags &= ~(AT_ON | AT_BOUNCED);
     if (this->actionFunc != func_8089C2A8) {
         this->actor.world.rot.y = this->actor.shape.rot.y;
@@ -967,7 +967,7 @@ void func_8089C724(EnDinofos* this, GlobalContext* globalCtx) {
         Math_StepToF(&this->actor.speedXZ, 0.0f, 0.5f);
     }
 
-    if (SkelAnime_FrameUpdateMatrix(&this->skelAnime)) {
+    if (SkelAnime_Update(&this->skelAnime)) {
         func_8089A9B0(this, globalCtx);
     }
 }
@@ -1002,7 +1002,7 @@ void func_8089C7B8(EnDinofos* this, GlobalContext* globalCtx) {
 }
 
 void func_8089C87C(EnDinofos* this, s32 arg1) {
-    SkelAnime_ChangeAnimDefaultStop(&this->skelAnime, &D_0600D21C);
+    Animation_PlayOnce(&this->skelAnime, &D_0600D21C);
     func_800BE5CC(&this->actor, &this->colliderJntSph, arg1);
     this->actor.shape.rot.y = BINANG_ROT180(this->actor.world.rot.y);
     this->actor.speedXZ = 10.0f;
@@ -1018,7 +1018,7 @@ void func_8089C87C(EnDinofos* this, s32 arg1) {
 
 void func_8089C938(EnDinofos* this, GlobalContext* globalCtx) {
     Math_StepToF(&this->actor.speedXZ, 0.0f, 0.5f);
-    if (SkelAnime_FrameUpdateMatrix(&this->skelAnime) && (this->actor.bgCheckFlags & 1)) {
+    if (SkelAnime_Update(&this->skelAnime) && (this->actor.bgCheckFlags & 1)) {
         if (this->actor.colChkInfo.health == 0) {
             if (this->actor.cutscene == -1) {
                 func_8089CFAC(this);
@@ -1035,7 +1035,7 @@ void func_8089C938(EnDinofos* this, GlobalContext* globalCtx) {
 }
 
 void func_8089CA14(EnDinofos* this) {
-    SkelAnime_ChangeAnimTransitionStop(&this->skelAnime, &D_06001040, -5.0f);
+    Animation_MorphToPlayOnce(&this->skelAnime, &D_06001040, -5.0f);
     this->colliderJntSph.base.acFlags |= AC_ON;
     this->actor.speedXZ = 0.0f;
     this->actor.world.rot.y = this->actor.shape.rot.y;
@@ -1045,9 +1045,9 @@ void func_8089CA14(EnDinofos* this) {
 void func_8089CA74(EnDinofos* this, GlobalContext* globalCtx) {
     Math_ScaledStepToS(&this->actor.shape.rot.y, this->actor.yawTowardsPlayer, 0x800);
     Math_StepToF(&this->actor.speedXZ, 0.0f, 0.5f);
-    if (SkelAnime_FrameUpdateMatrix(&this->skelAnime)) {
+    if (SkelAnime_Update(&this->skelAnime)) {
         func_8089CB10(this, globalCtx);
-    } else if (!func_8089AE00(this, globalCtx) && func_801378B8(&this->skelAnime, 12.0f)) {
+    } else if (!func_8089AE00(this, globalCtx) && Animation_OnFrame(&this->skelAnime, 12.0f)) {
         this->actor.speedXZ = 8.0f;
     }
 }
@@ -1056,7 +1056,7 @@ void func_8089CB10(EnDinofos* this, GlobalContext* globalCtx) {
     s32 i;
     Sphere16* worldSphere;
 
-    SkelAnime_ChangeAnimDefaultRepeat(&this->skelAnime, &D_060013C0);
+    Animation_PlayLoop(&this->skelAnime, &D_060013C0);
     this->unk_290 = 20;
     this->actor.speedXZ = 0.0f;
     this->colliderJntSph.base.atFlags |= AT_ON;
@@ -1087,7 +1087,7 @@ void func_8089CBEC(EnDinofos* this, GlobalContext* globalCtx) {
     f32 temp_f22;
     s32 temp_s0;
 
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     Math_ScaledStepToS(&this->actor.shape.rot.y, this->actor.yawTowardsPlayer, 0x800);
     temp_f20 = Math_SinS(temp_s3);
     temp_f22 = Math_CosS(temp_s3);
@@ -1128,7 +1128,7 @@ void func_8089CBEC(EnDinofos* this, GlobalContext* globalCtx) {
 }
 
 void func_8089CF00(EnDinofos* this, GlobalContext* globalCtx) {
-    SkelAnime_ChangeAnimDefaultStop(&this->skelAnime, &D_060017B8);
+    Animation_PlayOnce(&this->skelAnime, &D_060017B8);
     this->colliderJntSph.base.atFlags &= ~AT_ON;
     if (globalCtx->sceneNum == SCENE_MITURIN) {
         globalCtx->envCtx.unk_C3 = 255;
@@ -1137,13 +1137,13 @@ void func_8089CF00(EnDinofos* this, GlobalContext* globalCtx) {
 }
 
 void func_8089CF70(EnDinofos* this, GlobalContext* globalCtx) {
-    if (SkelAnime_FrameUpdateMatrix(&this->skelAnime)) {
+    if (SkelAnime_Update(&this->skelAnime)) {
         func_8089A9B0(this, globalCtx);
     }
 }
 
 void func_8089CFAC(EnDinofos* this) {
-    SkelAnime_ChangeAnimDefaultStop(&this->skelAnime, &D_0600ABD0);
+    Animation_PlayOnce(&this->skelAnime, &D_0600ABD0);
     this->actor.flags &= ~1;
     Audio_PlayActorSound2(&this->actor, NA_SE_EN_RIZA_DEAD);
     this->actor.speedXZ = 0.0f;
@@ -1152,7 +1152,7 @@ void func_8089CFAC(EnDinofos* this) {
 }
 
 void func_8089D018(EnDinofos* this, GlobalContext* globalCtx) {
-    if (SkelAnime_FrameUpdateMatrix(&this->skelAnime)) {
+    if (SkelAnime_Update(&this->skelAnime)) {
         s32 temp_v0 = this->unk_288 - 10;
 
         if (this->actor.category == ACTORCAT_ENEMY) {
@@ -1172,7 +1172,7 @@ void func_8089D018(EnDinofos* this, GlobalContext* globalCtx) {
         }
 
         this->actor.shape.shadowAlpha = this->unk_288;
-    } else if (func_801378B8(&this->skelAnime, 26.0f)) {
+    } else if (Animation_OnFrame(&this->skelAnime, 26.0f)) {
         Audio_PlayActorSound2(&this->actor, NA_SE_EN_GERUDOFT_DOWN);
     }
 }
@@ -1183,7 +1183,7 @@ void func_8089D11C(EnDinofos* this, s16 arg1) {
     } else {
         this->actor.speedXZ = 15.0f;
     }
-    SkelAnime_ChangeAnim(&this->skelAnime, &D_0600D62C, this->actor.speedXZ * (1.0f / 7.5f), 0.0f, 0.0f, 0, -4.0f);
+    Animation_Change(&this->skelAnime, &D_0600D62C, this->actor.speedXZ * (1.0f / 7.5f), 0.0f, 0.0f, 0, -4.0f);
     this->actor.world.rot.y = BINANG_ADD(this->actor.shape.rot.y, 0x4000);
     this->unk_292 = 10;
     this->unk_2A4 = 0.0f;
@@ -1195,17 +1195,17 @@ void func_8089D1E0(EnDinofos* this, GlobalContext* globalCtx) {
     Math_ScaledStepToS(&this->actor.shape.rot.y, this->actor.yawTowardsPlayer, 0xBB8);
     Math_StepToF(&this->actor.speedXZ, 0.0f, 2.0f);
 
-    this->skelAnime.animPlaybackSpeed =
+    this->skelAnime.playSpeed =
         (1.0f + fabsf(this->actor.speedXZ * (1.0f / 15.0f))) * ((this->actor.speedXZ >= 0.0f) ? 1.0f : -1.0f);
     this->actor.world.rot.y = BINANG_ADD(this->actor.shape.rot.y, 0x4000);
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     if (this->unk_292 != 0) {
         this->unk_292--;
     } else {
         func_8089A9B0(this, globalCtx);
     }
 
-    if (func_801378B8(&this->skelAnime, 0.0f) || func_801378B8(&this->skelAnime, 5.0f)) {
+    if (Animation_OnFrame(&this->skelAnime, 0.0f) || Animation_OnFrame(&this->skelAnime, 5.0f)) {
         Audio_PlayActorSound2(&this->actor, NA_SE_EN_RIZA_WALK);
     }
 }
@@ -1443,15 +1443,15 @@ void func_8089DC84(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3s*
 
     Collider_UpdateSpheres(limbIndex, &this->colliderJntSph);
     if (D_8089E3B0[limbIndex] != -1) {
-        SysMatrix_GetStateTranslation(&this->unk_2D4[D_8089E3B0[limbIndex]]);
+        Matrix_GetStateTranslation(&this->unk_2D4[D_8089E3B0[limbIndex]]);
     }
 
     if ((limbIndex == 14) && (this->unk_292 != this->unk_290) &&
         ((this->actionFunc == func_8089C56C) || (this->actionFunc == func_8089C2A8))) {
         Math_Vec3f_Copy(&sp74, &this->colliderQuad.dim.quad[0]);
         Math_Vec3f_Copy(&sp80, &this->colliderQuad.dim.quad[1]);
-        SysMatrix_MultiplyVector3fByState(&D_8089E38C, &sp68);
-        SysMatrix_MultiplyVector3fByState(&D_8089E398, &sp5C);
+        Matrix_MultiplyVector3fByState(&D_8089E38C, &sp68);
+        Matrix_MultiplyVector3fByState(&D_8089E398, &sp5C);
         Collider_SetQuadVertices(&this->colliderQuad, &sp5C, &sp68, &sp74, &sp80);
         if (this->colliderQuad.base.atFlags & AT_ON) {
             func_800A81F0(Effect_GetParams(this->unk_2A0), &sp68, &sp5C);
@@ -1460,18 +1460,18 @@ void func_8089DC84(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3s*
     }
 
     if (limbIndex == 4) {
-        SysMatrix_GetStateTranslationAndScaledX(300.0f, &this->actor.shape.feetPos[0]);
+        Matrix_GetStateTranslationAndScaledX(300.0f, &this->actor.shape.feetPos[0]);
     } else if (limbIndex == 7) {
-        SysMatrix_GetStateTranslationAndScaledX(300.0f, &this->actor.shape.feetPos[1]);
+        Matrix_GetStateTranslationAndScaledX(300.0f, &this->actor.shape.feetPos[1]);
     }
 
     if ((limbIndex == 16) && (this->actionFunc == func_8089B580)) {
-        if ((this->skelAnime.animCurrentFrame > 38.0f) && (this->skelAnime.animCurrentFrame <= 55.0f) &&
+        if ((this->skelAnime.curFrame > 38.0f) && (this->skelAnime.curFrame <= 55.0f) &&
             (this->unk_292 != this->unk_290)) {
-            sp48 = SysMatrix_GetCurrentState();
-            sp58 = 48 - (s32)this->skelAnime.animCurrentFrame;
+            sp48 = Matrix_GetCurrentState();
+            sp58 = 48 - (s32)this->skelAnime.curFrame;
             sp58 = CLAMP_MIN(sp58, 0);
-            SysMatrix_MultiplyVector3fByState(&D_8089E3A4, &sp4C);
+            Matrix_MultiplyVector3fByState(&D_8089E3A4, &sp4C);
             sp4C.x -= sp48->mf[3][0];
             sp4C.y -= sp48->mf[3][1];
             sp4C.z -= sp48->mf[3][2];
@@ -1495,8 +1495,8 @@ void EnDinofos_Draw(Actor* thisx, GlobalContext* globalCtx) {
 
         Scene_SetRenderModeXlu(globalCtx, 0, 1);
         POLY_OPA_DISP =
-            SkelAnime_DrawSV2(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl,
-                              this->skelAnime.dListCount, func_8089DC4C, func_8089DC84, &this->actor, POLY_OPA_DISP);
+            SkelAnime_DrawFlex(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable,
+                               this->skelAnime.dListCount, func_8089DC4C, func_8089DC84, &this->actor, POLY_OPA_DISP);
     } else {
         func_8012C2DC(globalCtx->state.gfxCtx);
         func_800B8118(&this->actor, globalCtx, 0);
@@ -1506,8 +1506,8 @@ void EnDinofos_Draw(Actor* thisx, GlobalContext* globalCtx) {
 
         Scene_SetRenderModeXlu(globalCtx, 1, 2);
         POLY_XLU_DISP =
-            SkelAnime_DrawSV2(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl,
-                              this->skelAnime.dListCount, func_8089DC4C, func_8089DC84, &this->actor, POLY_XLU_DISP);
+            SkelAnime_DrawFlex(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable,
+                               this->skelAnime.dListCount, func_8089DC4C, func_8089DC84, &this->actor, POLY_XLU_DISP);
     }
 
     func_800BE680(globalCtx, &this->actor, this->unk_2D4, 12, this->unk_2B4, this->unk_2B8, this->unk_2B0,
diff --git a/src/overlays/actors/ovl_En_Dnb/z_en_dnb.c b/src/overlays/actors/ovl_En_Dnb/z_en_dnb.c
index 6aab7a2cd..780ce1cda 100644
--- a/src/overlays/actors/ovl_En_Dnb/z_en_dnb.c
+++ b/src/overlays/actors/ovl_En_Dnb/z_en_dnb.c
@@ -163,17 +163,17 @@ void func_80A50510(EnDnb* this, GlobalContext* globalCtx) {
     func_8012C2DC(globalCtx->state.gfxCtx);
 
     for (i = 0; i < ARRAY_COUNT(this->particles); i++) {
-        SysMatrix_StatePush();
-        SysMatrix_InsertTranslation(this->particles[i].unk_0C.x, this->particles[i].unk_0C.y,
-                                    this->particles[i].unk_0C.z, MTXMODE_NEW);
-        SysMatrix_InsertXRotation_s(this->particles[i].unk_18.x, MTXMODE_APPLY);
+        Matrix_StatePush();
+        Matrix_InsertTranslation(this->particles[i].unk_0C.x, this->particles[i].unk_0C.y, this->particles[i].unk_0C.z,
+                                 MTXMODE_NEW);
+        Matrix_InsertXRotation_s(this->particles[i].unk_18.x, MTXMODE_APPLY);
         Matrix_RotateY(this->particles[i].unk_18.y, MTXMODE_APPLY);
-        SysMatrix_InsertZRotation_s(this->particles[i].unk_18.z, MTXMODE_APPLY);
+        Matrix_InsertZRotation_s(this->particles[i].unk_18.z, MTXMODE_APPLY);
 
         gSPMatrix(POLY_XLU_DISP++, Matrix_NewMtx(globalCtx->state.gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
         gSPDisplayList(POLY_XLU_DISP++, gfx[i]);
 
-        SysMatrix_StatePop();
+        Matrix_StatePop();
     }
 
     CLOSE_DISPS(globalCtx->state.gfxCtx);
@@ -188,17 +188,17 @@ void func_80A5063C(EnDnb* this, GlobalContext* globalCtx) {
     func_8012C28C(globalCtx->state.gfxCtx);
 
     for (i = 0; i < ARRAY_COUNT(this->particles); i++) {
-        SysMatrix_StatePush();
-        SysMatrix_InsertTranslation(this->particles[i].unk_0C.x, this->particles[i].unk_0C.y,
-                                    this->particles[i].unk_0C.z, MTXMODE_NEW);
-        SysMatrix_InsertXRotation_s(this->particles[i].unk_18.x, MTXMODE_APPLY);
+        Matrix_StatePush();
+        Matrix_InsertTranslation(this->particles[i].unk_0C.x, this->particles[i].unk_0C.y, this->particles[i].unk_0C.z,
+                                 MTXMODE_NEW);
+        Matrix_InsertXRotation_s(this->particles[i].unk_18.x, MTXMODE_APPLY);
         Matrix_RotateY(this->particles[i].unk_18.y, MTXMODE_APPLY);
-        SysMatrix_InsertZRotation_s(this->particles[i].unk_18.z, MTXMODE_APPLY);
+        Matrix_InsertZRotation_s(this->particles[i].unk_18.z, MTXMODE_APPLY);
 
         gSPMatrix(POLY_OPA_DISP++, Matrix_NewMtx(globalCtx->state.gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
         gSPDisplayList(POLY_OPA_DISP++, gfx[i]);
 
-        SysMatrix_StatePop();
+        Matrix_StatePop();
     }
 
     CLOSE_DISPS(globalCtx->state.gfxCtx);
@@ -279,16 +279,16 @@ s32 func_80A50950(EnDnbUnkStruct* arg0, GlobalContext* globalCtx2) {
                 gDPSetEnvColor(POLY_XLU_DISP++, 255, 255, 255, 0);
                 isGfxSetup = true;
             }
-            SysMatrix_StatePush();
+            Matrix_StatePush();
 
             if (1) {};
             arg0->unk_24 = (arg0->unk_01 / (f32)arg0->unk_02) * 255.0f;
 
             gDPSetPrimColor(POLY_XLU_DISP++, 0, 0, 255, 255, 255, (u8)arg0->unk_24);
 
-            SysMatrix_InsertTranslation(arg0->unk_0C.x, arg0->unk_0C.y, arg0->unk_0C.z, MTXMODE_NEW);
+            Matrix_InsertTranslation(arg0->unk_0C.x, arg0->unk_0C.y, arg0->unk_0C.z, MTXMODE_NEW);
             Matrix_Scale(arg0->unk_04, arg0->unk_04, 1.0f, MTXMODE_APPLY);
-            SysMatrix_NormalizeXYZ(&globalCtx->mf_187FC);
+            Matrix_NormalizeXYZ(&globalCtx->mf_187FC);
 
             gSPMatrix(POLY_XLU_DISP++, Matrix_NewMtx(globalCtx->state.gfxCtx),
                       G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
@@ -296,7 +296,7 @@ s32 func_80A50950(EnDnbUnkStruct* arg0, GlobalContext* globalCtx2) {
             gSPSegment(POLY_XLU_DISP++, 0x08, Lib_SegmentedToVirtual(D_80A50CBC[idx]));
             gSPDisplayList(POLY_XLU_DISP++, D_06000020);
 
-            SysMatrix_StatePop();
+            Matrix_StatePop();
             sp5C += 1;
         }
     }
diff --git a/src/overlays/actors/ovl_En_Dnk/z_en_dnk.c b/src/overlays/actors/ovl_En_Dnk/z_en_dnk.c
index 067f16642..59a39f65a 100644
--- a/src/overlays/actors/ovl_En_Dnk/z_en_dnk.c
+++ b/src/overlays/actors/ovl_En_Dnk/z_en_dnk.c
@@ -148,14 +148,14 @@ s32 func_80A514F0(SkelAnime* skelAnime, s16 animIndex) {
             sp30 = true;
             frameCount = sAnimations[animIndex].frameCount;
             if (frameCount < 0) {
-                frameCount = SkelAnime_GetFrameCount(&(sAnimations[animIndex].animationSeg)->common);
+                frameCount = Animation_GetLastFrame(sAnimations[animIndex].animationSeg);
             }
             frame = sAnimations[animIndex].frame;
             if (frame < 0) {
                 frame = frameCount;
             }
-            SkelAnime_ChangeAnim(skelAnime, sAnimations[animIndex].animationSeg, sAnimations[animIndex].playbackSpeed,
-                                 frame, frameCount, sAnimations[animIndex].mode, sAnimations[animIndex].transitionRate);
+            Animation_Change(skelAnime, sAnimations[animIndex].animationSeg, sAnimations[animIndex].playbackSpeed,
+                             frame, frameCount, sAnimations[animIndex].mode, sAnimations[animIndex].transitionRate);
         }
     }
     return sp30;
@@ -263,7 +263,7 @@ void EnDnk_Update(Actor* thisx, GlobalContext* globalCtx) {
     s32 pad;
 
     this->actionFunc(this, globalCtx);
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     func_80A515C4(this);
     Actor_SetHeight(&this->actor, 34.0f);
     Collider_UpdateCylinder(&this->actor, &this->collider);
@@ -288,10 +288,10 @@ void func_80A51AA4(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3s*
     Vec3s sp3C;
 
     if (limbIndex == 2) {
-        SysMatrix_MultiplyVector3fByState(&sp50, &sp44);
-        SysMatrix_CopyCurrentState(&sp5C);
+        Matrix_MultiplyVector3fByState(&sp50, &sp44);
+        Matrix_CopyCurrentState(&sp5C);
         func_8018219C(&sp5C, &sp3C, 0);
-        SysMatrix_InsertTranslation(sp44.x, sp44.y, sp44.z, MTXMODE_NEW);
+        Matrix_InsertTranslation(sp44.x, sp44.y, sp44.z, MTXMODE_NEW);
         Matrix_Scale(this->actor.scale.x, this->actor.scale.y, this->actor.scale.z, MTXMODE_APPLY);
         if (this->unk_28C & 0x10) {
             if (this->unk_28C & 0x20) {
@@ -315,8 +315,8 @@ void func_80A51AA4(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3s*
         }
 
         Matrix_RotateY(this->unk_292, MTXMODE_APPLY);
-        SysMatrix_InsertXRotation_s(this->unk_290, MTXMODE_APPLY);
-        SysMatrix_InsertZRotation_s(this->unk_294, MTXMODE_APPLY);
+        Matrix_InsertXRotation_s(this->unk_290, MTXMODE_APPLY);
+        Matrix_InsertZRotation_s(this->unk_294, MTXMODE_APPLY);
     }
 
     OPEN_DISPS(globalCtx->state.gfxCtx);
@@ -342,8 +342,8 @@ void func_80A51CB8(EnDnk* this, GlobalContext* globalCtx) {
     gSPSegment(POLY_OPA_DISP++, 0x08, Lib_SegmentedToVirtual(D_80A5245C[this->unk_2A0]));
     gDPPipeSync(POLY_OPA_DISP++);
 
-    SkelAnime_Draw(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl, func_80A51A78, func_80A51AA4,
-                   &this->actor);
+    SkelAnime_DrawOpa(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable, func_80A51A78, func_80A51AA4,
+                      &this->actor);
 
     CLOSE_DISPS(globalCtx->state.gfxCtx);
 }
@@ -364,10 +364,10 @@ void func_80A51DA4(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3s*
     Vec3s sp3C;
 
     if (limbIndex == 2) {
-        SysMatrix_MultiplyVector3fByState(&sp50, &sp44);
-        SysMatrix_CopyCurrentState(&sp5C);
+        Matrix_MultiplyVector3fByState(&sp50, &sp44);
+        Matrix_CopyCurrentState(&sp5C);
         func_8018219C(&sp5C, &sp3C, 0);
-        SysMatrix_InsertTranslation(sp44.x, sp44.y, sp44.z, MTXMODE_NEW);
+        Matrix_InsertTranslation(sp44.x, sp44.y, sp44.z, MTXMODE_NEW);
         Matrix_Scale(this->actor.scale.x, this->actor.scale.y, this->actor.scale.z, MTXMODE_APPLY);
 
         if (this->unk_28C & 0x10) {
@@ -392,8 +392,8 @@ void func_80A51DA4(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3s*
         }
 
         Matrix_RotateY(this->unk_292, MTXMODE_APPLY);
-        SysMatrix_InsertXRotation_s(this->unk_290, MTXMODE_APPLY);
-        SysMatrix_InsertZRotation_s(this->unk_294, MTXMODE_APPLY);
+        Matrix_InsertXRotation_s(this->unk_290, MTXMODE_APPLY);
+        Matrix_InsertZRotation_s(this->unk_294, MTXMODE_APPLY);
     }
 
     OPEN_DISPS(globalCtx->state.gfxCtx);
@@ -406,8 +406,8 @@ void func_80A51DA4(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3s*
 
 void func_80A51FC0(EnDnk* this, GlobalContext* globalCtx) {
     func_8012C28C(globalCtx->state.gfxCtx);
-    SkelAnime_Draw(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl, func_80A51D78, func_80A51DA4,
-                   &this->actor);
+    SkelAnime_DrawOpa(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable, func_80A51D78, func_80A51DA4,
+                      &this->actor);
 }
 
 void func_80A52018(Actor* thisx, GlobalContext* globalCtx) {
diff --git a/src/overlays/actors/ovl_En_Dno/z_en_dno.c b/src/overlays/actors/ovl_En_Dno/z_en_dno.c
index b39ac6640..ff7e3de3b 100644
--- a/src/overlays/actors/ovl_En_Dno/z_en_dno.c
+++ b/src/overlays/actors/ovl_En_Dno/z_en_dno.c
@@ -172,7 +172,7 @@ void func_80A715DC(EnDno* this, GlobalContext* globalCtx) {
                                   &this->actor.world.pos, &sp88)) {
                     Math_Vec3f_Diff(&this->actor.world.pos, &crace->actor.home.pos, &sp7C);
                     Matrix_RotateY(-crace->actor.home.rot.y, 0);
-                    SysMatrix_MultiplyVector3fByState(&sp7C, &sp70);
+                    Matrix_MultiplyVector3fByState(&sp7C, &sp70);
                     if ((fabsf(sp70.x) < 100.0f) && (sp70.y >= -10.0f) && (sp70.y <= 180.0f) && (sp70.z < 0.0f)) {
                         crace->unk_170 |= 1;
                     }
@@ -213,19 +213,19 @@ void EnDno_Init(Actor* thisx, GlobalContext* globalCtx) {
         if (actor == NULL) {
             Actor_ProcessInitChain(thisx, sInitChain);
             ActorShape_Init(&thisx->shape, 0.0f, func_800B3FC0, 21.0f);
-            SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_0600E1F8, &D_06007CA4, this->jointTable, this->morphTable,
-                             28);
+            SkelAnime_InitFlex(globalCtx, &this->skelAnime, &D_0600E1F8, &D_06007CA4, this->jointTable,
+                               this->morphTable, 28);
             Collider_InitCylinder(globalCtx, &this->collider);
             Collider_SetCylinder(globalCtx, &this->collider, thisx, &sCylinderInit);
             Actor_UpdateBgCheckInfo(globalCtx, thisx, 0.0f, 0.0f, 0.0f, 4);
-            SkelAnime_ChangeAnim(&this->skelAnime, sAnimations[14].animationSeg, 1.0f, 0.0f,
-                                 SkelAnime_GetFrameCount(&(sAnimations[14].animationSeg)->common), sAnimations[14].mode,
-                                 sAnimations[14].transitionRate);
+            Animation_Change(&this->skelAnime, sAnimations[14].animationSeg, 1.0f, 0.0f,
+                             Animation_GetLastFrame(sAnimations[14].animationSeg), sAnimations[14].mode,
+                             sAnimations[14].transitionRate);
             this->unk_3BE = 0x3E93;
             this->unk_3C0 = 60.0f;
             this->unk_3B0 = 0;
             this->unk_468 = 99;
-            this->skelAnime.animPlaybackSpeed = 0.0f;
+            this->skelAnime.playSpeed = 0.0f;
 
             switch (ENDNO_GET_C000(thisx)) {
                 case ENDNO_GET_C000_0:
@@ -309,7 +309,7 @@ void func_80A71C3C(EnDno* this, GlobalContext* globalCtx) {
 
         case 3:
         case 10:
-            if (this->skelAnime.animCurrentFrame == this->skelAnime.animFrameCount) {
+            if (this->skelAnime.curFrame == this->skelAnime.endFrame) {
                 func_8013E1C8(&this->skelAnime, sAnimations, 13, &this->unk_32C);
             }
             break;
@@ -319,7 +319,7 @@ void func_80A71C3C(EnDno* this, GlobalContext* globalCtx) {
             break;
 
         case 15:
-            if (this->skelAnime.animCurrentFrame == this->skelAnime.animFrameCount) {
+            if (this->skelAnime.curFrame == this->skelAnime.endFrame) {
                 func_8013E1C8(&this->skelAnime, sAnimations, 6, &this->unk_32C);
             }
 
@@ -390,8 +390,7 @@ void func_80A71F18(EnDno* this, GlobalContext* globalCtx) {
                     case 0x80F:
                         if (this->unk_32C == 13) {
                             func_8013E1C8(&this->skelAnime, sAnimations, 4, &this->unk_32C);
-                        } else if ((this->unk_32C == 4) &&
-                                   (this->skelAnime.animCurrentFrame == this->skelAnime.animFrameCount)) {
+                        } else if ((this->unk_32C == 4) && (this->skelAnime.curFrame == this->skelAnime.endFrame)) {
                             func_8013E1C8(&this->skelAnime, sAnimations, 11, &this->unk_32C);
                             func_801518B0(globalCtx, this->unk_464, &this->actor);
                         }
@@ -404,7 +403,7 @@ void func_80A71F18(EnDno* this, GlobalContext* globalCtx) {
             if (globalCtx->msgCtx.unk11F04 == 0x80B) {
                 switch (this->unk_32C) {
                     case 16:
-                        if (this->skelAnime.animCurrentFrame == this->skelAnime.animFrameCount) {
+                        if (this->skelAnime.curFrame == this->skelAnime.endFrame) {
                             func_8013E1C8(&this->skelAnime, sAnimations, 9, &this->unk_32C);
                         }
                         Math_ScaledStepToS(&this->actor.shape.rot.y,
@@ -412,7 +411,7 @@ void func_80A71F18(EnDno* this, GlobalContext* globalCtx) {
                         break;
 
                     case 10:
-                        if (this->skelAnime.animCurrentFrame == this->skelAnime.animFrameCount) {
+                        if (this->skelAnime.curFrame == this->skelAnime.endFrame) {
                             func_801477B4(globalCtx);
                             func_8013E1C8(&this->skelAnime, sAnimations, 0xD, &this->unk_32C);
                             func_80A71B68(this, globalCtx);
@@ -429,7 +428,7 @@ void func_80A71F18(EnDno* this, GlobalContext* globalCtx) {
                 case 0x80B:
                     switch (this->unk_32C) {
                         case 16:
-                            if (this->skelAnime.animCurrentFrame == this->skelAnime.animFrameCount) {
+                            if (this->skelAnime.curFrame == this->skelAnime.endFrame) {
                                 func_8013E1C8(&this->skelAnime, sAnimations, 9, &this->unk_32C);
                             }
                             break;
@@ -442,7 +441,7 @@ void func_80A71F18(EnDno* this, GlobalContext* globalCtx) {
                             break;
 
                         case 10:
-                            if (this->skelAnime.animCurrentFrame == this->skelAnime.animFrameCount) {
+                            if (this->skelAnime.curFrame == this->skelAnime.endFrame) {
                                 func_801477B4(globalCtx);
                                 func_8013E1C8(&this->skelAnime, sAnimations, 13, &this->unk_32C);
                                 func_80A71B68(this, globalCtx);
@@ -467,7 +466,7 @@ void func_80A71F18(EnDno* this, GlobalContext* globalCtx) {
                     if (this->unk_32C == 11) {
                         func_8013E1C8(&this->skelAnime, sAnimations, 3, &this->unk_32C);
                     } else if (this->unk_32C == 3) {
-                        if (this->skelAnime.animCurrentFrame == this->skelAnime.animFrameCount) {
+                        if (this->skelAnime.curFrame == this->skelAnime.endFrame) {
                             func_8013E1C8(&this->skelAnime, sAnimations, 13, &this->unk_32C);
                         }
                     } else if ((this->unk_32C == 13) && func_80147624(globalCtx)) {
@@ -496,7 +495,7 @@ void func_80A71F18(EnDno* this, GlobalContext* globalCtx) {
                             break;
 
                         case 15:
-                            if (this->skelAnime.animCurrentFrame == this->skelAnime.animFrameCount) {
+                            if (this->skelAnime.curFrame == this->skelAnime.endFrame) {
                                 func_8013E1C8(&this->skelAnime, sAnimations, 6, &this->unk_32C);
                             }
                             break;
@@ -564,8 +563,7 @@ void func_80A725F8(EnDno* this, GlobalContext* globalCtx) {
                         if (Math_ScaledStepToS(&this->actor.shape.rot.y, this->actor.yawTowardsPlayer, 0x2D8)) {
                             func_8013E1C8(&this->skelAnime, sAnimations, 5, &this->unk_32C);
                         }
-                    } else if ((this->unk_32C == 5) &&
-                               func_801378B8(&this->skelAnime, this->skelAnime.animFrameCount)) {
+                    } else if ((this->unk_32C == 5) && Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame)) {
                         if (Flags_GetSwitch(globalCtx, ENDNO_GET_3F80(&this->actor))) {
                             func_801518B0(globalCtx, 0x801, &this->actor);
                         } else if (Player_GetMask(globalCtx) == PLAYER_MASK_MASK_OF_SCENTS) {
@@ -596,18 +594,18 @@ void func_80A725F8(EnDno* this, GlobalContext* globalCtx) {
             if (((globalCtx->msgCtx.unk11F04 == 0x800) || (globalCtx->msgCtx.unk11F04 == 0x801)) &&
                 (this->unk_32C == 8)) {
                 Math_SmoothStepToF(&this->unk_454, 1.0f, 1.0f, 0.1f, 0.01f);
-                if (this->skelAnime.animCurrentFrame <= 23.0f) {
+                if (this->skelAnime.curFrame <= 23.0f) {
                     this->unk_452 = 3;
-                    if (func_801378B8(&this->skelAnime, 23.0f)) {
+                    if (Animation_OnFrame(&this->skelAnime, 23.0f)) {
                         Audio_PlayActorSound2(&this->actor, NA_SE_EV_OPEN_AMBRELLA);
                     }
-                } else if (this->skelAnime.animCurrentFrame <= 24.0f) {
+                } else if (this->skelAnime.curFrame <= 24.0f) {
                     this->unk_452 = 4;
-                } else if (this->skelAnime.animCurrentFrame >= 25.0f) {
+                } else if (this->skelAnime.curFrame >= 25.0f) {
                     this->unk_452 = 2;
                 }
 
-                if (func_801378B8(&this->skelAnime, this->skelAnime.animFrameCount)) {
+                if (Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame)) {
                     func_8013E1C8(&this->skelAnime, sAnimations, 12, &this->unk_32C);
                     func_801518B0(globalCtx, 0x803, &this->actor);
                 }
@@ -656,8 +654,7 @@ void func_80A725F8(EnDno* this, GlobalContext* globalCtx) {
                                 this->unk_3B0 |= 0x40;
                             }
                         }
-                    } else if ((this->unk_32C == 5) &&
-                               (this->skelAnime.animCurrentFrame == this->skelAnime.animFrameCount)) {
+                    } else if ((this->unk_32C == 5) && (this->skelAnime.curFrame == this->skelAnime.endFrame)) {
                         func_801477B4(globalCtx);
                         func_80A72438(this, globalCtx);
                     }
@@ -684,7 +681,7 @@ void func_80A72AE4(EnDno* this, GlobalContext* globalCtx) {
 }
 
 void func_80A72B3C(EnDno* this, GlobalContext* globalCtx) {
-    if (func_801378B8(&this->skelAnime, this->skelAnime.animFrameCount)) {
+    if (Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame)) {
         this->unk_44E = 0;
         func_80A72C04(this, globalCtx);
     }
@@ -785,7 +782,7 @@ void func_80A730A0(EnDno* this, GlobalContext* globalCtx) {
     f32 temp_f10;
     s32 phi_a2;
 
-    if (func_801378B8(&this->skelAnime, this->skelAnime.animFrameCount)) {
+    if (Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame)) {
         phi_a2 = -1;
         switch (this->unk_32C) {
             case 0:
@@ -850,18 +847,18 @@ void func_80A732C8(EnDno* this, GlobalContext* globalCtx) {
             func_8013E1C8(&this->skelAnime, sAnimations, 7, &this->unk_32C);
         }
     } else if (this->unk_44E == 3) {
-        if (func_801378B8(&this->skelAnime, this->skelAnime.animFrameCount)) {
+        if (Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame)) {
             func_8013E1C8(&this->skelAnime, sAnimations, 14, &this->unk_32C);
             func_80A72438(this, globalCtx);
         } else {
-            if (this->skelAnime.animCurrentFrame >= 20.0f) {
+            if (this->skelAnime.curFrame >= 20.0f) {
                 Math_SmoothStepToF(&this->unk_454, 0.0f, 1.0f, 0.125f, 0.01f);
             }
 
-            if (func_801378B8(&this->skelAnime, 4.0f)) {
+            if (Animation_OnFrame(&this->skelAnime, 4.0f)) {
                 Audio_PlayActorSound2(&this->actor, NA_SE_EV_CLOSE_AMBRELLA);
                 this->unk_452 = 4;
-            } else if (func_801378B8(&this->skelAnime, 5.0f)) {
+            } else if (Animation_OnFrame(&this->skelAnime, 5.0f)) {
                 this->unk_452 = 3;
             }
         }
@@ -899,7 +896,7 @@ void func_80A73408(EnDno* this, GlobalContext* globalCtx) {
         func_800EDF24(&this->actor, globalCtx, temp_v0);
     }
 
-    if ((func_801378B8(&this->skelAnime, this->skelAnime.animFrameCount)) && (this->unk_32C == 17)) {
+    if ((Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame)) && (this->unk_32C == 17)) {
         if (0) {};
         func_8013E1C8(&this->skelAnime, sAnimations, 18, &this->unk_32C);
     }
@@ -909,7 +906,7 @@ void EnDno_Update(Actor* thisx, GlobalContext* globalCtx) {
     EnDno* this = THIS;
     s32 pad;
 
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     func_80A73408(this, globalCtx);
     this->actionFunc(this, globalCtx);
     if (this->unk_3B0 & 4) {
@@ -923,8 +920,8 @@ void EnDno_Update(Actor* thisx, GlobalContext* globalCtx) {
 void EnDno_Draw(Actor* thisx, GlobalContext* globalCtx) {
     EnDno* this = THIS;
 
-    SkelAnime_DrawSV(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl, this->skelAnime.dListCount,
-                     EnDno_OverrideLimbDraw, EnDno_PostLimbDraw, &this->actor);
+    SkelAnime_DrawFlexOpa(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable, this->skelAnime.dListCount,
+                          EnDno_OverrideLimbDraw, EnDno_PostLimbDraw, &this->actor);
 }
 
 s32 EnDno_OverrideLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3f* pos, Vec3s* rot, Actor* thisx) {
@@ -987,8 +984,8 @@ void EnDno_PostLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Ve
 
         func_8012C28C(globalCtx->state.gfxCtx);
         if (limbIndex == 13) {
-            Matrix_Scale(this->unk_454, this->unk_454, this->unk_454, 1);
-            SysMatrix_InsertXRotation_s(this->unk_45C, 1);
+            Matrix_Scale(this->unk_454, this->unk_454, this->unk_454, MTXMODE_APPLY);
+            Matrix_InsertXRotation_s(this->unk_45C, 1);
         }
 
         gfxOpa = POLY_OPA_DISP;
@@ -1004,13 +1001,13 @@ void EnDno_PostLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Ve
 
         OPEN_DISPS(globalCtx->state.gfxCtx);
 
-        SysMatrix_StatePush();
+        Matrix_StatePush();
         frames = globalCtx->gameplayFrames;
-        SysMatrix_MultiplyVector3fByState(&D_80A73B40, &sp84);
+        Matrix_MultiplyVector3fByState(&D_80A73B40, &sp84);
         func_80A711D0(this, globalCtx, &sp84);
-        SysMatrix_NormalizeXYZ(&globalCtx->mf_187FC);
-        Matrix_Scale(0.15f, 0.15f, 1.0f, 1);
-        SysMatrix_InsertTranslation(0.0f, -3200.0f, 0.0f, 1);
+        Matrix_NormalizeXYZ(&globalCtx->mf_187FC);
+        Matrix_Scale(0.15f, 0.15f, 1.0f, MTXMODE_APPLY);
+        Matrix_InsertTranslation(0.0f, -3200.0f, 0.0f, MTXMODE_APPLY);
         gfxXlu = func_8012C2B4(POLY_XLU_DISP);
 
         gSPMatrix(gfxXlu, Matrix_NewMtx(globalCtx->state.gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
@@ -1022,7 +1019,7 @@ void EnDno_PostLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Ve
 
         POLY_XLU_DISP = gfxXlu + 5;
 
-        SysMatrix_StatePop();
+        Matrix_StatePop();
 
         CLOSE_DISPS(globalCtx->state.gfxCtx);
     }
diff --git a/src/overlays/actors/ovl_En_Dnp/z_en_dnp.c b/src/overlays/actors/ovl_En_Dnp/z_en_dnp.c
index 5c354d5d0..7477bbcc5 100644
--- a/src/overlays/actors/ovl_En_Dnp/z_en_dnp.c
+++ b/src/overlays/actors/ovl_En_Dnp/z_en_dnp.c
@@ -102,38 +102,38 @@ static s32 D_80B3DE58[] = {
 
 s32 func_80B3CA20(EnDnp* this) {
     if ((this->unk_340 == 2) || (this->unk_340 == 9)) {
-        if (func_801378B8(&this->skelAnime, 1.0f) || func_801378B8(&this->skelAnime, 5.0f) ||
-            func_801378B8(&this->skelAnime, 9.0f) || func_801378B8(&this->skelAnime, 13.0f)) {
+        if (Animation_OnFrame(&this->skelAnime, 1.0f) || Animation_OnFrame(&this->skelAnime, 5.0f) ||
+            Animation_OnFrame(&this->skelAnime, 9.0f) || Animation_OnFrame(&this->skelAnime, 13.0f)) {
             Audio_PlayActorSound2(&this->actor, NA_SE_EN_DEKUHIME_TURN);
         }
     } else if ((this->unk_340 == 24) || (this->unk_340 == 7)) {
-        if (func_801378B8(&this->skelAnime, 1.0f)) {
+        if (Animation_OnFrame(&this->skelAnime, 1.0f)) {
             Audio_PlayActorSound2(&this->actor, NA_SE_EN_DEKUHIME_TURN);
         }
     } else if (this->unk_340 == 14) {
-        if (func_801378B8(&this->skelAnime, 7.0f)) {
+        if (Animation_OnFrame(&this->skelAnime, 7.0f)) {
             Audio_PlayActorSound2(&this->actor, NA_SE_EN_DEKUHIME_GREET);
         }
-        if (func_801378B8(&this->skelAnime, 22.0f)) {
+        if (Animation_OnFrame(&this->skelAnime, 22.0f)) {
             Audio_PlayActorSound2(&this->actor, NA_SE_EN_DEKUHIME_GREET2);
         }
     } else if (this->unk_340 == 8) {
-        if (func_801378B8(&this->skelAnime, 9.0f)) {
+        if (Animation_OnFrame(&this->skelAnime, 9.0f)) {
             Audio_PlayActorSound2(&this->actor, NA_SE_EN_DEKUHIME_GREET);
         }
-        if (func_801378B8(&this->skelAnime, 18.0f)) {
+        if (Animation_OnFrame(&this->skelAnime, 18.0f)) {
             Audio_PlayActorSound2(&this->actor, NA_SE_EN_DEKUHIME_GREET2);
         }
     } else if ((this->unk_340 == 17) && (this->unk_340 == 18)) {
-        if (func_801378B8(&this->skelAnime, 7.0f) || func_801378B8(&this->skelAnime, 15.0f)) {
+        if (Animation_OnFrame(&this->skelAnime, 7.0f) || Animation_OnFrame(&this->skelAnime, 15.0f)) {
             Audio_PlayActorSound2(&this->actor, NA_SE_EN_DEKUHIME_WALK);
         }
     } else if (this->unk_340 == 21) {
-        if (func_801378B8(&this->skelAnime, 17.0f)) {
+        if (Animation_OnFrame(&this->skelAnime, 17.0f)) {
             Audio_PlayActorSound2(&this->actor, NA_SE_EN_DEKUHIME_WALK);
         }
     } else if (this->unk_340 == 23) {
-        if (func_801378B8(&this->skelAnime, 3.0f)) {
+        if (Animation_OnFrame(&this->skelAnime, 3.0f)) {
             Audio_PlayActorSound2(&this->actor, NA_SE_EN_DEKUHIME_WALK);
         }
     }
@@ -289,7 +289,7 @@ void func_80B3D11C(EnDnp* this, GlobalContext* globalCtx) {
         this->unk_324 = val;
         if (((this->unk_340 == 10) || (this->unk_340 == 12) || (this->unk_340 == 5) || (this->unk_340 == 19) ||
              (this->unk_340 == 22) || (this->unk_340 == 24)) &&
-            func_801378B8(&this->skelAnime, this->skelAnime.animFrameCount)) {
+            Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame)) {
             func_80B3CC38(this, this->unk_340 + 1);
         }
         func_800EDF24(&this->actor, globalCtx, temp_v0);
@@ -358,7 +358,7 @@ void EnDnp_Init(Actor* thisx, GlobalContext* globalCtx) {
     EnDnp* this = THIS;
 
     ActorShape_Init(&this->actor.shape, 0.0f, func_800B3FC0, 16.0f);
-    SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_06010D60, NULL, this->jointTable, this->morphTable, 26);
+    SkelAnime_InitFlex(globalCtx, &this->skelAnime, &D_06010D60, NULL, this->jointTable, this->morphTable, 26);
     this->unk_340 = -1;
     func_80B3CC38(this, 15);
     Collider_InitAndSetCylinder(globalCtx, &this->collider, &this->actor, &sCylinderInit);
@@ -405,12 +405,12 @@ void EnDnp_Update(Actor* thisx, GlobalContext* globalCtx) {
 
     if (!func_80B3CF60(this, globalCtx) && func_80B3D044(this, globalCtx)) {
         func_80B3D11C(this, globalCtx);
-        SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+        SkelAnime_Update(&this->skelAnime);
         func_80B3CD1C(this);
         func_80B3CEC0(this, globalCtx);
     } else {
         this->actionFunc(this, globalCtx);
-        SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+        SkelAnime_Update(&this->skelAnime);
         func_80B3CD1C(this);
         func_80B3CEC0(this, globalCtx);
         Actor_SetVelocityAndMoveYRotationAndGravity(&this->actor);
@@ -435,8 +435,8 @@ s32 func_80B3D974(s16 arg0, s16 arg1, Vec3f* arg2, Vec3s* arg3, s32 arg4, s32 ar
     Vec3s sp6C;
     MtxF sp2C;
 
-    SysMatrix_MultiplyVector3fByState(&D_801D15B0, &sp74);
-    SysMatrix_CopyCurrentState(&sp2C);
+    Matrix_MultiplyVector3fByState(&D_801D15B0, &sp74);
+    Matrix_CopyCurrentState(&sp2C);
     func_8018219C(&sp2C, &sp6C, 0);
     *arg2 = sp74;
     if (arg4 == 0) {
@@ -478,13 +478,13 @@ void func_80B3DAA0(GlobalContext* globalCtx, s32 limbIndex, Actor* thisx) {
     if (limbIndex == 12) {
         func_80B3D974(this->unk_330 + 0x4000, this->unk_332 + this->actor.shape.rot.y + 0x4000, &this->unk_1D8,
                       &this->unk_1E4, phi_v1, phi_v0);
-        SysMatrix_StatePop();
-        SysMatrix_InsertTranslation(this->unk_1D8.x, this->unk_1D8.y, this->unk_1D8.z, MTXMODE_NEW);
+        Matrix_StatePop();
+        Matrix_InsertTranslation(this->unk_1D8.x, this->unk_1D8.y, this->unk_1D8.z, MTXMODE_NEW);
         Matrix_Scale(this->actor.scale.x, this->actor.scale.y, this->actor.scale.z, MTXMODE_APPLY);
         Matrix_RotateY(this->unk_1E4.y, MTXMODE_APPLY);
-        SysMatrix_InsertXRotation_s(this->unk_1E4.x, MTXMODE_APPLY);
-        SysMatrix_InsertZRotation_s(this->unk_1E4.z, MTXMODE_APPLY);
-        SysMatrix_StatePush();
+        Matrix_InsertXRotation_s(this->unk_1E4.x, MTXMODE_APPLY);
+        Matrix_InsertZRotation_s(this->unk_1E4.z, MTXMODE_APPLY);
+        Matrix_StatePush();
     }
 }
 
@@ -504,8 +504,8 @@ void EnDnp_Draw(Actor* thisx, GlobalContext* globalCtx) {
 
         gSPSegment(POLY_OPA_DISP++, 0x08, Lib_SegmentedToVirtual(D_80B3DEAC[this->unk_336]));
 
-        func_801343C0(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl, this->skelAnime.dListCount,
-                      NULL, func_80B3DA88, func_80B3DAA0, &this->actor);
+        func_801343C0(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable, this->skelAnime.dListCount, NULL,
+                      func_80B3DA88, func_80B3DAA0, &this->actor);
 
         CLOSE_DISPS(globalCtx->state.gfxCtx);
     }
diff --git a/src/overlays/actors/ovl_En_Dnq/z_en_dnq.c b/src/overlays/actors/ovl_En_Dnq/z_en_dnq.c
index 861095e14..e392e6d60 100644
--- a/src/overlays/actors/ovl_En_Dnq/z_en_dnq.c
+++ b/src/overlays/actors/ovl_En_Dnq/z_en_dnq.c
@@ -148,7 +148,7 @@ s32 func_80A526F8(EnDnq* this) {
         this->unk_38C = ((s32)(Rand_ZeroOne() * 100.0f) % 4) + 3;
         this->unk_388 = 0;
         this->unk_386 = 1;
-    } else if (func_801378B8(&this->skelAnime, this->skelAnime.animFrameCount)) {
+    } else if (Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame)) {
         switch (this->unk_398) {
             case 8:
                 if (DECR(this->unk_38C) == 0) {
@@ -186,7 +186,7 @@ s32 func_80A526F8(EnDnq* this) {
         }
 
         if (this->unk_386 != 0) {
-            this->skelAnime.animCurrentFrame = 0.0f;
+            this->skelAnime.curFrame = 0.0f;
         }
     }
 
@@ -204,7 +204,7 @@ s32 func_80A52944(EnDnq* this) {
         this->unk_386 = 1;
         phi_v1 = this->unk_38C * 0x2000;
         this->actor.shape.rot.y += phi_v1;
-    } else if (func_801378B8(&this->skelAnime, this->skelAnime.animFrameCount)) {
+    } else if (Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame)) {
         this->unk_386++;
         if (this->unk_386 >= 6) {
             func_80A5257C(this, 12);
@@ -212,11 +212,11 @@ s32 func_80A52944(EnDnq* this) {
             phi_v1 = this->unk_38C * 0x2000;
         } else if (this->unk_386 <= 3) {
             this->unk_38C = -this->unk_38C;
-            this->skelAnime.animCurrentFrame = 0.0f;
+            this->skelAnime.curFrame = 0.0f;
             phi_v1 = this->unk_38C * 0x2000;
         } else {
             func_80A5257C(this, 13);
-            this->skelAnime.animCurrentFrame = 0.0f;
+            this->skelAnime.curFrame = 0.0f;
         }
         this->actor.shape.rot.y = this->actor.world.rot.y;
         this->actor.shape.rot.y += phi_v1;
@@ -242,14 +242,14 @@ s32 func_80A52A78(EnDnq* this, GlobalContext* globalCtx) {
         this->unk_38C--;
     }
 
-    if (func_801378B8(&this->skelAnime, this->skelAnime.animFrameCount)) {
+    if (Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame)) {
         if (this->unk_38C == 0) {
             this->unk_38C = Rand_S16Offset(20, 20);
             this->unk_388 += 3;
             this->unk_388 %= 5;
         }
         func_80A5257C(this, D_80A535DC[this->unk_388]);
-        this->skelAnime.animCurrentFrame = 0.0f;
+        this->skelAnime.curFrame = 0.0f;
     }
 
     this->unk_386 = 0;
@@ -403,12 +403,12 @@ void func_80A53038(EnDnq* this, GlobalContext* globalCtx) {
             this->unk_1DC = temp_v1;
         }
 
-        if ((this->unk_398 == 4) && func_801378B8(&this->skelAnime, 2.0f)) {
+        if ((this->unk_398 == 4) && Animation_OnFrame(&this->skelAnime, 2.0f)) {
             Audio_PlayActorSound2(&this->actor, NA_SE_EN_KINGNUTS_DAMAGE);
         }
 
         if (((this->unk_398 == 3) || (this->unk_398 == 6)) &&
-            func_801378B8(&this->skelAnime, this->skelAnime.animFrameCount)) {
+            Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame)) {
             func_80A5257C(this, this->unk_398 + 1);
         }
 
@@ -420,7 +420,7 @@ void EnDnq_Init(Actor* thisx, GlobalContext* globalCtx) {
     EnDnq* this = THIS;
 
     ActorShape_Init(&this->actor.shape, 0.0f, NULL, 14.0f);
-    SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_0600EB48, NULL, this->jointTable, this->morphTable, 33);
+    SkelAnime_InitFlex(globalCtx, &this->skelAnime, &D_0600EB48, NULL, this->jointTable, this->morphTable, 33);
     this->unk_398 = -1;
     func_80A5257C(this, 0);
     Collider_InitAndSetCylinder(globalCtx, &this->collider, &this->actor, &sCylinderInit);
@@ -450,11 +450,11 @@ void EnDnq_Update(Actor* thisx, GlobalContext* globalCtx) {
 
     if (!func_80A52D44(this, globalCtx) && func_80A52648(this, globalCtx)) {
         func_80A53038(this, globalCtx);
-        SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+        SkelAnime_Update(&this->skelAnime);
     } else {
         this->actionFunc(this, globalCtx);
         func_80A52B68(this, globalCtx);
-        SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+        SkelAnime_Update(&this->skelAnime);
         Actor_UpdateBgCheckInfo(globalCtx, &this->actor, 30.0f, 12.0f, 0.0f, 4);
         this->unk_394 = this->actor.xzDistToPlayer;
         func_80A52C6C(this, globalCtx);
@@ -470,6 +470,6 @@ void EnDnq_Draw(Actor* thisx, GlobalContext* globalCtx) {
     EnDnq* this = THIS;
 
     func_8012C28C(globalCtx->state.gfxCtx);
-    SkelAnime_DrawSV(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl, this->skelAnime.dListCount, NULL,
-                     NULL, &this->actor);
+    SkelAnime_DrawFlexOpa(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable, this->skelAnime.dListCount,
+                          NULL, NULL, &this->actor);
 }
diff --git a/src/overlays/actors/ovl_En_Dns/z_en_dns.c b/src/overlays/actors/ovl_En_Dns/z_en_dns.c
index 7d33a75ad..373e69880 100644
--- a/src/overlays/actors/ovl_En_Dns/z_en_dns.c
+++ b/src/overlays/actors/ovl_En_Dns/z_en_dns.c
@@ -84,7 +84,7 @@ void func_8092C5C0(EnDns* this) {
     s32 pad;
 
     if (((this->unk_2F8 == 2) || (this->unk_2F8 == 3) || (this->unk_2F8 == 6) || (this->unk_2F8 == 7)) &&
-        (func_801378B8(&this->skelAnime, 0.0f) || func_801378B8(&this->skelAnime, 3.0f))) {
+        (Animation_OnFrame(&this->skelAnime, 0.0f) || Animation_OnFrame(&this->skelAnime, 3.0f))) {
         Audio_PlayActorSound2(&this->actor, NA_SE_EN_NUTS_WALK);
     }
 }
@@ -226,7 +226,7 @@ s32 func_8092CAD0(EnDns* this, GlobalContext* globalCtx) {
             if (ENDNS_GET_4000(&this->actor)) {
                 this->unk_2F0 = 0.0f;
                 if (this->unk_2D2 != 0) {
-                    this->unk_2F0 = this->skelAnime.animCurrentFrame;
+                    this->unk_2F0 = this->skelAnime.curFrame;
                     func_8092C63C(this, 2);
                 }
                 this->unk_2DA = this->actor.world.rot.y;
@@ -303,10 +303,10 @@ s32 func_8092CE38(EnDns* this) {
     Vec3f sp2C;
     s32 ret = false;
 
-    if ((this->unk_2C6 & 0x200) || func_801378B8(&this->skelAnime, this->skelAnime.animFrameCount)) {
+    if ((this->unk_2C6 & 0x200) || Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame)) {
         func_8092C63C(this, D_8092DE00[this->unk_2D2]);
         this->unk_2C6 &= ~0x200;
-        this->skelAnime.animCurrentFrame = 0.0f;
+        this->skelAnime.curFrame = 0.0f;
         if (this->unk_2D2 == 2) {
             Audio_PlayActorSound2(&this->actor, NA_SE_EN_NUTS_JUMP);
         }
@@ -317,25 +317,25 @@ s32 func_8092CE38(EnDns* this) {
         ret = true;
     } else {
         if (this->unk_2D2 == 0) {
-            if (func_801378B8(&this->skelAnime, 13.0f)) {
+            if (Animation_OnFrame(&this->skelAnime, 13.0f)) {
                 this->actor.world.rot.y = BINANG_ROT180(this->actor.world.rot.y);
                 this->unk_2E4 = 0.0f;
                 this->actor.shape.rot.y = this->actor.world.rot.y;
                 Audio_PlayActorSound2(&this->actor, NA_SE_EN_NUTS_JUMP);
-            } else if (this->skelAnime.animCurrentFrame < 13.0f) {
-                frame = this->skelAnime.animCurrentFrame;
+            } else if (this->skelAnime.curFrame < 13.0f) {
+                frame = this->skelAnime.curFrame;
                 this->actor.shape.rot.y = this->actor.world.rot.y;
                 frame *= 2520;
                 this->actor.shape.rot.y += frame;
                 this->unk_2E4 -= -(40.0f / 13.0f);
             }
         } else {
-            if (func_801378B8(&this->skelAnime, 0.0f) || func_801378B8(&this->skelAnime, 6.0f) ||
-                func_801378B8(&this->skelAnime, 13.0f)) {
+            if (Animation_OnFrame(&this->skelAnime, 0.0f) || Animation_OnFrame(&this->skelAnime, 6.0f) ||
+                Animation_OnFrame(&this->skelAnime, 13.0f)) {
                 Audio_PlayActorSound2(&this->actor, NA_SE_EN_NUTS_WALK);
             }
 
-            if (this->skelAnime.animCurrentFrame > 7.0f) {
+            if (this->skelAnime.curFrame > 7.0f) {
                 this->unk_2E4 += -(20.0f / 13.0f);
             }
         }
@@ -371,8 +371,8 @@ void func_8092D108(EnDns* this, GlobalContext* globalCtx) {
 
     func_8012C28C(globalCtx->state.gfxCtx);
 
-    SysMatrix_SetStateRotationAndTranslation(this->actor.home.pos.x, this->actor.home.pos.y, this->actor.home.pos.z,
-                                             &this->actor.home.rot);
+    Matrix_SetStateRotationAndTranslation(this->actor.home.pos.x, this->actor.home.pos.y, this->actor.home.pos.z,
+                                          &this->actor.home.rot);
     Matrix_Scale(this->actor.scale.x, this->actor.scale.y, this->actor.scale.z, MTXMODE_APPLY);
 
     gSPMatrix(POLY_OPA_DISP++, Matrix_NewMtx(globalCtx->state.gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
@@ -450,7 +450,7 @@ void func_8092D4D8(EnDns* this, GlobalContext* globalCtx) {
         this->unk_2F4 = NULL;
         if (ENDNS_GET_4000(&this->actor)) {
             if (!(gSaveContext.eventInf[1] & 0x20)) {
-                this->skelAnime.animCurrentFrame = this->unk_2F0;
+                this->skelAnime.curFrame = this->unk_2F0;
                 this->actor.world.rot.y = this->unk_2DA;
                 func_8092C63C(this, 8);
             }
@@ -478,7 +478,7 @@ void func_8092D5E8(EnDns* this, GlobalContext* globalCtx) {
         }
 
         if (((this->unk_2F8 == 4) || (this->unk_2F8 == 6)) &&
-            func_801378B8(&this->skelAnime, this->skelAnime.animFrameCount)) {
+            Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame)) {
             func_8092C63C(this, this->unk_2F8 + 1);
         }
 
@@ -529,11 +529,11 @@ void EnDns_Update(Actor* thisx, GlobalContext* globalCtx) {
 
     if (!func_8092CAD0(this, globalCtx) && func_8092CB98(this, globalCtx)) {
         func_8092D5E8(this, globalCtx);
-        SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+        SkelAnime_Update(&this->skelAnime);
         func_8092C5C0(this);
     } else {
         this->actionFunc(this, globalCtx);
-        SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+        SkelAnime_Update(&this->skelAnime);
         func_8092C934(this);
         func_8092C86C(this, globalCtx);
         Actor_UpdateBgCheckInfo(globalCtx, &this->actor, 30.0f, 12.0f, 0.0f, 4);
@@ -549,8 +549,8 @@ s32 func_8092D954(s16 arg0, s16 arg1, Vec3f* arg2, Vec3s* arg3, s32 arg4, s32 ar
     Vec3s sp6C;
     MtxF sp2C;
 
-    SysMatrix_MultiplyVector3fByState(&D_801D15B0, &sp74);
-    SysMatrix_CopyCurrentState(&sp2C);
+    Matrix_MultiplyVector3fByState(&D_801D15B0, &sp74);
+    Matrix_CopyCurrentState(&sp2C);
     func_8018219C(&sp2C, &sp6C, 0);
     *arg2 = sp74;
 
@@ -600,11 +600,11 @@ void EnDns_PostLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Ve
     if (limbIndex == 2) {
         func_8092D954(this->unk_2CC, this->unk_2CE + this->actor.shape.rot.y, &this->unk_218, &this->unk_224, phi_v1,
                       phi_v0);
-        SysMatrix_InsertTranslation(this->unk_218.x, this->unk_218.y, this->unk_218.z, MTXMODE_NEW);
+        Matrix_InsertTranslation(this->unk_218.x, this->unk_218.y, this->unk_218.z, MTXMODE_NEW);
         Matrix_Scale(this->actor.scale.x, this->actor.scale.y, this->actor.scale.z, MTXMODE_APPLY);
         Matrix_RotateY(this->unk_224.y, MTXMODE_APPLY);
-        SysMatrix_InsertXRotation_s(this->unk_224.z, MTXMODE_APPLY);
-        SysMatrix_InsertZRotation_s(this->unk_224.x, MTXMODE_APPLY);
+        Matrix_InsertXRotation_s(this->unk_224.z, MTXMODE_APPLY);
+        Matrix_InsertZRotation_s(this->unk_224.x, MTXMODE_APPLY);
     }
 
     OPEN_DISPS(globalCtx->state.gfxCtx);
@@ -626,8 +626,8 @@ void EnDns_Draw(Actor* thisx, GlobalContext* globalCtx) {
     gSPSegment(POLY_OPA_DISP++, 0x08, Lib_SegmentedToVirtual(D_8092DE1C[this->unk_2E0]));
     gDPPipeSync(POLY_OPA_DISP++);
 
-    SkelAnime_Draw(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl, EnDns_OverrideLimbDraw,
-                   EnDns_PostLimbDraw, &this->actor);
+    SkelAnime_DrawOpa(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable, EnDns_OverrideLimbDraw,
+                      EnDns_PostLimbDraw, &this->actor);
     func_8092D108(this, globalCtx);
 
     CLOSE_DISPS(globalCtx->state.gfxCtx);
diff --git a/src/overlays/actors/ovl_En_Dodongo/z_en_dodongo.c b/src/overlays/actors/ovl_En_Dodongo/z_en_dodongo.c
index e913b669b..62cfddd0f 100644
--- a/src/overlays/actors/ovl_En_Dodongo/z_en_dodongo.c
+++ b/src/overlays/actors/ovl_En_Dodongo/z_en_dodongo.c
@@ -513,8 +513,8 @@ void func_80876DC4(EnDodongo* this, GlobalContext* globalCtx) {
 }
 
 s32 func_8087721C(EnDodongo* this) {
-    if ((this->actionFunc == func_8087784C) && (this->skelAnime.animCurrentFrame >= 29.0f) &&
-        (this->skelAnime.animCurrentFrame <= 43.0f)) {
+    if ((this->actionFunc == func_8087784C) && (this->skelAnime.curFrame >= 29.0f) &&
+        (this->skelAnime.curFrame <= 43.0f)) {
         return true;
     }
     return false;
@@ -544,27 +544,27 @@ s32 func_80877278(EnDodongo* this, GlobalContext* globalCtx) {
 }
 
 void func_808773C4(EnDodongo* this) {
-    SkelAnime_ChangeAnimTransitionRepeat(&this->skelAnime, &D_06004C20, -4.0f);
+    Animation_MorphToLoop(&this->skelAnime, &D_06004C20, -4.0f);
     this->actor.speedXZ = 0.0f;
     this->timer = Rand_S16Offset(30, 50);
     this->actionFunc = func_80877424;
 }
 
 void func_80877424(EnDodongo* this, GlobalContext* globalCtx) {
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     if (this->timer != 0) {
         this->timer--;
     }
 
     if (this->timer == 0) {
-        if (func_801378B8(&this->skelAnime, 0.0f)) {
+        if (Animation_OnFrame(&this->skelAnime, 0.0f)) {
             func_80877494(this);
         }
     }
 }
 
 void func_80877494(EnDodongo* this) {
-    SkelAnime_ChangeAnimTransitionRepeat(&this->skelAnime, &D_06008B1C, -4.0f);
+    Animation_MorphToLoop(&this->skelAnime, &D_06008B1C, -4.0f);
     this->actor.speedXZ = this->unk_334 * 1.5f;
     this->timer = Rand_S16Offset(50, 70);
     this->actionFunc = func_80877500;
@@ -575,14 +575,14 @@ void func_80877500(EnDodongo* this, GlobalContext* globalCtx) {
     Vec3f sp30;
     s16 temp_v1;
 
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
-    if (func_801378B8(&this->skelAnime, 19.0f)) {
+    SkelAnime_Update(&this->skelAnime);
+    if (Animation_OnFrame(&this->skelAnime, 19.0f)) {
         Audio_PlayActorSound2(&this->actor, NA_SE_EN_DODO_J_WALK);
         sp30.x = this->collider1Elements[2].dim.worldSphere.center.x;
         sp30.y = this->collider1Elements[2].dim.worldSphere.center.y;
         sp30.z = this->collider1Elements[2].dim.worldSphere.center.z;
         func_80876930(this, globalCtx, &sp30);
-    } else if (func_801378B8(&this->skelAnime, 39.0f)) {
+    } else if (Animation_OnFrame(&this->skelAnime, 39.0f)) {
         Audio_PlayActorSound2(&this->actor, NA_SE_EN_DODO_J_WALK);
         sp30.x = this->collider1Elements[1].dim.worldSphere.center.x;
         sp30.y = this->collider1Elements[1].dim.worldSphere.center.y;
@@ -623,7 +623,7 @@ void func_808777A8(EnDodongo* this) {
     s32 i;
     Sphere16* sph;
 
-    SkelAnime_ChangeAnimTransitionStop(&this->skelAnime, &D_060028F0, -4.0f);
+    Animation_MorphToPlayOnce(&this->skelAnime, &D_060028F0, -4.0f);
     this->actor.speedXZ = 0.0f;
 
     for (i = 0; i < ARRAY_COUNT(this->collider3Elements); i++) {
@@ -648,13 +648,13 @@ void func_8087784C(EnDodongo* this, GlobalContext* globalCtx) {
     f32 temp_f2;
     f32 temp_f12;
 
-    if (func_801378B8(&this->skelAnime, 24.0f)) {
+    if (Animation_OnFrame(&this->skelAnime, 24.0f)) {
         Audio_PlayActorSound2(&this->actor, NA_SE_EN_DODO_J_CRY);
     }
 
     if (func_8087721C(this)) {
         func_800B9010(&this->actor, NA_SE_EN_DODO_J_FIRE - SFX_FLAG);
-        frame = this->skelAnime.animCurrentFrame - 29.0f;
+        frame = this->skelAnime.curFrame - 29.0f;
         end = frame >> 1;
         if (end > 3) {
             end = 3;
@@ -678,29 +678,29 @@ void func_8087784C(EnDodongo* this, GlobalContext* globalCtx) {
         D_80879348.z = 2.5f * temp_f12;
         EffectSsDFire_Spawn(globalCtx, &this->unk_348[0], &D_80879354, &D_80879348, this->unk_334 * 100.0f,
                             this->unk_334 * 35.0f, 0xFF - (frame * 10), 5, 0, 8);
-    } else if ((this->skelAnime.animCurrentFrame >= 2.0f) && (this->skelAnime.animCurrentFrame <= 20.0f)) {
+    } else if ((this->skelAnime.curFrame >= 2.0f) && (this->skelAnime.curFrame <= 20.0f)) {
         func_800B9010(&this->actor, NA_SE_EN_DODO_J_BREATH - SFX_FLAG);
     }
 
-    if (SkelAnime_FrameUpdateMatrix(&this->skelAnime)) {
+    if (SkelAnime_Update(&this->skelAnime)) {
         func_80877D50(this);
     }
 }
 
 void func_80877D50(EnDodongo* this) {
-    SkelAnime_ChangeAnimDefaultStop(&this->skelAnime, &D_06003088);
+    Animation_PlayOnce(&this->skelAnime, &D_06003088);
     this->actionFunc = func_80877D90;
 }
 
 void func_80877D90(EnDodongo* this, GlobalContext* globalCtx) {
-    if (SkelAnime_FrameUpdateMatrix(&this->skelAnime)) {
+    if (SkelAnime_Update(&this->skelAnime)) {
         func_808773C4(this);
         this->timer = Rand_S16Offset(10, 20);
     }
 }
 
 void func_80877DE0(EnDodongo* this) {
-    SkelAnime_ChangeAnim(&this->skelAnime, &D_060028F0, -1.0f, 35.0f, 0.0f, 2, -4.0f);
+    Animation_Change(&this->skelAnime, &D_060028F0, -1.0f, 35.0f, 0.0f, 2, -4.0f);
     this->actor.flags |= 0x10;
     this->timer = 25;
     this->actionFunc = func_80877E60;
@@ -735,14 +735,14 @@ void func_80877E60(EnDodongo* this, GlobalContext* globalCtx) {
         this->actor.child->freezeTimer = 30000; // 25 minutes
     }
 
-    if (func_801378B8(&this->skelAnime, 28.0f)) {
+    if (Animation_OnFrame(&this->skelAnime, 28.0f)) {
         Audio_PlayActorSound2(&this->actor, NA_SE_EN_DODO_J_EAT);
         if (this->actor.child != NULL) {
             Actor_MarkForDeath(this->actor.child);
             this->actor.child = NULL;
         }
         this->actor.flags &= ~0x10;
-    } else if (this->skelAnime.animPlaybackSpeed > -0.5f) {
+    } else if (this->skelAnime.playSpeed > -0.5f) {
         this->timer--;
         if (this->timer == 10) {
             for (i = 10; i >= 0; i--) {
@@ -768,13 +768,13 @@ void func_80877E60(EnDodongo* this, GlobalContext* globalCtx) {
             }
             func_800BCB70(&this->actor, 0x4000, 0x78, 0, 8);
         }
-    } else if (func_801378B8(&this->skelAnime, 24.0f)) {
+    } else if (Animation_OnFrame(&this->skelAnime, 24.0f)) {
         this->timer--;
-        this->skelAnime.animPlaybackSpeed = 0.0f;
+        this->skelAnime.playSpeed = 0.0f;
     }
 
-    if (this->skelAnime.animCurrentFrame <= 27.0f) {
-        if ((this->skelAnime.animCurrentFrame <= 25.0f) && (this->timer < 11)) {
+    if (this->skelAnime.curFrame <= 27.0f) {
+        if ((this->skelAnime.curFrame <= 25.0f) && (this->timer < 11)) {
             func_80876DC4(this, globalCtx);
         } else {
             sp5E = this->unk_334 * 50.0f;
@@ -793,7 +793,7 @@ void func_80877E60(EnDodongo* this, GlobalContext* globalCtx) {
     this->unk_314.z = Math_SinS((this->actor.colorFilterTimer * 0x1000) >> 1) + 1.0f;
     this->unk_314.x = Math_SinS(this->actor.colorFilterTimer * 0x1000) + 1.0f;
     this->unk_314.y = this->unk_314.z;
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     if (this->timer == 0) {
         if (this->actor.colChkInfo.health == 0) {
             func_80878724(this);
@@ -819,7 +819,7 @@ void func_80878354(EnDodongo* this) {
     }
 
     Audio_PlayActorSound2(&this->actor, NA_SE_EN_DODO_J_TAIL);
-    SkelAnime_ChangeAnimPlaybackStop(&this->skelAnime, sp18, 2.0f);
+    Animation_PlayOnceSetSpeed(&this->skelAnime, sp18, 2.0f);
     this->timer = 0;
     this->collider1.base.atFlags |= AT_ON;
     this->unk_304 = -1;
@@ -831,7 +831,7 @@ void func_80878424(EnDodongo* this, GlobalContext* globalCtx) {
     Vec3f sp20;
 
     this->timer++;
-    if (SkelAnime_FrameUpdateMatrix(&this->skelAnime)) {
+    if (SkelAnime_Update(&this->skelAnime)) {
         if (!(player->stateFlags1 & 0x800000) && (Player_GetMask(globalCtx) != PLAYER_MASK_STONE_MASK)) {
             this->collider1.base.atFlags &= ~AT_ON;
             func_808777A8(this);
@@ -878,7 +878,7 @@ void func_808785B0(EnDodongo* this, GlobalContext* globalCtx) {
 }
 
 void func_8087864C(EnDodongo* this) {
-    SkelAnime_ChangeAnimTransitionStop(&this->skelAnime, &D_06001A44, -4.0f);
+    Animation_MorphToPlayOnce(&this->skelAnime, &D_06001A44, -4.0f);
     Audio_PlayActorSound2(&this->actor, NA_SE_EN_DODO_J_DAMAGE);
     this->timer = 0;
     this->unk_304 = 0;
@@ -892,13 +892,13 @@ void func_808786C8(EnDodongo* this, GlobalContext* globalCtx) {
         func_80876DC4(this, globalCtx);
     }
 
-    if (SkelAnime_FrameUpdateMatrix(&this->skelAnime)) {
+    if (SkelAnime_Update(&this->skelAnime)) {
         func_80876B08(this, globalCtx);
     }
 }
 
 void func_80878724(EnDodongo* this) {
-    SkelAnime_ChangeAnimTransitionStop(&this->skelAnime, &D_060013C4, -8.0f);
+    Animation_MorphToPlayOnce(&this->skelAnime, &D_060013C4, -8.0f);
     this->timer = 0;
     this->unk_304 = 0;
     Audio_PlayActorSound2(&this->actor, NA_SE_EN_DODO_J_DEAD);
@@ -911,7 +911,7 @@ void func_80878724(EnDodongo* this) {
 void func_808787B0(EnDodongo* this, GlobalContext* globalCtx) {
     s32 pad;
 
-    if (this->skelAnime.animCurrentFrame < 35.0f) {
+    if (this->skelAnime.curFrame < 35.0f) {
         if (this->unk_304 != 0) {
             func_80876DC4(this, globalCtx);
         }
@@ -919,7 +919,7 @@ void func_808787B0(EnDodongo* this, GlobalContext* globalCtx) {
         func_800BCB70(&this->actor, 0x4000, 0x78, 0, 4);
     }
 
-    if (SkelAnime_FrameUpdateMatrix(&this->skelAnime)) {
+    if (SkelAnime_Update(&this->skelAnime)) {
         if (this->timer == 0) {
             EnBom* bomb = (EnBom*)Actor_Spawn(&globalCtx->actorCtx, globalCtx, ACTOR_EN_BOM, this->actor.world.pos.x,
                                               this->actor.world.pos.y, this->actor.world.pos.z, 0, 0, 0, 0);
@@ -928,7 +928,7 @@ void func_808787B0(EnDodongo* this, GlobalContext* globalCtx) {
             }
             this->timer = 8;
         }
-    } else if (func_801378B8(&this->skelAnime, 52.0f)) {
+    } else if (Animation_OnFrame(&this->skelAnime, 52.0f)) {
         Audio_PlayActorSound2(&this->actor, NA_SE_EN_GERUDOFT_DOWN);
     }
 
@@ -1086,16 +1086,16 @@ void EnDodongo_PostLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList
     Collider_UpdateSpheres(limbIndex, &this->collider1);
     Collider_UpdateSpheres(limbIndex, &this->collider2);
     if (D_80879388[limbIndex] != -1) {
-        SysMatrix_GetStateTranslation(&this->unk_348[D_80879388[limbIndex]]);
+        Matrix_GetStateTranslation(&this->unk_348[D_80879388[limbIndex]]);
     }
 
     if (limbIndex == 7) {
-        SysMatrix_MultiplyVector3fByState(&D_80879370, &this->unk_308);
-        SysMatrix_MultiplyVector3fByState(&D_8087937C, &this->unk_348[0]);
-        SysMatrix_GetStateTranslation(&this->actor.focus.pos);
-        SysMatrix_GetStateTranslationAndScaledY(-200.0f, &this->unk_348[1]);
+        Matrix_MultiplyVector3fByState(&D_80879370, &this->unk_308);
+        Matrix_MultiplyVector3fByState(&D_8087937C, &this->unk_348[0]);
+        Matrix_GetStateTranslation(&this->actor.focus.pos);
+        Matrix_GetStateTranslationAndScaledY(-200.0f, &this->unk_348[1]);
     } else if (limbIndex == 13) {
-        SysMatrix_GetStateTranslationAndScaledX(1600.0f, &this->unk_320);
+        Matrix_GetStateTranslationAndScaledX(1600.0f, &this->unk_320);
     }
 
     if ((limbIndex == 30) && (this->actionFunc == func_80878424) && (this->timer != this->unk_304)) {
@@ -1108,8 +1108,8 @@ void EnDodongo_Draw(Actor* thisx, GlobalContext* globalCtx) {
     EnDodongo* this = THIS;
 
     func_8012C28C(globalCtx->state.gfxCtx);
-    SkelAnime_Draw(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl, EnDodongo_OverrideLimbDraw,
-                   EnDodongo_PostLimbDraw, &this->actor);
+    SkelAnime_DrawOpa(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable, EnDodongo_OverrideLimbDraw,
+                      EnDodongo_PostLimbDraw, &this->actor);
     func_800BE680(globalCtx, &this->actor, this->unk_348, ARRAY_COUNT(this->unk_348), this->unk_340 * this->unk_334,
                   this->unk_344 * this->unk_334, this->unk_33C, this->unk_300);
 }
diff --git a/src/overlays/actors/ovl_En_Elfbub/z_en_elfbub.c b/src/overlays/actors/ovl_En_Elfbub/z_en_elfbub.c
index 7d492ac1d..e8145f806 100644
--- a/src/overlays/actors/ovl_En_Elfbub/z_en_elfbub.c
+++ b/src/overlays/actors/ovl_En_Elfbub/z_en_elfbub.c
@@ -153,12 +153,12 @@ void EnElfbub_Draw(Actor* thisx, GlobalContext* globalCtx2) {
 
     func_8012C2DC(globalCtx->state.gfxCtx);
 
-    SysMatrix_InsertTranslation(0.0f, 0.0f, 1.0f, 1);
-    SysMatrix_NormalizeXYZ(&globalCtx->mf_187FC);
+    Matrix_InsertTranslation(0.0f, 0.0f, 1.0f, 1);
+    Matrix_NormalizeXYZ(&globalCtx->mf_187FC);
     Matrix_Scale(this->xyScale + 1.0f, this->xyScale + 1.0f, 1.0f, 1);
-    SysMatrix_InsertZRotation_s(this->zRot, 1);
+    Matrix_InsertZRotation_s(this->zRot, 1);
     Matrix_Scale(this->xScale + 1.0f, 1.0f, 1.0f, 1);
-    SysMatrix_InsertZRotation_s(this->zRot * -1, 1);
+    Matrix_InsertZRotation_s(this->zRot * -1, 1);
 
     gSPMatrix(POLY_XLU_DISP++, Matrix_NewMtx(globalCtx->state.gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
     gSPDisplayList(POLY_XLU_DISP++, D_06001000);
diff --git a/src/overlays/actors/ovl_En_Encount2/z_en_encount2.c b/src/overlays/actors/ovl_En_Encount2/z_en_encount2.c
index b61b73c58..ba444eb6c 100644
--- a/src/overlays/actors/ovl_En_Encount2/z_en_encount2.c
+++ b/src/overlays/actors/ovl_En_Encount2/z_en_encount2.c
@@ -270,7 +270,7 @@ void EnEncount2_DrawParticles(EnEncount2* this, GlobalContext* globalCtx) {
     func_8012C2DC(globalCtx->state.gfxCtx);
     for (i = 0; i < ARRAY_COUNT(this->particles); i++, sPtr++) {
         if (sPtr->enabled) {
-            SysMatrix_InsertTranslation(sPtr->pos.x, sPtr->pos.y, sPtr->pos.z, MTXMODE_NEW);
+            Matrix_InsertTranslation(sPtr->pos.x, sPtr->pos.y, sPtr->pos.z, MTXMODE_NEW);
             Matrix_Scale(sPtr->scale, sPtr->scale, sPtr->scale, MTXMODE_APPLY);
             POLY_XLU_DISP = Gfx_CallSetupDL(POLY_XLU_DISP, 20);
             gSPSegment(POLY_XLU_DISP++, 0x08, Lib_SegmentedToVirtual(&D_04079B10));
@@ -278,8 +278,8 @@ void EnEncount2_DrawParticles(EnEncount2* this, GlobalContext* globalCtx) {
             gDPPipeSync(POLY_XLU_DISP++);
             gDPSetPrimColor(POLY_XLU_DISP++, 0, 0, 255, 255, 255, 255);
             gDPSetEnvColor(POLY_XLU_DISP++, 250, 180, 255, sPtr->alpha);
-            SysMatrix_InsertMatrix(&globalCtx->mf_187FC, MTXMODE_APPLY);
-            SysMatrix_InsertZRotation_f(DEGTORAD(globalCtx->state.frames * 20.0f), MTXMODE_APPLY);
+            Matrix_InsertMatrix(&globalCtx->mf_187FC, MTXMODE_APPLY);
+            Matrix_InsertZRotation_f(DEGTORAD(globalCtx->state.frames * 20.0f), MTXMODE_APPLY);
             gSPMatrix(POLY_XLU_DISP++, Matrix_NewMtx(globalCtx->state.gfxCtx),
                       G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
             gSPDisplayList(POLY_XLU_DISP++, D_0407AB58);
diff --git a/src/overlays/actors/ovl_En_Ending_Hero/z_en_ending_hero.c b/src/overlays/actors/ovl_En_Ending_Hero/z_en_ending_hero.c
index f32c5cc5a..089ee3788 100644
--- a/src/overlays/actors/ovl_En_Ending_Hero/z_en_ending_hero.c
+++ b/src/overlays/actors/ovl_En_Ending_Hero/z_en_ending_hero.c
@@ -42,8 +42,7 @@ void EnEndingHero_Init(Actor* thisx, GlobalContext* globalCtx) {
     Actor_SetScale(&this->actor, 0.01f);
     this->actor.targetMode = 6;
     this->actor.gravity = -3.0f;
-    SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_0600B0CC, &D_06000BE0, this->limbDrawTable,
-                     this->transitionDrawTable, 15);
+    SkelAnime_InitFlex(globalCtx, &this->skelAnime, &D_0600B0CC, &D_06000BE0, this->jointTable, this->morphTable, 15);
     ActorShape_Init(&this->actor.shape, 0.0f, func_800B3FC0, 25.0f);
     func_80C1E748(this);
 }
@@ -57,7 +56,7 @@ void func_80C1E748(EnEndingHero* this) {
 }
 
 void func_80C1E764(EnEndingHero* this, GlobalContext* globalCtx) {
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
 }
 
 void EnEndingHero_Update(Actor* thisx, GlobalContext* globalCtx) {
@@ -93,8 +92,8 @@ void EnEndingHero_Draw(Actor* thisx, GlobalContext* globalCtx) {
     }
 
     gSPSegment(POLY_OPA_DISP++, 0x09, Lib_SegmentedToVirtual(D_80C1E984[index]));
-    SkelAnime_DrawSV(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl, this->skelAnime.dListCount, 0, 0,
-                     &this->actor);
+    SkelAnime_DrawFlexOpa(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable, this->skelAnime.dListCount,
+                          0, 0, &this->actor);
 
     CLOSE_DISPS(globalCtx->state.gfxCtx);
 }
diff --git a/src/overlays/actors/ovl_En_Ending_Hero/z_en_ending_hero.h b/src/overlays/actors/ovl_En_Ending_Hero/z_en_ending_hero.h
index bd81f7e06..95991fee8 100644
--- a/src/overlays/actors/ovl_En_Ending_Hero/z_en_ending_hero.h
+++ b/src/overlays/actors/ovl_En_Ending_Hero/z_en_ending_hero.h
@@ -10,8 +10,8 @@ typedef void (*EnEndingHeroActionFunc)(struct EnEndingHero*, GlobalContext*);
 typedef struct EnEndingHero {
     /* 0x000 */ Actor actor;
     /* 0x144 */ SkelAnime skelAnime;
-    /* 0x188 */ Vec3s limbDrawTable[15];
-    /* 0x1E2 */ Vec3s transitionDrawTable[15];
+    /* 0x188 */ Vec3s jointTable[15];
+    /* 0x1E2 */ Vec3s morphTable[15];
     /* 0x23C */ EnEndingHeroActionFunc actionFunc;
     /* 0x240 */ s16 unk240;
     /* 0x242 */ s16 unk242;
diff --git a/src/overlays/actors/ovl_En_Ending_Hero2/z_en_ending_hero2.c b/src/overlays/actors/ovl_En_Ending_Hero2/z_en_ending_hero2.c
index 8b201a7ae..0ff95496d 100644
--- a/src/overlays/actors/ovl_En_Ending_Hero2/z_en_ending_hero2.c
+++ b/src/overlays/actors/ovl_En_Ending_Hero2/z_en_ending_hero2.c
@@ -34,8 +34,7 @@ void EnEndingHero2_Init(Actor* thisx, GlobalContext* globalCtx) {
     Actor_SetScale(&this->actor, 0.01f);
     this->actor.targetMode = 6;
     this->actor.gravity = -3.0f;
-    SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_06007908, &D_060011C0, this->limbDrawTable,
-                     this->transitionDrawTable, 20);
+    SkelAnime_InitFlex(globalCtx, &this->skelAnime, &D_06007908, &D_060011C0, this->jointTable, this->morphTable, 20);
     ActorShape_Init(&this->actor.shape, 0.0f, func_800B3FC0, 25.0f);
     func_80C232E8(this);
 }
@@ -49,7 +48,7 @@ void func_80C232E8(EnEndingHero2* this) {
 }
 
 void func_80C23304(EnEndingHero2* this, GlobalContext* globalCtx) {
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
 }
 
 void EnEndingHero2_Update(Actor* thisx, GlobalContext* globalCtx) {
@@ -65,6 +64,6 @@ void EnEndingHero2_Draw(Actor* thisx, GlobalContext* globalCtx) {
 
     func_8012C28C(globalCtx->state.gfxCtx);
     func_8012C2DC(globalCtx->state.gfxCtx);
-    SkelAnime_DrawSV(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl, this->skelAnime.dListCount, 0, 0,
-                     &this->actor);
+    SkelAnime_DrawFlexOpa(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable, this->skelAnime.dListCount,
+                          0, 0, &this->actor);
 }
diff --git a/src/overlays/actors/ovl_En_Ending_Hero2/z_en_ending_hero2.h b/src/overlays/actors/ovl_En_Ending_Hero2/z_en_ending_hero2.h
index 99f57ab6a..fe7e6bf2e 100644
--- a/src/overlays/actors/ovl_En_Ending_Hero2/z_en_ending_hero2.h
+++ b/src/overlays/actors/ovl_En_Ending_Hero2/z_en_ending_hero2.h
@@ -10,8 +10,8 @@ typedef void (*EnEndingHero2ActionFunc)(struct EnEndingHero2*, GlobalContext*);
 typedef struct EnEndingHero2 {
     /* 0x000 */ Actor actor;
     /* 0x144 */ SkelAnime skelAnime;
-    /* 0x188 */ Vec3s limbDrawTable[20];
-    /* 0x200 */ Vec3s transitionDrawTable[20];
+    /* 0x188 */ Vec3s jointTable[20];
+    /* 0x200 */ Vec3s morphTable[20];
     /* 0x278 */ EnEndingHero2ActionFunc actionFunc;
     /* 0x27C */ u16 unk27C;
 } EnEndingHero2; // size = 0x280
diff --git a/src/overlays/actors/ovl_En_Ending_Hero3/z_en_ending_hero3.c b/src/overlays/actors/ovl_En_Ending_Hero3/z_en_ending_hero3.c
index 73d28cd18..91a42c409 100644
--- a/src/overlays/actors/ovl_En_Ending_Hero3/z_en_ending_hero3.c
+++ b/src/overlays/actors/ovl_En_Ending_Hero3/z_en_ending_hero3.c
@@ -34,8 +34,7 @@ void EnEndingHero3_Init(Actor* thisx, GlobalContext* globalCtx) {
     Actor_SetScale(&this->actor, 0.01f);
     this->actor.targetMode = 6;
     this->actor.gravity = -3.0f;
-    SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_06007150, &D_06000E50, this->limbDrawTable,
-                     this->transitionDrawTable, 17);
+    SkelAnime_InitFlex(globalCtx, &this->skelAnime, &D_06007150, &D_06000E50, this->jointTable, this->morphTable, 17);
     ActorShape_Init(&this->actor.shape, 0.0f, func_800B3FC0, 25.0f);
     func_80C23518(this);
 }
@@ -49,7 +48,7 @@ void func_80C23518(EnEndingHero3* this) {
 }
 
 void func_80C23534(EnEndingHero3* this, GlobalContext* globalCtx) {
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
 }
 
 void EnEndingHero3_Update(Actor* thisx, GlobalContext* globalCtx) {
@@ -65,6 +64,6 @@ void EnEndingHero3_Draw(Actor* thisx, GlobalContext* globalCtx) {
 
     func_8012C28C(globalCtx->state.gfxCtx);
     func_8012C2DC(globalCtx->state.gfxCtx);
-    SkelAnime_DrawSV(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl, this->skelAnime.dListCount, 0, 0,
-                     &this->actor);
+    SkelAnime_DrawFlexOpa(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable, this->skelAnime.dListCount,
+                          0, 0, &this->actor);
 }
diff --git a/src/overlays/actors/ovl_En_Ending_Hero3/z_en_ending_hero3.h b/src/overlays/actors/ovl_En_Ending_Hero3/z_en_ending_hero3.h
index fc5bb9c0f..b61452d77 100644
--- a/src/overlays/actors/ovl_En_Ending_Hero3/z_en_ending_hero3.h
+++ b/src/overlays/actors/ovl_En_Ending_Hero3/z_en_ending_hero3.h
@@ -10,8 +10,8 @@ typedef void (*EnEndingHero3ActionFunc)(struct EnEndingHero3*, GlobalContext*);
 typedef struct EnEndingHero3 {
     /* 0x000 */ Actor actor;
     /* 0x144 */ SkelAnime skelAnime;
-    /* 0x188 */ Vec3s limbDrawTable[17];
-    /* 0x1EE */ Vec3s transitionDrawTable[17];
+    /* 0x188 */ Vec3s jointTable[17];
+    /* 0x1EE */ Vec3s morphTable[17];
     /* 0x254 */ EnEndingHero3ActionFunc actionFunc;
     /* 0x258 */ u16 unk258;
 } EnEndingHero3; // size = 0x25C
diff --git a/src/overlays/actors/ovl_En_Ending_Hero4/z_en_ending_hero4.c b/src/overlays/actors/ovl_En_Ending_Hero4/z_en_ending_hero4.c
index 38729764a..949999b57 100644
--- a/src/overlays/actors/ovl_En_Ending_Hero4/z_en_ending_hero4.c
+++ b/src/overlays/actors/ovl_En_Ending_Hero4/z_en_ending_hero4.c
@@ -34,8 +34,7 @@ void EnEndingHero4_Init(Actor* thisx, GlobalContext* globalCtx) {
     Actor_SetScale(&this->actor, 0.01f);
     this->actor.targetMode = 6;
     this->actor.gravity = -3.0f;
-    SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_0600D640, &D_06002A84, this->limbDrawTable,
-                     this->transitionDrawTable, 17);
+    SkelAnime_InitFlex(globalCtx, &this->skelAnime, &D_0600D640, &D_06002A84, this->jointTable, this->morphTable, 17);
     ActorShape_Init(&this->actor.shape, 0.0f, func_800B3FC0, 25.0f);
     func_80C23748(this);
 }
@@ -49,7 +48,7 @@ void func_80C23748(EnEndingHero4* this) {
 }
 
 void func_80C23764(EnEndingHero4* this, GlobalContext* globalCtx) {
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
 }
 
 void EnEndingHero4_Update(Actor* thisx, GlobalContext* globalCtx) {
@@ -65,6 +64,6 @@ void EnEndingHero4_Draw(Actor* thisx, GlobalContext* globalCtx) {
 
     func_8012C28C(globalCtx->state.gfxCtx);
     func_8012C2DC(globalCtx->state.gfxCtx);
-    SkelAnime_DrawSV(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl, this->skelAnime.dListCount, 0, 0,
-                     &this->actor);
+    SkelAnime_DrawFlexOpa(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable, this->skelAnime.dListCount,
+                          0, 0, &this->actor);
 }
diff --git a/src/overlays/actors/ovl_En_Ending_Hero4/z_en_ending_hero4.h b/src/overlays/actors/ovl_En_Ending_Hero4/z_en_ending_hero4.h
index 048757932..09e3a72ee 100644
--- a/src/overlays/actors/ovl_En_Ending_Hero4/z_en_ending_hero4.h
+++ b/src/overlays/actors/ovl_En_Ending_Hero4/z_en_ending_hero4.h
@@ -10,8 +10,8 @@ typedef void (*EnEndingHero4ActionFunc)(struct EnEndingHero4*, GlobalContext*);
 typedef struct EnEndingHero4 {
     /* 0x000 */ Actor actor;
     /* 0x144 */ SkelAnime skelAnime;
-    /* 0x188 */ Vec3s limbDrawTable[17];
-    /* 0x1EE */ Vec3s transitionDrawTable[17];
+    /* 0x188 */ Vec3s jointTable[17];
+    /* 0x1EE */ Vec3s morphTable[17];
     /* 0x254 */ EnEndingHero4ActionFunc actionFunc;
     /* 0x258 */ u16 unk258;
 } EnEndingHero4; // size = 0x25C
diff --git a/src/overlays/actors/ovl_En_Ending_Hero5/z_en_ending_hero5.c b/src/overlays/actors/ovl_En_Ending_Hero5/z_en_ending_hero5.c
index ec48db441..1e392ef12 100644
--- a/src/overlays/actors/ovl_En_Ending_Hero5/z_en_ending_hero5.c
+++ b/src/overlays/actors/ovl_En_Ending_Hero5/z_en_ending_hero5.c
@@ -40,8 +40,7 @@ void EnEndingHero5_Init(Actor* thisx, GlobalContext* globalCtx) {
     Actor_SetScale(&this->actor, 0.01f);
     this->actor.targetMode = 6;
     this->actor.gravity = -3.0f;
-    SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_0600A850, &D_06002FA0, this->limbDrawTable,
-                     this->transitionDrawTable, 17);
+    SkelAnime_InitFlex(globalCtx, &this->skelAnime, &D_0600A850, &D_06002FA0, this->jointTable, this->morphTable, 17);
     ActorShape_Init(&this->actor.shape, 0.0f, func_800B3FC0, 25.0f);
     this->unk25C = this->actor.params;
     func_80C23980(this);
@@ -56,7 +55,7 @@ void func_80C23980(EnEndingHero5* this) {
 }
 
 void func_80C2399C(EnEndingHero5* this, GlobalContext* globalCtx) {
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
 }
 
 void EnEndingHero5_Update(Actor* thisx, GlobalContext* globalCtx) {
@@ -106,8 +105,8 @@ void EnEndingHero5_Draw(Actor* thisx, GlobalContext* globalCtx) {
             break;
     }
 
-    SkelAnime_DrawSV(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl, this->skelAnime.dListCount, NULL,
-                     func_80C23A30, &this->actor);
+    SkelAnime_DrawFlexOpa(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable, this->skelAnime.dListCount,
+                          NULL, func_80C23A30, &this->actor);
 
     CLOSE_DISPS(globalCtx->state.gfxCtx);
 }
diff --git a/src/overlays/actors/ovl_En_Ending_Hero5/z_en_ending_hero5.h b/src/overlays/actors/ovl_En_Ending_Hero5/z_en_ending_hero5.h
index a630b56f4..e9f3ecf18 100644
--- a/src/overlays/actors/ovl_En_Ending_Hero5/z_en_ending_hero5.h
+++ b/src/overlays/actors/ovl_En_Ending_Hero5/z_en_ending_hero5.h
@@ -10,8 +10,8 @@ typedef void (*EnEndingHero5ActionFunc)(struct EnEndingHero5*, GlobalContext*);
 typedef struct EnEndingHero5 {
     /* 0x000 */ Actor actor;
     /* 0x144 */ SkelAnime skelAnime;
-    /* 0x188 */ Vec3s limbDrawTable[17];
-    /* 0x1EE */ Vec3s transitionDrawTable[17];
+    /* 0x188 */ Vec3s jointTable[17];
+    /* 0x1EE */ Vec3s morphTable[17];
     /* 0x254 */ EnEndingHero5ActionFunc actionFunc;
     /* 0x258 */ u16 unk258;
     /* 0x25C */ s32 unk25C;
diff --git a/src/overlays/actors/ovl_En_Ending_Hero6/z_en_ending_hero6.c b/src/overlays/actors/ovl_En_Ending_Hero6/z_en_ending_hero6.c
index 334856872..d692d4f11 100644
--- a/src/overlays/actors/ovl_En_Ending_Hero6/z_en_ending_hero6.c
+++ b/src/overlays/actors/ovl_En_Ending_Hero6/z_en_ending_hero6.c
@@ -76,8 +76,8 @@ void EnEndingHero6_Init(Actor* thisx, GlobalContext* globalCtx) {
     Actor_SetScale(&this->actor, 0.01f);
     this->actor.targetMode = 6;
     this->actor.gravity = -3.0f;
-    SkelAnime_InitSV(globalCtx, &this->skelAnime, sSkeletons[this->npcIndex], sAnimations[this->npcIndex],
-                     this->jointTable, this->morphTable, sLimbCounts[this->npcIndex]);
+    SkelAnime_InitFlex(globalCtx, &this->skelAnime, sSkeletons[this->npcIndex], sAnimations[this->npcIndex],
+                       this->jointTable, this->morphTable, sLimbCounts[this->npcIndex]);
     ActorShape_Init(&this->actor.shape, 0.0f, func_800B3FC0, 25.0f);
     EnEndingHero6_SetupIdle(this);
 }
@@ -87,8 +87,8 @@ void EnEndingHero6_Destroy(Actor* thisx, GlobalContext* globalCtx) {
 
 void EnEndingHero6_InitSkelAnime(EnEndingHero6* this, s32 npcIndex) {
     this->animIndex = npcIndex;
-    this->frameCount = SkelAnime_GetFrameCount(&sAnimations[npcIndex]->common);
-    SkelAnime_ChangeAnim(&this->skelAnime, sAnimations[this->animIndex], 1.0f, 0.f, this->frameCount, 0, 0.0f);
+    this->frameCount = Animation_GetLastFrame(sAnimations[npcIndex]);
+    Animation_Change(&this->skelAnime, sAnimations[this->animIndex], 1.0f, 0.f, this->frameCount, 0, 0.0f);
 }
 
 void EnEndingHero6_SetupIdle(EnEndingHero6* this) {
@@ -98,7 +98,7 @@ void EnEndingHero6_SetupIdle(EnEndingHero6* this) {
 }
 
 void EnEndingHero6_Idle(EnEndingHero6* this, GlobalContext* globalCtx) {
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
 }
 
 void EnEndingHero6_Update(Actor* thisx, GlobalContext* globalCtx) {
@@ -182,8 +182,8 @@ void EnEndingHero6_Draw(Actor* thisx, GlobalContext* globalCtx) {
                 gSPSegment(POLY_OPA_DISP++, 0x09, Lib_SegmentedToVirtual(D_80C24294[index]));
             }
 
-            SkelAnime_DrawSV(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl,
-                             this->skelAnime.dListCount, NULL, EnEndingHero6_PostLimbDraw, &this->actor);
+            SkelAnime_DrawFlexOpa(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable,
+                                  this->skelAnime.dListCount, NULL, EnEndingHero6_PostLimbDraw, &this->actor);
         }
 
         CLOSE_DISPS(globalCtx->state.gfxCtx);
diff --git a/src/overlays/actors/ovl_En_Fg/z_en_fg.c b/src/overlays/actors/ovl_En_Fg/z_en_fg.c
index 3b94a5732..197f07606 100644
--- a/src/overlays/actors/ovl_En_Fg/z_en_fg.c
+++ b/src/overlays/actors/ovl_En_Fg/z_en_fg.c
@@ -117,11 +117,11 @@ s32 EnFg_UpdateAnimation(SkelAnime* skelAnime, s16 animIndex) {
         ret = true;
         frameCount = sAnimations[animIndex].frameCount;
         if (frameCount < 0) {
-            frameCount = SkelAnime_GetFrameCount(&sAnimations[animIndex].animationSeg->common);
+            frameCount = Animation_GetLastFrame(sAnimations[animIndex].animationSeg);
         }
-        SkelAnime_ChangeAnim(skelAnime, sAnimations[animIndex].animationSeg, sAnimations[animIndex].playbackSpeed,
-                             sAnimations[animIndex].frame, frameCount, sAnimations[animIndex].mode,
-                             sAnimations[animIndex].transitionRate);
+        Animation_Change(skelAnime, sAnimations[animIndex].animationSeg, sAnimations[animIndex].playbackSpeed,
+                         sAnimations[animIndex].frame, frameCount, sAnimations[animIndex].mode,
+                         sAnimations[animIndex].transitionRate);
     }
     return ret;
 }
@@ -137,7 +137,7 @@ void func_80A2D348(EnFg* this, GlobalContext* globalCtx) {
 }
 
 void func_80A2D3D4(EnFg* this, GlobalContext* globalCtx) {
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
 }
 
 u8 EnFg_UpdateHealth(EnFg* this) {
@@ -185,7 +185,7 @@ void EnFg_Idle(EnFg* this, GlobalContext* globalCtx) {
         case FG_DMGEFFECT_DEKUSTICK:
             this->actor.flags &= ~1;
             Audio_PlayActorSound2(&this->actor, NA_SE_EV_FROG_CRY_1);
-            this->skelAnime.animPlaybackSpeed = 0.0f;
+            this->skelAnime.playSpeed = 0.0f;
             this->actor.shape.shadowDraw = NULL;
             this->actor.scale.x *= 1.5f;
             this->actor.scale.z *= 1.5f;
@@ -197,7 +197,7 @@ void EnFg_Idle(EnFg* this, GlobalContext* globalCtx) {
             break;
         case FG_DMGEFFECT_ARROW:
             this->actor.flags &= ~1;
-            this->skelAnime.animPlaybackSpeed = 0.0f;
+            this->skelAnime.playSpeed = 0.0f;
             rotY = this->collider.base.ac->world.rot.y;
             rotX = this->collider.base.ac->world.rot.x;
             this->actor.scale.x = fabsf(0.01f * Math_CosS(rotY));
@@ -213,7 +213,7 @@ void EnFg_Idle(EnFg* this, GlobalContext* globalCtx) {
             Audio_PlayActorSound2(&this->actor, NA_SE_EV_FROG_CRY_0);
             if (1) {}
             this->actor.params = FG_BLACK;
-            this->skelAnime.animPlaybackSpeed = 0.0f;
+            this->skelAnime.playSpeed = 0.0f;
             ac = this->collider.base.ac;
             this->actor.world.rot.y = Math_Vec3f_Yaw(&ac->world.pos, &this->actor.world.pos);
             this->actor.shape.rot = this->actor.world.rot;
@@ -245,7 +245,7 @@ void EnFg_Jump(EnFg* this, GlobalContext* globalCtx) {
     switch (EnFg_GetDamageEffect(this)) {
         case FG_DMGEFFECT_ARROW:
             this->actor.flags &= ~1;
-            this->skelAnime.animPlaybackSpeed = 0.0f;
+            this->skelAnime.playSpeed = 0.0f;
             ac = this->collider.base.ac;
             rotY = ac->world.rot.y;
             rotX = ac->world.rot.x;
@@ -264,7 +264,7 @@ void EnFg_Jump(EnFg* this, GlobalContext* globalCtx) {
             Audio_PlayActorSound2(&this->actor, NA_SE_EV_FROG_CRY_0);
             EnFg_UpdateAnimation(&this->skelAnime, 0);
             this->actor.params = FG_BLACK;
-            this->skelAnime.animPlaybackSpeed = 0.0f;
+            this->skelAnime.playSpeed = 0.0f;
             ac = this->collider.base.ac;
             this->actor.world.rot.y = Math_Vec3f_Yaw(&ac->world.pos, &this->actor.world.pos);
             this->actor.shape.rot = this->actor.world.rot;
@@ -276,9 +276,9 @@ void EnFg_Jump(EnFg* this, GlobalContext* globalCtx) {
             this->actionFunc = EnFg_Knockback;
             break;
         default:
-            if (func_801378B8(&this->skelAnime, 8.0f)) {
-                this->skelAnime.animCurrentFrame = 8.0f;
-                this->skelAnime.animPlaybackSpeed = 0.0f;
+            if (Animation_OnFrame(&this->skelAnime, 8.0f)) {
+                this->skelAnime.curFrame = 8.0f;
+                this->skelAnime.playSpeed = 0.0f;
             }
 
             if ((this->actor.velocity.y <= 0.0f) && (this->actor.bgCheckFlags & 1)) {
@@ -321,7 +321,7 @@ void EnFg_Init(Actor* thisx, GlobalContext* globalCtx) {
     EnFg* this = THIS;
 
     ActorShape_Init(&this->actor.shape, 0.0f, func_800B3FC0, 10.0f);
-    SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_0600B538, NULL, this->limbDrawTbl, this->transitionDrawTbl, 24);
+    SkelAnime_InitFlex(globalCtx, &this->skelAnime, &D_0600B538, NULL, this->jointTable, this->morphTable, 24);
     EnFg_UpdateAnimation(&this->skelAnime, 0);
     Collider_InitCylinder(globalCtx, &this->collider);
     Collider_SetCylinder(globalCtx, &this->collider, &this->actor, &sCylinderInit);
@@ -360,8 +360,8 @@ void EnFg_Update(Actor* thisx, GlobalContext* globalCtx) {
     func_80A2D348(this, globalCtx);
 }
 
-s32 EnFg_OverrideLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3f* pos, Vec3s* rot, Actor* thisx) {
-    EnFg* this = THIS;
+s32 EnFg_OverrideLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3f* pos, Vec3s* rot, Actor* arg) {
+    EnFg* this = (EnFg*)arg;
 
     if ((limbIndex == 7) || (limbIndex == 8)) {
         *dList = NULL;
@@ -375,23 +375,23 @@ s32 EnFg_OverrideLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList,
     return 0;
 }
 
-void EnFg_PostLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3s* rot, Actor* thisx) {
-    EnFg* this = THIS;
+void EnFg_PostLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3s* rot, Actor* arg) {
+    EnFg* this = (EnFg*)arg;
     s16 pad;
     Vec3f vec1 = { 0.0f, 0.0f, 0.0f };
 
     if ((limbIndex == 7) || (limbIndex == 8)) {
         OPEN_DISPS(globalCtx->state.gfxCtx);
-        SysMatrix_StatePush();
-        SysMatrix_NormalizeXYZ(&globalCtx->mf_187FC);
+        Matrix_StatePush();
+        Matrix_NormalizeXYZ(&globalCtx->mf_187FC);
         gSPMatrix(POLY_OPA_DISP++, Matrix_NewMtx(globalCtx->state.gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
         gSPDisplayList(POLY_OPA_DISP++, *dList);
-        SysMatrix_StatePop();
+        Matrix_StatePop();
         CLOSE_DISPS(globalCtx->state.gfxCtx);
     }
 
     if (limbIndex == 4) {
-        SysMatrix_MultiplyVector3fByState(&vec1, &this->actor.focus.pos);
+        Matrix_MultiplyVector3fByState(&vec1, &this->actor.focus.pos);
     }
 }
 
@@ -403,9 +403,9 @@ void EnFg_Draw(Actor* thisx, GlobalContext* globalCtx) {
         { 120, 130, 230, 255 }, { 190, 190, 190, 255 }, { 0, 0, 0, 255 },
     };
 
-    SysMatrix_StatePush();
+    Matrix_StatePush();
     EnFg_DrawDust(globalCtx, &this->dustEffect[0]);
-    SysMatrix_StatePop();
+    Matrix_StatePop();
 
     OPEN_DISPS(globalCtx->state.gfxCtx);
     func_8012C28C(globalCtx->state.gfxCtx);
@@ -414,8 +414,8 @@ void EnFg_Draw(Actor* thisx, GlobalContext* globalCtx) {
                    envColor[this->actor.params].b, envColor[this->actor.params].a);
     gSPSegment(POLY_OPA_DISP++, 0x08, Lib_SegmentedToVirtual(&D_060059A0));
     gSPSegment(POLY_OPA_DISP++, 0x09, Lib_SegmentedToVirtual(&D_060059A0));
-    SkelAnime_DrawSV(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl, this->skelAnime.dListCount,
-                     EnFg_OverrideLimbDraw, EnFg_PostLimbDraw, &this->actor);
+    SkelAnime_DrawFlexOpa(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable, this->skelAnime.dListCount,
+                          EnFg_OverrideLimbDraw, EnFg_PostLimbDraw, &this->actor);
     CLOSE_DISPS(globalCtx->state.gfxCtx);
 }
 
@@ -476,8 +476,8 @@ void EnFg_DrawDust(GlobalContext* globalCtx, EnFgEffectDust* dustEffect) {
             alpha = (255.0f / 16.0f) * dustEffect->timer;
             gDPSetPrimColor(POLY_XLU_DISP++, 0, 0, 0, 0, 0, alpha);
             gDPPipeSync(POLY_XLU_DISP++);
-            SysMatrix_InsertTranslation(dustEffect->pos.x, dustEffect->pos.y, dustEffect->pos.z, MTXMODE_NEW);
-            SysMatrix_NormalizeXYZ(&globalCtx->mf_187FC);
+            Matrix_InsertTranslation(dustEffect->pos.x, dustEffect->pos.y, dustEffect->pos.z, MTXMODE_NEW);
+            Matrix_NormalizeXYZ(&globalCtx->mf_187FC);
             Matrix_Scale(dustEffect->xyScale, dustEffect->xyScale, 1.0f, MTXMODE_APPLY);
             gSPMatrix(POLY_XLU_DISP++, Matrix_NewMtx(globalCtx->state.gfxCtx),
                       G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
diff --git a/src/overlays/actors/ovl_En_Fg/z_en_fg.h b/src/overlays/actors/ovl_En_Fg/z_en_fg.h
index 5f12fca6e..45f643a1c 100644
--- a/src/overlays/actors/ovl_En_Fg/z_en_fg.h
+++ b/src/overlays/actors/ovl_En_Fg/z_en_fg.h
@@ -42,8 +42,8 @@ typedef struct EnFg {
     /* 0x144 */ EnFgActionFunc actionFunc;
     /* 0x148 */ SkelAnime skelAnime;
     /* 0x18C */ ColliderCylinder collider;
-    /* 0x1D8 */ Vec3s limbDrawTbl[24];
-    /* 0x268 */ Vec3s transitionDrawTbl[24];
+    /* 0x1D8 */ Vec3s jointTable[24];
+    /* 0x268 */ Vec3s morphTable[24];
     /* 0x2F8 */ s16 timer;
     /* 0x2FA */ s16 bounceCounter;
     /* 0x2FC */ EnFgEffectDust dustEffect[10];
diff --git a/src/overlays/actors/ovl_En_Firefly/z_en_firefly.c b/src/overlays/actors/ovl_En_Firefly/z_en_firefly.c
index 6590796ae..716c460a8 100644
--- a/src/overlays/actors/ovl_En_Firefly/z_en_firefly.c
+++ b/src/overlays/actors/ovl_En_Firefly/z_en_firefly.c
@@ -268,7 +268,7 @@ void EnFirefly_SetupFlyIdle(EnFirefly* this) {
     this->actor.speedXZ = (Rand_ZeroOne() * 1.5f) + 1.5f;
     Math_ScaledStepToS(&this->actor.shape.rot.y, Actor_YawToPoint(&this->actor, &this->actor.home.pos), 0x300);
     this->targetPitch = ((this->maxAltitude < this->actor.world.pos.y) ? 0xC00 : -0xC00) + 0x1554;
-    this->skelAnime.animPlaybackSpeed = 1.0f;
+    this->skelAnime.playSpeed = 1.0f;
     this->actionFunc = EnFirefly_FlyIdle;
 }
 
@@ -276,12 +276,12 @@ void EnFirefly_FlyIdle(EnFirefly* this, GlobalContext* globalCtx) {
     s32 isSkelAnimeUpdated;
     f32 rand;
 
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     if (this->timer != 0) {
         this->timer--;
     }
 
-    isSkelAnimeUpdated = func_801378B8(&this->skelAnime, 0.0f);
+    isSkelAnimeUpdated = Animation_OnFrame(&this->skelAnime, 0.0f);
     this->actor.speedXZ = (Rand_ZeroOne() * 1.5f) + 1.5f;
 
     if (!EnFirefly_ReturnToPerch(this, globalCtx) && !EnFirefly_SeekTorch(this, globalCtx)) {
@@ -331,7 +331,7 @@ void EnFirefly_FlyIdle(EnFirefly* this, GlobalContext* globalCtx) {
 void EnFirefly_SetupFall(EnFirefly* this, GlobalContext* globalCtx) {
     this->timer = 40;
     this->actor.velocity.y = 0.0f;
-    SkelAnime_ChangeAnim(&this->skelAnime, &D_0600017C, 0.0f, 6.0f, 6.0f, 2, 0.0f);
+    Animation_Change(&this->skelAnime, &D_0600017C, 0.0f, 6.0f, 6.0f, 2, 0.0f);
     Audio_PlayActorSound2(&this->actor, NA_SE_EN_FFLY_DEAD);
     this->actor.flags |= 0x10;
 
@@ -411,7 +411,7 @@ void EnFirefly_Die(EnFirefly* this, GlobalContext* globalCtx) {
 
 void EnFirefly_SetupDiveAttack(EnFirefly* this) {
     this->timer = Rand_S16Offset(70, 100);
-    this->skelAnime.animPlaybackSpeed = 1.0f;
+    this->skelAnime.playSpeed = 1.0f;
     this->targetPitch = ((this->actor.yDistToPlayer > 0.0f) ? -0xC00 : 0xC00) + 0x1554;
     this->actionFunc = EnFirefly_DiveAttack;
 }
@@ -420,7 +420,7 @@ void EnFirefly_DiveAttack(EnFirefly* this, GlobalContext* globalCtx) {
     Player* player = GET_PLAYER(globalCtx);
     Vec3f preyPos;
 
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
 
     if (this->timer != 0) {
         this->timer--;
@@ -432,9 +432,9 @@ void EnFirefly_DiveAttack(EnFirefly* this, GlobalContext* globalCtx) {
         Math_SmoothStepToS(&this->actor.shape.rot.y, this->actor.wallYaw, 2, 0xC00, 0x300);
         Math_ScaledStepToS(&this->actor.shape.rot.x, this->targetPitch, 0x100);
     } else if (Actor_IsActorFacingLink(&this->actor, 0x2800)) {
-        if (func_801378B8(&this->skelAnime, 4.0f)) {
-            this->skelAnime.animPlaybackSpeed = 0.0f;
-            this->skelAnime.animCurrentFrame = 4.0f;
+        if (Animation_OnFrame(&this->skelAnime, 4.0f)) {
+            this->skelAnime.playSpeed = 0.0f;
+            this->skelAnime.curFrame = 4.0f;
         }
 
         Math_SmoothStepToS(&this->actor.shape.rot.y, this->actor.yawTowardsPlayer, 2, 0xC00, 0x300);
@@ -444,7 +444,7 @@ void EnFirefly_DiveAttack(EnFirefly* this, GlobalContext* globalCtx) {
         Math_SmoothStepToS(&this->actor.shape.rot.x, Actor_PitchToPoint(&this->actor, &preyPos) + 0x1554, 2, 0x400,
                            0x100);
     } else {
-        this->skelAnime.animPlaybackSpeed = 1.5f;
+        this->skelAnime.playSpeed = 1.5f;
         if (this->actor.xzDistToPlayer > 80.0f) {
             Math_SmoothStepToS(&this->actor.shape.rot.y, this->actor.yawTowardsPlayer, 2, 0xC00, 0x300);
         }
@@ -471,14 +471,14 @@ void EnFirefly_DiveAttack(EnFirefly* this, GlobalContext* globalCtx) {
 void EnFirefly_SetupRebound(EnFirefly* this) {
     this->actor.world.rot.x = 0x7000;
     this->timer = 18;
-    this->skelAnime.animPlaybackSpeed = 1.0f;
+    this->skelAnime.playSpeed = 1.0f;
     this->actor.speedXZ = 2.5f;
     this->actionFunc = EnFirefly_Rebound;
 }
 
 // Knockback after hitting player
 void EnFirefly_Rebound(EnFirefly* this, GlobalContext* globalCtx) {
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     Math_ScaledStepToS(&this->actor.shape.rot.x, 0, 0x100);
     Math_StepToF(&this->actor.velocity.y, 0.0f, 0.4f);
     if (Math_StepToF(&this->actor.speedXZ, 0.0f, 0.15f)) {
@@ -496,11 +496,11 @@ void EnFirefly_SetupFlyAway(EnFirefly* this) {
     this->timer = 150;
     this->targetPitch = 0x954;
     this->actionFunc = EnFirefly_FlyAway;
-    this->skelAnime.animPlaybackSpeed = 1.0f;
+    this->skelAnime.playSpeed = 1.0f;
 }
 
 void EnFirefly_FlyAway(EnFirefly* this, GlobalContext* globalCtx) {
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
 
     if (this->timer != 0) {
         this->timer--;
@@ -584,8 +584,8 @@ void EnFirefly_SetupPerch(EnFirefly* this) {
 void EnFirefly_Perch(EnFirefly* this, GlobalContext* globalCtx) {
     Math_ScaledStepToS(&this->actor.shape.rot.x, 0, 0x100);
     if (this->timer != 0) {
-        SkelAnime_FrameUpdateMatrix(&this->skelAnime);
-        if (func_801378B8(&this->skelAnime, 6.0f)) {
+        SkelAnime_Update(&this->skelAnime);
+        if (Animation_OnFrame(&this->skelAnime, 6.0f)) {
             this->timer--;
         }
     } else if (Rand_ZeroOne() < 0.02f) {
@@ -598,7 +598,7 @@ void EnFirefly_Perch(EnFirefly* this, GlobalContext* globalCtx) {
 }
 
 void EnFirefly_SetupDisturbDiveAttack(EnFirefly* this) {
-    this->skelAnime.animPlaybackSpeed = 3.0f;
+    this->skelAnime.playSpeed = 3.0f;
     this->actor.shape.rot.x = 0x1554;
     this->actor.shape.rot.y = this->actor.yawTowardsPlayer;
     this->timer = 50;
@@ -610,7 +610,7 @@ void EnFirefly_DisturbDiveAttack(EnFirefly* this, GlobalContext* globalCtx) {
     Player* player = GET_PLAYER(globalCtx);
     Vec3f preyPos;
 
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
 
     if (this->timer != 0) {
         this->timer--;
@@ -705,7 +705,7 @@ void EnFirefly_Update(Actor* thisx, GlobalContext* globalCtx2) {
         CollisionCheck_SetAC(globalCtx, &globalCtx->colChkCtx, &this->collider.base);
         this->actor.world.rot.y = this->actor.shape.rot.y;
 
-        if (func_801378B8(&this->skelAnime, 5.0f)) {
+        if (Animation_OnFrame(&this->skelAnime, 5.0f)) {
             Audio_PlayActorSound2(&this->actor, NA_SE_EN_FFLY_FLY);
         }
     }
@@ -762,7 +762,7 @@ void EnFirefly_PostLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList
                ((this->auraType == KEESE_AURA_FIRE) || (this->auraType == KEESE_AURA_ICE)) &&
                ((limbIndex == 15) || (limbIndex == 21))) {
         if (this->actionFunc != EnFirefly_Die) {
-            SysMatrix_GetStateTranslation(&auraPos);
+            Matrix_GetStateTranslation(&auraPos);
             auraPos.x += Rand_ZeroFloat(5.0f);
             auraPos.y += Rand_ZeroFloat(5.0f);
             auraPos.z += Rand_ZeroFloat(5.0f);
@@ -795,11 +795,11 @@ void EnFirefly_PostLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList
     }
 
     if (limbIndex == 15) {
-        SysMatrix_GetStateTranslation(&this->unk_2F8);
+        Matrix_GetStateTranslation(&this->unk_2F8);
     } else if (limbIndex == 21) {
-        SysMatrix_GetStateTranslation(&this->unk_304);
+        Matrix_GetStateTranslation(&this->unk_304);
     } else if (limbIndex == 10) {
-        SysMatrix_GetStateTranslation(&this->unk_310);
+        Matrix_GetStateTranslation(&this->unk_310);
     }
 }
 
@@ -824,8 +824,8 @@ void EnFirefly_Draw(Actor* thisx, GlobalContext* globalCtx) {
         gDPSetEnvColor(&gfx[1], 0, 0, 0, 255);
     }
 
-    gfx = SkelAnime_Draw2(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl, EnFirefly_OverrideLimbDraw,
-                          EnFirefly_PostLimbDraw, &this->actor, &gfx[2]);
+    gfx = SkelAnime_Draw(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable, EnFirefly_OverrideLimbDraw,
+                         EnFirefly_PostLimbDraw, &this->actor, &gfx[2]);
     if (this->isInvisible) {
         POLY_XLU_DISP = gfx;
     } else {
diff --git a/src/overlays/actors/ovl_En_Fsn/z_en_fsn.c b/src/overlays/actors/ovl_En_Fsn/z_en_fsn.c
index 291495635..606e5f955 100644
--- a/src/overlays/actors/ovl_En_Fsn/z_en_fsn.c
+++ b/src/overlays/actors/ovl_En_Fsn/z_en_fsn.c
@@ -711,8 +711,8 @@ void EnFsn_Idle(EnFsn* this, GlobalContext* globalCtx) {
     Player* player = GET_PLAYER(globalCtx);
 
     if (this->animationIdx == 4) {
-        s16 curFrame = this->skelAnime.animCurrentFrame;
-        s16 frameCount = SkelAnime_GetFrameCount(&sAnimations[this->animationIdx].animationSeg->common);
+        s16 curFrame = this->skelAnime.curFrame;
+        s16 frameCount = Animation_GetLastFrame(sAnimations[this->animationIdx].animationSeg);
         if (curFrame == frameCount) {
             this->animationIdx = 5;
             func_8013BC6C(&this->skelAnime, sAnimations, this->animationIdx);
@@ -745,15 +745,15 @@ void EnFsn_Idle(EnFsn* this, GlobalContext* globalCtx) {
 }
 
 void EnFsn_Haggle(EnFsn* this, GlobalContext* globalCtx) {
-    s16 curFrame = this->skelAnime.animCurrentFrame;
-    s16 frameCount = SkelAnime_GetFrameCount(&sAnimations[this->animationIdx].animationSeg->common);
+    s16 curFrame = this->skelAnime.curFrame;
+    s16 frameCount = Animation_GetLastFrame(sAnimations[this->animationIdx].animationSeg);
 
     if (this->flags & ENFSN_ANGRY) {
         this->flags &= ~ENFSN_ANGRY;
         this->animationIdx = 11;
         func_8013BC6C(&this->skelAnime, sAnimations, this->animationIdx);
     } else {
-        if (this->animationIdx == 11 && func_801378B8(&this->skelAnime, 18.0f)) {
+        if (this->animationIdx == 11 && Animation_OnFrame(&this->skelAnime, 18.0f)) {
             Audio_PlayActorSound2(&this->actor, NA_SE_EV_HANKO);
         }
         if (this->flags & ENFSN_CALM_DOWN) {
@@ -770,7 +770,7 @@ void EnFsn_Haggle(EnFsn* this, GlobalContext* globalCtx) {
                     this->animationIdx = 5;
                     func_8013BC6C(&this->skelAnime, sAnimations, this->animationIdx);
                 } else {
-                    if (func_801378B8(&this->skelAnime, 28.0f)) {
+                    if (Animation_OnFrame(&this->skelAnime, 28.0f)) {
                         Audio_PlayActorSound2(&this->actor, NA_SE_EV_HANKO);
                     }
                     return;
@@ -1398,8 +1398,7 @@ void EnFsn_Init(Actor* thisx, GlobalContext* globalCtx) {
     s32 pad;
 
     ActorShape_Init(&this->actor.shape, 0.0f, func_800B3FC0, 20.0f);
-    SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_06013320, &D_06012C34, this->limbDrawTable,
-                     this->transitionDrawTable, 19);
+    SkelAnime_InitFlex(globalCtx, &this->skelAnime, &D_06013320, &D_06012C34, this->jointTable, this->morphTable, 19);
     if (ENFSN_IS_SHOP(&this->actor)) {
         this->actor.shape.rot.y = BINANG_ROT180(this->actor.shape.rot.y);
         this->actor.flags &= ~1;
@@ -1442,7 +1441,7 @@ void EnFsn_Update(Actor* thisx, GlobalContext* globalCtx) {
         EnFsn_UpdateStickDirectionPromptAnim(this);
         EnFsn_UpdateCursorAnim(this);
     }
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     if (ENFSN_IS_BACKROOM(&this->actor)) {
         EnFsn_UpdateCollider(this, globalCtx);
     }
@@ -1559,7 +1558,7 @@ s32 EnFsn_OverrideLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList,
     s32 limbRotTableIdx;
 
     if (limbIndex == 16) {
-        SysMatrix_InsertXRotation_s(this->headRot.y, MTXMODE_APPLY);
+        Matrix_InsertXRotation_s(this->headRot.y, MTXMODE_APPLY);
     }
     if (ENFSN_IS_BACKROOM(&this->actor)) {
         switch (limbIndex) {
@@ -1614,8 +1613,8 @@ void EnFsn_Draw(Actor* thisx, GlobalContext* globalCtx) {
     func_8012C5B0(globalCtx->state.gfxCtx);
     gSPSegment(POLY_OPA_DISP++, 0x08, Lib_SegmentedToVirtual(sEyeTextures[this->eyeTextureIdx]));
     gSPSegment(POLY_OPA_DISP++, 0x09, Lib_SegmentedToVirtual(sEyeTextures[this->eyeTextureIdx]));
-    SkelAnime_DrawSV(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl, this->skelAnime.dListCount,
-                     EnFsn_OverrideLimbDraw, EnFsn_PostLimbDraw, &this->actor);
+    SkelAnime_DrawFlexOpa(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable, this->skelAnime.dListCount,
+                          EnFsn_OverrideLimbDraw, EnFsn_PostLimbDraw, &this->actor);
 
     for (i = 0; i < this->totalSellingItems; i++) {
         this->items[i]->actor.scale.x = 0.2f;
diff --git a/src/overlays/actors/ovl_En_Fsn/z_en_fsn.h b/src/overlays/actors/ovl_En_Fsn/z_en_fsn.h
index 945bb0d76..139e145da 100644
--- a/src/overlays/actors/ovl_En_Fsn/z_en_fsn.h
+++ b/src/overlays/actors/ovl_En_Fsn/z_en_fsn.h
@@ -27,8 +27,8 @@ typedef struct EnFsn {
     /* 0x24E */ s16 limbRotZTable[19];
     /* 0x274 */ Vec3s headRot;
     /* 0x27A */ Vec3s unk27A; // Set but never used
-    /* 0x280 */ Vec3s limbDrawTable[19];
-    /* 0x2F2 */ Vec3s transitionDrawTable[19];
+    /* 0x280 */ Vec3s jointTable[19];
+    /* 0x2F2 */ Vec3s morphTable[19];
     /* 0x364 */ s16 eyeTextureIdx;
     /* 0x366 */ s16 blinkTimer;
     /* 0x368 */ s16 cutsceneState;
diff --git a/src/overlays/actors/ovl_En_Fu/z_en_fu.c b/src/overlays/actors/ovl_En_Fu/z_en_fu.c
index 04ddc07a4..550a54f62 100644
--- a/src/overlays/actors/ovl_En_Fu/z_en_fu.c
+++ b/src/overlays/actors/ovl_En_Fu/z_en_fu.c
@@ -200,7 +200,8 @@ void EnFu_Init(Actor* thisx, GlobalContext* globalCtx) {
 
     if (fuKaiten != NULL) {
         ActorShape_Init(&this->actor.shape, 0.0f, func_800B3FC0, 36.0f);
-        SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_0600B2B0, &D_06001F74, this->jointTable, this->morphTable, 21);
+        SkelAnime_InitFlex(globalCtx, &this->skelAnime, &D_0600B2B0, &D_06001F74, this->jointTable, this->morphTable,
+                           21);
         Collider_InitCylinder(globalCtx, &this->collider);
         Collider_SetCylinder(globalCtx, &this->collider, &this->actor, &sCylinderInit);
         this->actor.colChkInfo.mass = MASS_IMMOVABLE;
@@ -366,10 +367,10 @@ void func_8096209C(EnFu* this, GlobalContext* globalCtx) {
         sp34 = D_80964B24;
     }
 
-    SysMatrix_StatePush();
+    Matrix_StatePush();
     Matrix_RotateY(this->actor.shape.rot.y, MTXMODE_NEW);
-    SysMatrix_MultiplyVector3fByState(&sp34, &this->actor.focus.pos);
-    SysMatrix_StatePop();
+    Matrix_MultiplyVector3fByState(&sp34, &this->actor.focus.pos);
+    Matrix_StatePop();
     this->actor.focus.pos.x += this->actor.world.pos.x;
     this->actor.focus.pos.y += this->actor.world.pos.y;
     this->actor.focus.pos.z += this->actor.world.pos.z;
@@ -1341,7 +1342,7 @@ void EnFu_Update(Actor* thisx, GlobalContext* globalCtx) {
     Actor_SetVelocityAndMoveYRotationAndGravity(&this->actor);
     func_8096209C(this, globalCtx);
     Actor_UpdateBgCheckInfo(globalCtx, &this->actor, 0.0f, 0.0f, 0.0f, 4);
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     func_80961D7C(globalCtx);
     func_809640D8(this, globalCtx);
     func_80964034(this, globalCtx);
@@ -1351,17 +1352,17 @@ s32 EnFu_OverrideLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList,
     EnFu* this = THIS;
 
     if (limbIndex == 9) {
-        SysMatrix_InsertTranslation(1600.0f, 300.0f, 0.0f, MTXMODE_APPLY);
-        SysMatrix_InsertXRotation_s(this->unk_524[1], MTXMODE_APPLY);
-        SysMatrix_InsertZRotation_s(this->unk_524[0], MTXMODE_APPLY);
+        Matrix_InsertTranslation(1600.0f, 300.0f, 0.0f, MTXMODE_APPLY);
+        Matrix_InsertXRotation_s(this->unk_524[1], MTXMODE_APPLY);
+        Matrix_InsertZRotation_s(this->unk_524[0], MTXMODE_APPLY);
         Matrix_RotateY(this->unk_524[2], MTXMODE_APPLY);
-        SysMatrix_InsertTranslation(-1600.0f, -300.0f, 0.0f, MTXMODE_APPLY);
+        Matrix_InsertTranslation(-1600.0f, -300.0f, 0.0f, MTXMODE_APPLY);
     } else if (limbIndex == 20) {
-        SysMatrix_InsertTranslation(1800.0f, 200.0f, 0.0f, MTXMODE_APPLY);
-        SysMatrix_InsertXRotation_s(this->unk_52A[1], MTXMODE_APPLY);
-        SysMatrix_InsertZRotation_s(this->unk_52A[0], MTXMODE_APPLY);
+        Matrix_InsertTranslation(1800.0f, 200.0f, 0.0f, MTXMODE_APPLY);
+        Matrix_InsertXRotation_s(this->unk_52A[1], MTXMODE_APPLY);
+        Matrix_InsertZRotation_s(this->unk_52A[0], MTXMODE_APPLY);
         Matrix_RotateY(this->unk_52A[2], MTXMODE_APPLY);
-        SysMatrix_InsertTranslation(-1800.0f, -200.0f, 0.0f, MTXMODE_APPLY);
+        Matrix_InsertTranslation(-1800.0f, -200.0f, 0.0f, MTXMODE_APPLY);
     }
     return false;
 }
@@ -1372,9 +1373,9 @@ void EnFu_PostLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec
     EnFu* this = THIS;
 
     if (limbIndex == 9) {
-        SysMatrix_MultiplyVector3fByState(&D_80964C28, &this->unk_508);
+        Matrix_MultiplyVector3fByState(&D_80964C28, &this->unk_508);
     } else if (limbIndex == 20) {
-        SysMatrix_MultiplyVector3fByState(&D_80964C34, &this->unk_514);
+        Matrix_MultiplyVector3fByState(&D_80964C34, &this->unk_514);
     }
 }
 
@@ -1382,9 +1383,9 @@ void EnFu_Draw(Actor* thisx, GlobalContext* globalCtx) {
     s32 pad;
     EnFu* this = THIS;
 
-    SysMatrix_StatePush();
+    Matrix_StatePush();
     func_80964950(globalCtx, this->unk_2D8, ARRAY_COUNT(this->unk_2D8));
-    SysMatrix_StatePop();
+    Matrix_StatePop();
 
     OPEN_DISPS(globalCtx->state.gfxCtx);
 
@@ -1393,8 +1394,8 @@ void EnFu_Draw(Actor* thisx, GlobalContext* globalCtx) {
     gDPPipeSync(POLY_OPA_DISP++);
     gSPSegment(POLY_OPA_DISP++, 0x08, Gfx_EnvColor(globalCtx->state.gfxCtx, 0, 50, 160, 0));
     gSPSegment(POLY_OPA_DISP++, 0x09, Gfx_EnvColor(globalCtx->state.gfxCtx, 255, 255, 255, 0));
-    SkelAnime_DrawSV(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl, this->skelAnime.dListCount,
-                     EnFu_OverrideLimbDraw, EnFu_PostLimbDraw, &this->actor);
+    SkelAnime_DrawFlexOpa(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable, this->skelAnime.dListCount,
+                          EnFu_OverrideLimbDraw, EnFu_PostLimbDraw, &this->actor);
 
     CLOSE_DISPS(globalCtx->state.gfxCtx);
 }
@@ -1435,11 +1436,11 @@ void func_809647EC(GlobalContext* globalCtx, EnFuUnkStruct* ptr, s32 len) {
             ptr->unk_08.y += ptr->unk_20.y;
             ptr->unk_08.x += 2.0f * Math_SinS(ptr->unk_2C);
             ptr->unk_08.z += 2.0f * Math_CosS(ptr->unk_2C);
-            SysMatrix_StatePush();
-            SysMatrix_InsertTranslation(ptr->unk_08.x, ptr->unk_08.y, ptr->unk_08.z, MTXMODE_NEW);
+            Matrix_StatePush();
+            Matrix_InsertTranslation(ptr->unk_08.x, ptr->unk_08.y, ptr->unk_08.z, MTXMODE_NEW);
             Matrix_RotateY(activeCam, MTXMODE_APPLY);
-            SysMatrix_MultiplyVector3fByState(&sp44, &ptr->unk_08);
-            SysMatrix_StatePop();
+            Matrix_MultiplyVector3fByState(&sp44, &ptr->unk_08);
+            Matrix_StatePop();
             ptr->unk_2C += 6000;
         }
     }
@@ -1460,8 +1461,8 @@ void func_80964950(GlobalContext* globalCtx, EnFuUnkStruct* ptr, s32 len) {
                 gSPDisplayList(POLY_OPA_DISP++, D_0600B0A0);
                 flag = true;
             }
-            SysMatrix_InsertTranslation(ptr->unk_08.x, ptr->unk_08.y, ptr->unk_08.z, MTXMODE_NEW);
-            SysMatrix_NormalizeXYZ(&globalCtx->mf_187FC);
+            Matrix_InsertTranslation(ptr->unk_08.x, ptr->unk_08.y, ptr->unk_08.z, MTXMODE_NEW);
+            Matrix_NormalizeXYZ(&globalCtx->mf_187FC);
             Matrix_Scale(ptr->unk_00, ptr->unk_00, ptr->unk_00, MTXMODE_APPLY);
 
             gSPSegment(POLY_OPA_DISP++, 0x08, Lib_SegmentedToVirtual(&D_0405E6F0));
diff --git a/src/overlays/actors/ovl_En_Ginko_Man/z_en_ginko_man.c b/src/overlays/actors/ovl_En_Ginko_Man/z_en_ginko_man.c
index 25f89e6f7..9997acd54 100644
--- a/src/overlays/actors/ovl_En_Ginko_Man/z_en_ginko_man.c
+++ b/src/overlays/actors/ovl_En_Ginko_Man/z_en_ginko_man.c
@@ -63,8 +63,7 @@ void EnGinkoMan_Init(Actor* thisx, GlobalContext* globalCtx) {
     this->isStampChecked = false;
     this->choiceDepositWithdrawl = GINKOMAN_CHOICE_RESET;
     this->serviceFee = 0;
-    SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_0600C240, &D_060043F0, this->limbDrawTbl, this->transitionDrawTbl,
-                     16);
+    SkelAnime_InitFlex(globalCtx, &this->skelAnime, &D_0600C240, &D_060043F0, this->jointTable, this->morphTable, 16);
     EnGinkoMan_SetupIdle(this);
 }
 
@@ -496,8 +495,7 @@ void EnGinkoMan_Dialogue(EnGinkoMan* this, GlobalContext* globalCtx) {
             break;
     }
 
-    if ((this->skelAnime.animCurrentSeg == &D_060008C0) &&
-        func_801378B8(&this->skelAnime, this->skelAnime.animFrameCount)) {
+    if ((this->skelAnime.animation == &D_060008C0) && Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame)) {
         Audio_PlayActorSound2(&this->actor, NA_SE_EV_BANK_MAN_HAND_HIT);
     }
 }
@@ -566,11 +564,11 @@ void EnGinkoMan_SetupStamp(EnGinkoMan* this) {
 
 void EnGinkoMan_Stamp(EnGinkoMan* this, GlobalContext* globalCtx) {
     if ((this->curTextId == 0x464) // "Hey, relax! It doesn't leave any marks, and it's not gonna hurt."
-        && (func_801378B8(&this->skelAnime, 10.0f))) {
+        && (Animation_OnFrame(&this->skelAnime, 10.0f))) {
         Audio_PlayActorSound2(&this->actor, NA_SE_EV_HANKO); // "stamp"
     }
 
-    if (func_801378B8(&this->skelAnime, this->skelAnime.animFrameCount)) {
+    if (Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame)) {
         switch (this->curTextId) {
             case 0x464: // "Hey, relax! It doesn't leave any marks, and it's not gonna hurt."
                 func_800BDC5C(&this->skelAnime, animations, GINKO_SITTING);
@@ -597,12 +595,12 @@ void EnGinkoMan_Stamp(EnGinkoMan* this, GlobalContext* globalCtx) {
 void EnGinkoMan_SwitchAnimation(EnGinkoMan* this, GlobalContext* globalCtx) {
     if (this->actor.xzDistToPlayer > 160.0f) {
         if (this->animTimer == 0) {
-            if (this->skelAnime.animCurrentSeg != &D_06004A7C) {
+            if (this->skelAnime.animation != &D_06004A7C) {
                 this->animTimer = 40;
                 func_800BDC5C(&this->skelAnime, animations, GINKO_ADVERTISING);
             }
         }
-    } else if ((this->animTimer == 0) && (this->skelAnime.animCurrentSeg != &D_06000AC4)) {
+    } else if ((this->animTimer == 0) && (this->skelAnime.animation != &D_06000AC4)) {
         this->animTimer = 40;
         func_800BDC5C(&this->skelAnime, animations, GINKO_AMAZED);
     }
@@ -611,8 +609,8 @@ void EnGinkoMan_SwitchAnimation(EnGinkoMan* this, GlobalContext* globalCtx) {
 }
 
 void EnGinkoMan_FacePlayer(EnGinkoMan* this, GlobalContext* globalCtx) {
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
-    if (this->skelAnime.animCurrentSeg != &D_06004A7C) {
+    SkelAnime_Update(&this->skelAnime);
+    if (this->skelAnime.animation != &D_06004A7C) {
         func_800E9250(globalCtx, &this->actor, &this->limb15Rot, &this->limb8Rot, this->actor.focus.pos);
     } else {
         func_800E8F08(&this->limb15Rot, &this->limb8Rot);
@@ -629,27 +627,27 @@ void EnGinkoMan_Update(Actor* thisx, GlobalContext* globalCtx) {
 }
 
 s32 EnGinkoMan_OverrideLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3f* pos, Vec3s* rot,
-                                Actor* thisx) {
-    EnGinkoMan* this = THIS;
+                                Actor* arg) {
+    EnGinkoMan* this = (EnGinkoMan*)arg;
 
     if (limbIndex == 15) {
         *dList = D_0600B1D8;
     }
 
     if (limbIndex == 15) {
-        SysMatrix_InsertTranslation(1500.0f, 0.0f, 0.0f, 1);
-        SysMatrix_InsertXRotation_s(this->limb15Rot.y, 1);
-        SysMatrix_InsertZRotation_s(this->limb15Rot.x, 1);
-        SysMatrix_InsertTranslation(-1500.0f, 0.0f, 0.0f, 1);
+        Matrix_InsertTranslation(1500.0f, 0.0f, 0.0f, MTXMODE_APPLY);
+        Matrix_InsertXRotation_s(this->limb15Rot.y, 1);
+        Matrix_InsertZRotation_s(this->limb15Rot.x, 1);
+        Matrix_InsertTranslation(-1500.0f, 0.0f, 0.0f, MTXMODE_APPLY);
     } else if (limbIndex == 8) {
-        SysMatrix_InsertXRotation_s(-this->limb8Rot.y, 1);
-        SysMatrix_InsertZRotation_s(-this->limb8Rot.x, 1);
+        Matrix_InsertXRotation_s(-this->limb8Rot.y, 1);
+        Matrix_InsertZRotation_s(-this->limb8Rot.x, 1);
     }
 
     return 0;
 }
 
-void EnGinkoMan_PostLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3s* rot, Actor* thisx) {
+void EnGinkoMan_PostLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3s* rot, Actor* arg) {
 }
 
 void EnGinkoMan_Draw(Actor* thisx, GlobalContext* globalCtx) {
@@ -663,8 +661,8 @@ void EnGinkoMan_Draw(Actor* thisx, GlobalContext* globalCtx) {
     gSPSegment(POLY_OPA_DISP++, 0x09, Gfx_EnvColor(globalCtx->state.gfxCtx, 50, 80, 0, 0));
     gDPPipeSync(POLY_OPA_DISP++);
 
-    SkelAnime_DrawSV(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl, this->skelAnime.dListCount,
-                     &EnGinkoMan_OverrideLimbDraw, &EnGinkoMan_PostLimbDraw, &this->actor);
+    SkelAnime_DrawFlexOpa(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable, this->skelAnime.dListCount,
+                          EnGinkoMan_OverrideLimbDraw, EnGinkoMan_PostLimbDraw, &this->actor);
 
     CLOSE_DISPS(globalCtx->state.gfxCtx);
 }
diff --git a/src/overlays/actors/ovl_En_Ginko_Man/z_en_ginko_man.h b/src/overlays/actors/ovl_En_Ginko_Man/z_en_ginko_man.h
index ce992c0b3..e605be1d6 100644
--- a/src/overlays/actors/ovl_En_Ginko_Man/z_en_ginko_man.h
+++ b/src/overlays/actors/ovl_En_Ginko_Man/z_en_ginko_man.h
@@ -11,8 +11,8 @@ typedef struct EnGinkoMan {
     /* 0x000 */ Actor actor;
     /* 0x144 */ SkelAnime skelAnime;
     /* 0x188 */ EnGinkoManActionFunc actionFunc;
-    /* 0x18C */ Vec3s limbDrawTbl[0x10];
-    /* 0x1EC */ Vec3s transitionDrawTbl[0x10];
+    /* 0x18C */ Vec3s jointTable[0x10];
+    /* 0x1EC */ Vec3s morphTable[0x10];
     /* 0x24C */ Vec3s limb15Rot;
     /* 0x252 */ Vec3s limb8Rot;
     /* 0x258 */ s16 curTextId;
diff --git a/src/overlays/actors/ovl_En_Guruguru/z_en_guruguru.c b/src/overlays/actors/ovl_En_Guruguru/z_en_guruguru.c
index b87748b8a..71e0c8cd0 100644
--- a/src/overlays/actors/ovl_En_Guruguru/z_en_guruguru.c
+++ b/src/overlays/actors/ovl_En_Guruguru/z_en_guruguru.c
@@ -80,7 +80,7 @@ void EnGuruguru_Init(Actor* thisx, GlobalContext* globalCtx) {
 
     this->actor.colChkInfo.mass = MASS_IMMOVABLE;
     ActorShape_Init(&this->actor.shape, 0.0f, func_800B3FC0, 19.0f);
-    SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_06006C90, &D_06000B04, this->jointTable, this->morphTable, 16);
+    SkelAnime_InitFlex(globalCtx, &this->skelAnime, &D_06006C90, &D_06000B04, this->jointTable, this->morphTable, 16);
     this->actor.targetMode = 0;
     if (this->actor.params != 2) {
         Collider_InitAndSetCylinder(globalCtx, &this->collider, &this->actor, &sCylinderInit);
@@ -112,9 +112,9 @@ void EnGuruguru_Destroy(Actor* thisx, GlobalContext* globalCtx) {
 }
 
 void EnGuruguru_ChangeAnimation(EnGuruguru* this, s32 arg1) {
-    this->frameCount = SkelAnime_GetFrameCount(&D_80BC79CC[arg1]->common);
-    SkelAnime_ChangeAnim(&this->skelAnime, D_80BC79CC[arg1], D_80BC79D8[arg1], 0.0f, this->frameCount, D_80BC79D4[arg1],
-                         -4.0f);
+    this->frameCount = Animation_GetLastFrame(D_80BC79CC[arg1]);
+    Animation_Change(&this->skelAnime, D_80BC79CC[arg1], D_80BC79D8[arg1], 0.0f, this->frameCount, D_80BC79D4[arg1],
+                     -4.0f);
 }
 
 void EnGuruguru_DoNothing(EnGuruguru* this, GlobalContext* globalCtx) {
@@ -152,7 +152,7 @@ void func_80BC6F14(EnGuruguru* this, GlobalContext* globalCtx) {
     s16 yaw;
     s16 yawTemp;
 
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     if (this->unk270 != 0) {
         Player* player = GET_PLAYER(globalCtx);
 
@@ -194,7 +194,7 @@ void func_80BC7068(EnGuruguru* this, GlobalContext* globalCtx) {
     Player* player = GET_PLAYER(globalCtx);
 
     if (this->unk268 != 0) {
-        SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+        SkelAnime_Update(&this->skelAnime);
     } else if (this->unusedTimer == 0) {
         this->unusedTimer = 6;
         if (func_80152498(&globalCtx->msgCtx) != 5) {
@@ -262,11 +262,11 @@ void func_80BC7068(EnGuruguru* this, GlobalContext* globalCtx) {
                 this->texIndex = 1;
             }
             if ((this->unk268 != 0) && (this->textIdIndex >= 7)) {
-                this->skelAnime.animPlaybackSpeed = 2.0f;
+                this->skelAnime.playSpeed = 2.0f;
                 func_801A29D4(3, 1.18921f, 2);
                 func_801A3B48(0);
             } else {
-                if (this->skelAnime.animPlaybackSpeed == 2.0f) {
+                if (this->skelAnime.playSpeed == 2.0f) {
                     func_801A29D4(3, 1.0f, 2);
                 }
                 if (this->unk268 == 0) {
@@ -274,7 +274,7 @@ void func_80BC7068(EnGuruguru* this, GlobalContext* globalCtx) {
                 } else {
                     func_801A3B48(0);
                 }
-                this->skelAnime.animPlaybackSpeed = 1.0f;
+                this->skelAnime.playSpeed = 1.0f;
             }
             this->unk266 = 1;
             func_80151938(globalCtx, textIDs[this->textIdIndex]);
@@ -295,7 +295,7 @@ void func_80BC73F4(EnGuruguru* this) {
 }
 
 void func_80BC7440(EnGuruguru* this, GlobalContext* globalCtx) {
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     if (Actor_HasParent(&this->actor, globalCtx)) {
         this->actor.parent = NULL;
         this->textIdIndex++;
@@ -311,7 +311,7 @@ void func_80BC7440(EnGuruguru* this, GlobalContext* globalCtx) {
 }
 
 void func_80BC7520(EnGuruguru* this, GlobalContext* globalCtx) {
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     if (func_800B84D0(&this->actor, globalCtx)) {
         this->actionFunc = func_80BC7068;
     } else {
@@ -394,7 +394,7 @@ void EnGuruguru_Draw(Actor* thisx, GlobalContext* globalCtx) {
     func_8012C2DC(globalCtx->state.gfxCtx);
     gSPSegment(POLY_OPA_DISP++, 0x08, SEGMENTED_TO_VIRTUAL(sEyeTextures[this->texIndex]));
     gSPSegment(POLY_OPA_DISP++, 0x09, SEGMENTED_TO_VIRTUAL(sMouthTextures[this->texIndex]));
-    SkelAnime_DrawSV(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl, this->skelAnime.dListCount,
-                     EnGuruguru_OverrideLimbDraw, NULL, &this->actor);
+    SkelAnime_DrawFlexOpa(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable, this->skelAnime.dListCount,
+                          EnGuruguru_OverrideLimbDraw, NULL, &this->actor);
     CLOSE_DISPS(globalCtx->state.gfxCtx);
 }
diff --git a/src/overlays/actors/ovl_En_Hg/z_en_hg.c b/src/overlays/actors/ovl_En_Hg/z_en_hg.c
index 54c62e52d..7de50c75d 100644
--- a/src/overlays/actors/ovl_En_Hg/z_en_hg.c
+++ b/src/overlays/actors/ovl_En_Hg/z_en_hg.c
@@ -27,8 +27,8 @@ void func_80BCF6D0(EnHg* this, GlobalContext* globalCtx);
 void func_80BCF8A0(EnHg* this, GlobalContext* globalCtx);
 void func_80BCF93C(EnHg* this);
 void func_80BCF95C(EnHg* this, GlobalContext* globalCtx);
-s32 EnHg_OverrideLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3f* pos, Vec3s* rot, Actor* thisx);
-void EnHg_PostLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3s* rot, Actor* thisx);
+s32 EnHg_OverrideLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3f* pos, Vec3s* rot, Actor* arg);
+void EnHg_PostLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3s* rot, Actor* arg);
 
 extern AnimationHeader D_06000370;
 extern AnimationHeader D_06001138;
@@ -127,8 +127,8 @@ void EnHg_Init(Actor* thisx, GlobalContext* globalCtx) {
     s32 i;
 
     ActorShape_Init(&this->actor.shape, 0.0f, NULL, 36.0f);
-    SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_06008580, &D_0600260C, this->limbDrawTbl, this->transitionDrawTbl,
-                     HG_LIMB_MAX);
+    SkelAnime_InitFlex(globalCtx, &this->skelAnime, &D_06008580, &D_0600260C, this->jointTable, this->morphTable,
+                       HG_LIMB_MAX);
     Collider_InitCylinder(globalCtx, &this->collider);
     Collider_SetCylinder(globalCtx, &this->collider, &this->actor, &sCylinderInit);
     CollisionCheck_SetInfo2(&this->actor.colChkInfo, &sDamageTable, &sColChkInfoInit2);
@@ -183,8 +183,8 @@ void func_80BCF4AC(EnHg* this, GlobalContext* globalCtx) {
 
     this->actor.speedXZ = 1.6f;
     if (!(player->stateFlags2 & 0x08000000) && !func_80152498(&globalCtx->msgCtx)) {
-        if (((this->skelAnime.animCurrentFrame > 9.0f) && (this->skelAnime.animCurrentFrame < 16.0f)) ||
-            ((this->skelAnime.animCurrentFrame > 44.0f) && (this->skelAnime.animCurrentFrame < 51.0f))) {
+        if (((this->skelAnime.curFrame > 9.0f) && (this->skelAnime.curFrame < 16.0f)) ||
+            ((this->skelAnime.curFrame > 44.0f) && (this->skelAnime.curFrame < 51.0f))) {
             Actor_SetVelocityAndMoveYRotationAndGravity(&this->actor);
             Math_SmoothStepToS(&this->actor.shape.rot.y, this->actor.yawTowardsPlayer, 5, 0x3E8, 0x14);
             this->actor.world.rot.y = this->actor.shape.rot.y;
@@ -215,7 +215,7 @@ void func_80BCF68C(EnHg* this) {
 }
 
 void func_80BCF6D0(EnHg* this, GlobalContext* globalCtx) {
-    if (func_801378B8(&this->skelAnime, this->skelAnime.animFrameCount)) {
+    if (Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame)) {
         func_80BCF5F0(this);
     }
 }
@@ -283,7 +283,7 @@ void func_80BCF95C(EnHg* this, GlobalContext* globalCtx) {
             this->cutscenes[3] = globalCtx->csCtx.npcActions[actionIndex]->unk0;
             switch (globalCtx->csCtx.npcActions[actionIndex]->unk0) {
                 case 1:
-                    this->currentAnimation = NULL;
+                    this->currentAnimation = 0;
                     func_800BDC5C(&this->skelAnime, sAnimations, 0);
                     break;
                 case 2:
@@ -314,7 +314,7 @@ void func_80BCF95C(EnHg* this, GlobalContext* globalCtx) {
                     break;
             }
         } else {
-            if (func_801378B8(&this->skelAnime, this->skelAnime.animFrameCount)) {
+            if (Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame)) {
                 switch (this->currentAnimation) {
                     case 3:
                         this->currentAnimation = 4;
@@ -393,7 +393,7 @@ void EnHg_Update(Actor* thisx, GlobalContext* globalCtx) {
     EnHg* this = THIS;
 
     this->actionFunc(this, globalCtx);
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     func_80BCF7D8(this, globalCtx);
     func_80BCFC0C(this, globalCtx);
     Actor_UpdateBgCheckInfo(globalCtx, &this->actor, 30.0f, 25.0f, 0.0f, 5);
@@ -407,9 +407,9 @@ s32 EnHg_OverrideLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList,
 void EnHg_PostLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3s* rot, Actor* thisx) {
     EnHg* this = THIS;
     if (limbIndex == HG_LIMB_HEAD) {
-        SysMatrix_CopyCurrentState(&this->unk1D8);
+        Matrix_CopyCurrentState(&this->unk1D8);
     } else if (limbIndex == HG_LIMB_PELVIS) {
-        SysMatrix_GetStateTranslation(&this->actor.focus.pos);
+        Matrix_GetStateTranslation(&this->actor.focus.pos);
     }
 }
 
@@ -418,9 +418,9 @@ void EnHg_Draw(Actor* thisx, GlobalContext* globalCtx) {
 
     OPEN_DISPS(globalCtx->state.gfxCtx);
     func_8012C28C(globalCtx->state.gfxCtx);
-    SkelAnime_DrawSV(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl, this->skelAnime.dListCount,
-                     EnHg_OverrideLimbDraw, EnHg_PostLimbDraw, &this->actor);
-    SysMatrix_SetCurrentState(&this->unk1D8);
+    SkelAnime_DrawFlexOpa(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable, this->skelAnime.dListCount,
+                          EnHg_OverrideLimbDraw, EnHg_PostLimbDraw, &this->actor);
+    Matrix_SetCurrentState(&this->unk1D8);
     gSPMatrix(POLY_OPA_DISP++, Matrix_NewMtx(globalCtx->state.gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
     gSPDisplayList(POLY_OPA_DISP++, D_06005E28);
     CLOSE_DISPS(globalCtx->state.gfxCtx);
diff --git a/src/overlays/actors/ovl_En_Hg/z_en_hg.h b/src/overlays/actors/ovl_En_Hg/z_en_hg.h
index e6825ea45..489db0afb 100644
--- a/src/overlays/actors/ovl_En_Hg/z_en_hg.h
+++ b/src/overlays/actors/ovl_En_Hg/z_en_hg.h
@@ -38,8 +38,8 @@ typedef struct EnHg {
     /* 0x1D8 */ MtxF unk1D8;
     /* 0x218 */ s32 unk218;
     /* 0x21C */ s32 currentAnimation;
-    /* 0x220 */ Vec3s limbDrawTbl[HG_LIMB_MAX];
-    /* 0x292 */ Vec3s transitionDrawTbl[HG_LIMB_MAX];
+    /* 0x220 */ Vec3s jointTable[HG_LIMB_MAX];
+    /* 0x292 */ Vec3s morphTable[HG_LIMB_MAX];
     /* 0x304 */ UNK_TYPE1 pad304[0xC];
     /* 0x310 */ u16 cutscenes[4];
 } EnHg; // size = 0x318
diff --git a/src/overlays/actors/ovl_En_Holl/z_en_holl.c b/src/overlays/actors/ovl_En_Holl/z_en_holl.c
index ad9e4e873..b2e0a09d9 100644
--- a/src/overlays/actors/ovl_En_Holl/z_en_holl.c
+++ b/src/overlays/actors/ovl_En_Holl/z_en_holl.c
@@ -330,7 +330,7 @@ void EnHoll_Draw(Actor* thisx, GlobalContext* globalCtx) {
         }
         dl = Gfx_CallSetupDL(dl, dlIndex);
         if (this->playerSide == EN_HOLL_BEHIND) {
-            SysMatrix_InsertYRotation_f(M_PI, MTXMODE_APPLY);
+            Matrix_InsertYRotation_f(M_PI, MTXMODE_APPLY);
         }
         gSPMatrix(dl++, Matrix_NewMtx(globalCtx->state.gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
         gDPSetPrimColor(dl++, 0, 0, 0, 0, 0, this->alpha);
diff --git a/src/overlays/actors/ovl_En_In/z_en_in.c b/src/overlays/actors/ovl_En_In/z_en_in.c
index e3b34d19f..fe421558f 100644
--- a/src/overlays/actors/ovl_En_In/z_en_in.c
+++ b/src/overlays/actors/ovl_En_In/z_en_in.c
@@ -199,11 +199,11 @@ s32 func_808F30B0(SkelAnime* skelAnime, s16 animIndex) {
         ret = true;
         frameCount = sAnimations[animIndex].frameCount;
         if (frameCount < 0) {
-            frameCount = SkelAnime_GetFrameCount(&sAnimations[animIndex].animationSeg->common);
+            frameCount = Animation_GetLastFrame(sAnimations[animIndex].animationSeg);
         }
-        SkelAnime_ChangeAnim(skelAnime, sAnimations[animIndex].animationSeg, sAnimations[animIndex].playbackSpeed,
-                             sAnimations[animIndex].frame, frameCount, sAnimations[animIndex].mode,
-                             sAnimations[animIndex].transitionRate);
+        Animation_Change(skelAnime, sAnimations[animIndex].animationSeg, sAnimations[animIndex].playbackSpeed,
+                         sAnimations[animIndex].frame, frameCount, sAnimations[animIndex].mode,
+                         sAnimations[animIndex].transitionRate);
     }
     return ret;
 }
@@ -279,7 +279,7 @@ void func_808F3414(EnIn* this, GlobalContext* globalCtx) {
     Vec3f sp30;
 
     if (this->unk23D == 0) {
-        this->unk494 = SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+        this->unk494 = SkelAnime_Update(&this->skelAnime);
     }
     if (func_8013D5E8(this->actor.shape.rot.y, 0x2710, this->actor.yawTowardsPlayer)) {
         sp30.x = player->actor.world.pos.x;
@@ -346,8 +346,8 @@ void func_808F374C(EnIn* this, GlobalContext* globalCtx) {
     AnimationHeader* animations[] = { &D_06015E38, &D_06016A60, &D_060177AC, &D_06016484,
                                       &D_060170DC, &D_06018240, &D_060187C8, &D_060198A8 };
 
-    if (this->skelAnime.animCurrentSeg == &D_06016484 || this->skelAnime.animCurrentSeg == &D_060170DC) {
-        if (func_801378B8(&this->skelAnime, 8.0f)) {
+    if (this->skelAnime.animation == &D_06016484 || this->skelAnime.animation == &D_060170DC) {
+        if (Animation_OnFrame(&this->skelAnime, 8.0f)) {
             func_8019F88C(&this->actor.projectedPos, NA_SE_VO_IN_LASH_0, 2);
             if (Rand_ZeroOne() < 0.3f) {
                 func_8019F1C0(&this->actor.projectedPos, NA_SE_IT_INGO_HORSE_NEIGH);
@@ -355,13 +355,13 @@ void func_808F374C(EnIn* this, GlobalContext* globalCtx) {
             func_8019F1C0(&this->actor.projectedPos, NA_SE_IT_LASH);
         }
     }
-    if (this->skelAnime.animCurrentSeg == &D_060198A8 && func_801378B8(&this->skelAnime, 20.0f)) {
+    if (this->skelAnime.animation == &D_060198A8 && Animation_OnFrame(&this->skelAnime, 20.0f)) {
         Audio_PlayActorSound2(&this->actor, NA_SE_VO_IN_CRY_0);
     }
-    if (SkelAnime_FrameUpdateMatrix(&this->skelAnime)) {
+    if (SkelAnime_Update(&this->skelAnime)) {
         this->unk486 = this->unk488 %= 8;
-        SkelAnime_ChangeAnim(&this->skelAnime, animations[this->unk488], 1.0f, 0.0f,
-                             SkelAnime_GetFrameCount(&animations[this->unk488]->common), 2, -10.0f);
+        Animation_Change(&this->skelAnime, animations[this->unk488], 1.0f, 0.0f,
+                         Animation_GetLastFrame(animations[this->unk488]), 2, -10.0f);
     }
 }
 
@@ -1399,7 +1399,7 @@ void EnIn_Init(Actor* thisx, GlobalContext* globalCtx) {
 
     Actor_ProcessInitChain(&this->actor, sInitChain);
     ActorShape_Init(&this->actor.shape, 0.0f, func_800B3FC0, 30.0f);
-    SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_06014EA8, NULL, this->limbDrawTbl, this->transitionDrawTbl, 20);
+    SkelAnime_InitFlex(globalCtx, &this->skelAnime, &D_06014EA8, NULL, this->jointTable, this->morphTable, 20);
     func_808F30B0(&this->skelAnime, 0);
     Collider_InitCylinder(globalCtx, &this->colliderCylinder);
     Collider_SetCylinder(globalCtx, &this->colliderCylinder, &this->actor, &sCylinderInit);
@@ -1415,8 +1415,7 @@ void EnIn_Init(Actor* thisx, GlobalContext* globalCtx) {
     if (type == ENIN_HORSE_RIDER_YELLOW_SHIRT || type == ENIN_HORSE_RIDER_BLUE_SHIRT) {
         ActorShape_Init(&this->actor.shape, 0.0f, NULL, 0.0f);
         this->unk488 = 1;
-        SkelAnime_ChangeAnim(&this->skelAnime, &D_06016A60, 1.0f, 0.0f, SkelAnime_GetFrameCount(&D_06016A60.common), 2,
-                             0.0f);
+        Animation_Change(&this->skelAnime, &D_06016A60, 1.0f, 0.0f, Animation_GetLastFrame(&D_06016A60), 2, 0.0f);
         Actor_SetScale(&this->actor, 0.01f);
         this->unk23C = 0;
         this->unk23D = 1;
@@ -1443,8 +1442,7 @@ void EnIn_Init(Actor* thisx, GlobalContext* globalCtx) {
                     func_808F30B0(&this->skelAnime, 4);
                 }
                 if ((gSaveContext.weekEventReg[92] & (1 | 2 | 4)) == 2) {
-                    this->skelAnime.animCurrentFrame =
-                        ((Rand_ZeroOne() * 0.6f) + 0.2f) * this->skelAnime.animFrameCount;
+                    this->skelAnime.curFrame = ((Rand_ZeroOne() * 0.6f) + 0.2f) * this->skelAnime.endFrame;
                 }
                 if (this->unk4AC & 8) {
                     this->actionFunc = func_808F39DC;
@@ -1523,7 +1521,7 @@ void func_808F6334(EnIn* this, GlobalContext* globalCtx) {
     this->unk4C4 += this->unk4C0 != 0.0f ? 40.0f : -40.0f;
     this->unk4C4 = CLAMP(this->unk4C4, 0.0f, 80.0f);
 
-    SysMatrix_InsertTranslation(this->unk4C4, 0.0f, 0.0f, MTXMODE_APPLY);
+    Matrix_InsertTranslation(this->unk4C4, 0.0f, 0.0f, MTXMODE_APPLY);
     if (this == (EnIn*)player->targetActor &&
         !(globalCtx->msgCtx.unk11F04 >= 0xFF && globalCtx->msgCtx.unk11F04 <= 0x200) && newUnk4C8 == 3 &&
         this->unk4C8 == 3) {
@@ -1536,8 +1534,8 @@ void func_808F6334(EnIn* this, GlobalContext* globalCtx) {
     this->unk4C8 = newUnk4C8;
 }
 
-s32 EnIn_OverrideLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3f* pos, Vec3s* rot, Actor* thisx) {
-    EnIn* this = THIS;
+s32 EnIn_OverrideLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3f* pos, Vec3s* rot, Actor* arg) {
+    EnIn* this = (EnIn*)arg;
     s32 pad;
     Gfx* sp50[] = {
         NULL,       NULL,       D_060149A8, D_06014AE0, D_06014C30, D_060145D8, D_06014710,
@@ -1565,15 +1563,15 @@ s32 EnIn_OverrideLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList,
     CLOSE_DISPS(globalCtx->state.gfxCtx);
 
     if (limbIndex == 16) {
-        SysMatrix_InsertTranslation(1500.0f, 0.0f, 0.0f, MTXMODE_APPLY);
-        SysMatrix_InsertXRotation_s(this->unk35A, MTXMODE_APPLY);
-        SysMatrix_InsertZRotation_s(-this->unk358, MTXMODE_APPLY);
-        SysMatrix_InsertTranslation(-1500.0f, 0.0f, 0.0f, MTXMODE_APPLY);
+        Matrix_InsertTranslation(1500.0f, 0.0f, 0.0f, MTXMODE_APPLY);
+        Matrix_InsertXRotation_s(this->unk35A, MTXMODE_APPLY);
+        Matrix_InsertZRotation_s(-this->unk358, MTXMODE_APPLY);
+        Matrix_InsertTranslation(-1500.0f, 0.0f, 0.0f, MTXMODE_APPLY);
         func_808F6334(this, globalCtx);
     }
     if (limbIndex == 9) {
         Matrix_RotateY(this->unk360, MTXMODE_APPLY);
-        SysMatrix_InsertXRotation_s(this->unk35E, MTXMODE_APPLY);
+        Matrix_InsertXRotation_s(this->unk35E, MTXMODE_APPLY);
     }
     if (limbIndex == 9 || limbIndex == 10 || limbIndex == 13) {
         rot->y += (s16)(Math_SinS(this->unk376[limbIndex]) * 200.0f);
@@ -1597,22 +1595,22 @@ s32 EnIn_OverrideLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList,
     return 0;
 }
 
-void EnIn_PostLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3s* rot, Actor* thisx) {
-    EnIn* this = THIS;
+void EnIn_PostLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3s* rot, Actor* arg) {
+    EnIn* this = (EnIn*)arg;
     Vec3f sp50 = { 1600.0f, 0.0f, 0.0f };
     Vec3f sp44 = { 0.0f, 0.0f, 0.0f };
 
     if (limbIndex == 16) {
-        SysMatrix_MultiplyVector3fByState(&sp50, &this->unk4B4);
+        Matrix_MultiplyVector3fByState(&sp50, &this->unk4B4);
         Math_Vec3f_Copy(&this->actor.focus.pos, &this->unk4B4);
     }
     if (this->unk23D == 0) {
         Collider_UpdateSpheres(limbIndex, &this->colliderJntSph);
         if (limbIndex == 4) {
-            SysMatrix_MultiplyVector3fByState(&sp44, &this->unk248);
+            Matrix_MultiplyVector3fByState(&sp44, &this->unk248);
         }
         if (limbIndex == 7) {
-            SysMatrix_MultiplyVector3fByState(&sp44, &this->unk254);
+            Matrix_MultiplyVector3fByState(&sp44, &this->unk254);
         }
         if (this->unk23C == 0) {
             if (!(this->unk4AC & 8)) {
@@ -1642,7 +1640,7 @@ void EnIn_Draw(Actor* thisx, GlobalContext* globalCtx) {
     OPEN_DISPS(globalCtx->state.gfxCtx);
     func_8012C28C(globalCtx->state.gfxCtx);
     gDPPipeSync(POLY_OPA_DISP++);
-    SkelAnime_DrawSV(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl, this->skelAnime.dListCount,
-                     EnIn_OverrideLimbDraw, EnIn_PostLimbDraw, &this->actor);
+    SkelAnime_DrawFlexOpa(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable, this->skelAnime.dListCount,
+                          EnIn_OverrideLimbDraw, EnIn_PostLimbDraw, &this->actor);
     CLOSE_DISPS(globalCtx->state.gfxCtx);
 }
diff --git a/src/overlays/actors/ovl_En_In/z_en_in.h b/src/overlays/actors/ovl_En_In/z_en_in.h
index e874ced5d..ca67df431 100644
--- a/src/overlays/actors/ovl_En_In/z_en_in.h
+++ b/src/overlays/actors/ovl_En_In/z_en_in.h
@@ -34,8 +34,8 @@ typedef struct EnIn {
     /* 0x254 */ Vec3f unk254;
     /* 0x260 */ u8 unk260;
     /* 0x261 */ u8 unk261;
-    /* 0x262 */ Vec3s limbDrawTbl[20];
-    /* 0x2DA */ Vec3s transitionDrawTbl[20];
+    /* 0x262 */ Vec3s jointTable[20];
+    /* 0x2DA */ Vec3s morphTable[20];
     /* 0x352 */ s16 unk352;
     /* 0x354 */ s16 unk354;
     /* 0x356 */ char unk356[0x2];
diff --git a/src/overlays/actors/ovl_En_Invadepoh/z_en_invadepoh.c b/src/overlays/actors/ovl_En_Invadepoh/z_en_invadepoh.c
index a6aaa90c4..42b9a6c91 100644
--- a/src/overlays/actors/ovl_En_Invadepoh/z_en_invadepoh.c
+++ b/src/overlays/actors/ovl_En_Invadepoh/z_en_invadepoh.c
@@ -325,7 +325,7 @@ static Gfx* D_80B4E984[] = {
 
 static s8 D_80B4E994 = 0;
 
-static s8 D_80B4E998 = NULL;
+static s8 D_80B4E998 = 0;
 
 static s8 D_80B4E99C[] = { 0 };
 
@@ -1369,7 +1369,7 @@ void func_80B454BC(EnInvadepoh* this, GlobalContext* globalCtx) {
 }
 
 void EnInvadepoh_SetSysMatrix(Vec3f* vec) {
-    MtxF* sysMatrix = SysMatrix_GetCurrentState();
+    MtxF* sysMatrix = Matrix_GetCurrentState();
 
     sysMatrix->wx = vec->x;
     sysMatrix->wy = vec->y;
@@ -2160,7 +2160,7 @@ void func_80B474DC(EnInvadepoh* this, GlobalContext* globalCtx) {
 }
 
 void func_80B47568(EnInvadepoh* this) {
-    SkelAnime_ChangeAnimTransitionRepeat(&this->skelAnime, &D_06001D80, -6.0f);
+    Animation_MorphToLoop(&this->skelAnime, &D_06001D80, -6.0f);
     this->collider.base.atFlags &= ~0x1;
     this->collider.base.acFlags &= ~0x1;
     this->collider.base.ocFlags1 &= ~0x1;
@@ -2202,8 +2202,8 @@ void func_80B47600(EnInvadepoh* this, GlobalContext* globalCtx) {
 }
 
 void func_80B4770C(EnInvadepoh* this) {
-    if (this->skelAnime.animCurrentSeg != &D_06001D80) {
-        SkelAnime_ChangeAnimTransitionRepeat(&this->skelAnime, &D_06001D80, -6.0f);
+    if (this->skelAnime.animation != &D_06001D80) {
+        Animation_MorphToLoop(&this->skelAnime, &D_06001D80, -6.0f);
     }
     this->collider.base.atFlags |= 1;
     this->collider.base.acFlags |= 1;
@@ -2231,7 +2231,7 @@ void func_80B47830(EnInvadepoh* this) {
     this->collider.base.atFlags &= ~1;
     this->collider.base.acFlags &= ~1;
     this->collider.base.ocFlags1 |= 1;
-    SkelAnime_ChangeAnimDefaultRepeat(&this->skelAnime, &D_060006C8);
+    Animation_PlayLoop(&this->skelAnime, &D_060006C8);
     func_800BCB70(&this->actor, 0x4000, 255, 0, 16);
     this->alienAlpha = 255;
     this->actor.draw = func_80B4DB14;
@@ -2256,7 +2256,7 @@ void func_80B47938(EnInvadepoh* this) {
     this->collider.base.atFlags &= ~1;
     this->collider.base.acFlags &= ~1;
     this->collider.base.ocFlags1 &= ~1;
-    SkelAnime_ChangeAnimDefaultRepeat(&this->skelAnime, &D_06000608);
+    Animation_PlayLoop(&this->skelAnime, &D_06000608);
     this->actor.flags &= ~1;
     this->actionTimer = 10;
     this->alienAlpha = 255;
@@ -2327,9 +2327,9 @@ void func_80B47BAC(Actor* thisx, GlobalContext* globalCtx) {
         Actor_SetObjectSegment(globalCtx, &this->actor);
         func_80B45080();
         this->actor.update = func_80B47D30;
-        SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_06004E50, &D_06001D80, this->limbDrawTable,
-                         this->transitionDrawTable, 14);
-        this->skelAnime.animCurrentFrame = (this->actor.params & 7) * this->skelAnime.animFrameCount * 0.125f;
+        SkelAnime_InitFlex(globalCtx, &this->skelAnime, &D_06004E50, &D_06001D80, this->jointTable, this->morphTable,
+                           14);
+        this->skelAnime.curFrame = (this->actor.params & 7) * this->skelAnime.endFrame * 0.125f;
         func_80B444BC(this, globalCtx);
         func_80B442E4(this);
         func_80B447C0(this, globalCtx);
@@ -2378,7 +2378,7 @@ void func_80B47D30(Actor* thisx, GlobalContext* globalCtx) {
 
     this->actionFunc(this, globalCtx);
     if (thisx->draw != NULL) {
-        this->animPlayFlag = SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+        this->animPlayFlag = SkelAnime_Update(&this->skelAnime);
     }
 
     Collider_UpdateCylinder(&this->actor, &this->collider);
@@ -2410,9 +2410,8 @@ void func_80B47FA8(Actor* thisx, GlobalContext* globalCtx) {
         Actor_SetObjectSegment(globalCtx, thisx);
         this->actor.update = func_80B48060;
         this->actor.draw = func_80B4E158;
-        SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_06004010, NULL, this->limbDrawTable, this->transitionDrawTable,
-                         6);
-        SkelAnime_ChangeAnimDefaultRepeat(&this->skelAnime, &D_06004264);
+        SkelAnime_InitFlex(globalCtx, &this->skelAnime, &D_06004010, NULL, this->jointTable, this->morphTable, 6);
+        Animation_PlayLoop(&this->skelAnime, &D_06004264);
     }
 }
 
@@ -2429,19 +2428,19 @@ void func_80B48060(Actor* thisx, GlobalContext* globalCtx) {
     }
 
     temp = this->actor.params & 7;
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     Math_ScaledStepToS(&this->actor.shape.rot.x, D_80B4EDC0[temp], 0x32);
     if (this->actor.child != NULL) {
-        SysMatrix_StatePush();
-        SysMatrix_SetStateRotationAndTranslation(this->actor.world.pos.x, this->actor.world.pos.y,
-                                                 this->actor.world.pos.z, &this->actor.shape.rot);
-        SysMatrix_InsertTranslation(0, 57.0f, -36.0f, MTXMODE_APPLY);
-        SysMatrix_InsertXRotation_s(this->actor.shape.rot.x * -0.7f, MTXMODE_APPLY);
-        SysMatrix_InsertZRotation_s(this->actor.shape.rot.z * -0.7f, MTXMODE_APPLY);
-        SysMatrix_GetStateTranslation(&this->actor.child->world.pos);
-        SysMatrix_CopyCurrentState(&unkMtx);
+        Matrix_StatePush();
+        Matrix_SetStateRotationAndTranslation(this->actor.world.pos.x, this->actor.world.pos.y, this->actor.world.pos.z,
+                                              &this->actor.shape.rot);
+        Matrix_InsertTranslation(0, 57.0f, -36.0f, MTXMODE_APPLY);
+        Matrix_InsertXRotation_s(this->actor.shape.rot.x * -0.7f, MTXMODE_APPLY);
+        Matrix_InsertZRotation_s(this->actor.shape.rot.z * -0.7f, MTXMODE_APPLY);
+        Matrix_GetStateTranslation(&this->actor.child->world.pos);
+        Matrix_CopyCurrentState(&unkMtx);
         func_8018219C(&unkMtx, &this->actor.child->shape.rot, 0);
-        SysMatrix_StatePop();
+        Matrix_StatePop();
     }
 }
 
@@ -2454,9 +2453,8 @@ void func_80B481C4(Actor* thisx, GlobalContext* globalCtx) {
         Actor_SetObjectSegment(globalCtx, &this->actor);
         this->actor.update = func_80B4827C;
         this->actor.draw = func_80B4E1B0;
-        SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_06004C30, NULL, this->limbDrawTable, this->transitionDrawTable,
-                         6);
-        SkelAnime_ChangeAnimDefaultRepeat(&this->skelAnime, &D_06004E98);
+        SkelAnime_InitFlex(globalCtx, &this->skelAnime, &D_06004C30, NULL, this->jointTable, this->morphTable, 6);
+        Animation_PlayLoop(&this->skelAnime, &D_06004E98);
     }
 }
 
@@ -2468,12 +2466,12 @@ void func_80B4827C(Actor* thisx, GlobalContext* globalCtx) {
         return;
     }
 
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
 }
 
 void func_80B482D4(EnInvadepoh* this) {
     this->actionTimer = 40;
-    SkelAnime_ChangeAnimTransitionRepeat(&this->skelAnime, &D_06002A8C, -10.0f);
+    Animation_MorphToLoop(&this->skelAnime, &D_06002A8C, -10.0f);
     this->actor.draw = NULL;
     this->actionFunc = func_80B48324;
 }
@@ -2489,7 +2487,7 @@ void func_80B48324(EnInvadepoh* this, GlobalContext* globalCtx) {
 
 void func_80B48374(EnInvadepoh* this) {
     this->actionTimer = 60;
-    SkelAnime_ChangeAnimTransitionRepeat(&this->skelAnime, &D_06002A8C, -10.0f);
+    Animation_MorphToLoop(&this->skelAnime, &D_06002A8C, -10.0f);
     this->actor.draw = func_80B4E324;
     this->actionFunc = func_80B483CC;
 }
@@ -2521,7 +2519,7 @@ void func_80B4843C(EnInvadepoh* this) {
     this->behaviorInfo.unk44 = 0.1f;
     this->behaviorInfo.unk48 = 2000;
     this->actionTimer = 50;
-    SkelAnime_ChangeAnim(&this->skelAnime, &D_06007328, 2.0f, 0.0f, 0.0f, 0, -5.0f);
+    Animation_Change(&this->skelAnime, &D_06007328, 2.0f, 0.0f, 0.0f, 0, -5.0f);
     this->actor.draw = func_80B4E324;
     this->actionFunc = func_80B484EC;
 }
@@ -2551,7 +2549,7 @@ void func_80B48588(EnInvadepoh* this) {
     this->behaviorInfo.unk42 = 0;
     this->behaviorInfo.unk44 = 0.28f;
     this->behaviorInfo.unk48 = 7000;
-    SkelAnime_ChangeAnimTransitionStop(&this->skelAnime, &D_06009E58, -10.0f);
+    Animation_MorphToPlayOnce(&this->skelAnime, &D_06009E58, -10.0f);
     this->actor.draw = func_80B4E324;
     this->actionFunc = func_80B48610;
 }
@@ -2568,10 +2566,10 @@ void func_80B48620(Actor* thisx, GlobalContext* globalCtx) {
         Actor_SetObjectSegment(globalCtx, &this->actor);
         func_80B44F58();
         this->actor.update = func_80B4873C;
-        SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_06013928, &D_06009E58, this->limbDrawTable,
-                         this->transitionDrawTable, 23);
+        SkelAnime_InitFlex(globalCtx, &this->skelAnime, &D_06013928, &D_06009E58, this->jointTable, this->morphTable,
+                           23);
         func_80B45C04(&this->behaviorInfo, D_80B4EA90, 6, D_80B4EB00, 2, &D_801D15BC, 5000, 0.05f, 0.3f, 0.12f);
-        SkelAnime_ChangeAnimDefaultRepeat(&this->skelAnime, &D_06009E58);
+        Animation_PlayLoop(&this->skelAnime, &D_06009E58);
         func_80B482D4(this);
     }
 }
@@ -2586,7 +2584,7 @@ void func_80B4873C(Actor* thisx, GlobalContext* globalCtx) {
         return;
     }
     this->actionFunc(this, globalCtx);
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     func_80B45CE0(substruct);
     if (substruct->unk40 != 0) {
         this->actor.shape.rot.x = -substruct->unk40;
@@ -2604,7 +2602,7 @@ void func_80B487B4(EnInvadepoh* this) {
     substruct->unk26.z = 0;
     substruct->unk30 = 0.1f;
     substruct->unk2C = 800;
-    SkelAnime_ChangeAnimTransitionRepeat(&this->skelAnime, &D_06014088, -10.0f);
+    Animation_MorphToLoop(&this->skelAnime, &D_06014088, -10.0f);
     this->actionFunc = func_80B48848;
 }
 
@@ -2621,7 +2619,7 @@ void func_80B48848(EnInvadepoh* this, GlobalContext* globalCtx) {
     }
     func_80B43E6C(this, 6, this->behaviorInfo.unk4C, 0x46);
     if (((this->actor.flags & 0x40) == 0x40) &&
-        (func_801378B8(&this->skelAnime, 0.0f) || func_801378B8(&this->skelAnime, 7.0f))) {
+        (Animation_OnFrame(&this->skelAnime, 0.0f) || Animation_OnFrame(&this->skelAnime, 7.0f))) {
         Audio_PlayActorSound2(&this->actor, NA_SE_EN_ROMANI_WALK);
     }
     if (this->actionTimer > 0) {
@@ -2664,7 +2662,7 @@ void func_80B48948(EnInvadepoh* this) {
         substruct->unk2C = 1000;
     }
 
-    SkelAnime_ChangeAnimTransitionRepeat(&this->skelAnime, &D_06009E58, -10.0f);
+    Animation_MorphToLoop(&this->skelAnime, &D_06009E58, -10.0f);
     this->actionFunc = func_80B48AD4;
 }
 
@@ -2735,7 +2733,7 @@ void func_80B48DE4(EnInvadepoh* this) {
     AlienBehaviorInfo* substruct = &this->behaviorInfo;
 
     this->actor.speedXZ = 0.0f;
-    SkelAnime_ChangeAnimTransitionRepeat(&this->skelAnime, &D_06009E58, -10.0f);
+    Animation_MorphToLoop(&this->skelAnime, &D_06009E58, -10.0f);
     this->behaviorInfo.unk4C = 0;
     substruct->unk30 = 0.05f;
     substruct->unk2C = 1200;
@@ -2772,8 +2770,8 @@ void func_80B48FB0(Actor* thisx, GlobalContext* globalCtx) {
         this->actor.update = func_80B490F0;
         this->actor.draw = func_80B4E324;
         this->actor.textId = 0x3330;
-        SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_06013928, &D_06009E58, this->limbDrawTable,
-                         this->transitionDrawTable, 23);
+        SkelAnime_InitFlex(globalCtx, &this->skelAnime, &D_06013928, &D_06009E58, this->jointTable, this->morphTable,
+                           23);
         func_80B45C04(&this->behaviorInfo, D_80B4EA90, 6, D_80B4EB00, 2, &D_801D15BC, 100, 0.03, 0.3, 0.03);
         func_80B444F4(this, globalCtx);
         EnInvadepoh_SetPathPointToWorldPos(this, 0);
@@ -2795,7 +2793,7 @@ void func_80B490F0(Actor* thisx, GlobalContext* globalCtx) {
     }
     this->actionFunc(this, globalCtx);
     if (sp2C) {
-        SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+        SkelAnime_Update(&this->skelAnime);
         func_80B45CE0(&this->behaviorInfo);
         if ((this->actionFunc != func_80B48E4C) && !isTalking && this->actor.isTargeted) {
             func_800B8614(&this->actor, globalCtx, 100.0f);
@@ -3042,7 +3040,7 @@ void func_80B49B1C(Actor* thisx, GlobalContext* globalCtx) {
 void func_80B49BD0(EnInvadepoh* this) {
     AlienBehaviorInfo* substruct = &this->behaviorInfo;
 
-    SkelAnime_ChangeAnimTransitionRepeat(&this->skelAnime, &D_06014088, -10.0f);
+    Animation_MorphToLoop(&this->skelAnime, &D_06014088, -10.0f);
     substruct->unk26.x = 0;
     substruct->unk26.y = 0;
     substruct->unk26.z = 0;
@@ -3074,7 +3072,7 @@ void func_80B49C38(EnInvadepoh* this, GlobalContext* globalCtx) {
     }
 
     if (((this->actor.flags & 0x40) == 0x40) &&
-        (func_801378B8(&this->skelAnime, 0.0f) || func_801378B8(&this->skelAnime, 7.0f))) {
+        (Animation_OnFrame(&this->skelAnime, 0.0f) || Animation_OnFrame(&this->skelAnime, 7.0f))) {
         Audio_PlayActorSound2(&this->actor, NA_SE_EN_ROMANI_WALK);
     }
     if (this->clockTime >= 0.9999f) {
@@ -3086,7 +3084,7 @@ void func_80B49DA0(EnInvadepoh* this) {
     this->behaviorInfo.unk30 = 0.08f;
     this->behaviorInfo.unk2C = 2000;
     this->behaviorInfo.unk4C = 0;
-    SkelAnime_ChangeAnimTransitionRepeat(&this->skelAnime, &D_06009E58, -10.0f);
+    Animation_MorphToLoop(&this->skelAnime, &D_06009E58, -10.0f);
     this->actionFunc = func_80B49DFC;
 }
 
@@ -3124,8 +3122,8 @@ void func_80B49F88(Actor* thisx, GlobalContext* globalCtx) {
         this->actor.objBankIndex = this->bankIndex;
         Actor_SetObjectSegment(globalCtx, &this->actor);
         func_80B44F58();
-        SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_06013928, &D_06014088, this->limbDrawTable,
-                         this->transitionDrawTable, 23);
+        SkelAnime_InitFlex(globalCtx, &this->skelAnime, &D_06013928, &D_06014088, this->jointTable, this->morphTable,
+                           23);
         func_80B45C04(&this->behaviorInfo, D_80B4EA90, 1, D_80B4EB00, 1, &D_801D15BC, 100, 0.03, 0.3, 0.03);
         func_80B44540(this, globalCtx);
         func_80B44570(this);
@@ -3178,7 +3176,7 @@ void func_80B4A1B8(Actor* thisx, GlobalContext* globalCtx) {
     }
     this->actionFunc(this, globalCtx);
     if (sp2C && this->actor.update != NULL) {
-        SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+        SkelAnime_Update(&this->skelAnime);
         func_80B45CE0(&this->behaviorInfo);
         if ((this->actionFunc != func_80B49DFC) && !isTalking && this->actor.isTargeted) {
             func_800B8614(&this->actor, globalCtx, 350.0f);
@@ -3191,7 +3189,7 @@ void func_80B4A1B8(Actor* thisx, GlobalContext* globalCtx) {
 void func_80B4A2C0(EnInvadepoh* this) {
     AlienBehaviorInfo* substruct = &this->behaviorInfo;
 
-    SkelAnime_ChangeAnimTransitionRepeat(&this->skelAnime, &D_06009E58, -10.0f);
+    Animation_MorphToLoop(&this->skelAnime, &D_06009E58, -10.0f);
     substruct->unk26.x = 0;
     substruct->unk26.y = 0;
     substruct->unk26.z = 0;
@@ -3250,7 +3248,7 @@ void func_80B4A350(EnInvadepoh* this, GlobalContext* globalCtx) {
 void func_80B4A570(EnInvadepoh* this) {
     AlienBehaviorInfo* substruct = &this->behaviorInfo;
 
-    SkelAnime_ChangeAnimTransitionStop(&this->skelAnime, &D_06002A8C, -10.0f);
+    Animation_MorphToPlayOnce(&this->skelAnime, &D_06002A8C, -10.0f);
     substruct->unk26.x = 0;
     substruct->unk26.y = 0;
     substruct->unk26.z = 0;
@@ -3269,7 +3267,7 @@ void func_80B4A5E4(EnInvadepoh* this, GlobalContext* globalCtx) {
 void func_80B4A614(EnInvadepoh* this) {
     AlienBehaviorInfo* substruct = &this->behaviorInfo;
 
-    SkelAnime_ChangeAnimTransitionRepeat(&this->skelAnime, &D_06014088, 0.0f);
+    Animation_MorphToLoop(&this->skelAnime, &D_06014088, 0.0f);
     substruct->unk26.x = 0;
     substruct->unk26.y = 0;
     substruct->unk26.z = 0;
@@ -3300,7 +3298,7 @@ void func_80B4A67C(EnInvadepoh* this, GlobalContext* globalCtx) {
         this->actor.flags |= (0x8 | 0x1);
     }
     if (((this->actor.flags & 0x40) == 0x40) &&
-        (func_801378B8(&this->skelAnime, 0.0f) || func_801378B8(&this->skelAnime, 7.0f))) {
+        (Animation_OnFrame(&this->skelAnime, 0.0f) || Animation_OnFrame(&this->skelAnime, 7.0f))) {
         Audio_PlayActorSound2(&this->actor, NA_SE_EN_ROMANI_WALK);
     }
     if (this->pathIndex == this->endPoint) {
@@ -3312,7 +3310,7 @@ void func_80B4A7C0(EnInvadepoh* this) {
     this->behaviorInfo.unk30 = 0.08f;
     this->behaviorInfo.unk2C = 2000;
     this->behaviorInfo.unk4C = 0;
-    SkelAnime_ChangeAnimTransitionRepeat(&this->skelAnime, &D_06009E58, 0.0f);
+    Animation_MorphToLoop(&this->skelAnime, &D_06009E58, 0.0f);
     this->actionFunc = func_80B4A81C;
 }
 
@@ -3355,8 +3353,8 @@ void func_80B4A9C8(Actor* thisx, GlobalContext* globalCtx) {
         this->actor.objBankIndex = this->bankIndex;
         Actor_SetObjectSegment(globalCtx, &this->actor);
         func_80B44F58();
-        SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_06013928, &D_06014088, this->limbDrawTable,
-                         this->transitionDrawTable, 23);
+        SkelAnime_InitFlex(globalCtx, &this->skelAnime, &D_06013928, &D_06014088, this->jointTable, this->morphTable,
+                           23);
         func_80B45C04(&this->behaviorInfo, D_80B4EA90, 1, D_80B4EB00, 1, &D_801D15BC, 100, 0.03f, 0.3f, 0.03f);
         func_80B44620(this, globalCtx);
         if ((sp38 < CLOCK_TIME(2, 15)) || (sp38 >= CLOCK_TIME(6, 0))) {
@@ -3407,7 +3405,7 @@ void func_80B4ABDC(Actor* thisx, GlobalContext* globalCtx) {
     }
     this->actionFunc(this, globalCtx);
     if (sp2C) {
-        this->animPlayFlag = SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+        this->animPlayFlag = SkelAnime_Update(&this->skelAnime);
         func_80B45CE0(&this->behaviorInfo);
         if ((this->actionFunc != func_80B4A81C) && !isTalking && this->actor.isTargeted) {
             func_800B8614(&this->actor, globalCtx, 100.0f);
@@ -3530,9 +3528,9 @@ void func_80B4B0C4(Actor* thisx, GlobalContext* globalCtx) {
         Actor_SetObjectSegment(globalCtx, &this->actor);
         func_80B44F58();
         this->actor.update = func_80B4B218;
-        SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_06013928, &D_06014088, this->limbDrawTable,
-                         this->transitionDrawTable, 23);
-        SkelAnime_ChangeAnimTransitionRepeat(&this->skelAnime, &D_06009E58, 0.0f);
+        SkelAnime_InitFlex(globalCtx, &this->skelAnime, &D_06013928, &D_06014088, this->jointTable, this->morphTable,
+                           23);
+        Animation_MorphToLoop(&this->skelAnime, &D_06009E58, 0.0f);
         substruct = &this->behaviorInfo;
         func_80B45C04(&this->behaviorInfo, D_80B4EA90, 1, D_80B4EB00, 3, &D_801D15BC, 2000, 0.08f, 0.3f, 0.03f);
         substruct->unk30 = 0.08f;
@@ -3553,7 +3551,7 @@ void func_80B4B218(Actor* thisx, GlobalContext* globalCtx) {
 
     this->actionFunc(this, globalCtx);
     if (sp38 && this->actor.update != NULL) {
-        SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+        SkelAnime_Update(&this->skelAnime);
         player = GET_PLAYER(globalCtx);
         Math_StepToS(&this->behaviorInfo.unk4C, 2000, 40);
         Math_SmoothStepToS(&this->actor.shape.rot.y, this->actor.yawTowardsPlayer, 6, this->behaviorInfo.unk4C, 40);
@@ -3573,13 +3571,13 @@ void func_80B4B218(Actor* thisx, GlobalContext* globalCtx) {
 void func_80B4B3DC(EnInvadepoh* this) {
     s32 pad;
 
-    if (func_801378B8(&this->skelAnime, 1.0f) || func_801378B8(&this->skelAnime, 7.0f)) {
+    if (Animation_OnFrame(&this->skelAnime, 1.0f) || Animation_OnFrame(&this->skelAnime, 7.0f)) {
         Audio_PlayActorSound2(&this->actor, NA_SE_EV_MONKEY_WALK);
     }
 }
 
 void func_80B4B430(EnInvadepoh* this) {
-    SkelAnime_ChangeAnimTransitionRepeat(&this->skelAnime, &D_060021C8, -6.0f);
+    Animation_MorphToLoop(&this->skelAnime, &D_060021C8, -6.0f);
     this->actionTimer = Rand_S16Offset(50, 80);
     this->actionFunc = func_80B4B484;
 }
@@ -3602,7 +3600,7 @@ void func_80B4B484(EnInvadepoh* this, GlobalContext* globalCtx) {
 }
 
 void func_80B4B510(EnInvadepoh* this) {
-    SkelAnime_ChangeAnimTransitionRepeat(&this->skelAnime, &D_06001BD8, -6.0f);
+    Animation_MorphToLoop(&this->skelAnime, &D_06001BD8, -6.0f);
     this->actionTimer = Rand_S16Offset(50, 200);
     this->actionFunc = func_80B4B564;
 }
@@ -3646,7 +3644,7 @@ void func_80B4B564(EnInvadepoh* this, GlobalContext* globalCtx) {
 }
 
 void func_80B4B724(EnInvadepoh* this) {
-    SkelAnime_ChangeAnimTransitionStop(&this->skelAnime, &D_06000998, -6.0f);
+    Animation_MorphToPlayOnce(&this->skelAnime, &D_06000998, -6.0f);
     this->actionFunc = func_80B4B768;
 }
 
@@ -3657,7 +3655,7 @@ void func_80B4B768(EnInvadepoh* this, GlobalContext* globalCtx) {
     Math_SmoothStepToS(&this->actor.world.rot.y, Actor_YawBetweenActors(&this->actor, &D_80B5040C->actor), 5, 0x1388,
                        0x64);
     func_80B44E90(this, globalCtx);
-    if (func_801378B8(&this->skelAnime, 13.0f) || func_801378B8(&this->skelAnime, 19.0f)) {
+    if (Animation_OnFrame(&this->skelAnime, 13.0f) || Animation_OnFrame(&this->skelAnime, 19.0f)) {
         Audio_PlayActorSound2(&this->actor, NA_SE_EV_SMALL_DOG_ANG_BARK);
     }
     if (this->animPlayFlag) {
@@ -3666,7 +3664,7 @@ void func_80B4B768(EnInvadepoh* this, GlobalContext* globalCtx) {
 }
 
 void func_80B4B820(EnInvadepoh* this) {
-    SkelAnime_ChangeAnimTransitionStop(&this->skelAnime, &D_06001560, -6.0f);
+    Animation_MorphToPlayOnce(&this->skelAnime, &D_06001560, -6.0f);
     this->actionFunc = func_80B4B864;
 }
 
@@ -3685,8 +3683,8 @@ void func_80B4B8BC(Actor* thisx, GlobalContext* globalCtx) {
     if (Object_IsLoaded(&globalCtx->objectCtx, this->bankIndex)) {
         this->actor.objBankIndex = this->bankIndex;
         Actor_SetObjectSegment(globalCtx, &this->actor);
-        SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_060080F0, &D_060021C8, this->limbDrawTable,
-                         this->transitionDrawTable, 13);
+        SkelAnime_InitFlex(globalCtx, &this->skelAnime, &D_060080F0, &D_060021C8, this->jointTable, this->morphTable,
+                           13);
         func_80B45C04(&this->behaviorInfo, 0, 0, 0, 0, &D_801D15BC, 3000, 0.1f, 0.0f, 0.0f);
         func_80B44664(this, globalCtx);
         EnInvadepoh_SetPathPointToWorldPos(this, 0);
@@ -3755,7 +3753,7 @@ void func_80B4BA84(Actor* thisx, GlobalContext* globalCtx) {
     }
 
     this->actionFunc(this, globalCtx);
-    this->animPlayFlag = SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    this->animPlayFlag = SkelAnime_Update(&this->skelAnime);
     if (sp34 && (this->actor.update != NULL)) {
         func_80B45CE0(&this->behaviorInfo);
         Collider_UpdateCylinder(&this->actor, &this->collider);
@@ -3766,7 +3764,7 @@ void func_80B4BA84(Actor* thisx, GlobalContext* globalCtx) {
 void func_80B4BBE0(EnInvadepoh* this) {
     AlienBehaviorInfo* substruct = &this->behaviorInfo;
 
-    SkelAnime_ChangeAnimTransitionRepeat(&this->skelAnime, &D_06016720, -6.0f);
+    Animation_MorphToLoop(&this->skelAnime, &D_06016720, -6.0f);
     substruct->unk26.x = 0;
     substruct->unk26.y = 0;
     substruct->unk26.z = 0;
@@ -3834,7 +3832,7 @@ void func_80B4BC4C(EnInvadepoh* this, GlobalContext* globalCtx) {
     }
 
     if (((this->actor.flags & 0x40) == 0x40) &&
-        (func_801378B8(&this->skelAnime, 0.0f) || func_801378B8(&this->skelAnime, 12.0f))) {
+        (Animation_OnFrame(&this->skelAnime, 0.0f) || Animation_OnFrame(&this->skelAnime, 12.0f))) {
         Audio_PlayActorSound2(&this->actor, NA_SE_EN_ROMANI_WALK);
     }
     if (gSaveContext.time > CLOCK_TIME(20, 15)) {
@@ -3847,7 +3845,7 @@ void func_80B4BC4C(EnInvadepoh* this, GlobalContext* globalCtx) {
 void func_80B4BFFC(EnInvadepoh* this) {
     this->behaviorInfo.unk30 = 0.08f;
     this->behaviorInfo.unk2C = 2000;
-    SkelAnime_ChangeAnimTransitionRepeat(&this->skelAnime, &D_0600A174, -6.0f);
+    Animation_MorphToLoop(&this->skelAnime, &D_0600A174, -6.0f);
     this->behaviorInfo.unk4C = 0;
     this->actionFunc = func_80B4C058;
 }
@@ -3879,7 +3877,7 @@ void func_80B4C058(EnInvadepoh* this, GlobalContext* globalCtx) {
 void func_80B4C1BC(EnInvadepoh* this) {
     this->behaviorInfo.unk30 = 0.08f;
     this->behaviorInfo.unk2C = 2000;
-    SkelAnime_ChangeAnimTransitionRepeat(&this->skelAnime, &D_0600A174, -6.0f);
+    Animation_MorphToLoop(&this->skelAnime, &D_0600A174, -6.0f);
     this->behaviorInfo.unk4C = 0;
     this->actionFunc = func_80B4C218;
 }
@@ -3919,8 +3917,8 @@ void func_80B4C3A0(Actor* thisx, GlobalContext* globalCtx) {
         this->actor.objBankIndex = this->bankIndex;
         Actor_SetObjectSegment(globalCtx, &this->actor);
         func_80B44FEC();
-        SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_06015C28, &D_06016720, this->limbDrawTable,
-                         this->transitionDrawTable, 22);
+        SkelAnime_InitFlex(globalCtx, &this->skelAnime, &D_06015C28, &D_06016720, this->jointTable, this->morphTable,
+                           22);
         func_80B45C04(&this->behaviorInfo, D_80B4EBDC, 1, D_80B4EC08, 0, &D_801D15BC, 100, 0.03f, 0.3f, 0.03f);
         this->actor.textId = 0x33CD;
         if (currentTime < 0xD5A0) {
@@ -3969,7 +3967,7 @@ void func_80B4C5C0(Actor* thisx, GlobalContext* globalCtx) {
     }
     this->actionFunc(this, globalCtx);
     if (sp2C && (this->actor.update != NULL)) {
-        SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+        SkelAnime_Update(&this->skelAnime);
         func_80B45CE0(&this->behaviorInfo);
         if ((this->actionFunc != func_80B4C058) && !isTalking && this->actor.isTargeted) {
             func_800B8614(&this->actor, globalCtx, 350.0f);
@@ -3982,7 +3980,7 @@ void func_80B4C5C0(Actor* thisx, GlobalContext* globalCtx) {
 void func_80B4C6C8(EnInvadepoh* this) {
     AlienBehaviorInfo* substruct = &this->behaviorInfo;
 
-    SkelAnime_ChangeAnimTransitionRepeat(&this->skelAnime, &D_06014088, -10.0f);
+    Animation_MorphToLoop(&this->skelAnime, &D_06014088, -10.0f);
     substruct->unk26.x = 0;
     substruct->unk26.y = 0;
     substruct->unk26.z = 0;
@@ -4055,7 +4053,7 @@ void func_80B4C730(EnInvadepoh* this, GlobalContext* globalCtx) {
     }
 
     if (((this->actor.flags & 0x40) == 0x40) &&
-        (func_801378B8(&this->skelAnime, 0.0f) || func_801378B8(&this->skelAnime, 7.0f))) {
+        (Animation_OnFrame(&this->skelAnime, 0.0f) || Animation_OnFrame(&this->skelAnime, 7.0f))) {
         Audio_PlayActorSound2(&this->actor, NA_SE_EN_ROMANI_WALK);
     }
 
@@ -4072,7 +4070,7 @@ void func_80B4C730(EnInvadepoh* this, GlobalContext* globalCtx) {
 void func_80B4CAB0(EnInvadepoh* this) {
     this->behaviorInfo.unk30 = 0.08f;
     this->behaviorInfo.unk2C = 4000;
-    SkelAnime_ChangeAnimTransitionRepeat(&this->skelAnime, &D_06009E58, -10.0f);
+    Animation_MorphToLoop(&this->skelAnime, &D_06009E58, -10.0f);
     this->behaviorInfo.unk4C = 0;
     this->actionFunc = func_80B4CB0C;
 }
@@ -4101,7 +4099,7 @@ void func_80B4CB0C(EnInvadepoh* this, GlobalContext* globalCtx) {
 void func_80B4CC70(EnInvadepoh* this) {
     this->behaviorInfo.unk30 = 0.08f;
     this->behaviorInfo.unk2C = 2000;
-    SkelAnime_ChangeAnimTransitionRepeat(&this->skelAnime, &D_06009E58, -10.0f);
+    Animation_MorphToLoop(&this->skelAnime, &D_06009E58, -10.0f);
     this->behaviorInfo.unk4C = 0;
     this->actionFunc = func_80B4CCCC;
 }
@@ -4140,8 +4138,8 @@ void func_80B4CE54(Actor* thisx, GlobalContext* globalCtx) {
         this->actor.objBankIndex = this->bankIndex;
         Actor_SetObjectSegment(globalCtx, &this->actor);
         func_80B44F58();
-        SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_06013928, &D_06014088, this->limbDrawTable,
-                         this->transitionDrawTable, 23);
+        SkelAnime_InitFlex(globalCtx, &this->skelAnime, &D_06013928, &D_06014088, this->jointTable, this->morphTable,
+                           23);
         func_80B45C04(&this->behaviorInfo, D_80B4EA90, 1, D_80B4EB00, 3, &D_801D15BC, 100, 0.03f, 0.3f, 0.03f);
         func_80B446D0(this, globalCtx);
         this->actor.world.rot.y = this->actor.shape.rot.y;
@@ -4185,7 +4183,7 @@ void func_80B4D054(Actor* thisx, GlobalContext* globalCtx) {
     }
     this->actionFunc(this, globalCtx);
     if (sp2C && this->actor.update != NULL) {
-        SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+        SkelAnime_Update(&this->skelAnime);
         func_80B45CE0(&this->behaviorInfo);
         if ((this->actionFunc != func_80B4CB0C) && !isTalking && this->actor.isTargeted) {
             func_800B8614(thisx, globalCtx, 350.0f);
@@ -4200,8 +4198,8 @@ void func_80B4D15C(EnInvadepoh* this) {
     s32 temp_v1 = this->actor.params & 7;
     unkstruct80B4EE0C* temp_v0;
 
-    SkelAnime_ChangeAnimDefaultRepeat(&this->skelAnime, &D_06001674);
-    this->skelAnime.animCurrentFrame = ((this->actor.params & 7) * this->skelAnime.animFrameCount) * 0.25f;
+    Animation_PlayLoop(&this->skelAnime, &D_06001674);
+    this->skelAnime.curFrame = ((this->actor.params & 7) * this->skelAnime.endFrame) * 0.25f;
     this->alienAlpha = 255;
     this->actor.draw = func_80B4DB14;
     this->drawAlien = true;
@@ -4252,8 +4250,8 @@ void func_80B4D290(EnInvadepoh* this, GlobalContext* globalCtx) {
 }
 
 void func_80B4D3E4(EnInvadepoh* this) {
-    SkelAnime_ChangeAnimDefaultRepeat(&this->skelAnime, &D_06001674);
-    this->skelAnime.animCurrentFrame = (this->actor.params & 7) * this->skelAnime.animFrameCount * 0.25f;
+    Animation_PlayLoop(&this->skelAnime, &D_06001674);
+    this->skelAnime.curFrame = (this->actor.params & 7) * this->skelAnime.endFrame * 0.25f;
     this->alienAlpha = 255;
     this->actor.draw = NULL;
     this->drawAlien = true;
@@ -4329,8 +4327,8 @@ void func_80B4D670(Actor* thisx, GlobalContext* globalCtx) {
         Actor_SetObjectSegment(globalCtx, &this->actor);
         func_80B45080();
         this->actor.update = func_80B4D760;
-        SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_06004E50, &D_06001674, this->limbDrawTable,
-                         this->transitionDrawTable, 14);
+        SkelAnime_InitFlex(globalCtx, &this->skelAnime, &D_06004E50, &D_06001674, this->jointTable, this->morphTable,
+                           14);
         if (invadepohType < 3) {
             func_80B453F4(this, globalCtx, invadepohType);
             func_80B4D15C(this);
@@ -4346,7 +4344,7 @@ void func_80B4D760(Actor* thisx, GlobalContext* globalCtx) {
 
     this->actionFunc(this, globalCtx);
     if (this->actor.update != NULL) {
-        SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+        SkelAnime_Update(&this->skelAnime);
         func_800B9010(&this->actor, NA_SE_EN_FOLLOWERS_BEAM_PRE - SFX_FLAG);
     }
 }
@@ -4365,7 +4363,7 @@ void func_80B4D7B8(GlobalContext* globalCtx) {
             temp_v0 = globalCtx->gameplayFrames;
             temp_s5 = (temp_v0 + ((0x10 * i) & 0xFFU)) & 0x7F;
             temp_s6 = (u8)(temp_v0 * -0xF);
-            SysMatrix_InsertTranslation(phi_s2->unk4.x, phi_s2->unk4.y, phi_s2->unk4.z, MTXMODE_NEW);
+            Matrix_InsertTranslation(phi_s2->unk4.x, phi_s2->unk4.y, phi_s2->unk4.z, MTXMODE_NEW);
             Matrix_Scale(0.1f, 0.1f, 0.1f, MTXMODE_APPLY);
             gDPPipeSync(POLY_XLU_DISP++);
             gDPSetPrimColor(POLY_XLU_DISP++, 0x80, 0x80, 255, 255, 170, phi_s2->unk2);
@@ -4394,22 +4392,22 @@ void func_80B4D9F4(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3s*
     EnInvadepoh* this = THIS;
 
     if ((limbIndex == 12) && (this->alienBeamAlpha != 0)) {
-        SysMatrix_StatePush();
-        SysMatrix_InsertZRotation_s(-0x53ED, MTXMODE_APPLY);
+        Matrix_StatePush();
+        Matrix_InsertZRotation_s(-0x53ED, MTXMODE_APPLY);
         Matrix_RotateY(-0x3830, MTXMODE_APPLY);
         Matrix_Scale(1.0f, 1.0f, 1.5f, MTXMODE_APPLY);
-        SysMatrix_CopyCurrentState(&D_80B502A0);
-        SysMatrix_StatePop();
+        Matrix_CopyCurrentState(&D_80B502A0);
+        Matrix_StatePop();
     } else if ((limbIndex == 13) && (this->alienBeamAlpha != 0)) {
-        SysMatrix_StatePush();
-        SysMatrix_InsertZRotation_s(-0x53ED, MTXMODE_APPLY);
+        Matrix_StatePush();
+        Matrix_InsertZRotation_s(-0x53ED, MTXMODE_APPLY);
         Matrix_RotateY(-0x47D0, MTXMODE_APPLY);
         Matrix_Scale(1.0f, 1.0f, 1.5f, MTXMODE_APPLY);
-        SysMatrix_CopyCurrentState(&D_80B502E0);
-        SysMatrix_StatePop();
+        Matrix_CopyCurrentState(&D_80B502E0);
+        Matrix_StatePop();
     }
     if (limbIndex == 11) {
-        SysMatrix_MultiplyVector3fByState(&D_80B4EE24, &this->actor.focus.pos);
+        Matrix_MultiplyVector3fByState(&D_80B4EE24, &this->actor.focus.pos);
     }
 }
 
@@ -4420,7 +4418,7 @@ void func_80B4DB14(Actor* thisx, GlobalContext* globalCtx) {
 
     OPEN_DISPS(spCC);
     func_8012C2DC(spCC);
-    SysMatrix_StatePush();
+    Matrix_StatePush();
     if (this->drawAlien) {
         Gfx* new_var6;
         Gfx* spBC;
@@ -4431,16 +4429,16 @@ void func_80B4DB14(Actor* thisx, GlobalContext* globalCtx) {
             AnimatedMat_Draw(globalCtx, D_80B50400);
             Scene_SetRenderModeXlu(globalCtx, 0, 1);
             gDPSetEnvColor(spCC->polyOpa.p++, 0, 0, 0, 255);
-            spCC->polyOpa.p = SkelAnime_DrawSV2(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl,
-                                                this->skelAnime.dListCount, func_80B4D9D8, func_80B4D9F4, &this->actor,
-                                                spCC->polyOpa.p);
+            spCC->polyOpa.p = SkelAnime_DrawFlex(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable,
+                                                 this->skelAnime.dListCount, func_80B4D9D8, func_80B4D9F4, &this->actor,
+                                                 spCC->polyOpa.p);
         } else {
             AnimatedMat_Draw(globalCtx, D_80B50400);
             Scene_SetRenderModeXlu(globalCtx, 1, 2);
             gDPSetEnvColor(spCC->polyXlu.p++, 0, 0, 0, this->alienAlpha);
-            spCC->polyXlu.p = SkelAnime_DrawSV2(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl,
-                                                this->skelAnime.dListCount, func_80B4D9D8, func_80B4D9F4, &this->actor,
-                                                spCC->polyXlu.p);
+            spCC->polyXlu.p = SkelAnime_DrawFlex(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable,
+                                                 this->skelAnime.dListCount, func_80B4D9D8, func_80B4D9F4, &this->actor,
+                                                 spCC->polyXlu.p);
         }
 
         if (this->alienBeamAlpha != 0) {
@@ -4450,10 +4448,10 @@ void func_80B4DB14(Actor* thisx, GlobalContext* globalCtx) {
             gDPPipeSync(spBC++);
             gDPSetPrimColor(spBC++, 0, 255, 240, 180, 100, 60);
             gDPSetEnvColor(spBC++, 255, 255, 255, this->alienBeamAlpha * (150.0f / 255.0f));
-            SysMatrix_InsertMatrix(&D_80B502A0, MTXMODE_NEW);
+            Matrix_InsertMatrix(&D_80B502A0, MTXMODE_NEW);
             gSPMatrix(spBC++, Matrix_NewMtx(globalCtx->state.gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
             gSPDisplayList(spBC++, D_06000080);
-            SysMatrix_InsertMatrix(&D_80B502E0, MTXMODE_NEW);
+            Matrix_InsertMatrix(&D_80B502E0, MTXMODE_NEW);
             gSPMatrix(spBC++, Matrix_NewMtx(globalCtx->state.gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
             gSPDisplayList(spBC++, D_06000080);
             spB8->polyXlu.p = spBC;
@@ -4461,8 +4459,8 @@ void func_80B4DB14(Actor* thisx, GlobalContext* globalCtx) {
     }
 
     if (this->drawAlienDeathEffect) {
-        SysMatrix_SetStateRotationAndTranslation(this->actor.world.pos.x, this->actor.world.pos.y + 68.0f,
-                                                 this->actor.world.pos.z, &this->actor.shape.rot);
+        Matrix_SetStateRotationAndTranslation(this->actor.world.pos.x, this->actor.world.pos.y + 68.0f,
+                                              this->actor.world.pos.z, &this->actor.shape.rot);
         Matrix_Scale(this->alienDeathEffectScale.x, this->alienDeathEffectScale.y, this->alienDeathEffectScale.z,
                      MTXMODE_APPLY);
         gSPMatrix(spCC->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx),
@@ -4482,12 +4480,12 @@ void func_80B4DB14(Actor* thisx, GlobalContext* globalCtx) {
         gSPSetOtherMode(gfx++, G_SETOTHERMODE_H, 4, 4, 0x00000080);
         gDPSetCombineLERP(gfx++, 0, 0, 0, PRIMITIVE, TEXEL0, 0, PRIMITIVE, 0, 0, 0, 0, PRIMITIVE, TEXEL0, 0, PRIMITIVE,
                           0);
-        SysMatrix_InsertMatrix(&globalCtx->mf_187FC, MTXMODE_NEW);
-        SysMatrix_GetStateTranslationAndScaledZ(60.0f, &sp80);
+        Matrix_InsertMatrix(&globalCtx->mf_187FC, MTXMODE_NEW);
+        Matrix_GetStateTranslationAndScaledZ(60.0f, &sp80);
         sp74.x = thisx->world.pos.x + sp80.x;
         sp74.y = thisx->world.pos.y + sp80.y + 68.0f;
         sp74.z = thisx->world.pos.z + sp80.z;
-        SysMatrix_InsertTranslation(sp74.x, sp74.y, sp74.z, MTXMODE_NEW);
+        Matrix_InsertTranslation(sp74.x, sp74.y, sp74.z, MTXMODE_NEW);
         Matrix_Scale(0.25f, 0.25f, 0.25f, MTXMODE_APPLY);
         alpha2 = this->alienAlpha * (100.0f / 255.0f);
         gSPDisplayList(gfx++, D_04029CB0);
@@ -4501,7 +4499,7 @@ void func_80B4DB14(Actor* thisx, GlobalContext* globalCtx) {
         }
     }
 
-    SysMatrix_StatePop();
+    Matrix_StatePop();
     CLOSE_DISPS(spCC);
 }
 
@@ -4517,26 +4515,28 @@ void func_80B4E158(Actor* thisx, GlobalContext* globalCtx) {
     EnInvadepoh* this = THIS;
 
     func_8012C5B0(globalCtx->state.gfxCtx);
-    SkelAnime_DrawSV(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl, this->skelAnime.dListCount,
-                     func_80B4E120, NULL, &this->actor);
+    SkelAnime_DrawFlexOpa(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable, this->skelAnime.dListCount,
+                          func_80B4E120, NULL, &this->actor);
 }
 
 void func_80B4E1B0(Actor* thisx, GlobalContext* globalCtx) {
     EnInvadepoh* this = THIS;
 
     func_8012C5B0(globalCtx->state.gfxCtx);
-    SkelAnime_DrawSV(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl, this->skelAnime.dListCount, NULL,
-                     NULL, &this->actor);
+    SkelAnime_DrawFlexOpa(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable, this->skelAnime.dListCount,
+                          NULL, NULL, &this->actor);
 }
 
 s32 func_80B4E200(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3f* pos, Vec3s* rot, Actor* thisx) {
     if (limbIndex == 14) {
         EnInvadepoh* this = THIS; // both of these needed to match
+
         rot->x += this->behaviorInfo.unk20.y;
         rot->y += this->behaviorInfo.unk20.z;
         rot->z += this->behaviorInfo.unk20.x;
     } else if (limbIndex == 13) {
         EnInvadepoh* this = THIS; // both of these needed to match
+
         rot->x += (s16)(this->behaviorInfo.unk34 * this->behaviorInfo.unk20.y);
         rot->z += this->behaviorInfo.unk40;
     }
@@ -4551,7 +4551,7 @@ void func_80B4E2AC(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3s*
         gSPDisplayList(POLY_OPA_DISP++, D_060003B0);
         CLOSE_DISPS(globalCtx->state.gfxCtx);
     } else if (limbIndex == 14) {
-        SysMatrix_MultiplyVector3fByState(&D_80B4EE30, &this->actor.focus.pos);
+        Matrix_MultiplyVector3fByState(&D_80B4EE30, &this->actor.focus.pos);
     }
 }
 
@@ -4562,8 +4562,8 @@ void func_80B4E324(Actor* thisx, GlobalContext* globalCtx) {
     func_8012C28C(globalCtx->state.gfxCtx);
     gSPSegment(POLY_OPA_DISP++, 0x09, D_80B4E958[this->behaviorInfo.unk10.unkF]);
     gSPSegment(POLY_OPA_DISP++, 0x08, D_80B4E944[this->behaviorInfo.unk0.unkF]);
-    SkelAnime_DrawSV(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl, this->skelAnime.dListCount,
-                     func_80B4E200, func_80B4E2AC, &this->actor);
+    SkelAnime_DrawFlexOpa(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable, this->skelAnime.dListCount,
+                          func_80B4E200, func_80B4E2AC, &this->actor);
     CLOSE_DISPS(globalCtx->state.gfxCtx);
 }
 
@@ -4571,16 +4571,16 @@ void func_80B4E3F0(Actor* thisx, GlobalContext* globalCtx) {
     s32 pad[2];
     Vec3f sp5C;
 
-    SysMatrix_StatePush();
-    SysMatrix_InsertMatrix(&globalCtx->mf_187FC, MTXMODE_NEW);
-    SysMatrix_GetStateTranslationAndScaledZ(200.0f, &sp5C);
-    SysMatrix_StatePop();
+    Matrix_StatePush();
+    Matrix_InsertMatrix(&globalCtx->mf_187FC, MTXMODE_NEW);
+    Matrix_GetStateTranslationAndScaledZ(200.0f, &sp5C);
+    Matrix_StatePop();
     sp5C.x += thisx->world.pos.x;
     sp5C.y += thisx->world.pos.y;
     sp5C.z += thisx->world.pos.z;
     EnInvadepoh_SetSysMatrix(&sp5C);
-    SysMatrix_NormalizeXYZ(&globalCtx->mf_187FC);
-    SysMatrix_InsertZRotation_s(((EnInvadepoh*)thisx)->unk304, MTXMODE_APPLY);
+    Matrix_NormalizeXYZ(&globalCtx->mf_187FC);
+    Matrix_InsertZRotation_s(((EnInvadepoh*)thisx)->unk304, MTXMODE_APPLY);
     OPEN_DISPS(globalCtx->state.gfxCtx);
     func_8012C2DC(globalCtx->state.gfxCtx);
     gSPMatrix(POLY_XLU_DISP++, Matrix_NewMtx(globalCtx->state.gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
@@ -4598,6 +4598,7 @@ void func_80B4E3F0(Actor* thisx, GlobalContext* globalCtx) {
 s32 func_80B4E5B0(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3f* pos, Vec3s* rot, Actor* thisx) {
     if ((limbIndex == 5) || (limbIndex == 6) || (limbIndex == 7)) {
         EnInvadepoh* this = THIS;
+
         rot->x += this->behaviorInfo.unk20.x;
         rot->y += this->behaviorInfo.unk20.y;
         rot->z += this->behaviorInfo.unk20.z;
@@ -4607,8 +4608,10 @@ s32 func_80B4E5B0(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3f* p
 }
 
 void func_80B4E61C(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3s* rot, Actor* thisx) {
+    EnInvadepoh* this = THIS;
+
     if (limbIndex == 5) {
-        SysMatrix_GetStateTranslationAndScaledY(20.0f, &thisx->focus.pos);
+        Matrix_GetStateTranslationAndScaledY(20.0f, &this->actor.focus.pos);
     }
 }
 
@@ -4618,27 +4621,31 @@ void func_80B4E660(Actor* thisx, GlobalContext* globalCtx) {
     OPEN_DISPS(globalCtx->state.gfxCtx);
     func_8012C28C(globalCtx->state.gfxCtx);
     gDPSetEnvColor(POLY_OPA_DISP++, 255, 255, 200, 0);
-    SkelAnime_DrawSV(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl, this->skelAnime.dListCount,
-                     func_80B4E5B0, func_80B4E61C, &this->actor);
+    SkelAnime_DrawFlexOpa(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable, this->skelAnime.dListCount,
+                          func_80B4E5B0, func_80B4E61C, &this->actor);
     CLOSE_DISPS(globalCtx->state.gfxCtx);
 }
 
 s32 func_80B4E6E4(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3f* pos, Vec3s* rot, Actor* thisx) {
     if (limbIndex == 9) {
         EnInvadepoh* this = THIS; // both of these needed to match
+
         rot->x += this->behaviorInfo.unk20.y;
         rot->y += this->behaviorInfo.unk20.z;
         rot->z += this->behaviorInfo.unk20.x;
     } else if (limbIndex == 2) {
         EnInvadepoh* this = THIS; // both of these needed to match
+
         rot->x += (s16)(this->behaviorInfo.unk34 * this->behaviorInfo.unk20.y);
     }
     return 0;
 }
 
 void func_80B4E784(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3s* rot, Actor* thisx) {
+    EnInvadepoh* this = THIS;
+
     if (limbIndex == 9) {
-        SysMatrix_GetStateTranslation(&thisx->focus.pos);
+        Matrix_GetStateTranslation(&this->actor.focus.pos);
     }
 }
 
@@ -4649,7 +4656,7 @@ void func_80B4E7BC(Actor* thisx, GlobalContext* globalCtx) {
     func_8012C28C(globalCtx->state.gfxCtx);
     gSPSegment(POLY_OPA_DISP++, 0x09, D_80B4E984[this->behaviorInfo.unk10.unkF]);
     gSPSegment(POLY_OPA_DISP++, 0x08, D_80B4E96C[this->behaviorInfo.unk0.unkF]);
-    SkelAnime_DrawSV(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl, this->skelAnime.dListCount,
-                     func_80B4E6E4, func_80B4E784, &this->actor);
+    SkelAnime_DrawFlexOpa(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable, this->skelAnime.dListCount,
+                          func_80B4E6E4, func_80B4E784, &this->actor);
     CLOSE_DISPS(globalCtx->state.gfxCtx);
 }
diff --git a/src/overlays/actors/ovl_En_Invadepoh/z_en_invadepoh.h b/src/overlays/actors/ovl_En_Invadepoh/z_en_invadepoh.h
index 8b766189f..3a242eace 100644
--- a/src/overlays/actors/ovl_En_Invadepoh/z_en_invadepoh.h
+++ b/src/overlays/actors/ovl_En_Invadepoh/z_en_invadepoh.h
@@ -109,8 +109,8 @@ typedef struct AlienBehaviorInfo {
 typedef struct EnInvadepoh {
     /* 0x000 */ Actor actor;
     /* 0x144 */ SkelAnime skelAnime;
-    /* 0x188 */ Vec3s limbDrawTable[23];
-    /* 0x212 */ Vec3s transitionDrawTable[23];
+    /* 0x188 */ Vec3s jointTable[23];
+    /* 0x212 */ Vec3s morphTable[23];
     /* 0x29C */ s8 animPlayFlag;
     /* 0x2A0 */ ColliderCylinder collider;
     /* 0x2EC */ EnInvadepohActionFunc actionFunc;
diff --git a/src/overlays/actors/ovl_En_Jc_Mato/z_en_jc_mato.c b/src/overlays/actors/ovl_En_Jc_Mato/z_en_jc_mato.c
index 3fee5e073..7390d9f7c 100644
--- a/src/overlays/actors/ovl_En_Jc_Mato/z_en_jc_mato.c
+++ b/src/overlays/actors/ovl_En_Jc_Mato/z_en_jc_mato.c
@@ -163,6 +163,6 @@ void EnJcMato_Draw(Actor* thisx, GlobalContext* globalCtx) {
     func_8012C28C(globalCtx->state.gfxCtx);
     gSPMatrix(POLY_OPA_DISP++, Matrix_NewMtx(globalCtx->state.gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
     gSPDisplayList(POLY_OPA_DISP++, D_06000390);
-    SysMatrix_MultiplyVector3fByState(&movement, &this->pos);
+    Matrix_MultiplyVector3fByState(&movement, &this->pos);
     CLOSE_DISPS(globalCtx->state.gfxCtx);
 }
diff --git a/src/overlays/actors/ovl_En_Kgy/z_en_kgy.c b/src/overlays/actors/ovl_En_Kgy/z_en_kgy.c
index 457178720..26bf172bc 100644
--- a/src/overlays/actors/ovl_En_Kgy/z_en_kgy.c
+++ b/src/overlays/actors/ovl_En_Kgy/z_en_kgy.c
@@ -67,7 +67,7 @@ void EnKgy_Init(Actor* thisx, GlobalContext* globalCtx) {
     s32 i;
 
     Actor_SetScale(&this->actor, 0.01f);
-    SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_0600F910, &D_06004B98, this->jointTable, this->morphTable, 23);
+    SkelAnime_InitFlex(globalCtx, &this->skelAnime, &D_0600F910, &D_06004B98, this->jointTable, this->morphTable, 23);
     this->unk_2D2 = -1;
     this->unk_29C = 0;
     this->unk_2E4 = 0;
@@ -131,8 +131,8 @@ void EnKgy_ChangeAnim(EnKgy* this, s16 animIndex, u8 mode, f32 transitionRate) {
         &D_06001764, &D_06003334, &D_06010B84, &D_06001EA4, &D_06003D88,
     };
 
-    SkelAnime_ChangeAnim(&this->skelAnime, sAnimations[animIndex], 1.0f, 0.0f,
-                         SkelAnime_GetFrameCount(&sAnimations[animIndex]->common), mode, transitionRate);
+    Animation_Change(&this->skelAnime, sAnimations[animIndex], 1.0f, 0.0f,
+                     Animation_GetLastFrame(sAnimations[animIndex]), mode, transitionRate);
     this->unk_2D2 = animIndex;
 }
 
@@ -432,7 +432,7 @@ void func_80B415A8(GlobalContext* globalCtx, Vec3f* arg1) {
 void func_80B4163C(EnKgy* this, GlobalContext* globalCtx) {
     this->actor.focus.pos = this->unk_2A8;
 
-    if (SkelAnime_FrameUpdateMatrix(&this->skelAnime)) {
+    if (SkelAnime_Update(&this->skelAnime)) {
         if (this->unk_2D2 == 6) {
             if (this->unk_2EA > 0) {
                 EnKgy_ChangeAnim(this, 6, 2, 0.0f);
@@ -444,10 +444,10 @@ void func_80B4163C(EnKgy* this, GlobalContext* globalCtx) {
         } else {
             EnKgy_ChangeAnim(this, 6, 2, -5.0f);
         }
-        SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+        SkelAnime_Update(&this->skelAnime);
     }
 
-    switch ((s32)this->skelAnime.animCurrentFrame) {
+    switch ((s32)this->skelAnime.curFrame) {
         case 1:
         case 7:
         case 13:
@@ -523,7 +523,7 @@ void func_80B419B0(EnKgy* this, GlobalContext* globalCtx) {
 }
 
 void func_80B41A48(EnKgy* this, GlobalContext* globalCtx) {
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     if (this->unk_2E4 > 0) {
         this->unk_2E4--;
     } else {
@@ -536,7 +536,7 @@ void func_80B41ACC(EnKgy* this, GlobalContext* globalCtx) {
     s32 temp_v0;
     Player* player = GET_PLAYER(globalCtx);
 
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     if (func_80152498(&globalCtx->msgCtx) == 0x10) {
         temp_v0 = func_80123810(globalCtx);
         if (temp_v0 != 0) {
@@ -585,7 +585,7 @@ void func_80B41C30(EnKgy* this, GlobalContext* globalCtx) {
 }
 
 void func_80B41C54(EnKgy* this, GlobalContext* globalCtx) {
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     if (func_800B867C(&this->actor, globalCtx)) {
         this->actionFunc = func_80B41C30;
         this->actor.flags &= ~0x100;
@@ -594,7 +594,7 @@ void func_80B41C54(EnKgy* this, GlobalContext* globalCtx) {
 }
 
 void func_80B41CBC(EnKgy* this, GlobalContext* globalCtx) {
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     if (func_800B84D0(&this->actor, globalCtx)) {
         this->actor.flags &= ~0x10000;
         func_80B40E18(this, this->actor.textId);
@@ -606,7 +606,7 @@ void func_80B41CBC(EnKgy* this, GlobalContext* globalCtx) {
 }
 
 void func_80B41D64(EnKgy* this, GlobalContext* globalCtx) {
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     if (Actor_HasParent(&this->actor, globalCtx)) {
         this->actionFunc = func_80B41CBC;
         this->actor.flags |= 0x10000;
@@ -622,7 +622,7 @@ void func_80B41E18(EnKgy* this, GlobalContext* globalCtx) {
     s32 pad;
     Player* player = GET_PLAYER(globalCtx);
 
-    if (SkelAnime_FrameUpdateMatrix(&this->skelAnime) && (this->unk_2D2 == 3)) {
+    if (SkelAnime_Update(&this->skelAnime) && (this->unk_2D2 == 3)) {
         func_80B40BC0(this, 4);
     }
 
@@ -844,7 +844,7 @@ void func_80B42508(EnKgy* this, GlobalContext* globalCtx) {
     s32 pad;
     Player* player = GET_PLAYER(globalCtx);
 
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     this->actor.focus.pos = this->unk_2A8;
     if (func_800B84D0(&this->actor, globalCtx) || (&this->actor == player->targetActor)) {
         this->actionFunc = func_80B41E18;
@@ -854,7 +854,7 @@ void func_80B42508(EnKgy* this, GlobalContext* globalCtx) {
 }
 
 void func_80B425A0(EnKgy* this, GlobalContext* globalCtx) {
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     this->actor.focus.pos = this->unk_2A8;
     if (func_800B84D0(&this->actor, globalCtx)) {
         this->actionFunc = func_80B41E18;
@@ -867,7 +867,7 @@ void func_80B425A0(EnKgy* this, GlobalContext* globalCtx) {
 }
 
 void func_80B42660(EnKgy* this, GlobalContext* globalCtx) {
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     this->actor.focus.pos = this->unk_2A8;
     if ((func_80152498(&globalCtx->msgCtx) == 5) && func_80147624(globalCtx)) {
         func_801477B4(globalCtx);
@@ -883,7 +883,7 @@ void func_80B42714(EnKgy* this, GlobalContext* globalCtx) {
     s32 pad;
     Player* player = GET_PLAYER(globalCtx);
 
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     this->actor.focus.pos = this->unk_2A8;
     if (func_800B84D0(&this->actor, globalCtx) || (&this->actor == player->targetActor)) {
         func_80B411DC(this, globalCtx, 4);
@@ -900,7 +900,7 @@ void func_80B427C8(EnKgy* this, GlobalContext* globalCtx) {
     s32 pad;
     u16 temp_a2;
 
-    if (SkelAnime_FrameUpdateMatrix(&this->skelAnime)) {
+    if (SkelAnime_Update(&this->skelAnime)) {
         if (this->unk_2D2 == 5) {
             func_80B40BC0(this, 7);
         }
@@ -946,7 +946,7 @@ void func_80B427C8(EnKgy* this, GlobalContext* globalCtx) {
 }
 
 void func_80B4296C(EnKgy* this, GlobalContext* globalCtx) {
-    if (SkelAnime_FrameUpdateMatrix(&this->skelAnime) && (this->unk_2D2 == 8)) {
+    if (SkelAnime_Update(&this->skelAnime) && (this->unk_2D2 == 8)) {
         func_80B40BC0(this, 2);
     }
 
@@ -971,7 +971,7 @@ void func_80B42A8C(EnKgy* this, GlobalContext* globalCtx) {
     u16 temp_a2;
     s32 pad;
 
-    if (SkelAnime_FrameUpdateMatrix(&this->skelAnime)) {
+    if (SkelAnime_Update(&this->skelAnime)) {
         if (this->unk_2D2 == 5) {
             func_80B40BC0(this, 1);
         }
@@ -1058,7 +1058,7 @@ void func_80B42A8C(EnKgy* this, GlobalContext* globalCtx) {
 }
 
 void func_80B42D28(EnKgy* this, GlobalContext* globalCtx) {
-    if (SkelAnime_FrameUpdateMatrix(&this->skelAnime) && (this->unk_2D2 == 8)) {
+    if (SkelAnime_Update(&this->skelAnime) && (this->unk_2D2 == 8)) {
         func_80B40BC0(this, 2);
     }
 
@@ -1134,11 +1134,11 @@ void EnKgy_PostLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Ve
     EnKgy* this = THIS;
 
     if (limbIndex == 11) {
-        SysMatrix_MultiplyVector3fByState(&D_80B432D8, &this->unk_2A8);
+        Matrix_MultiplyVector3fByState(&D_80B432D8, &this->unk_2A8);
     }
 
     if (limbIndex == 16) {
-        SysMatrix_MultiplyVector3fByState(&D_80B432E4, &this->unk_2C0);
+        Matrix_MultiplyVector3fByState(&D_80B432E4, &this->unk_2C0);
     }
 }
 
@@ -1150,9 +1150,9 @@ void func_80B43074(EnKgy* this, GlobalContext* globalCtx) {
 
     func_8012C28C(globalCtx->state.gfxCtx);
     func_800B8050(&this->actor, globalCtx, MTXMODE_NEW);
-    SysMatrix_StatePush();
-    SysMatrix_InsertTranslation(-800.0f, 3100.0f, 8400.0f, MTXMODE_APPLY);
-    SysMatrix_InsertXRotation_s(0x4000, MTXMODE_APPLY);
+    Matrix_StatePush();
+    Matrix_InsertTranslation(-800.0f, 3100.0f, 8400.0f, MTXMODE_APPLY);
+    Matrix_InsertXRotation_s(0x4000, MTXMODE_APPLY);
 
     if (func_80B40D8C(globalCtx)) {
         AnimatedMat_Draw(globalCtx, Lib_SegmentedToVirtual(D_0600F6A0));
@@ -1174,7 +1174,7 @@ void func_80B43074(EnKgy* this, GlobalContext* globalCtx) {
 
     CLOSE_DISPS(globalCtx->state.gfxCtx);
 
-    SysMatrix_StatePop();
+    Matrix_StatePop();
 }
 
 void EnKgy_Draw(Actor* thisx, GlobalContext* globalCtx) {
@@ -1184,6 +1184,6 @@ void EnKgy_Draw(Actor* thisx, GlobalContext* globalCtx) {
     if (this->unk_29C & 1) {
         func_80B43074(this, globalCtx);
     }
-    SkelAnime_DrawSV(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl, this->skelAnime.dListCount,
-                     EnKgy_OverrideLimbDraw, EnKgy_PostLimbDraw, &this->actor);
+    SkelAnime_DrawFlexOpa(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable, this->skelAnime.dListCount,
+                          EnKgy_OverrideLimbDraw, EnKgy_PostLimbDraw, &this->actor);
 }
diff --git a/src/overlays/actors/ovl_En_Ma4/z_en_ma4.c b/src/overlays/actors/ovl_En_Ma4/z_en_ma4.c
index b83fba1b4..e2ff014c9 100644
--- a/src/overlays/actors/ovl_En_Ma4/z_en_ma4.c
+++ b/src/overlays/actors/ovl_En_Ma4/z_en_ma4.c
@@ -154,9 +154,9 @@ static struct_80B8E1A8 sAnimationInfo[] = {
 };
 
 void EnMa4_ChangeAnim(EnMa4* this, s32 index) {
-    SkelAnime_ChangeAnim(&this->skelAnime, sAnimationInfo[index].animationSeg, 1.0f, 0.0f,
-                         SkelAnime_GetFrameCount(&sAnimationInfo[index].animationSeg->common),
-                         sAnimationInfo[index].mode, sAnimationInfo[index].transitionRate);
+    Animation_Change(&this->skelAnime, sAnimationInfo[index].animationSeg, 1.0f, 0.0f,
+                     Animation_GetLastFrame(sAnimationInfo[index].animationSeg), sAnimationInfo[index].mode,
+                     sAnimationInfo[index].transitionRate);
 }
 
 void func_80ABDD9C(EnMa4* this, GlobalContext* globalCtx) {
@@ -164,8 +164,8 @@ void func_80ABDD9C(EnMa4* this, GlobalContext* globalCtx) {
     s16 flag;
 
     if (this->unk_1D8.unk_00 == 0 &&
-        ((this->skelAnime.animCurrentSeg == &D_06007328) || (this->skelAnime.animCurrentSeg == &D_06002A8C) ||
-         (this->skelAnime.animCurrentSeg == &D_06015B7C))) {
+        ((this->skelAnime.animation == &D_06007328) || (this->skelAnime.animation == &D_06002A8C) ||
+         (this->skelAnime.animation == &D_06015B7C))) {
         flag = 1;
     } else {
         flag = (this->type == MA4_TYPE_ALIENS_WON && this->actionFunc != EnMa4_DialogueHandler) ? 1 : 0;
@@ -201,8 +201,8 @@ void EnMa4_Init(Actor* thisx, GlobalContext* globalCtx) {
     s32 pad;
 
     ActorShape_Init(&this->actor.shape, 0.0f, func_800B3FC0, 18.0f);
-    SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_06013928, NULL, this->limbDrawTable, this->transitionDrawTable,
-                     MA1_LIMB_MAX);
+    SkelAnime_InitFlex(globalCtx, &this->skelAnime, &D_06013928, NULL, this->jointTable, this->morphTable,
+                       MA1_LIMB_MAX);
 
     Collider_InitCylinder(globalCtx, &this->collider);
     Collider_SetCylinder(globalCtx, &this->collider, &this->actor, &sCylinderInit);
@@ -270,7 +270,7 @@ void EnMa4_RunInCircles(EnMa4* this, GlobalContext* globalCtx) {
     s32 pad;
     s16 sp2E;
 
-    if (sCurrentAnim != 9 && func_801378B8(&this->skelAnime, this->skelAnime.animFrameCount)) {
+    if (sCurrentAnim != 9 && Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame)) {
         if (sCurrentAnim == 3) {
             if (D_80AC0250 < 3) {
                 D_80AC0250++;
@@ -286,7 +286,7 @@ void EnMa4_RunInCircles(EnMa4* this, GlobalContext* globalCtx) {
         }
     }
 
-    if (sCurrentAnim == 13 && func_801378B8(&this->skelAnime, 37.0f)) {
+    if (sCurrentAnim == 13 && Animation_OnFrame(&this->skelAnime, 37.0f)) {
         Audio_PlayActorSound2(&this->actor, NA_SE_EV_ROMANI_BOW_FLICK);
     }
 
@@ -318,8 +318,8 @@ void EnMa4_RunInCircles(EnMa4* this, GlobalContext* globalCtx) {
 
     Actor_UpdateBgCheckInfo(globalCtx, &this->actor, 0.0f, 0.0f, 0.0f, 4);
     Actor_SetVelocityAndMoveYRotationAndGravity(&this->actor);
-    if (this->skelAnime.animCurrentSeg == &D_06007328) { // Walking animation
-        if (func_801378B8(&this->skelAnime, 0.0f) || func_801378B8(&this->skelAnime, 4.0f)) {
+    if (this->skelAnime.animation == &D_06007328) { // Walking animation
+        if (Animation_OnFrame(&this->skelAnime, 0.0f) || Animation_OnFrame(&this->skelAnime, 4.0f)) {
             Audio_PlayActorSound2(&this->actor, NA_SE_EN_ROMANI_WALK);
         }
     }
@@ -353,7 +353,7 @@ void EnMa4_Wait(EnMa4* this, GlobalContext* globalCtx) {
         this->actor.flags |= 0x10000;
     } else if (this->type != MA4_TYPE_ALIENS_WON) {
         EnMa4_RunInCircles(this, globalCtx);
-    } else if (func_801378B8(&this->skelAnime, this->skelAnime.animFrameCount)) {
+    } else if (Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame)) {
         this->animTimer++;
         if (this->animTimer == 5) {
             EnMa4_ChangeAnim(this, 17); // Traumatized anim
@@ -843,8 +843,7 @@ void EnMa4_EponasSongCs(EnMa4* this, GlobalContext* globalCtx) {
         }
 
         func_800EDF24(&this->actor, globalCtx, actionIndex);
-        if (D_80AC0260 == 2 && this->animTimer == 0 &&
-            func_801378B8(&this->skelAnime, this->skelAnime.animFrameCount)) {
+        if (D_80AC0260 == 2 && this->animTimer == 0 && Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame)) {
             EnMa4_ChangeAnim(this, 7);
         }
     } else {
@@ -1042,7 +1041,7 @@ void EnMa4_Update(Actor* thisx, GlobalContext* globalCtx) {
 
     Collider_UpdateCylinder(&this->actor, &this->collider);
     CollisionCheck_SetOC(globalCtx, &globalCtx->colChkCtx, &this->collider.base);
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     EnMa4_UpdateEyes(this);
     this->actionFunc(this, globalCtx);
     func_80ABDD9C(this, globalCtx);
@@ -1071,7 +1070,7 @@ void EnMa4_PostLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Ve
     Vec3f sp28 = { 800.0f, 0.0f, 0.0f };
 
     if (limbIndex == MA1_LIMB_HEAD) {
-        SysMatrix_MultiplyVector3fByState(&sp28, &this->actor.focus.pos);
+        Matrix_MultiplyVector3fByState(&sp28, &this->actor.focus.pos);
     } else if (limbIndex == MA1_LIMB_HAND_LEFT) {
         if (this->hasBow == true) {
             OPEN_DISPS(globalCtx->state.gfxCtx);
@@ -1095,8 +1094,8 @@ void EnMa4_Draw(Actor* thisx, GlobalContext* globalCtx) {
     gSPSegment(POLY_OPA_DISP++, 0x08, SEGMENTED_TO_VIRTUAL(sEyeTextures[this->eyeTexIndex]));
     gSPSegment(POLY_OPA_DISP++, 0x09, SEGMENTED_TO_VIRTUAL(sMouthTextures[this->mouthTexIndex]));
 
-    SkelAnime_DrawSV(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl, this->skelAnime.dListCount,
-                     EnMa4_OverrideLimbDraw, EnMa4_PostLimbDraw, &this->actor);
+    SkelAnime_DrawFlexOpa(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable, this->skelAnime.dListCount,
+                          EnMa4_OverrideLimbDraw, EnMa4_PostLimbDraw, &this->actor);
 
     CLOSE_DISPS(globalCtx->state.gfxCtx);
 }
diff --git a/src/overlays/actors/ovl_En_Ma4/z_en_ma4.h b/src/overlays/actors/ovl_En_Ma4/z_en_ma4.h
index 1ecc67ed5..b1e25569b 100644
--- a/src/overlays/actors/ovl_En_Ma4/z_en_ma4.h
+++ b/src/overlays/actors/ovl_En_Ma4/z_en_ma4.h
@@ -15,9 +15,9 @@ typedef struct EnMa4 {
     /* 0x18C */ ColliderCylinder collider;
     /* 0x1D8 */ struct_800BD888_arg1 unk_1D8;
     /* 0x200 */ Vec3s* pathPoints;
-    /* 0x204 */ Vec3s limbDrawTable[MA1_LIMB_MAX];
+    /* 0x204 */ Vec3s jointTable[MA1_LIMB_MAX];
     /* 0x28E */ UNK_TYPE1 unk28E[0x6];
-    /* 0x294 */ Vec3s transitionDrawTable[MA1_LIMB_MAX];
+    /* 0x294 */ Vec3s morphTable[MA1_LIMB_MAX];
     /* 0x31E */ UNK_TYPE1 unk31E[0x6];
     /* 0x324 */ s16 pathIndex;
     /* 0x326 */ s16 pathPointsCount;
diff --git a/src/overlays/actors/ovl_En_Ma_Yto/z_en_ma_yto.c b/src/overlays/actors/ovl_En_Ma_Yto/z_en_ma_yto.c
index b8f7f969b..9d9969e68 100644
--- a/src/overlays/actors/ovl_En_Ma_Yto/z_en_ma_yto.c
+++ b/src/overlays/actors/ovl_En_Ma_Yto/z_en_ma_yto.c
@@ -189,8 +189,8 @@ void EnMaYto_Init(Actor* thisx, GlobalContext* globalCtx) {
     }
 
     ActorShape_Init(&this->actor.shape, 0.0f, func_800B3FC0, 18.0f);
-    SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_06015C28, NULL, this->limbDrawTbl, this->transitionDrawTbl,
-                     MA2_LIMB_MAX);
+    SkelAnime_InitFlex(globalCtx, &this->skelAnime, &D_06015C28, NULL, this->jointTable, this->morphTable,
+                       MA2_LIMB_MAX);
     EnMaYto_InitAnimation(this, globalCtx);
 
     Collider_InitCylinder(globalCtx, &this->collider);
@@ -464,8 +464,8 @@ void EnMaYto_DefaultDialogueHandler(EnMaYto* this, GlobalContext* globalCtx) {
     }
 
     Math_SmoothStepToS(&this->actor.shape.rot.y, this->actor.yawTowardsPlayer, 5, 0x3000, 0x100);
-    if (this->textId == 0x3395 && this->skelAnime.animCurrentSeg == &D_0600AF7C &&
-        func_801378B8(&this->skelAnime, this->skelAnime.animFrameCount)) {
+    if (this->textId == 0x3395 && this->skelAnime.animation == &D_0600AF7C &&
+        Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame)) {
         EnMaYto_ChangeAnim(this, 4);
     }
 }
@@ -1081,8 +1081,8 @@ void EnMaYto_WarmFuzzyFeelingCs(EnMaYto* this, GlobalContext* globalCtx) {
         }
 
         func_800EDF24(&this->actor, globalCtx, csActionIndex);
-        if (D_80B915F0 == 2 && this->skelAnime.animCurrentSeg == &D_06001FD0 &&
-            func_801378B8(&this->skelAnime, this->skelAnime.animFrameCount)) {
+        if (D_80B915F0 == 2 && this->skelAnime.animation == &D_06001FD0 &&
+            Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame)) {
             EnMaYto_ChangeAnim(this, 20);
         }
     } else {
@@ -1293,16 +1293,16 @@ void EnMaYto_BarnStartDialogue(EnMaYto* this, GlobalContext* globalCtx) {
 }
 
 void EnMaYto_ChangeAnim(EnMaYto* this, s32 index) {
-    SkelAnime_ChangeAnim(&this->skelAnime, sAnimationInfo[index].animationSeg, 1.0f, 0.0f,
-                         SkelAnime_GetFrameCount(&sAnimationInfo[index].animationSeg->common),
-                         sAnimationInfo[index].mode, sAnimationInfo[index].transitionRate);
+    Animation_Change(&this->skelAnime, sAnimationInfo[index].animationSeg, 1.0f, 0.0f,
+                     Animation_GetLastFrame(sAnimationInfo[index].animationSeg), sAnimationInfo[index].mode,
+                     sAnimationInfo[index].transitionRate);
 }
 
 void func_80B90C78(EnMaYto* this, GlobalContext* globalCtx) {
     Player* player = GET_PLAYER(globalCtx);
     s16 flag;
 
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     flag = this->unk31E == 2 ? true : false;
 
     if (this->unk31E == 0) {
@@ -1464,12 +1464,12 @@ s32 EnMaYto_OverrideLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dLis
         rot->x += sp4.y;
         rot->z += sp4.x;
     } else if (limbIndex == MA2_LIMB_TORSO) {
-        if (this->skelAnime.animCurrentSeg != &D_06007E28 && this->skelAnime.animCurrentSeg != &D_06003D54) {
+        if (this->skelAnime.animation != &D_06007E28 && this->skelAnime.animation != &D_06003D54) {
             sp4 = this->unk_1D8.unk_0E;
 
             rot->x += sp4.y;
-            if (this->skelAnime.animCurrentSeg == &D_0600A174 || this->skelAnime.animCurrentSeg == &D_060070EC ||
-                this->skelAnime.animCurrentSeg == &D_06003D54) {
+            if (this->skelAnime.animation == &D_0600A174 || this->skelAnime.animation == &D_060070EC ||
+                this->skelAnime.animation == &D_06003D54) {
                 rot->z += sp4.x;
             }
         }
@@ -1481,7 +1481,7 @@ void EnMaYto_PostLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList,
     EnMaYto* this = THIS;
 
     if (limbIndex == MA2_LIMB_HEAD) {
-        SysMatrix_GetStateTranslation(&this->actor.focus.pos);
+        Matrix_GetStateTranslation(&this->actor.focus.pos);
     }
 }
 
@@ -1499,8 +1499,8 @@ void EnMaYto_Draw(Actor* thisx, GlobalContext* globalCtx) {
     gSPSegment(POLY_OPA_DISP++, 0x09, Lib_SegmentedToVirtual(sMouthTextures[this->mouthTexIndex]));
     gSPSegment(POLY_OPA_DISP++, 0x08, Lib_SegmentedToVirtual(sEyesTextures[this->eyeTexIndex]));
 
-    SkelAnime_DrawSV(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl, this->skelAnime.dListCount,
-                     EnMaYto_OverrideLimbDraw, EnMaYto_PostLimbDraw, &this->actor);
+    SkelAnime_DrawFlexOpa(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable, this->skelAnime.dListCount,
+                          EnMaYto_OverrideLimbDraw, EnMaYto_PostLimbDraw, &this->actor);
 
     CLOSE_DISPS(globalCtx->state.gfxCtx);
 }
diff --git a/src/overlays/actors/ovl_En_Ma_Yto/z_en_ma_yto.h b/src/overlays/actors/ovl_En_Ma_Yto/z_en_ma_yto.h
index 0fe7e009f..0feaea48a 100644
--- a/src/overlays/actors/ovl_En_Ma_Yto/z_en_ma_yto.h
+++ b/src/overlays/actors/ovl_En_Ma_Yto/z_en_ma_yto.h
@@ -42,8 +42,8 @@ typedef struct EnMaYto {
     /* 0x1D8 */ struct_800BD888_arg1 unk_1D8;
     /* 0x200 */ s32 unk200; // unused
     /* 0x204 */ s32 type;
-    /* 0x208 */ Vec3s limbDrawTbl[MA2_LIMB_MAX];
-    /* 0x28C */ Vec3s transitionDrawTbl[MA2_LIMB_MAX];
+    /* 0x208 */ Vec3s jointTable[MA2_LIMB_MAX];
+    /* 0x28C */ Vec3s morphTable[MA2_LIMB_MAX];
     /* 0x310 */ s16 unk310; // state?
     /* 0x312 */ UNK_TYPE1 unk_312[0x2];
     /* 0x314 */ s16 currentAnim; // Used only in DefaultWait
diff --git a/src/overlays/actors/ovl_En_Ma_Yts/z_en_ma_yts.c b/src/overlays/actors/ovl_En_Ma_Yts/z_en_ma_yts.c
index 786dee4ba..266ba90e9 100644
--- a/src/overlays/actors/ovl_En_Ma_Yts/z_en_ma_yts.c
+++ b/src/overlays/actors/ovl_En_Ma_Yts/z_en_ma_yts.c
@@ -125,12 +125,6 @@ static struct_80B8E1A8 sAnimationInfo[] = {
     { &D_060180DC, 1.0f, 2, 0.0f }, { &D_060180DC, 1.0f, 2, -6.0f }, // Turns around anim
 };
 
-void EnMaYts_ChangeAnim(EnMaYts* this, s32 index) {
-    SkelAnime_ChangeAnim(&this->skelAnime, sAnimationInfo[index].animationSeg, 1.0f, 0.0f,
-                         SkelAnime_GetFrameCount(&sAnimationInfo[index].animationSeg->common),
-                         sAnimationInfo[index].mode, sAnimationInfo[index].transitionRate);
-}
-
 static void* sMouthTextures[] = {
     D_060127C8,
     D_06012BC8,
@@ -142,6 +136,12 @@ static void* sEyeTextures[] = {
     D_0600FFC8, D_060107C8, D_06010FC8, D_060117C8, D_06011FC8,
 };
 
+void EnMaYts_ChangeAnim(EnMaYts* this, s32 index) {
+    Animation_Change(&this->skelAnime, sAnimationInfo[index].animationSeg, 1.0f, 0.0f,
+                     Animation_GetLastFrame(sAnimationInfo[index].animationSeg), sAnimationInfo[index].mode,
+                     sAnimationInfo[index].transitionRate);
+}
+
 void func_80B8D12C(EnMaYts* this, GlobalContext* globalCtx) {
     Player* player = GET_PLAYER(globalCtx);
     s16 flag = this->unk_32C == 2 ? true : false;
@@ -246,8 +246,8 @@ void EnMaYts_Init(Actor* thisx, GlobalContext* globalCtx) {
         Actor_MarkForDeath(&this->actor);
     }
     ActorShape_Init(&this->actor.shape, 0.0f, func_800B3FC0, 18.0f);
-    SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_06013928, NULL, this->limbDrawTbl, this->transitionDrawTbl,
-                     MA1_LIMB_MAX);
+    SkelAnime_InitFlex(globalCtx, &this->skelAnime, &D_06013928, NULL, this->jointTable, this->morphTable,
+                       MA1_LIMB_MAX);
     EnMaYts_InitAnimation(this, globalCtx);
 
     Collider_InitCylinder(globalCtx, &this->collider);
@@ -435,7 +435,7 @@ void EnMaYts_EndCreditsHandler(EnMaYts* this, GlobalContext* globalCtx) {
 
         func_800EDF24(&this->actor, globalCtx, actionIndex);
         if ((D_80B8E32C == 2) && (this->endCreditsFlag == 0) &&
-            (func_801378B8(&this->skelAnime, this->skelAnime.animFrameCount) != 0)) {
+            (Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame) != 0)) {
             this->endCreditsFlag++;
             EnMaYts_ChangeAnim(this, 5);
         }
@@ -517,20 +517,19 @@ void EnMaYts_Update(Actor* thisx, GlobalContext* globalCtx) {
     collider = &this->collider;
     Collider_UpdateCylinder(&this->actor, collider);
     CollisionCheck_SetOC(globalCtx, &globalCtx->colChkCtx, &collider->base);
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     EnMaYts_UpdateEyes(this);
     func_80B8D12C(this, globalCtx);
 }
 
-s32 EnMaYts_OverrideLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3f* pos, Vec3s* rot,
-                             Actor* thisx) {
-    EnMaYts* this = THIS;
+s32 EnMaYts_OverrideLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3f* pos, Vec3s* rot, Actor* arg) {
+    EnMaYts* this = (EnMaYts*)arg;
     Vec3s sp4;
 
     if (limbIndex == MA1_LIMB_HEAD) {
         sp4 = this->unk_1D8.unk_08;
         rot->x += sp4.y;
-        if ((this->skelAnime.animCurrentSeg == &D_06009E58) || (this->skelAnime.animCurrentSeg == &D_06007D98)) {
+        if ((this->skelAnime.animation == &D_06009E58) || (this->skelAnime.animation == &D_06007D98)) {
             rot->z += sp4.x;
         }
     } else if (limbIndex == MA1_LIMB_TORSO) {
@@ -542,11 +541,11 @@ s32 EnMaYts_OverrideLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dLis
     return 0;
 }
 
-void EnMaYts_PostLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3s* rot, Actor* thisx) {
-    EnMaYts* this = THIS;
+void EnMaYts_PostLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3s* rot, Actor* arg) {
+    EnMaYts* this = (EnMaYts*)arg;
 
     if (limbIndex == MA1_LIMB_HEAD) {
-        SysMatrix_GetStateTranslation(&this->actor.focus.pos);
+        Matrix_GetStateTranslation(&this->actor.focus.pos);
     } else if (limbIndex == MA1_LIMB_HAND_LEFT) {
         if (this->hasBow == true) {
             OPEN_DISPS(globalCtx->state.gfxCtx);
@@ -565,8 +564,8 @@ void EnMaYts_Draw(Actor* thisx, GlobalContext* globalCtx) {
     gSPSegment(POLY_OPA_DISP++, 0x09, SEGMENTED_TO_VIRTUAL(sMouthTextures[this->mouthTexIndex]));
     gSPSegment(POLY_OPA_DISP++, 0x08, SEGMENTED_TO_VIRTUAL(sEyeTextures[this->eyeTexIndex]));
 
-    SkelAnime_DrawSV(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl, this->skelAnime.dListCount,
-                     EnMaYts_OverrideLimbDraw, EnMaYts_PostLimbDraw, &this->actor);
+    SkelAnime_DrawFlexOpa(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable, this->skelAnime.dListCount,
+                          EnMaYts_OverrideLimbDraw, EnMaYts_PostLimbDraw, &this->actor);
 
     CLOSE_DISPS(globalCtx->state.gfxCtx);
 }
diff --git a/src/overlays/actors/ovl_En_Ma_Yts/z_en_ma_yts.h b/src/overlays/actors/ovl_En_Ma_Yts/z_en_ma_yts.h
index 75f0ee0b6..2fcc20509 100644
--- a/src/overlays/actors/ovl_En_Ma_Yts/z_en_ma_yts.h
+++ b/src/overlays/actors/ovl_En_Ma_Yts/z_en_ma_yts.h
@@ -41,9 +41,9 @@ typedef struct EnMaYts {
     /* 0x18C */ ColliderCylinder collider;
     /* 0x1D8 */ struct_800BD888_arg1 unk_1D8;
     /* 0x200 */ s32 unk_200; // Set, but not used
-    /* 0x204 */ Vec3s limbDrawTbl[MA1_LIMB_MAX];
+    /* 0x204 */ Vec3s jointTable[MA1_LIMB_MAX];
     /* 0x28E */ char unk_28E[0x6];
-    /* 0x294 */ Vec3s transitionDrawTbl[MA1_LIMB_MAX];
+    /* 0x294 */ Vec3s morphTable[MA1_LIMB_MAX];
     /* 0x31E */ char unk_31E[0x8];
     /* 0x326 */ s16 blinkTimer;
     /* 0x328 */ s16 overrideEyeTexIndex; // If non-zero, then this index will be used instead of eyeTexIndex
diff --git a/src/overlays/actors/ovl_En_Minifrog/z_en_minifrog.c b/src/overlays/actors/ovl_En_Minifrog/z_en_minifrog.c
index d1f4a0d90..9de59a963 100644
--- a/src/overlays/actors/ovl_En_Minifrog/z_en_minifrog.c
+++ b/src/overlays/actors/ovl_En_Minifrog/z_en_minifrog.c
@@ -92,8 +92,7 @@ void EnMinifrog_Init(Actor* thisx, GlobalContext* globalCtx) {
 
     Actor_ProcessInitChain(&this->actor, sInitChain);
     ActorShape_Init(&this->actor.shape, 0.0f, func_800B3FC0, 15.0f);
-    SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_0600B538, &D_06001534, this->limbDrawTable,
-                     this->transitionDrawTable, 24);
+    SkelAnime_InitFlex(globalCtx, &this->skelAnime, &D_0600B538, &D_06001534, this->jointTable, this->morphTable, 24);
     CollisionCheck_SetInfo(&this->actor.colChkInfo, NULL, &sColChkInfoInit);
     Collider_InitAndSetCylinder(globalCtx, &this->collider, &this->actor, &sCylinderInit);
 
@@ -181,7 +180,7 @@ EnMinifrog* EnMinifrog_GetFrog(GlobalContext* globalCtx) {
 void EnMinifrog_SetJumpState(EnMinifrog* this) {
     if (this->jumpState == MINIFROG_STATE_GROUND) {
         this->jumpState = MINIFROG_STATE_JUMP;
-        SkelAnime_ChangeAnim(&this->skelAnime, &D_060007BC, 1.0f, 0.0f, 7.0f, 2, -5.0f);
+        Animation_Change(&this->skelAnime, &D_060007BC, 1.0f, 0.0f, 7.0f, 2, -5.0f);
     }
 }
 
@@ -195,10 +194,10 @@ void EnMinifrog_JumpTimer(EnMinifrog* this) {
 }
 
 void EnMinifrog_Jump(EnMinifrog* this) {
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     switch (this->jumpState) {
         case MINIFROG_STATE_JUMP:
-            if (func_801378B8(&this->skelAnime, 4.0f)) {
+            if (Animation_OnFrame(&this->skelAnime, 4.0f)) {
                 this->actor.bgCheckFlags &= ~1;
                 this->actor.velocity.y = 6.0f;
                 Audio_PlayActorSound2(&this->actor, NA_SE_EV_FROG_JUMP);
@@ -208,8 +207,8 @@ void EnMinifrog_Jump(EnMinifrog* this) {
         case MINIFROG_STATE_AIR:
             if (this->actor.bgCheckFlags & 1) {
                 this->jumpState = MINIFROG_STATE_GROUND;
-                SkelAnime_ChangeAnimTransitionRepeat(&this->skelAnime, &D_06001534, -2.5f);
-                SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+                Animation_MorphToLoop(&this->skelAnime, &D_06001534, -2.5f);
+                SkelAnime_Update(&this->skelAnime);
             }
             break;
     }
@@ -606,7 +605,7 @@ void EnMinifrog_UpdateMissingFrog(Actor* thisx, GlobalContext* globalCtx) {
 }
 
 s32 EnMinifrog_OverrideLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3f* pos, Vec3s* rot,
-                                Actor* thisx) {
+                                Actor* arg) {
     if (limbIndex == 1) {
         pos->z -= 500.0f;
     }
@@ -618,19 +617,19 @@ s32 EnMinifrog_OverrideLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** d
     return 0;
 }
 
-void EnMinifrog_PostLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3s* rot, Actor* thisx) {
-    EnMinifrog* this = THIS;
+void EnMinifrog_PostLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3s* rot, Actor* arg) {
+    EnMinifrog* this = (EnMinifrog*)arg;
 
     if ((limbIndex == 7) || (limbIndex == 8)) {
         OPEN_DISPS(globalCtx->state.gfxCtx);
-        SysMatrix_NormalizeXYZ(&globalCtx->mf_187FC);
+        Matrix_NormalizeXYZ(&globalCtx->mf_187FC);
         gSPMatrix(POLY_OPA_DISP++, Matrix_NewMtx(globalCtx->state.gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
         gSPDisplayList(POLY_OPA_DISP++, *dList);
         CLOSE_DISPS(globalCtx->state.gfxCtx);
     }
 
     if (limbIndex == 4) {
-        SysMatrix_GetStateTranslation(&this->actor.focus.pos);
+        Matrix_GetStateTranslation(&this->actor.focus.pos);
     }
 }
 
@@ -648,7 +647,7 @@ void EnMinifrog_Draw(Actor* thisx, GlobalContext* globalCtx) {
     gSPSegment(POLY_OPA_DISP++, 0x08, D_808A4D74[0]);
     gSPSegment(POLY_OPA_DISP++, 0x09, D_808A4D74[0]);
     gDPSetEnvColor(POLY_OPA_DISP++, envColor->r, envColor->g, envColor->b, envColor->a);
-    SkelAnime_DrawSV(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl, this->skelAnime.dListCount,
-                     EnMinifrog_OverrideLimbDraw, EnMinifrog_PostLimbDraw, &this->actor);
+    SkelAnime_DrawFlexOpa(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable, this->skelAnime.dListCount,
+                          EnMinifrog_OverrideLimbDraw, EnMinifrog_PostLimbDraw, &this->actor);
     CLOSE_DISPS(globalCtx->state.gfxCtx);
 }
diff --git a/src/overlays/actors/ovl_En_Minifrog/z_en_minifrog.h b/src/overlays/actors/ovl_En_Minifrog/z_en_minifrog.h
index 1dc4a53de..201ef5c47 100644
--- a/src/overlays/actors/ovl_En_Minifrog/z_en_minifrog.h
+++ b/src/overlays/actors/ovl_En_Minifrog/z_en_minifrog.h
@@ -27,8 +27,8 @@ typedef enum {
 typedef struct EnMinifrog {
     /* 0x000 */ Actor actor;
     /* 0x144 */ SkelAnime skelAnime;
-    /* 0x188 */ Vec3s limbDrawTable[24];
-    /* 0x218 */ Vec3s transitionDrawTable[24];
+    /* 0x188 */ Vec3s jointTable[24];
+    /* 0x218 */ Vec3s morphTable[24];
     /* 0x2A8 */ EnMinifrogActionFunc actionFunc;
     /* 0x2AC */ struct EnMinifrog* frog;
     /* 0x2B0 */ s16 frogIndex;
diff --git a/src/overlays/actors/ovl_En_Niw/z_en_niw.c b/src/overlays/actors/ovl_En_Niw/z_en_niw.c
index f3af54caf..4bad3b031 100644
--- a/src/overlays/actors/ovl_En_Niw/z_en_niw.c
+++ b/src/overlays/actors/ovl_En_Niw/z_en_niw.c
@@ -8,6 +8,8 @@
 
 #define FLAGS 0x00800010
 
+#define THIS ((EnNiw*)thisx)
+
 void EnNiw_Init(Actor* thisx, GlobalContext* globalCtx);
 void EnNiw_Destroy(Actor* thisx, GlobalContext* globalCtx);
 void EnNiw_Update(Actor* thisx, GlobalContext* globalCtx);
@@ -28,7 +30,6 @@ void EnNiw_UpdateFeather(EnNiw* this, GlobalContext* globalCtx);
 void EnNiw_DrawFeathers(EnNiw* this, GlobalContext* globalCtx);
 void EnNiw_CheckRage(EnNiw* this, GlobalContext* globalCtx);
 void func_80891320(EnNiw* this, GlobalContext* globalCtx, s16 arg2);
-s32 EnNiw_LimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3f* pos, Vec3s* rot, struct Actor* actor);
 void EnNiw_SpawnFeather(EnNiw* this, Vec3f* pos, Vec3f* vel, Vec3f* accel, f32 scale);
 
 extern FlexSkeletonHeader D_06002530;
@@ -125,8 +126,8 @@ void EnNiw_Init(Actor* thisx, GlobalContext* globalCtx) {
 
     ActorShape_Init(&thisx->shape, 0.0f, func_800B3FC0, 25.0f);
 
-    SkelAnime_InitSV(globalCtx, &this->skelanime, &D_06002530, &D_060000E8, this->limbDrawTbl,
-                     this->transitionDrawtable, ENNIW_LIMBCOUNT);
+    SkelAnime_InitFlex(globalCtx, &this->skelanime, &D_06002530, &D_060000E8, this->jointTable, this->morphTable,
+                       ENNIW_LIMBCOUNT);
     Math_Vec3f_Copy(&this->unk2A4, &this->actor.world.pos);
     Math_Vec3f_Copy(&this->unk2B0, &this->actor.world.pos);
 
@@ -326,8 +327,7 @@ void func_808917F8(EnNiw* this, GlobalContext* globalCtx, s32 arg2) {
 }
 
 void EnNiw_SetupIdle(EnNiw* this) {
-    SkelAnime_ChangeAnim(&this->skelanime, &D_060000E8, 1.0f, 0.0f, SkelAnime_GetFrameCount(&D_060000E8.common), 0,
-                         -10.0f);
+    Animation_Change(&this->skelanime, &D_060000E8, 1.0f, 0.0f, Animation_GetLastFrame(&D_060000E8), 0, -10.0f);
     this->unknownState28E = 0;
     this->actionFunc = EnNiw_Idle;
 }
@@ -629,8 +629,7 @@ void EnNiw_CuccoStorm(EnNiw* this, GlobalContext* globalCtx) {
 }
 
 void EnNiw_SetupRunAway(EnNiw* this) {
-    SkelAnime_ChangeAnim(&this->skelanime, &D_060000E8, 1.0f, 0.0f, SkelAnime_GetFrameCount(&D_060000E8.common), 0,
-                         -10.0f);
+    Animation_Change(&this->skelanime, &D_060000E8, 1.0f, 0.0f, Animation_GetLastFrame(&D_060000E8), 0, -10.0f);
     this->unk29A = Rand_ZeroFloat(1.99f);
     this->unknownState28E = 7;
     this->actionFunc = EnNiw_RunAway;
@@ -907,8 +906,8 @@ void EnNiw_Update(Actor* thisx, GlobalContext* globalCtx) {
     }
 }
 
-s32 EnNiw_LimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3f* pos, Vec3s* rot, Actor* actor) {
-    EnNiw* this = (EnNiw*)actor;
+s32 EnNiw_LimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3f* pos, Vec3s* rot, Actor* thisx) {
+    EnNiw* this = THIS;
 
     if (limbIndex == 13) {
         rot->y += (s16)this->limbDRot;
@@ -933,8 +932,8 @@ void EnNiw_Draw(Actor* thisx, GlobalContext* globalCtx) {
     EnNiw* this = (EnNiw*)thisx;
 
     func_8012C28C(globalCtx->state.gfxCtx);
-    SkelAnime_DrawSV(globalCtx, this->skelanime.skeleton, this->skelanime.limbDrawTbl, this->skelanime.dListCount,
-                     EnNiw_LimbDraw, NULL, &this->actor);
+    SkelAnime_DrawFlexOpa(globalCtx, this->skelanime.skeleton, this->skelanime.jointTable, this->skelanime.dListCount,
+                          EnNiw_LimbDraw, NULL, &this->actor);
     EnNiw_DrawFeathers(this, globalCtx);
 }
 
@@ -1007,11 +1006,11 @@ void EnNiw_DrawFeathers(EnNiw* this, GlobalContext* globalCtx) {
                 isMaterialApplied++;
             }
 
-            SysMatrix_InsertTranslation(feather->pos.x, feather->pos.y, feather->pos.z, MTXMODE_NEW);
-            SysMatrix_NormalizeXYZ(&globalCtx->mf_187FC);
+            Matrix_InsertTranslation(feather->pos.x, feather->pos.y, feather->pos.z, MTXMODE_NEW);
+            Matrix_NormalizeXYZ(&globalCtx->mf_187FC);
             Matrix_Scale(feather->scale, feather->scale, 1.0f, MTXMODE_APPLY);
-            SysMatrix_InsertZRotation_f(feather->zRot, MTXMODE_APPLY);
-            SysMatrix_InsertTranslation(0.0f, -1000.0f, 0.0f, MTXMODE_APPLY);
+            Matrix_InsertZRotation_f(feather->zRot, MTXMODE_APPLY);
+            Matrix_InsertTranslation(0.0f, -1000.0f, 0.0f, MTXMODE_APPLY);
 
             gSPMatrix(POLY_XLU_DISP++, Matrix_NewMtx(gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
 
diff --git a/src/overlays/actors/ovl_En_Niw/z_en_niw.h b/src/overlays/actors/ovl_En_Niw/z_en_niw.h
index 07d958893..5a03215bc 100644
--- a/src/overlays/actors/ovl_En_Niw/z_en_niw.h
+++ b/src/overlays/actors/ovl_En_Niw/z_en_niw.h
@@ -25,8 +25,8 @@ typedef struct {
 typedef struct EnNiw {
     /* 0x000 */ Actor actor;
     /* 0x144 */ SkelAnime skelanime;
-    /* 0x188 */ Vec3s limbDrawTbl[ENNIW_LIMBCOUNT];
-    /* 0x1E8 */ Vec3s transitionDrawtable[ENNIW_LIMBCOUNT];
+    /* 0x188 */ Vec3s jointTable[ENNIW_LIMBCOUNT];
+    /* 0x1E8 */ Vec3s morphTable[ENNIW_LIMBCOUNT];
     /* 0x248 */ EnNiwActionFunc actionFunc;
     /* 0x24C */ s16 unkTimer24C;
     /* 0x24E */ s16 unkTimer24E;
diff --git a/src/overlays/actors/ovl_En_Nutsball/z_en_nutsball.c b/src/overlays/actors/ovl_En_Nutsball/z_en_nutsball.c
index bae091c19..b9aa32a0c 100644
--- a/src/overlays/actors/ovl_En_Nutsball/z_en_nutsball.c
+++ b/src/overlays/actors/ovl_En_Nutsball/z_en_nutsball.c
@@ -165,8 +165,8 @@ void EnNutsball_Draw(Actor* thisx, GlobalContext* globalCtx) {
 
     OPEN_DISPS(globalCtx->state.gfxCtx);
     func_8012C28C(globalCtx->state.gfxCtx);
-    SysMatrix_InsertMatrix(&globalCtx->mf_187FC, 1);
-    SysMatrix_InsertZRotation_s(this->actor.home.rot.z, 1);
+    Matrix_InsertMatrix(&globalCtx->mf_187FC, MTXMODE_APPLY);
+    Matrix_InsertZRotation_s(this->actor.home.rot.z, MTXMODE_APPLY);
     gSPMatrix(POLY_OPA_DISP++, Matrix_NewMtx(globalCtx->state.gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
     gSPDisplayList(POLY_OPA_DISP++, D_04058BA0);
     CLOSE_DISPS(globalCtx->state.gfxCtx);
diff --git a/src/overlays/actors/ovl_En_Ossan/z_en_ossan.c b/src/overlays/actors/ovl_En_Ossan/z_en_ossan.c
index 046f3bb80..be2c4b570 100644
--- a/src/overlays/actors/ovl_En_Ossan/z_en_ossan.c
+++ b/src/overlays/actors/ovl_En_Ossan/z_en_ossan.c
@@ -355,8 +355,8 @@ void EnOssan_Idle(EnOssan* this, GlobalContext* globalCtx) {
 
 void EnOssan_BeginInteraction(EnOssan* this, GlobalContext* globalCtx) {
     ActorAnimationEntryS* animations = sAnimations[this->actor.params];
-    s16 curFrame = this->skelAnime.animCurrentFrame;
-    s16 frameCount = SkelAnime_GetFrameCount(&animations[this->animationIdx].animationSeg->common);
+    s16 curFrame = this->skelAnime.curFrame;
+    s16 frameCount = Animation_GetLastFrame(animations[this->animationIdx].animationSeg);
 
     if (this->animationIdx == 3) {
         frameCount = 0;
@@ -550,7 +550,7 @@ void EnOssan_Hello(EnOssan* this, GlobalContext* globalCtx) {
         this->animationIdx = 9;
         func_8013BC6C(&this->skelAnime, animations, 9);
     }
-    if (this->animationIdx == 11 && func_801378B8(&this->skelAnime, 18.0f)) {
+    if (this->animationIdx == 11 && Animation_OnFrame(&this->skelAnime, 18.0f)) {
         Audio_PlayActorSound2(&this->actor, NA_SE_EV_HANKO);
     }
 }
@@ -1329,14 +1329,12 @@ void EnOssan_Blink(EnOssan* this) {
 }
 
 void EnOssan_InitCuriosityShopMan(EnOssan* this, GlobalContext* globalCtx) {
-    SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_06013320, &D_06012C34, this->limbDrawTbl, this->transitionDrawTbl,
-                     19);
+    SkelAnime_InitFlex(globalCtx, &this->skelAnime, &D_06013320, &D_06012C34, this->jointTable, this->morphTable, 19);
     this->actor.draw = EnOssan_DrawCuriosityShopMan;
 }
 
 void EnOssan_InitPartTimeWorker(EnOssan* this, GlobalContext* globalCtx) {
-    SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_060028A0, &D_06009D34, this->limbDrawTbl, this->transitionDrawTbl,
-                     16);
+    SkelAnime_InitFlex(globalCtx, &this->skelAnime, &D_060028A0, &D_06009D34, this->jointTable, this->morphTable, 16);
     this->actor.draw = EnOssan_DrawPartTimeWorker;
 }
 
@@ -1521,7 +1519,7 @@ void EnOssan_Update(Actor* thisx, GlobalContext* globalCtx) {
         func_800E9250(globalCtx, &this->actor, &this->headRot, &this->unk2CC, this->actor.focus.pos);
         this->actionFunc(this, globalCtx);
         Actor_SetHeight(&this->actor, 90.0f);
-        SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+        SkelAnime_Update(&this->skelAnime);
     } else {
         this->actionFunc(this, globalCtx);
     }
@@ -1642,7 +1640,7 @@ s32 EnOssan_OverrideLimbDrawCuriosityShopMan(GlobalContext* globalCtx, s32 limbI
     EnOssan* this = THIS;
 
     if (limbIndex == 16) {
-        SysMatrix_InsertXRotation_s(this->headRot.y, MTXMODE_APPLY);
+        Matrix_InsertXRotation_s(this->headRot.y, MTXMODE_APPLY);
     }
     return false;
 }
@@ -1652,8 +1650,8 @@ s32 EnOssan_OverrideLimbDrawPartTimeWorker(GlobalContext* globalCtx, s32 limbInd
     EnOssan* this = THIS;
 
     if (limbIndex == 15) {
-        SysMatrix_InsertXRotation_s(this->headRotPartTimeWorker.y, MTXMODE_APPLY);
-        SysMatrix_InsertZRotation_s(this->headRotPartTimeWorker.x, MTXMODE_APPLY);
+        Matrix_InsertXRotation_s(this->headRotPartTimeWorker.y, MTXMODE_APPLY);
+        Matrix_InsertZRotation_s(this->headRotPartTimeWorker.x, MTXMODE_APPLY);
     }
     return false;
 }
@@ -1674,7 +1672,7 @@ void EnOssan_PostLimbDrawPartTimeWorker(GlobalContext* globalCtx, s32 limbIndex,
     EnOssan* this = THIS;
 
     if (limbIndex == 15) {
-        SysMatrix_MultiplyVector3fByState(&sPartTimeWorkerFocusOffset, &this->actor.focus.pos);
+        Matrix_MultiplyVector3fByState(&sPartTimeWorkerFocusOffset, &this->actor.focus.pos);
     }
 }
 
@@ -1686,8 +1684,8 @@ void EnOssan_DrawCuriosityShopMan(Actor* thisx, GlobalContext* globalCtx) {
     OPEN_DISPS(globalCtx->state.gfxCtx);
     func_8012C28C(globalCtx->state.gfxCtx);
     gSPSegment(POLY_OPA_DISP++, 0x08, Lib_SegmentedToVirtual(sEyeTextures[this->eyeTexIndex]));
-    SkelAnime_DrawSV(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl, this->skelAnime.dListCount,
-                     EnOssan_OverrideLimbDrawCuriosityShopMan, EnOssan_PostLimbDrawCuriosityShopMan, &this->actor);
+    SkelAnime_DrawFlexOpa(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable, this->skelAnime.dListCount,
+                          EnOssan_OverrideLimbDrawCuriosityShopMan, EnOssan_PostLimbDrawCuriosityShopMan, &this->actor);
     EnOssan_DrawCursor(globalCtx, this, this->cursorPos.x, this->cursorPos.y, this->cursorPos.z, this->drawCursor);
     EnOssan_DrawStickDirectionPrompts(globalCtx, this);
     CLOSE_DISPS(globalCtx->state.gfxCtx);
@@ -1701,8 +1699,8 @@ void EnOssan_DrawPartTimeWorker(Actor* thisx, GlobalContext* globalCtx) {
     OPEN_DISPS(globalCtx->state.gfxCtx);
     func_8012C28C(globalCtx->state.gfxCtx);
     gSPSegment(POLY_OPA_DISP++, 0x08, Lib_SegmentedToVirtual(sEyeTextures[this->eyeTexIndex]));
-    SkelAnime_DrawSV(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl, this->skelAnime.dListCount,
-                     EnOssan_OverrideLimbDrawPartTimeWorker, EnOssan_PostLimbDrawPartTimeWorker, &this->actor);
+    SkelAnime_DrawFlexOpa(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable, this->skelAnime.dListCount,
+                          EnOssan_OverrideLimbDrawPartTimeWorker, EnOssan_PostLimbDrawPartTimeWorker, &this->actor);
     EnOssan_DrawCursor(globalCtx, this, this->cursorPos.x, this->cursorPos.y, this->cursorPos.z, this->drawCursor);
     EnOssan_DrawStickDirectionPrompts(globalCtx, this);
     CLOSE_DISPS(globalCtx->state.gfxCtx);
diff --git a/src/overlays/actors/ovl_En_Ossan/z_en_ossan.h b/src/overlays/actors/ovl_En_Ossan/z_en_ossan.h
index 689d352cf..53f8b8f39 100644
--- a/src/overlays/actors/ovl_En_Ossan/z_en_ossan.h
+++ b/src/overlays/actors/ovl_En_Ossan/z_en_ossan.h
@@ -50,8 +50,8 @@ typedef struct EnOssan {
     /* 0x2CC */ Vec3s unk2CC; // Set but never used
     /* 0x2D2 */ s16 limbRotTableY[19];
     /* 0x2F8 */ s16 limbRotTableZ[19];
-    /* 0x31E */ Vec3s limbDrawTbl[19];
-    /* 0x390 */ Vec3s transitionDrawTbl[19];
+    /* 0x31E */ Vec3s jointTable[19];
+    /* 0x390 */ Vec3s morphTable[19];
     /* 0x402 */ s16 animationIdx;
     /* 0x404 */ Vec3s headRotPartTimeWorker;
     /* 0x40A */ u16 flags;
diff --git a/src/overlays/actors/ovl_En_Owl/z_en_owl.c b/src/overlays/actors/ovl_En_Owl/z_en_owl.c
index 381f4e90a..f0a2327fd 100644
--- a/src/overlays/actors/ovl_En_Owl/z_en_owl.c
+++ b/src/overlays/actors/ovl_En_Owl/z_en_owl.c
@@ -139,8 +139,10 @@ void EnOwl_Init(Actor* thisx, GlobalContext* globalCtx) {
     }
 
     ActorShape_Init(&this->actor.shape, 0.0f, func_800B3FC0, 36.0f);
-    SkelAnime_InitSV(globalCtx, &this->skelAnime1, &D_0600C5F8, &D_06001ADC, this->jointTable1, this->morphTable1, 21);
-    SkelAnime_InitSV(globalCtx, &this->skelAnime2, &D_060105C0, &D_0600CDB0, this->jointTable2, this->morphTable2, 16);
+    SkelAnime_InitFlex(globalCtx, &this->skelAnime1, &D_0600C5F8, &D_06001ADC, this->jointTable1, this->morphTable1,
+                       21);
+    SkelAnime_InitFlex(globalCtx, &this->skelAnime2, &D_060105C0, &D_0600CDB0, this->jointTable2, this->morphTable2,
+                       16);
     Collider_InitAndSetCylinder(globalCtx, &this->collider, &this->actor, &sCylinderInit);
     this->actor.colChkInfo.mass = MASS_IMMOVABLE;
     this->actor.minVelocityY = -10.0f;
@@ -425,9 +427,9 @@ void func_8095B0C8(EnOwl* this) {
 }
 
 void func_8095B158(EnOwl* this) {
-    if (func_801378B8(&this->skelAnime1, 2.0f) || func_801378B8(&this->skelAnime1, 9.0f) ||
-        func_801378B8(&this->skelAnime1, 23.0f) || func_801378B8(&this->skelAnime1, 40.0f) ||
-        func_801378B8(&this->skelAnime1, 58.0f)) {
+    if (Animation_OnFrame(&this->skelAnime1, 2.0f) || Animation_OnFrame(&this->skelAnime1, 9.0f) ||
+        Animation_OnFrame(&this->skelAnime1, 23.0f) || Animation_OnFrame(&this->skelAnime1, 40.0f) ||
+        Animation_OnFrame(&this->skelAnime1, 58.0f)) {
         Audio_PlayActorSound2(&this->actor, NA_SE_EN_OWL_FLUTTER);
     }
 }
@@ -458,15 +460,15 @@ void func_8095B254(EnOwl* this, GlobalContext* globalCtx) {
 
 void func_8095B2F8(EnOwl* this, GlobalContext* globalCtx) {
     func_8095B06C(this);
-    if (this->skelAnime1.animCurrentFrame >= 18.0f) {
+    if (this->skelAnime1.curFrame >= 18.0f) {
         Math_SmoothStepToS(&this->actor.world.rot.y, this->unk_3EC, 2, 0x200, 0x80);
         this->actor.shape.rot.y = this->actor.world.rot.y;
     }
 
     if ((this->actor.shape.rot.y == this->unk_3EC) && (this->actionFlags & 1)) {
         this->actionFunc = func_8095B254;
-        SkelAnime_ChangeAnim(this->skelAnime3, this->skelAnime3->animCurrentSeg, 1.0f, 19.0f,
-                             SkelAnime_GetFrameCount(&D_06001168.common), 2, 0.0f);
+        Animation_Change(this->skelAnime3, this->skelAnime3->animation, 1.0f, 19.0f,
+                         Animation_GetLastFrame(&D_06001168), 2, 0.0f);
         this->unk_414 = func_8095C484;
     }
 
@@ -476,7 +478,7 @@ void func_8095B2F8(EnOwl* this, GlobalContext* globalCtx) {
 void func_8095B3DC(EnOwl* this, GlobalContext* globalCtx) {
     if (this->actionFlags & 1) {
         this->actionFunc = func_8095B2F8;
-        SkelAnime_ChangeAnim(this->skelAnime3, &D_06001168, 1.0f, 0.0f, 35.0f, 2, 0.0f);
+        Animation_Change(this->skelAnime3, &D_06001168, 1.0f, 0.0f, 35.0f, 2, 0.0f);
         this->unk_414 = func_8095C408;
         this->unk_3EC = 0x5500;
         this->actor.world.pos.y += 100.0f;
@@ -532,8 +534,7 @@ void func_8095B650(EnOwl* this, GlobalContext* globalCtx) {
 
 void func_8095B6C8(EnOwl* this, GlobalContext* globalCtx) {
     if (this->actionFlags & 1) {
-        SkelAnime_ChangeAnim(this->skelAnime3, &D_0600CB94, -1.0f, SkelAnime_GetFrameCount(&D_0600CB94.common), 0.0f, 2,
-                             0.0f);
+        Animation_Change(this->skelAnime3, &D_0600CB94, -1.0f, Animation_GetLastFrame(&D_0600CB94), 0.0f, 2, 0.0f);
         this->unk_414 = func_8095C484;
         this->actionFunc = func_8095B650;
     }
@@ -588,7 +589,7 @@ void func_8095B76C(EnOwl* this, GlobalContext* globalCtx) {
 }
 
 void func_8095B960(EnOwl* this, GlobalContext* globalCtx) {
-    if (this->skelAnime1.animCurrentFrame >= 18.0f) {
+    if (this->skelAnime1.curFrame >= 18.0f) {
         Math_SmoothStepToS(&this->actor.world.rot.y, this->unk_3EC, 2, 0x200, 0x80);
         this->actor.shape.rot.y = this->actor.world.rot.y;
     }
@@ -605,7 +606,7 @@ void func_8095B960(EnOwl* this, GlobalContext* globalCtx) {
 void func_8095B9FC(EnOwl* this, GlobalContext* globalCtx) {
     if (this->actionFlags & 1) {
         this->actionFunc = func_8095B960;
-        SkelAnime_ChangeAnim(this->skelAnime3, &D_06001168, 1.0f, 0.0f, 35.0f, 2, 0.0f);
+        Animation_Change(this->skelAnime3, &D_06001168, 1.0f, 0.0f, 35.0f, 2, 0.0f);
         this->unk_414 = func_8095C408;
         func_8095B0C8(this);
     }
@@ -766,16 +767,16 @@ void func_8095BF78(EnOwl* this, GlobalContext* globalCtx) {
 }
 
 void func_8095C09C(EnOwl* this, GlobalContext* globalCtx) {
-    if (this->skelAnime1.animCurrentFrame > 10.0f) {
+    if (this->skelAnime1.curFrame > 10.0f) {
         Math_SmoothStepToS(&this->actor.world.rot.y, this->unk_3EC, 2, 0x400, 0x40);
         this->actor.shape.rot.y = this->actor.world.rot.y;
     }
 
-    if (this->skelAnime1.animCurrentFrame > 45.0f) {
+    if (this->skelAnime1.curFrame > 45.0f) {
         this->actor.velocity.y = 2.0f;
         this->actor.gravity = 0.0f;
         this->actor.speedXZ = 8.0f;
-    } else if (this->skelAnime1.animCurrentFrame > 17.0f) {
+    } else if (this->skelAnime1.curFrame > 17.0f) {
         this->actor.velocity.y = 6.0f;
         this->actor.gravity = 0.0f;
         this->actor.speedXZ = 4.0f;
@@ -802,36 +803,34 @@ void func_8095C1C8(EnOwl* this, GlobalContext* globalCtx) {
 }
 
 void func_8095C258(EnOwl* this) {
-    SkelAnime_FrameUpdateMatrix(this->skelAnime3);
+    SkelAnime_Update(this->skelAnime3);
     if (this->unk_3EA > 0) {
         this->unk_3EA--;
         this->actor.shape.rot.z = Math_SinS(this->unk_3EA * 0x333) * 1000.0f;
     } else {
         this->unk_414 = func_8095C328;
         this->unk_3EA = 6;
-        SkelAnime_ChangeAnim(this->skelAnime3, &D_06001ADC, 1.0f, 0.0f, SkelAnime_GetFrameCount(&D_06001ADC.common), 2,
-                             5.0f);
+        Animation_Change(this->skelAnime3, &D_06001ADC, 1.0f, 0.0f, Animation_GetLastFrame(&D_06001ADC), 2, 5.0f);
     }
 }
 
 void func_8095C328(EnOwl* this) {
-    if (SkelAnime_FrameUpdateMatrix(this->skelAnime3)) {
+    if (SkelAnime_Update(this->skelAnime3)) {
         if (this->unk_3EA > 0) {
             this->unk_3EA--;
-            SkelAnime_ChangeAnim(this->skelAnime3, this->skelAnime3->animCurrentSeg, 1.0f, 0.0f,
-                                 SkelAnime_GetFrameCount(this->skelAnime3->genericSeg), 2, 0.0f);
+            Animation_Change(this->skelAnime3, this->skelAnime3->animation, 1.0f, 0.0f,
+                             Animation_GetLastFrame(this->skelAnime3->animation), 2, 0.0f);
         } else {
             this->unk_3EA = 160;
             this->unk_414 = func_8095C258;
-            SkelAnime_ChangeAnim(this->skelAnime3, &D_0600C6D4, 1.0f, 0.0f, SkelAnime_GetFrameCount(&D_0600C6D4.common),
-                                 0, 5.0f);
+            Animation_Change(this->skelAnime3, &D_0600C6D4, 1.0f, 0.0f, Animation_GetLastFrame(&D_0600C6D4), 0, 5.0f);
         }
     }
 }
 
 void func_8095C408(EnOwl* this) {
-    if (SkelAnime_FrameUpdateMatrix(this->skelAnime3)) {
-        SkelAnime_ChangeAnim(this->skelAnime3, this->skelAnime3->animCurrentSeg, 1.0f, 18.0f, 35.0f, 2, 0.0f);
+    if (SkelAnime_Update(this->skelAnime3)) {
+        Animation_Change(this->skelAnime3, this->skelAnime3->animation, 1.0f, 18.0f, 35.0f, 2, 0.0f);
         this->actionFlags |= 1;
     } else {
         this->actionFlags &= ~1;
@@ -839,9 +838,9 @@ void func_8095C408(EnOwl* this) {
 }
 
 void func_8095C484(EnOwl* this) {
-    if (SkelAnime_FrameUpdateMatrix(this->skelAnime3)) {
-        SkelAnime_ChangeAnim(this->skelAnime3, this->skelAnime3->animCurrentSeg, 1.0f, 0.0f,
-                             SkelAnime_GetFrameCount(this->skelAnime3->genericSeg), 2, 0.0f);
+    if (SkelAnime_Update(this->skelAnime3)) {
+        Animation_Change(this->skelAnime3, this->skelAnime3->animation, 1.0f, 0.0f,
+                         Animation_GetLastFrame(this->skelAnime3->animation), 2, 0.0f);
         this->actionFlags |= 1;
     } else {
         this->actionFlags &= ~1;
@@ -905,7 +904,7 @@ void EnOwl_Update(Actor* thisx, GlobalContext* globalCtx) {
     Collider_UpdateCylinder(&this->actor, &this->collider);
     CollisionCheck_SetOC(globalCtx, &globalCtx->colChkCtx, &this->collider.base);
     if (this->actor.update != NULL) {
-        if ((this->skelAnime1.animCurrentSeg == &D_06001ADC) && func_801378B8(&this->skelAnime1, 4.0f)) {
+        if ((this->skelAnime1.animation == &D_06001ADC) && Animation_OnFrame(&this->skelAnime1, 4.0f)) {
             Audio_PlayActorSound2(&this->actor, NA_SE_EN_OWL_FLUTTER);
         }
 
@@ -1143,7 +1142,7 @@ void EnOwl_PostLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Ve
     }
 
     if (limbIndex == 3) {
-        SysMatrix_MultiplyVector3fByState(&sp18, &this->actor.focus.pos);
+        Matrix_MultiplyVector3fByState(&sp18, &this->actor.focus.pos);
     }
 }
 
@@ -1162,8 +1161,8 @@ void EnOwl_Draw(Actor* thisx, GlobalContext* globalCtx) {
 
     gSPSegment(POLY_OPA_DISP++, 0x08, Lib_SegmentedToVirtual(eyeTextures[this->eyeTexIndex]));
 
-    SkelAnime_DrawSV(globalCtx, this->skelAnime3->skeleton, this->skelAnime3->limbDrawTbl, this->skelAnime3->dListCount,
-                     EnOwl_OverrideLimbDraw, EnOwl_PostLimbDraw, &this->actor);
+    SkelAnime_DrawFlexOpa(globalCtx, this->skelAnime3->skeleton, this->skelAnime3->jointTable,
+                          this->skelAnime3->dListCount, EnOwl_OverrideLimbDraw, EnOwl_PostLimbDraw, &this->actor);
 
     CLOSE_DISPS(globalCtx->state.gfxCtx);
 }
@@ -1173,9 +1172,9 @@ void func_8095D074(Actor* thisx, GlobalContext* globalCtx) {
 
     OPEN_DISPS(globalCtx->state.gfxCtx);
 
-    SysMatrix_InsertTranslation(0.0f, 500.0f, 0.0f, 1);
-    SysMatrix_InsertXRotation_s(this->unk_3D8 - 0x4000, 1);
-    SysMatrix_InsertTranslation(0.0f, 0.0f, -500.0f, 1);
+    Matrix_InsertTranslation(0.0f, 500.0f, 0.0f, 1);
+    Matrix_InsertXRotation_s(this->unk_3D8 - 0x4000, 1);
+    Matrix_InsertTranslation(0.0f, 0.0f, -500.0f, 1);
     if (this->unk_3DC >= 0x20) {
         gSPMatrix(POLY_OPA_DISP++, Matrix_NewMtx(globalCtx->state.gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
 
@@ -1200,8 +1199,8 @@ void func_8095D074(Actor* thisx, GlobalContext* globalCtx) {
 void EnOwl_ChangeMode(EnOwl* this, EnOwlActionFunc actionFunc, EnOwlFunc unkFunc, SkelAnime* skelAnime,
                       AnimationHeader* animationSeg, f32 transitionRate) {
     this->skelAnime3 = skelAnime;
-    SkelAnime_ChangeAnim(this->skelAnime3, animationSeg, 1.0f, 0.0f, SkelAnime_GetFrameCount(&animationSeg->common), 2,
-                         transitionRate);
+    Animation_Change(this->skelAnime3, animationSeg, 1.0f, 0.0f, Animation_GetLastFrame(animationSeg), 2,
+                     transitionRate);
     this->actionFunc = actionFunc;
     this->unk_414 = unkFunc;
 }
diff --git a/src/overlays/actors/ovl_En_Pamera/z_en_pamera.c b/src/overlays/actors/ovl_En_Pamera/z_en_pamera.c
index 94f8605af..bb7a5ffbd 100644
--- a/src/overlays/actors/ovl_En_Pamera/z_en_pamera.c
+++ b/src/overlays/actors/ovl_En_Pamera/z_en_pamera.c
@@ -152,8 +152,8 @@ void EnPamera_Init(Actor* thisx, GlobalContext* globalCtx) {
     Vec3f sp44;
 
     ActorShape_Init(&this->actor.shape, 0.0f, func_800B3FC0, 15.0f);
-    SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_06008448, &D_060005BC, this->limbDrawTbl, this->transitionDrawTbl,
-                     PAMERA_LIMB_MAX);
+    SkelAnime_InitFlex(globalCtx, &this->skelAnime, &D_06008448, &D_060005BC, this->jointTable, this->morphTable,
+                       PAMERA_LIMB_MAX);
     Collider_InitCylinder(globalCtx, &this->collider);
     Collider_SetCylinder(globalCtx, &this->collider, &this->actor, &sCylinderInit);
     CollisionCheck_SetInfo2(&this->actor.colChkInfo, NULL, &sColChkInfoInit2);
@@ -406,7 +406,7 @@ void EnPamera_LookDownWell(EnPamera* this) {
 
 void func_80BD8F60(EnPamera* this, GlobalContext* globalCtx) {
     Math_SmoothStepToS(&this->actor.shape.rot.y, this->actor.yawTowardsPlayer, 0xA, 0x3000, 0x1000);
-    if (func_801378B8(&this->skelAnime, this->skelAnime.animFrameCount)) {
+    if (Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame)) {
         func_800BDC5C(&this->skelAnime, sAnimations, 2);
         this->actor.speedXZ = 3.0f;
         func_80BD93CC(this, 0, 0);
@@ -510,12 +510,12 @@ void func_80BD93CC(EnPamera* this, s16 arg1, s16 arg2) {
 void func_80BD93F4(EnPamera* this, GlobalContext* globalCtx) {
     if ((this->actionFunc == func_80BD8B70) || (this->actionFunc == func_80BD8DB0) ||
         (this->actionFunc == func_80BD8964) || (this->actionFunc == func_80BD8A7C)) {
-        if (this->skelAnime.animCurrentSeg == &D_06008AE0) {
-            if (func_801378B8(&this->skelAnime, 9.0f) || func_801378B8(&this->skelAnime, 18.0f)) {
+        if (this->skelAnime.animation == &D_06008AE0) {
+            if (Animation_OnFrame(&this->skelAnime, 9.0f) || Animation_OnFrame(&this->skelAnime, 18.0f)) {
                 Audio_PlayActorSound2(&this->actor, NA_SE_EV_PAMERA_WALK);
             }
-        } else if ((this->skelAnime.animCurrentSeg == &D_06008E38) &&
-                   (func_801378B8(&this->skelAnime, 2.0f) || func_801378B8(&this->skelAnime, 6.0f))) {
+        } else if ((this->skelAnime.animation == &D_06008E38) &&
+                   (Animation_OnFrame(&this->skelAnime, 2.0f) || Animation_OnFrame(&this->skelAnime, 6.0f))) {
             Audio_PlayActorSound2(&this->actor, NA_SE_EV_PAMERA_WALK);
         }
     }
@@ -536,7 +536,7 @@ void EnPamera_Update(Actor* thisx, GlobalContext* globalCtx) {
     EnPamera* this = THIS;
 
     this->actionFunc(this, globalCtx);
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     func_80BD90AC(this, globalCtx);
     func_80BD9384(this, globalCtx);
     func_80BD94E0(this, globalCtx);
@@ -557,8 +557,10 @@ s32 EnPamera_OverrideLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dLi
 }
 
 void EnPamera_PostLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3s* rot, Actor* thisx) {
+    EnPamera* this = THIS;
+
     if (limbIndex == PAMERA_LIMB_HAIR) {
-        SysMatrix_MultiplyVector3fByState(&D_80BDA5F0, &thisx->focus.pos);
+        Matrix_MultiplyVector3fByState(&D_80BDA5F0, &this->actor.focus.pos);
     }
 }
 
@@ -570,8 +572,8 @@ void EnPamera_Draw(Actor* thisx, GlobalContext* globalCtx) {
     gSPSegment(POLY_OPA_DISP++, 0x08, SEGMENTED_TO_VIRTUAL(D_80BDA604[this->unk_312]));
     gSPSegment(POLY_OPA_DISP++, 0x09, SEGMENTED_TO_VIRTUAL(D_80BDA610[this->unk_314]));
     gSPSegment(POLY_OPA_DISP++, 0x0A, SEGMENTED_TO_VIRTUAL(D_80BDA5FC[this->unk_310]));
-    SkelAnime_DrawSV(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl, this->skelAnime.dListCount,
-                     EnPamera_OverrideLimbDraw, EnPamera_PostLimbDraw, &this->actor);
+    SkelAnime_DrawFlexOpa(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable, this->skelAnime.dListCount,
+                          EnPamera_OverrideLimbDraw, EnPamera_PostLimbDraw, &this->actor);
     CLOSE_DISPS(globalCtx->state.gfxCtx);
 }
 
@@ -775,13 +777,13 @@ void func_80BD9EE0(EnPamera* this) {
 
 void func_80BD9F3C(EnPamera* this, GlobalContext* globalCtx) {
     if (this->unk_31E == 1) {
-        if (func_801378B8(&this->skelAnime, 2.0f) || func_801378B8(&this->skelAnime, 6.0f) ||
-            func_801378B8(&this->skelAnime, 10.0f) || func_801378B8(&this->skelAnime, 14.0f) ||
-            func_801378B8(&this->skelAnime, 18.0f) || func_801378B8(&this->skelAnime, 22.0f) ||
-            func_801378B8(&this->skelAnime, 25.0f)) {
+        if (Animation_OnFrame(&this->skelAnime, 2.0f) || Animation_OnFrame(&this->skelAnime, 6.0f) ||
+            Animation_OnFrame(&this->skelAnime, 10.0f) || Animation_OnFrame(&this->skelAnime, 14.0f) ||
+            Animation_OnFrame(&this->skelAnime, 18.0f) || Animation_OnFrame(&this->skelAnime, 22.0f) ||
+            Animation_OnFrame(&this->skelAnime, 25.0f)) {
             Audio_PlayActorSound2(&this->actor, NA_SE_EV_PAMERA_WALK);
         }
-        if (func_801378B8(&this->skelAnime, this->skelAnime.animFrameCount)) {
+        if (Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame)) {
             this->unk_31E = 0;
             func_80BD93CC(this, 0, 0);
             func_800BDC5C(&this->skelAnime, sAnimations, 6);
@@ -808,7 +810,7 @@ void func_80BDA0A0(EnPamera* this) {
 
 void func_80BDA0FC(EnPamera* this, GlobalContext* globalCtx) {
     if (this->unk_31E == 1) {
-        if (func_801378B8(&this->skelAnime, this->skelAnime.animFrameCount)) {
+        if (Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame)) {
             this->unk_31E = 0;
             func_80BD93CC(this, 0, 0);
             func_800BDC5C(&this->skelAnime, sAnimations, 6);
@@ -825,11 +827,11 @@ void func_80BDA170(EnPamera* this) {
 
 void func_80BDA1C8(EnPamera* this, GlobalContext* globalCtx) {
     if (this->unk_31E == 1) {
-        if (func_801378B8(&this->skelAnime, 2.0f) || func_801378B8(&this->skelAnime, 6.0f) ||
-            func_801378B8(&this->skelAnime, 10.0f) || func_801378B8(&this->skelAnime, 14.0f)) {
+        if (Animation_OnFrame(&this->skelAnime, 2.0f) || Animation_OnFrame(&this->skelAnime, 6.0f) ||
+            Animation_OnFrame(&this->skelAnime, 10.0f) || Animation_OnFrame(&this->skelAnime, 14.0f)) {
             Audio_PlayActorSound2(&this->actor, NA_SE_EV_PAMERA_WALK);
         }
-        if (func_801378B8(&this->skelAnime, this->skelAnime.animFrameCount)) {
+        if (Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame)) {
             this->unk_31E = 0;
             func_80BD93CC(this, 0, 0);
             func_800BDC5C(&this->skelAnime, sAnimations, 10);
@@ -846,7 +848,7 @@ void func_80BDA288(EnPamera* this) {
 
 void func_80BDA2E0(EnPamera* this, GlobalContext* globalCtx) {
     if (this->unk_31E == 1) {
-        if (func_801378B8(&this->skelAnime, this->skelAnime.animFrameCount)) {
+        if (Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame)) {
             this->unk_31E = 0;
             func_800BDC5C(&this->skelAnime, sAnimations, 12);
         }
@@ -858,7 +860,7 @@ void func_80BDA344(Actor* thisx, GlobalContext* globalCtx) {
     EnPamera* this = THIS;
 
     this->actionFunc(this, globalCtx);
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     func_80BD9384(this, globalCtx);
     if (func_80BD9CB8(this, globalCtx)) {
         // Pamela is outside
diff --git a/src/overlays/actors/ovl_En_Pamera/z_en_pamera.h b/src/overlays/actors/ovl_En_Pamera/z_en_pamera.h
index 4ad65de5e..d19030aae 100644
--- a/src/overlays/actors/ovl_En_Pamera/z_en_pamera.h
+++ b/src/overlays/actors/ovl_En_Pamera/z_en_pamera.h
@@ -46,8 +46,8 @@ typedef struct EnPamera {
     /* 0x1E4 */ s32 pathPointsCount;
     /* 0x1E8 */ s32 pathId; 
     /* 0x1EC */ s32 unk_1EC;
-    /* 0x1F0 */ Vec3s limbDrawTbl[PAMERA_LIMB_MAX];
-    /* 0x27A */ Vec3s transitionDrawTbl[PAMERA_LIMB_MAX];
+    /* 0x1F0 */ Vec3s jointTable[PAMERA_LIMB_MAX];
+    /* 0x27A */ Vec3s morphTable[PAMERA_LIMB_MAX];
     /* 0x304 */ Vec3s limb9Rot;
     /* 0x30A */ Vec3s limb8Rot;
     /* 0x310 */ s16 unk_310;
diff --git a/src/overlays/actors/ovl_En_Pametfrog/z_en_pametfrog.c b/src/overlays/actors/ovl_En_Pametfrog/z_en_pametfrog.c
index ca90a1fd4..2b8246f34 100644
--- a/src/overlays/actors/ovl_En_Pametfrog/z_en_pametfrog.c
+++ b/src/overlays/actors/ovl_En_Pametfrog/z_en_pametfrog.c
@@ -207,8 +207,7 @@ void EnPametfrog_Init(Actor* thisx, GlobalContext* globalCtx) {
     Actor_ProcessInitChain(&this->actor, sInitChain);
     ActorShape_Init(&this->actor.shape, 0.0f, func_800B3FC0, 55.0f);
     CollisionCheck_SetInfo(&this->actor.colChkInfo, &sDamageTable, &sColChkInit);
-    SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_0600DF98, &D_0600F990, this->limbDrawTable,
-                     this->transitionDrawTable, 24);
+    SkelAnime_InitFlex(globalCtx, &this->skelAnime, &D_0600DF98, &D_0600F990, this->jointTable, this->morphTable, 24);
     Collider_InitAndSetJntSph(globalCtx, &this->collider, &this->actor, &sJntSphInit, this->colElement);
     this->params = CLAMP(this->actor.params, 1, 4);
     if (Actor_GetRoomCleared(globalCtx, globalCtx->roomCtx.currRoom.num)) {
@@ -336,8 +335,8 @@ s32 func_8086A2CC(EnPametfrog* this, CollisionPoly* floorPoly) {
 
     Math3D_CrossProduct(&this->unk_2DC, &floorNorm, &vec2);
     EnPametfrog_Vec3fNormalize(&vec2);
-    SysMatrix_InsertRotationAroundUnitVector_f(rotation, &vec2, 0);
-    SysMatrix_MultiplyVector3fByState(&this->unk_2E8, &vec2);
+    Matrix_InsertRotationAroundUnitVector_f(rotation, &vec2, 0);
+    Matrix_MultiplyVector3fByState(&this->unk_2E8, &vec2);
     Math_Vec3f_Copy(&this->unk_2E8, &vec2);
     Math3D_CrossProduct(&this->unk_2E8, &floorNorm, &this->unk_2D0);
     EnPametfrog_Vec3fNormalize(&this->unk_2D0);
@@ -398,9 +397,9 @@ void EnPametfrog_PlaceSnapper(EnPametfrog* this, GlobalContext* globalCtx) {
 }
 
 void EnPametfrog_JumpOnGround(EnPametfrog* this, GlobalContext* globalCtx) {
-    if (func_801378B8(&this->skelAnime, 1.0f)) {
+    if (Animation_OnFrame(&this->skelAnime, 1.0f)) {
         Audio_PlayActorSound2(&this->actor, NA_SE_EN_FROG_JUMP);
-    } else if (func_801378B8(&this->skelAnime, 11.0f)) {
+    } else if (Animation_OnFrame(&this->skelAnime, 11.0f)) {
         EnPametfrog_JumpWaterEffects(this, globalCtx);
         Audio_PlayActorSound2(&this->actor, NA_SE_EV_WALK_WATER);
     }
@@ -440,11 +439,11 @@ void EnPametfrog_ApplyStun(EnPametfrog* this) {
 
 void EnPametfrog_SetupRearOnSnapper(EnPametfrog* this) {
     if (this->actionFunc == EnPametfrog_RearOnSnapperRise) {
-        SkelAnime_ChangeAnimDefaultStop(&this->skelAnime, &D_06005694);
+        Animation_PlayOnce(&this->skelAnime, &D_06005694);
     } else if (this->actionFunc == EnPametfrog_RearOnSnapperWave) {
-        SkelAnime_ChangeAnimDefaultStop(&this->skelAnime, &D_060052EC);
+        Animation_PlayOnce(&this->skelAnime, &D_060052EC);
     } else {
-        SkelAnime_ChangeAnimDefaultStop(&this->skelAnime, &D_06004680);
+        Animation_PlayOnce(&this->skelAnime, &D_06004680);
     }
 
     this->actor.flags &= ~1;
@@ -457,11 +456,11 @@ void EnPametfrog_RearOnSnapper(EnPametfrog* this, GlobalContext* globalCtx) {
     Vec3f rearingPoint;
     s32 pad;
 
-    if (SkelAnime_FrameUpdateMatrix(&this->skelAnime)) {
+    if (SkelAnime_Update(&this->skelAnime)) {
         if (Rand_ZeroOne() < 0.5f) {
-            SkelAnime_ChangeAnimDefaultStop(&this->skelAnime, &D_06004D50);
+            Animation_PlayOnce(&this->skelAnime, &D_06004D50);
         } else {
-            SkelAnime_ChangeAnimDefaultStop(&this->skelAnime, &D_06004680);
+            Animation_PlayOnce(&this->skelAnime, &D_06004680);
         }
     }
 
@@ -479,13 +478,13 @@ void EnPametfrog_RearOnSnapper(EnPametfrog* this, GlobalContext* globalCtx) {
 }
 
 void EnPametfrog_SetupRearOnSnapperWave(EnPametfrog* this) {
-    SkelAnime_ChangeAnimDefaultStop(&this->skelAnime, &D_06004894);
+    Animation_PlayOnce(&this->skelAnime, &D_06004894);
     this->timer = 15;
     this->actionFunc = EnPametfrog_RearOnSnapperWave;
 }
 
 void EnPametfrog_RearOnSnapperWave(EnPametfrog* this, GlobalContext* globalCtx) {
-    if (SkelAnime_FrameUpdateMatrix(&this->skelAnime) && this->timer > 0) {
+    if (SkelAnime_Update(&this->skelAnime) && this->timer > 0) {
         this->timer--;
         if (this->timer == 0) {
             EnPametfrog_SetupRearOnSnapper(this);
@@ -494,7 +493,7 @@ void EnPametfrog_RearOnSnapperWave(EnPametfrog* this, GlobalContext* globalCtx)
 }
 
 void EnPametfrog_SetupRearOnSnapperRise(EnPametfrog* this) {
-    SkelAnime_ChangeAnimDefaultStop(&this->skelAnime, &D_060050B8);
+    Animation_PlayOnce(&this->skelAnime, &D_060050B8);
     this->timer = 10;
     this->actor.params = GEKKO_REAR_ON_SNAPPER;
     this->actor.shape.rot.x = 0;
@@ -504,7 +503,7 @@ void EnPametfrog_SetupRearOnSnapperRise(EnPametfrog* this) {
 }
 
 void EnPametfrog_RearOnSnapperRise(EnPametfrog* this, GlobalContext* globalCtx) {
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     this->timer--;
     if (this->timer == 0) {
         EnPametfrog_SetupRearOnSnapper(this);
@@ -518,7 +517,7 @@ void EnPametfrog_SetupFallOffSnapper(EnPametfrog* this, GlobalContext* globalCtx
     Vec3f eye;
     s16 yaw;
 
-    SkelAnime_ChangeAnimDefaultStop(&this->skelAnime, &D_06001F20);
+    Animation_PlayOnce(&this->skelAnime, &D_06001F20);
     this->actor.params = GEKKO_FALL_OFF_SNAPPER;
     this->actor.speedXZ = 7.0f;
     this->actor.velocity.y = 15.0f;
@@ -539,7 +538,7 @@ void EnPametfrog_SetupFallOffSnapper(EnPametfrog* this, GlobalContext* globalCtx
 void EnPametfrog_FallOffSnapper(EnPametfrog* this, GlobalContext* globalCtx) {
     f32 sin;
 
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     this->actor.shape.rot.x += 0x800;
     this->actor.shape.rot.z += 0x1000;
     if (this->timer != 0) {
@@ -555,7 +554,7 @@ void EnPametfrog_FallOffSnapper(EnPametfrog* this, GlobalContext* globalCtx) {
 }
 
 void EnPametfrog_SetupJumpToWall(EnPametfrog* this) {
-    SkelAnime_ChangeAnim(&this->skelAnime, &D_060039C4, 2.0f, 0.0f, 0.0f, 0, -2.0f);
+    Animation_Change(&this->skelAnime, &D_060039C4, 2.0f, 0.0f, 0.0f, 0, -2.0f);
     this->actor.shape.rot.x = 0;
     this->actor.shape.rot.z = 0;
     this->actor.bgCheckFlags &= ~8;
@@ -564,13 +563,13 @@ void EnPametfrog_SetupJumpToWall(EnPametfrog* this) {
 }
 
 void EnPametfrog_JumpToWall(EnPametfrog* this, GlobalContext* globalCtx) {
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     EnPametfrog_JumpOnGround(this, globalCtx);
     if ((this->actor.bgCheckFlags & 1) && (this->actor.bgCheckFlags & 8) && (this->actor.wallBgId == BGCHECK_SCENE) &&
         (COLPOLY_GET_NORMAL(this->actor.wallPoly->normal.y) < 0.5f)) {
         EnPametfrog_SetupWallCrawl(this);
     } else if (!(this->actor.bgCheckFlags & 1) ||
-               ((this->skelAnime.animCurrentFrame > 1.0f) && (this->skelAnime.animCurrentFrame < 12.0f))) {
+               ((this->skelAnime.curFrame > 1.0f) && (this->skelAnime.curFrame < 12.0f))) {
         this->actor.speedXZ = 12.0f;
     } else {
         this->actor.speedXZ = 0.0f;
@@ -579,7 +578,7 @@ void EnPametfrog_JumpToWall(EnPametfrog* this, GlobalContext* globalCtx) {
 
 void EnPametfrog_SetupWallCrawl(EnPametfrog* this) {
     if (this->actionFunc == EnPametfrog_JumpToWall) {
-        SkelAnime_ChangeAnimDefaultRepeat(&this->skelAnime, &D_06001E14);
+        Animation_PlayLoop(&this->skelAnime, &D_06001E14);
         this->collider.base.acFlags |= AC_ON;
         this->unk_2D0.x = 0.0f;
         this->unk_2D0.z = 0.0f;
@@ -599,7 +598,7 @@ void EnPametfrog_SetupWallCrawl(EnPametfrog* this) {
         this->actor.floorPoly = this->actor.wallPoly;
         this->wallPauseTimer = 10;
     } else {
-        this->skelAnime.animPlaybackSpeed = 1.0f;
+        this->skelAnime.playSpeed = 1.0f;
     }
 
     Audio_PlayActorSound2(&this->actor, NA_SE_EN_FROG_RUNAWAY);
@@ -623,7 +622,7 @@ void EnPametfrog_WallCrawl(EnPametfrog* this, GlobalContext* globalCtx) {
     if (this->freezeTimer > 0) {
         this->freezeTimer--;
     } else {
-        SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+        SkelAnime_Update(&this->skelAnime);
         this->timer--;
         this->actor.speedXZ = 8.0f;
         doubleSpeedXZ = this->actor.speedXZ * 2.0f;
@@ -657,7 +656,7 @@ void EnPametfrog_WallCrawl(EnPametfrog* this, GlobalContext* globalCtx) {
             func_8086A238(this);
         }
 
-        if (func_801378B8(&this->skelAnime, 15.0f)) {
+        if (Animation_OnFrame(&this->skelAnime, 15.0f)) {
             Audio_PlayActorSound2(&this->actor, NA_SE_EN_BOMCHU_WALK);
         }
 
@@ -682,7 +681,7 @@ void EnPametfrog_SetupWallPause(EnPametfrog* this) {
     f32 randFloat;
 
     this->actor.speedXZ = 0.0f;
-    this->skelAnime.animPlaybackSpeed = 1.5f;
+    this->skelAnime.playSpeed = 1.5f;
     if (this->timer != 0) {
         this->wallRotation = this->unk_2E8.y > 0.0f ? (M_PI / 30) : (-M_PI / 30);
     } else {
@@ -700,10 +699,10 @@ void EnPametfrog_WallPause(EnPametfrog* this, GlobalContext* globalCtx) {
     if (this->freezeTimer > 0) {
         this->freezeTimer--;
     } else {
-        SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+        SkelAnime_Update(&this->skelAnime);
         this->timer--;
-        SysMatrix_InsertRotationAroundUnitVector_f(this->wallRotation, &this->unk_2DC, 0);
-        SysMatrix_MultiplyVector3fByState(&this->unk_2D0, &vec);
+        Matrix_InsertRotationAroundUnitVector_f(this->wallRotation, &this->unk_2DC, 0);
+        Matrix_MultiplyVector3fByState(&this->unk_2D0, &vec);
         Math_Vec3f_Copy(&this->unk_2D0, &vec);
         Math3D_CrossProduct(&this->unk_2DC, &this->unk_2D0, &this->unk_2E8);
         func_8086A238(this);
@@ -720,8 +719,7 @@ void EnPametfrog_WallPause(EnPametfrog* this, GlobalContext* globalCtx) {
 void EnPametfrog_SetupClimbDownWall(EnPametfrog* this) {
     s16 yaw;
 
-    SkelAnime_ChangeAnim(&this->skelAnime, &D_060039C4, 0.0f, 0.0f, SkelAnime_GetFrameCount(&D_060039C4.common), 2,
-                         0.0f);
+    Animation_Change(&this->skelAnime, &D_060039C4, 0.0f, 0.0f, Animation_GetLastFrame(&D_060039C4), 2, 0.0f);
     this->actor.shape.rot.y = Actor_YawBetweenActors(&this->actor, this->actor.child);
     this->actor.world.rot.y = this->actor.shape.rot.y;
     this->actor.shape.rot.x = 0;
@@ -755,31 +753,30 @@ void EnPametfrog_ClimbDownWall(EnPametfrog* this, GlobalContext* globalCtx) {
 }
 
 void EnPametfrog_SetupRunToSnapper(EnPametfrog* this) {
-    SkelAnime_ChangeAnim(&this->skelAnime, &D_060039C4, 2.0f, 0.0f, 0.0f, 0, -2.0f);
+    Animation_Change(&this->skelAnime, &D_060039C4, 2.0f, 0.0f, 0.0f, 0, -2.0f);
     this->actor.params = GEKKO_RETURN_TO_SNAPPER;
     this->actionFunc = EnPametfrog_RunToSnapper;
 }
 
 void EnPametfrog_RunToSnapper(EnPametfrog* this, GlobalContext* globalCtx) {
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     EnPametfrog_JumpOnGround(this, globalCtx);
     this->actor.shape.rot.y = Actor_YawBetweenActors(&this->actor, this->actor.child);
     this->actor.world.rot.y = this->actor.shape.rot.y;
-    if (!(this->actor.bgCheckFlags & 1) ||
-        ((this->skelAnime.animCurrentFrame > 1.0f) && (this->skelAnime.animCurrentFrame < 12.0f))) {
+    if (!(this->actor.bgCheckFlags & 1) || ((this->skelAnime.curFrame > 1.0f) && (this->skelAnime.curFrame < 12.0f))) {
         this->actor.speedXZ = 12.0f;
     } else {
         this->actor.speedXZ = 0.0f;
     }
 
     if ((this->actor.child->params == 1) && (Actor_XZDistanceBetweenActors(&this->actor, this->actor.child) < 120.0f) &&
-        func_801378B8(&this->skelAnime, 0.0f)) {
+        Animation_OnFrame(&this->skelAnime, 0.0f)) {
         EnPametfrog_SetupJumpOnSnapper(this);
     }
 }
 
 void EnPametfrog_SetupJumpOnSnapper(EnPametfrog* this) {
-    SkelAnime_ChangeAnimTransitionStop(&this->skelAnime, &D_06004680, 6.0f);
+    Animation_MorphToPlayOnce(&this->skelAnime, &D_06004680, 6.0f);
     this->timer = 6;
     this->collider.base.ocFlags1 &= ~OC1_ON;
     this->collider.base.acFlags &= ~AC_ON;
@@ -796,7 +793,7 @@ void EnPametfrog_JumpOnSnapper(EnPametfrog* this, GlobalContext* globalCtx) {
     f32 temp_f0;
     EnBigpamet* bigpamet;
 
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     this->timer--;
     if (this->timer == 0) {
         EnPametfrog_SetupLandOnSnapper(this);
@@ -811,14 +808,14 @@ void EnPametfrog_JumpOnSnapper(EnPametfrog* this, GlobalContext* globalCtx) {
 }
 
 void EnPametfrog_SetupLandOnSnapper(EnPametfrog* this) {
-    SkelAnime_ChangeAnimDefaultStop(&this->skelAnime, &D_06000994);
+    Animation_PlayOnce(&this->skelAnime, &D_06000994);
     this->actor.shape.rot.y = this->actor.child->shape.rot.y;
     this->actor.params = GEKKO_ON_SNAPPER;
     this->actionFunc = EnPametfrog_LandOnSnapper;
 }
 
 void EnPametfrog_LandOnSnapper(EnPametfrog* this, GlobalContext* globalCtx) {
-    if (SkelAnime_FrameUpdateMatrix(&this->skelAnime)) {
+    if (SkelAnime_Update(&this->skelAnime)) {
         EnPametfrog_StopCutscene(this, globalCtx);
         EnPametfrog_SetupRearOnSnapper(this);
     }
@@ -829,7 +826,7 @@ void EnPametfrog_SetupFallInAir(EnPametfrog* this, GlobalContext* globalCtx) {
     Vec3f eye;
     f32 xzDist;
 
-    SkelAnime_ChangeAnimDefaultStop(&this->skelAnime, &D_06001F20);
+    Animation_PlayOnce(&this->skelAnime, &D_06001F20);
     if (this->actor.colChkInfo.health > 0) {
         this->actor.params = GEKKO_RETURN_TO_SNAPPER;
     }
@@ -868,7 +865,7 @@ void EnPametfrog_SetupFallInAir(EnPametfrog* this, GlobalContext* globalCtx) {
 }
 
 void EnPametfrog_FallInAir(EnPametfrog* this, GlobalContext* globalCtx) {
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     this->actor.colorFilterTimer = 0x10;
     if (this->timer > 0) {
         this->timer--;
@@ -890,7 +887,7 @@ void EnPametfrog_FallInAir(EnPametfrog* this, GlobalContext* globalCtx) {
 }
 
 void EnPametfrog_SetupFallOnGround(EnPametfrog* this, GlobalContext* globalCtx) {
-    SkelAnime_ChangeAnimDefaultStop(&this->skelAnime, &D_06004298);
+    Animation_PlayOnce(&this->skelAnime, &D_06004298);
     this->actor.shape.rot.x = 0;
     this->actor.shape.rot.y += this->spinYaw;
     this->actor.shape.rot.z = 0;
@@ -903,15 +900,15 @@ void EnPametfrog_SetupFallOnGround(EnPametfrog* this, GlobalContext* globalCtx)
 }
 
 void EnPametfrog_FallOnGround(EnPametfrog* this, GlobalContext* globalCtx) {
-    if (SkelAnime_FrameUpdateMatrix(&this->skelAnime)) {
-        if (this->skelAnime.animCurrentSeg == &D_06004298) {
+    if (SkelAnime_Update(&this->skelAnime)) {
+        if (this->skelAnime.animation == &D_06004298) {
             if (this->actor.colChkInfo.health == 0) {
                 this->timer--;
                 if (this->timer == 0) {
                     EnPametfrog_SetupDefeatGekko(this, globalCtx);
                 }
             } else {
-                SkelAnime_ChangeAnimDefaultStop(&this->skelAnime, &D_060030E4);
+                Animation_PlayOnce(&this->skelAnime, &D_060030E4);
             }
         } else {
             EnPametfrog_SetupRunToSnapper(this);
@@ -1044,7 +1041,7 @@ void EnPametfrog_PlayCutscene(EnPametfrog* this, GlobalContext* globalCtx) {
 }
 
 void EnPametfrog_SetupLookAround(EnPametfrog* this) {
-    SkelAnime_ChangeAnimDefaultStop(&this->skelAnime, &D_060066B4);
+    Animation_PlayOnce(&this->skelAnime, &D_060066B4);
     this->collider.base.atFlags &= ~AT_ON;
     this->actor.speedXZ = 0.0f;
     this->actor.world.rot.y = this->actor.shape.rot.y;
@@ -1055,7 +1052,7 @@ void EnPametfrog_LookAround(EnPametfrog* this, GlobalContext* globalCtx) {
     EnPametfrog_IdleWaterEffects(this, globalCtx);
     Math_SmoothStepToS(&this->actor.world.rot.y, this->actor.yawTowardsPlayer, 5, 0x400, 0x80);
     this->actor.shape.rot.y = this->actor.world.rot.y;
-    if (SkelAnime_FrameUpdateMatrix(&this->skelAnime) && (func_801690CC(globalCtx) == 0)) {
+    if (SkelAnime_Update(&this->skelAnime) && (func_801690CC(globalCtx) == 0)) {
         if (!this->unk_2AE) {
             func_801A2E54(0x38);
             this->unk_2AE = true;
@@ -1065,7 +1062,7 @@ void EnPametfrog_LookAround(EnPametfrog* this, GlobalContext* globalCtx) {
 }
 
 void EnPametfrog_SetupJumpToLink(EnPametfrog* this) {
-    SkelAnime_ChangeAnimDefaultRepeat(&this->skelAnime, &D_060039C4);
+    Animation_PlayLoop(&this->skelAnime, &D_060039C4);
     this->collider.base.acFlags |= AC_ON;
     this->actor.world.rot.y = this->actor.shape.rot.y;
     this->actionFunc = EnPametfrog_JumpToLink;
@@ -1074,10 +1071,9 @@ void EnPametfrog_SetupJumpToLink(EnPametfrog* this) {
 void EnPametfrog_JumpToLink(EnPametfrog* this, GlobalContext* globalCtx) {
     Math_SmoothStepToS(&this->actor.world.rot.y, this->actor.yawTowardsPlayer, 5, 0x1000, 0x80);
     this->actor.shape.rot.y = this->actor.world.rot.y;
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     EnPametfrog_JumpOnGround(this, globalCtx);
-    if (!(this->actor.bgCheckFlags & 1) ||
-        (this->skelAnime.animCurrentFrame > 1.0f && this->skelAnime.animCurrentFrame < 12.0f)) {
+    if (!(this->actor.bgCheckFlags & 1) || (this->skelAnime.curFrame > 1.0f && this->skelAnime.curFrame < 12.0f)) {
         this->actor.speedXZ = 8.0f;
     } else {
         this->actor.speedXZ = 0.0f;
@@ -1085,13 +1081,13 @@ void EnPametfrog_JumpToLink(EnPametfrog* this, GlobalContext* globalCtx) {
 
     if ((this->collider.base.ocFlags1 & OC1_HIT) && (this->collider.base.ocFlags2 & OC2_HIT_PLAYER) &&
         Actor_IsActorFacingLink(&this->actor, 0x3000) &&
-        (this->skelAnime.animCurrentFrame <= 2.0f || this->skelAnime.animCurrentFrame >= 11.0f)) {
+        (this->skelAnime.curFrame <= 2.0f || this->skelAnime.curFrame >= 11.0f)) {
         EnPametfrog_SetupMeleeAttack(this);
     }
 }
 
 void EnPametfrog_SetupMeleeAttack(EnPametfrog* this) {
-    SkelAnime_ChangeAnimDefaultStop(&this->skelAnime, &D_0600F990);
+    Animation_PlayOnce(&this->skelAnime, &D_0600F990);
     this->timer = 7;
     this->actor.speedXZ = 0.0f;
     this->actionFunc = EnPametfrog_MeleeAttack;
@@ -1106,23 +1102,23 @@ static AnimationHeader* sAttackAnimations[] = {
 
 void EnPametfrog_MeleeAttack(EnPametfrog* this, GlobalContext* globalCtx) {
     EnPametfrog_IdleWaterEffects(this, globalCtx);
-    if (SkelAnime_FrameUpdateMatrix(&this->skelAnime)) {
+    if (SkelAnime_Update(&this->skelAnime)) {
         this->timer--;
         if (this->timer == 0) {
             EnPametfrog_SetupLookAround(this);
         } else if (this->timer == 6) {
-            SkelAnime_ChangeAnimDefaultStop(&this->skelAnime, &D_0600F990);
+            Animation_PlayOnce(&this->skelAnime, &D_0600F990);
         } else {
-            SkelAnime_ChangeAnimDefaultStop(&this->skelAnime, sAttackAnimations[(s32)Rand_ZeroFloat(4.0f) % 4]);
+            Animation_PlayOnce(&this->skelAnime, sAttackAnimations[(s32)Rand_ZeroFloat(4.0f) % 4]);
         }
     }
 
-    if ((this->skelAnime.animCurrentSeg == &D_0600347C && func_801378B8(&this->skelAnime, 2.0f)) ||
-        (this->skelAnime.animCurrentSeg == &D_060070C4 && func_801378B8(&this->skelAnime, 9.0f)) ||
-        (this->skelAnime.animCurrentSeg == &D_06003F28 && func_801378B8(&this->skelAnime, 2.0f)) ||
-        ((this->skelAnime.animCurrentSeg == &D_0600F048) && func_801378B8(&this->skelAnime, 27.0f))) {
+    if ((this->skelAnime.animation == &D_0600347C && Animation_OnFrame(&this->skelAnime, 2.0f)) ||
+        (this->skelAnime.animation == &D_060070C4 && Animation_OnFrame(&this->skelAnime, 9.0f)) ||
+        (this->skelAnime.animation == &D_06003F28 && Animation_OnFrame(&this->skelAnime, 2.0f)) ||
+        ((this->skelAnime.animation == &D_0600F048) && Animation_OnFrame(&this->skelAnime, 27.0f))) {
         this->collider.base.atFlags |= AT_ON;
-        if (this->skelAnime.animCurrentSeg == &D_06003F28) {
+        if (this->skelAnime.animation == &D_06003F28) {
             Audio_PlayActorSound2(&this->actor, NA_SE_EN_FROG_KICK);
         } else {
             Audio_PlayActorSound2(&this->actor, NA_SE_EN_FROG_PUNCH1);
@@ -1133,7 +1129,7 @@ void EnPametfrog_MeleeAttack(EnPametfrog* this, GlobalContext* globalCtx) {
 }
 
 void EnPametfrog_SetupDamage(EnPametfrog* this) {
-    SkelAnime_ChangeAnimTransitionStop(&this->skelAnime, &D_06005D54, -3.0f);
+    Animation_MorphToPlayOnce(&this->skelAnime, &D_06005D54, -3.0f);
     this->timer = 20;
     this->collider.base.atFlags &= ~AT_ON;
     this->collider.base.acFlags &= ~AC_ON;
@@ -1146,7 +1142,7 @@ void EnPametfrog_SetupDamage(EnPametfrog* this) {
 }
 
 void EnPametfrog_Damage(EnPametfrog* this, GlobalContext* globalCtx) {
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     this->timer--;
     Math_StepToF(&this->actor.speedXZ, 0.0f, 0.5f);
     if (this->timer == 0) {
@@ -1159,9 +1155,9 @@ void EnPametfrog_Damage(EnPametfrog* this, GlobalContext* globalCtx) {
 }
 
 void EnPametfrog_SetupStun(EnPametfrog* this) {
-    if (this->skelAnime.animCurrentSeg == &D_060039C4) {
-        this->skelAnime.animCurrentFrame = 0.0f;
-        SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    if (this->skelAnime.animation == &D_060039C4) {
+        this->skelAnime.curFrame = 0.0f;
+        SkelAnime_Update(&this->skelAnime);
     }
 
     this->collider.base.atFlags &= ~AT_ON;
@@ -1191,7 +1187,7 @@ void EnPametfrog_SetupCallSnapper(EnPametfrog* this, GlobalContext* globalCtx) {
     Vec3f at;
     s16 yawDiff;
 
-    SkelAnime_ChangeAnimTransitionStop(&this->skelAnime, &D_06001B08, 3.0f);
+    Animation_MorphToPlayOnce(&this->skelAnime, &D_06001B08, 3.0f);
     Audio_PlayActorSound2(&this->actor, NA_SE_EN_FROG_GREET);
     this->actor.flags &= ~1;
     this->actor.colChkInfo.health = 6;
@@ -1219,7 +1215,7 @@ void EnPametfrog_SetupCallSnapper(EnPametfrog* this, GlobalContext* globalCtx) {
 }
 
 void EnPametfrog_CallSnapper(EnPametfrog* this, GlobalContext* globalCtx) {
-    if (SkelAnime_FrameUpdateMatrix(&this->skelAnime)) {
+    if (SkelAnime_Update(&this->skelAnime)) {
         EnPametfrog_SetupSnapperSpawn(this, globalCtx);
     }
 }
@@ -1408,16 +1404,16 @@ static s8 limbPosIndex[] = {
     -1, -1, 0, -1, 1, -1, 2, -1, 3, -1, 4, -1, 5, 6, -1, 7, 8, 9, -1, 10, -1, 11, -1, -1,
 };
 
-void EnPametfrog_PostLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3s* rot, Actor* thisx) {
-    EnPametfrog* this = THIS;
+void EnPametfrog_PostLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3s* rot, Actor* arg) {
+    EnPametfrog* this = (EnPametfrog*)arg;
     Vec3f vec;
     Vec3s* center;
     s8 index;
 
     if (limbIndex == GEKKO_LIMB_HEAD) {
-        SysMatrix_GetStateTranslation(&this->actor.focus.pos);
+        Matrix_GetStateTranslation(&this->actor.focus.pos);
         this->actor.focus.rot.y = this->actor.shape.rot.y;
-        SysMatrix_GetStateTranslationAndScaledY(2500.0f, &vec);
+        Matrix_GetStateTranslationAndScaledY(2500.0f, &vec);
         center = &this->collider.elements[0].dim.worldSphere.center;
         center->x = vec.x;
         center->y = vec.y;
@@ -1430,7 +1426,7 @@ void EnPametfrog_PostLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dLi
 
     index = limbPosIndex[limbIndex];
     if (index != -1) {
-        SysMatrix_GetStateTranslation(&this->limbPos[index]);
+        Matrix_GetStateTranslation(&this->limbPos[index]);
     }
 }
 
@@ -1439,8 +1435,8 @@ void EnPametfrog_Draw(Actor* thisx, GlobalContext* globalCtx) {
 
     func_8012C28C(globalCtx->state.gfxCtx);
     Matrix_RotateY(this->spinYaw, MTXMODE_APPLY);
-    SkelAnime_DrawSV(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl, this->skelAnime.dListCount, NULL,
-                     EnPametfrog_PostLimbDraw, &this->actor);
+    SkelAnime_DrawFlexOpa(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable, this->skelAnime.dListCount,
+                          NULL, EnPametfrog_PostLimbDraw, &this->actor);
     func_800BE680(globalCtx, &this->actor, this->limbPos, ARRAY_COUNT(this->limbPos), this->unk_2C8, this->unk_2CC,
                   this->unk_2C4, this->drawEffect);
 }
diff --git a/src/overlays/actors/ovl_En_Pametfrog/z_en_pametfrog.h b/src/overlays/actors/ovl_En_Pametfrog/z_en_pametfrog.h
index 58b8dcf4b..f00acecb5 100644
--- a/src/overlays/actors/ovl_En_Pametfrog/z_en_pametfrog.h
+++ b/src/overlays/actors/ovl_En_Pametfrog/z_en_pametfrog.h
@@ -58,8 +58,8 @@ typedef enum {
 typedef struct EnPametfrog {
     /* 0x000 */ Actor actor;
     /* 0x144 */ SkelAnime skelAnime;
-    /* 0x188 */ Vec3s limbDrawTable[GEKKO_LIMB_MAX];
-    /* 0x218 */ Vec3s transitionDrawTable[GEKKO_LIMB_MAX];
+    /* 0x188 */ Vec3s jointTable[GEKKO_LIMB_MAX];
+    /* 0x218 */ Vec3s morphTable[GEKKO_LIMB_MAX];
     /* 0x2A8 */ EnPametfrogActionFunc actionFunc;
     /* 0x2AC */ u8 drawEffect;
     /* 0x2AD */ u8 wallPauseTimer; // Gekko stops 10 times along wall/ceiling after being blown off of Snapper
diff --git a/src/overlays/actors/ovl_En_Po_Fusen/z_en_po_fusen.c b/src/overlays/actors/ovl_En_Po_Fusen/z_en_po_fusen.c
index b4d540fe7..c578e3d37 100644
--- a/src/overlays/actors/ovl_En_Po_Fusen/z_en_po_fusen.c
+++ b/src/overlays/actors/ovl_En_Po_Fusen/z_en_po_fusen.c
@@ -26,7 +26,7 @@ void EnPoFusen_Pop(EnPoFusen* this, GlobalContext* globalCtx);
 void EnPoFusen_Idle(EnPoFusen* this, GlobalContext* globalCtx);
 void EnPoFusen_IdleFuse(EnPoFusen* this, GlobalContext* globalCtx);
 s32 EnPoFusen_OverrideLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3f* pos, Vec3s* rot,
-                               struct Actor* actor);
+                               Actor* arg);
 
 extern AnimationHeader D_06000040;
 extern FlexSkeletonHeader D_060024F0;
@@ -111,7 +111,7 @@ void EnPoFusen_Init(Actor* thisx, GlobalContext* globalCtx) {
 
     if (0) {}
     this->collider.dim.worldSphere.radius = 40;
-    SkelAnime_InitSV(globalCtx, &this->anime, &D_060024F0, &D_06000040, this->limbDrawTbl, this->transitionDrawTbl, 10);
+    SkelAnime_InitFlex(globalCtx, &this->anime, &D_060024F0, &D_06000040, this->jointTable, this->morphTable, 10);
     ActorShape_Init(&this->actor.shape, 0.0f, func_800B3FC0, 25.0f);
     Actor_UpdateBgCheckInfo(globalCtx, &this->actor, 0.0f, 0.0f, 0.0f, 0x4);
 
@@ -271,8 +271,8 @@ void EnPoFusen_Update(Actor* thisx, GlobalContext* globalCtx) {
 }
 
 s32 EnPoFusen_OverrideLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3f* pos, Vec3s* rot,
-                               struct Actor* actor) {
-    EnPoFusen* this = (EnPoFusen*)actor;
+                               Actor* arg) {
+    EnPoFusen* this = (EnPoFusen*)arg;
     f32 zScale;
     f32 yScale;
     f32 xScale;
@@ -289,10 +289,10 @@ s32 EnPoFusen_OverrideLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dL
         yScale = yScale * yScale;
         xRot = ((Math_SinS(this->randXZRotChange) * 2730.0f));
         zRot = ((Math_CosS(this->randXZRotChange) * 2730.0f));
-        SysMatrix_InsertRotation(xRot, 0, zRot, 1);
-        Matrix_Scale(xScale, yScale, zScale, 1);
-        SysMatrix_InsertZRotation_s(-zRot, 1);
-        SysMatrix_InsertXRotation_s(-xRot, 1);
+        Matrix_InsertRotation(xRot, 0, zRot, MTXMODE_APPLY);
+        Matrix_Scale(xScale, yScale, zScale, MTXMODE_APPLY);
+        Matrix_InsertZRotation_s(-zRot, MTXMODE_APPLY);
+        Matrix_InsertXRotation_s(-xRot, MTXMODE_APPLY);
     } else if (limbIndex == 3) {
         rot->y += this->limb3Rot;
     } else if (limbIndex == 6) {
@@ -310,15 +310,15 @@ s32 EnPoFusen_OverrideLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dL
     return 0;
 }
 
-void EnPoFusen_PostLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3s* rot, Actor* actor) {
+void EnPoFusen_PostLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3s* rot, Actor* arg) {
 }
 
-void EnPoFusen_UnkActorDraw(GlobalContext* globalCtx, s32 limbIndex, Actor* actor) {
+void EnPoFusen_UnkActorDraw(GlobalContext* globalCtx, s32 limbIndex, Actor* thisx) {
 }
 
 void EnPoFusen_Draw(Actor* thisx, GlobalContext* globalCtx) {
     EnPoFusen* this = THIS;
     func_8012C28C(globalCtx->state.gfxCtx);
-    func_801343C0(globalCtx, this->anime.skeleton, this->anime.limbDrawTbl, this->anime.dListCount,
+    func_801343C0(globalCtx, this->anime.skeleton, this->anime.jointTable, this->anime.dListCount,
                   EnPoFusen_OverrideLimbDraw, EnPoFusen_PostLimbDraw, EnPoFusen_UnkActorDraw, &this->actor);
 }
diff --git a/src/overlays/actors/ovl_En_Po_Fusen/z_en_po_fusen.h b/src/overlays/actors/ovl_En_Po_Fusen/z_en_po_fusen.h
index b19cc01f9..5a879ddb1 100644
--- a/src/overlays/actors/ovl_En_Po_Fusen/z_en_po_fusen.h
+++ b/src/overlays/actors/ovl_En_Po_Fusen/z_en_po_fusen.h
@@ -12,8 +12,8 @@ typedef struct EnPoFusen {
     /* 0x144 */ SkelAnime anime;
     /* 0x188 */ EnPoFusenActionFunc actionFunc;
     /* 0x18C */ ColliderSphere collider;
-    /* 0x1E4 */ Vec3s limbDrawTbl[0xA];
-    /* 0x220 */ Vec3s transitionDrawTbl[0xA];
+    /* 0x1E4 */ Vec3s jointTable[0xA];
+    /* 0x220 */ Vec3s morphTable[0xA];
     /* 0x25C */ s16 randScaleChange;
     /* 0x25E */ s16 randXZRotChange;
     /* 0x260 */ s16 randYRotChange;
diff --git a/src/overlays/actors/ovl_En_Poh/z_en_poh.c b/src/overlays/actors/ovl_En_Poh/z_en_poh.c
index ace41a2ba..bddd970b9 100644
--- a/src/overlays/actors/ovl_En_Poh/z_en_poh.c
+++ b/src/overlays/actors/ovl_En_Poh/z_en_poh.c
@@ -222,15 +222,15 @@ void func_80B2C9B8(EnPoh* this, GlobalContext* globalCtx) {
 }
 
 void func_80B2CA4C(EnPoh* this) {
-    SkelAnime_ChangeAnimDefaultRepeat(&this->skelAnime, &D_060015B0);
+    Animation_PlayLoop(&this->skelAnime, &D_060015B0);
     this->unk_18E = Rand_S16Offset(2, 3);
     this->actionFunc = func_80B2CAA4;
     this->actor.speedXZ = 0.0f;
 }
 
 void func_80B2CAA4(EnPoh* this, GlobalContext* globalCtx) {
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
-    if (func_801378B8(&this->skelAnime, 0.0f) && (this->unk_18E != 0)) {
+    SkelAnime_Update(&this->skelAnime);
+    if (Animation_OnFrame(&this->skelAnime, 0.0f) && (this->unk_18E != 0)) {
         this->unk_18E--;
     }
 
@@ -248,16 +248,16 @@ void func_80B2CAA4(EnPoh* this, GlobalContext* globalCtx) {
 }
 
 void func_80B2CB60(EnPoh* this) {
-    SkelAnime_ChangeAnimDefaultRepeat(&this->skelAnime, &D_06000A60);
+    Animation_PlayLoop(&this->skelAnime, &D_06000A60);
     this->unk_18E = Rand_S16Offset(15, 3);
     this->colliderCylinder.base.acFlags |= AC_ON;
     this->actionFunc = func_80B2CBBC;
 }
 
 void func_80B2CBBC(EnPoh* this, GlobalContext* globalCtx) {
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     Math_StepToF(&this->actor.speedXZ, 1.0f, 0.2f);
-    if (func_801378B8(&this->skelAnime, 0.0f) && (this->unk_18E != 0)) {
+    if (Animation_OnFrame(&this->skelAnime, 0.0f) && (this->unk_18E != 0)) {
         this->unk_18E--;
     }
 
@@ -283,7 +283,7 @@ void func_80B2CBBC(EnPoh* this, GlobalContext* globalCtx) {
 }
 
 void func_80B2CD14(EnPoh* this) {
-    SkelAnime_ChangeAnimDefaultRepeat(&this->skelAnime, &D_06000A60);
+    Animation_PlayLoop(&this->skelAnime, &D_06000A60);
     this->actionFunc = func_80B2CD64;
     this->unk_18E = 0;
     this->actor.speedXZ = 2.0f;
@@ -293,7 +293,7 @@ void func_80B2CD64(EnPoh* this, GlobalContext* globalCtx) {
     Player* player = GET_PLAYER(globalCtx);
     s16 yawDiff;
 
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     if (this->unk_18E != 0) {
         this->unk_18E--;
     }
@@ -322,7 +322,7 @@ void func_80B2CD64(EnPoh* this, GlobalContext* globalCtx) {
 }
 
 void func_80B2CEC8(EnPoh* this) {
-    SkelAnime_ChangeAnimTransitionRepeat(&this->skelAnime, &D_060001A8, -6.0f);
+    Animation_MorphToLoop(&this->skelAnime, &D_060001A8, -6.0f);
     this->unk_18E = 12;
     this->actor.speedXZ = 0.0f;
     Audio_PlayActorSound2(&this->actor, NA_SE_EN_PO_LAUGH);
@@ -330,8 +330,8 @@ void func_80B2CEC8(EnPoh* this) {
 }
 
 void func_80B2CF28(EnPoh* this, GlobalContext* globalCtx) {
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
-    if (func_801378B8(&this->skelAnime, 0.0f)) {
+    SkelAnime_Update(&this->skelAnime);
+    if (Animation_OnFrame(&this->skelAnime, 0.0f)) {
         Audio_PlayActorSound2(&this->actor, NA_SE_EN_PO_KANTERA);
         if (this->unk_18E != 0) {
             this->unk_18E--;
@@ -343,7 +343,7 @@ void func_80B2CF28(EnPoh* this, GlobalContext* globalCtx) {
         Math_ScaledStepToS(&this->actor.world.rot.y, this->actor.yawTowardsPlayer, 0xAAA);
     } else if (this->unk_18E == 9) {
         this->actor.speedXZ = 5.0f;
-        this->skelAnime.animPlaybackSpeed = 2.0f;
+        this->skelAnime.playSpeed = 2.0f;
     } else if (this->unk_18E == 0) {
         func_80B2CB60(this);
         this->unk_18E = 0x17;
@@ -351,7 +351,7 @@ void func_80B2CF28(EnPoh* this, GlobalContext* globalCtx) {
 }
 
 void func_80B2CFF8(EnPoh* this) {
-    SkelAnime_ChangeAnimTransitionStop(&this->skelAnime, &D_060004EC, -6.0f);
+    Animation_MorphToPlayOnce(&this->skelAnime, &D_060004EC, -6.0f);
     func_800BE504(&this->actor, &this->colliderCylinder);
     this->colliderCylinder.base.acFlags &= ~AC_ON;
     this->actor.speedXZ = 5.0f;
@@ -361,7 +361,7 @@ void func_80B2CFF8(EnPoh* this) {
 
 void func_80B2D07C(EnPoh* this, GlobalContext* globalCtx) {
     Math_StepToF(&this->actor.speedXZ, 0.0f, 0.5f);
-    if (SkelAnime_FrameUpdateMatrix(&this->skelAnime)) {
+    if (SkelAnime_Update(&this->skelAnime)) {
         if (this->actor.colChkInfo.health != 0) {
             func_80B2DAD0(this);
         } else {
@@ -373,23 +373,23 @@ void func_80B2D07C(EnPoh* this, GlobalContext* globalCtx) {
 void func_80B2D0E8(EnPoh* this) {
     this->unk_197 = 0;
     this->actor.flags &= ~1;
-    SkelAnime_ChangeAnimPlaybackStop(&this->skelAnime, &D_060011C4, 0.0f);
+    Animation_PlayOnceSetSpeed(&this->skelAnime, &D_060011C4, 0.0f);
     this->actionFunc = func_80B2D140;
 }
 
 void func_80B2D140(EnPoh* this, GlobalContext* globalCtx) {
-    if (SkelAnime_FrameUpdateMatrix(&this->skelAnime)) {
+    if (SkelAnime_Update(&this->skelAnime)) {
         this->unk_197 = 255;
         this->unk_190 = Rand_S16Offset(700, 300);
         this->actor.flags |= 1;
         func_80B2CB60(this);
-    } else if (this->skelAnime.animCurrentFrame > 10.0f) {
-        this->unk_197 = (this->skelAnime.animCurrentFrame - 10.0f) * 0.05f * 255.0f;
+    } else if (this->skelAnime.curFrame > 10.0f) {
+        this->unk_197 = (this->skelAnime.curFrame - 10.0f) * 0.05f * 255.0f;
     }
 
-    if ((this->skelAnime.animPlaybackSpeed < 0.5f) && (this->actor.xzDistToPlayer < 280.0f)) {
+    if ((this->skelAnime.playSpeed < 0.5f) && (this->actor.xzDistToPlayer < 280.0f)) {
         Audio_PlayActorSound2(&this->actor, NA_SE_EN_STALKIDS_APPEAR);
-        this->skelAnime.animPlaybackSpeed = 1.0f;
+        this->skelAnime.playSpeed = 1.0f;
     }
 }
 
@@ -452,13 +452,13 @@ void func_80B2D300(EnPoh* this, GlobalContext* globalCtx) {
 }
 
 void func_80B2D5DC(EnPoh* this) {
-    SkelAnime_ChangeAnimDefaultStop(&this->skelAnime, &D_06000A60);
+    Animation_PlayOnce(&this->skelAnime, &D_06000A60);
     this->actionFunc = func_80B2D628;
     this->actor.speedXZ = -5.0f;
 }
 
 void func_80B2D628(EnPoh* this, GlobalContext* globalCtx) {
-    if (SkelAnime_FrameUpdateMatrix(&this->skelAnime)) {
+    if (SkelAnime_Update(&this->skelAnime)) {
         this->actor.world.rot.y = this->actor.shape.rot.y;
         func_80B2CB60(this);
         this->unk_18E = 23;
@@ -469,14 +469,14 @@ void func_80B2D628(EnPoh* this, GlobalContext* globalCtx) {
 }
 
 void func_80B2D694(EnPoh* this) {
-    SkelAnime_ChangeAnimDefaultRepeat(&this->skelAnime, &D_060015B0);
+    Animation_PlayLoop(&this->skelAnime, &D_060015B0);
     this->unk_192 = BINANG_ROT180(this->actor.world.rot.y);
     this->actionFunc = func_80B2D6EC;
     this->actor.speedXZ = 0.0f;
 }
 
 void func_80B2D6EC(EnPoh* this, GlobalContext* globalCtx) {
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     if (Math_ScaledStepToS(&this->actor.world.rot.y, this->unk_192, 0x71C)) {
         func_80B2CB60(this);
     }
@@ -547,7 +547,7 @@ void func_80B2D980(EnPoh* this, GlobalContext* globalCtx) {
 }
 
 void func_80B2DAD0(EnPoh* this) {
-    SkelAnime_ChangeAnimTransitionRepeat(&this->skelAnime, &D_060006E0, -5.0f);
+    Animation_MorphToLoop(&this->skelAnime, &D_060006E0, -5.0f);
     this->actor.speedXZ = 5.0f;
     this->actor.world.rot.y = BINANG_ROT180(this->actor.shape.rot.y);
     this->colliderCylinder.base.acFlags |= AC_ON;
@@ -558,7 +558,7 @@ void func_80B2DAD0(EnPoh* this) {
 void func_80B2DB44(EnPoh* this, GlobalContext* globalCtx) {
     f32 sp24;
 
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     sp24 = Math_SinS(this->unk_18D * 0x800) * 3.0f;
     this->actor.world.pos.x -= sp24 * Math_CosS(this->actor.shape.rot.y);
     this->actor.world.pos.z += sp24 * Math_SinS(this->actor.shape.rot.y);
@@ -791,9 +791,9 @@ void func_80B2E6C0(EnPoh* this) {
 }
 
 void func_80B2E8E0(EnPoh* this) {
-    if ((this->actionFunc == func_80B2D140) && (this->skelAnime.animCurrentFrame < 12.0f)) {
-        this->unk_198 = this->unk_199 = this->unk_19A = (this->skelAnime.animCurrentFrame * 16.66f) + 55.0f;
-        this->unk_19B = this->skelAnime.animCurrentFrame * 16.666666f;
+    if ((this->actionFunc == func_80B2D140) && (this->skelAnime.curFrame < 12.0f)) {
+        this->unk_198 = this->unk_199 = this->unk_19A = (this->skelAnime.curFrame * 16.66f) + 55.0f;
+        this->unk_19B = this->skelAnime.curFrame * 16.666666f;
     } else {
         f32 rand = Rand_ZeroOne();
 
@@ -895,7 +895,7 @@ void EnPoh_PostLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Ve
         if ((this->actionFunc == func_80B2D300) && (this->unk_18E >= 19) && (this->actor.scale.x != 0.0f)) {
             Matrix_Scale(0.01f / this->actor.scale.x, 0.01f / this->actor.scale.x, 0.01f / this->actor.scale.x, 1);
         }
-        SysMatrix_CopyCurrentState(&this->unk_3D8);
+        Matrix_CopyCurrentState(&this->unk_3D8);
         func_80B2C910(&sp60, globalCtx);
         Lights_PointGlowSetInfo(&this->lightInfo, this->colliderSph.elements[0].dim.worldSphere.center.x + (s32)sp60.x,
                                 this->colliderSph.elements[0].dim.worldSphere.center.y + (s32)sp60.y,
@@ -906,19 +906,19 @@ void EnPoh_PostLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Ve
     temp_s3 = D_80B2F71C[limbIndex];
     if (temp_s3 != -1) {
         if (temp_s3 < 4) {
-            SysMatrix_GetStateTranslation(&this->unk_2A0[temp_s3]);
+            Matrix_GetStateTranslation(&this->unk_2A0[temp_s3]);
         } else if (temp_s3 == 4) {
-            SysMatrix_GetStateTranslationAndScaledX(2000.0f, &this->unk_2A0[temp_s3]);
+            Matrix_GetStateTranslationAndScaledX(2000.0f, &this->unk_2A0[temp_s3]);
         } else {
             s32 i;
             Vec3f* vec = &this->unk_2A0[temp_s3 + 2];
             Vec3f* vec2 = &D_80B2F734[0];
 
-            SysMatrix_GetStateTranslationAndScaledX(-2000.0f, &this->unk_2A0[temp_s3]);
-            SysMatrix_GetStateTranslationAndScaledY(-2000.0f, &this->unk_2A0[temp_s3 + 1]);
+            Matrix_GetStateTranslationAndScaledX(-2000.0f, &this->unk_2A0[temp_s3]);
+            Matrix_GetStateTranslationAndScaledY(-2000.0f, &this->unk_2A0[temp_s3 + 1]);
 
             for (i = temp_s3 + 2; i < ARRAY_COUNT(this->unk_2A0); i++, vec++, vec2++) {
-                SysMatrix_MultiplyVector3fByState(vec2, vec);
+                Matrix_MultiplyVector3fByState(vec2, vec);
             }
         }
     }
@@ -938,8 +938,8 @@ void EnPoh_Draw(Actor* thisx, GlobalContext* globalCtx) {
         gDPSetEnvColor(&gfx[1], this->unk_194, this->unk_195, this->unk_196, this->unk_197);
         gSPSegment(&gfx[2], 0x08, D_801AEFA0);
 
-        gfx = SkelAnime_Draw2(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl, EnPoh_OverrideLimbDraw,
-                              EnPoh_PostLimbDraw, &this->actor, &gfx[3]);
+        gfx = SkelAnime_Draw(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable, EnPoh_OverrideLimbDraw,
+                             EnPoh_PostLimbDraw, &this->actor, &gfx[3]);
 
         POLY_OPA_DISP = gfx;
     } else {
@@ -949,8 +949,8 @@ void EnPoh_Draw(Actor* thisx, GlobalContext* globalCtx) {
         gDPSetEnvColor(&gfx[1], 255, 255, 255, this->unk_197);
         gSPSegment(&gfx[2], 0x08, D_801AEF88);
 
-        POLY_XLU_DISP = SkelAnime_Draw2(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl,
-                                        EnPoh_OverrideLimbDraw, EnPoh_PostLimbDraw, &this->actor, &gfx[3]);
+        POLY_XLU_DISP = SkelAnime_Draw(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable,
+                                       EnPoh_OverrideLimbDraw, EnPoh_PostLimbDraw, &this->actor, &gfx[3]);
 
         gfx = POLY_OPA_DISP;
         gSPDisplayList(gfx++, &sSetupDL[6 * 25]);
@@ -959,7 +959,7 @@ void EnPoh_Draw(Actor* thisx, GlobalContext* globalCtx) {
     gDPPipeSync(&gfx[0]);
     gDPSetEnvColor(&gfx[1], this->unk_198, this->unk_199, this->unk_19A, 255);
 
-    SysMatrix_SetCurrentState(&this->unk_3D8);
+    Matrix_SetCurrentState(&this->unk_3D8);
 
     gSPMatrix(&gfx[2], Matrix_NewMtx(globalCtx->state.gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
     gSPDisplayList(&gfx[3], D_06002D28);
@@ -1013,8 +1013,7 @@ void func_80B2F37C(Actor* thisx, GlobalContext* globalCtx) {
         gDPSetPrimColor(POLY_XLU_DISP++, 0x80, 0x80, 255, 170, 255, this->unk_197);
         gDPSetEnvColor(POLY_XLU_DISP++, this->unk_194, this->unk_195, this->unk_196, 255);
 
-        SysMatrix_InsertYRotation_f((func_800DFCDC(GET_ACTIVE_CAM(globalCtx)) + 0x8000) * (M_PI / 32768),
-                                    MTXMODE_APPLY);
+        Matrix_InsertYRotation_f((func_800DFCDC(GET_ACTIVE_CAM(globalCtx)) + 0x8000) * (M_PI / 32768), MTXMODE_APPLY);
 
         gSPMatrix(POLY_XLU_DISP++, Matrix_NewMtx(globalCtx->state.gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
         gSPDisplayList(POLY_XLU_DISP++, D_06003850);
diff --git a/src/overlays/actors/ovl_En_Railgibud/z_en_railgibud.c b/src/overlays/actors/ovl_En_Railgibud/z_en_railgibud.c
index 8105dfb66..5f9fe203a 100644
--- a/src/overlays/actors/ovl_En_Railgibud/z_en_railgibud.c
+++ b/src/overlays/actors/ovl_En_Railgibud/z_en_railgibud.c
@@ -220,7 +220,7 @@ void EnRailgibud_Init(Actor* thisx, GlobalContext* globalCtx) {
     }
 
     ActorShape_Init(&this->actor.shape, 0.0f, func_800B3FC0, 28.0f);
-    SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_060053E8, &D_0600ABE0, this->jointTable, this->morphTable, 26);
+    SkelAnime_InitFlex(globalCtx, &this->skelAnime, &D_060053E8, &D_0600ABE0, this->jointTable, this->morphTable, 26);
     Collider_InitCylinder(globalCtx, &this->collider);
     Collider_SetCylinder(globalCtx, &this->collider, &this->actor, &sCylinderInit);
     CollisionCheck_SetInfo2(&this->actor.colChkInfo, &sDamageTable, &sColChkInfoInit);
@@ -354,7 +354,7 @@ void func_80BA5B64(EnRailgibud* this, GlobalContext* globalCtx) {
         this->unk_3F4--;
     }
 
-    if (func_801378B8(&this->skelAnime, 10.0f) || func_801378B8(&this->skelAnime, 22.0f)) {
+    if (Animation_OnFrame(&this->skelAnime, 10.0f) || Animation_OnFrame(&this->skelAnime, 22.0f)) {
         Audio_PlayActorSound2(&this->actor, NA_SE_EN_RIZA_WALK);
     } else if ((globalCtx->gameplayFrames & 95) == 0) {
         Audio_PlayActorSound2(&this->actor, NA_SE_EN_REDEAD_CRY);
@@ -378,7 +378,7 @@ void func_80BA5E18(EnRailgibud* this, GlobalContext* globalCtx) {
     switch (this->unk_3F0) {
         case 0:
             sp34 = func_80BA7088(this, globalCtx);
-            if (func_801378B8(&this->skelAnime, this->skelAnime.animFrameCount) && (sp34 == 1)) {
+            if (Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame) && (sp34 == 1)) {
                 this->unk_3F0 = 1;
                 func_800BDC5C(&this->skelAnime, sAnimations, 0);
             } else if (!(player->stateFlags2 & 0x80)) {
@@ -402,7 +402,7 @@ void func_80BA5E18(EnRailgibud* this, GlobalContext* globalCtx) {
                 this->unk_3F2++;
             }
 
-            if (func_801378B8(&this->skelAnime, 0.0f)) {
+            if (Animation_OnFrame(&this->skelAnime, 0.0f)) {
                 Audio_PlayActorSound2(&this->actor, NA_SE_EN_REDEAD_ATTACK);
             }
 
@@ -419,7 +419,7 @@ void func_80BA5E18(EnRailgibud* this, GlobalContext* globalCtx) {
             break;
 
         case 2:
-            if (func_801378B8(&this->skelAnime, this->skelAnime.animFrameCount)) {
+            if (Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame)) {
                 this->unk_3F4 = 40;
                 this->actor.shape.yOffset = 0.0f;
                 func_80BA5AF0(this);
@@ -445,7 +445,7 @@ void func_80BA60B0(EnRailgibud* this, GlobalContext* globalCtx) {
     this->actor.world.rot.y = this->actor.yawTowardsPlayer;
     Math_SmoothStepToS(&this->unk_3E2, 0, 1, 0x12C, 0);
     Math_SmoothStepToS(&this->unk_3E8, 0, 1, 0x12C, 0);
-    if (func_801378B8(&this->skelAnime, this->skelAnime.animFrameCount)) {
+    if (Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame)) {
         this->actor.world.rot.y = this->actor.shape.rot.y;
         func_80BA6158(this);
     }
@@ -516,12 +516,12 @@ void func_80BA64AC(EnRailgibud* this, GlobalContext* globalCtx) {
         this->actor.speedXZ += 0.15f;
     }
 
-    if (func_801378B8(&this->skelAnime, this->skelAnime.animFrameCount)) {
+    if (Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame)) {
         this->unk_405 = -1;
         this->actor.world.rot.y = this->actor.shape.rot.y;
         if ((this->unk_3F6 > 0) && (this->unk_404 == 0) && (this->unk_3F8 == 0)) {
             this->actor.hintId = 0x2A;
-            SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_06010B88, NULL, this->jointTable, this->morphTable, 26);
+            SkelAnime_InitFlex(globalCtx, &this->skelAnime, &D_06010B88, NULL, this->jointTable, this->morphTable, 26);
             this->unk_3F8 = 1;
         }
         func_80BA6284(this);
@@ -584,7 +584,7 @@ void func_80BA66C8(EnRailgibud* this, GlobalContext* globalCtx) {
     }
 
     if ((this->unk_3F2 == 20) && (this->unk_3F6 > 0) && (this->unk_404 == 0) && (this->unk_3F8 == 0)) {
-        SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_06010B88, NULL, this->jointTable, this->morphTable, 26);
+        SkelAnime_InitFlex(globalCtx, &this->skelAnime, &D_06010B88, NULL, this->jointTable, this->morphTable, 26);
         this->unk_3F8 = 1;
     }
 }
@@ -912,7 +912,7 @@ void EnRailgibud_Update(Actor* thisx, GlobalContext* globalCtx) {
     func_80BA6DF8(this, globalCtx);
     this->actionFunc(this, globalCtx);
     if (this->actionFunc != func_80BA6604) {
-        SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+        SkelAnime_Update(&this->skelAnime);
     }
     func_80BA71E4(this, globalCtx);
     func_80BA76C4(this, globalCtx);
@@ -949,7 +949,7 @@ void EnRailgibud_PostLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dLi
         ((limbIndex == 3) || (limbIndex == 4) || (limbIndex == 6) || (limbIndex == 8) || (limbIndex == 9) ||
          (limbIndex == 11) || (limbIndex == 14) || (limbIndex == 16) || (limbIndex == 17) || (limbIndex == 18) ||
          (limbIndex == 20) || (limbIndex == 21) || (limbIndex == 22) || (limbIndex == 24) || (limbIndex == 25))) {
-        SysMatrix_GetStateTranslation(&this->unk_1D8[this->unk_28C]);
+        Matrix_GetStateTranslation(&this->unk_1D8[this->unk_28C]);
         this->unk_28C++;
     }
 }
@@ -966,18 +966,18 @@ void EnRailgibud_Draw(Actor* thisx, GlobalContext* globalCtx) {
         gDPSetEnvColor(POLY_OPA_DISP++, 0, 0, 0, this->actor.shape.shadowAlpha);
         gSPSegment(POLY_OPA_DISP++, 0x08, D_801AEFA0);
 
-        POLY_OPA_DISP = SkelAnime_DrawSV2(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl,
-                                          this->skelAnime.dListCount, EnRailgibud_OverrideLimbDraw,
-                                          EnRailgibud_PostLimbDraw, &this->actor, POLY_OPA_DISP);
+        POLY_OPA_DISP = SkelAnime_DrawFlex(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable,
+                                           this->skelAnime.dListCount, EnRailgibud_OverrideLimbDraw,
+                                           EnRailgibud_PostLimbDraw, &this->actor, POLY_OPA_DISP);
     } else {
         func_8012C2DC(globalCtx->state.gfxCtx);
 
         gDPSetEnvColor(POLY_XLU_DISP++, 0, 0, 0, this->actor.shape.shadowAlpha);
         gSPSegment(POLY_XLU_DISP++, 0x08, D_801AEF88);
 
-        POLY_XLU_DISP = SkelAnime_DrawSV2(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl,
-                                          this->skelAnime.dListCount, EnRailgibud_OverrideLimbDraw,
-                                          EnRailgibud_PostLimbDraw, &this->actor, POLY_XLU_DISP);
+        POLY_XLU_DISP = SkelAnime_DrawFlex(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable,
+                                           this->skelAnime.dListCount, EnRailgibud_OverrideLimbDraw,
+                                           EnRailgibud_PostLimbDraw, &this->actor, POLY_XLU_DISP);
     }
 
     if (this->unk_3F6 > 0) {
@@ -996,7 +996,7 @@ void func_80BA7B6C(EnRailgibud* this, GlobalContext* globalCtx) {
     this->actor.flags |= 0x100000;
     this->actor.flags |= 0x10;
     ActorShape_Init(&this->actor.shape, 0.0f, func_800B3FC0, 28.0f);
-    SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_060053E8, &D_0600ABE0, this->jointTable, this->morphTable, 26);
+    SkelAnime_InitFlex(globalCtx, &this->skelAnime, &D_060053E8, &D_0600ABE0, this->jointTable, this->morphTable, 26);
     Collider_InitCylinder(globalCtx, &this->collider);
     Collider_SetCylinder(globalCtx, &this->collider, &this->actor, &sCylinderInit);
     CollisionCheck_SetInfo2(&this->actor.colChkInfo, &sDamageTable, &sColChkInfoInit);
@@ -1091,7 +1091,7 @@ s32 func_80BA7DC8(EnRailgibud* this, GlobalContext* globalCtx) {
                     func_800BDC5C(&this->skelAnime, sAnimations, 10);
                     break;
             }
-        } else if (func_801378B8(&this->skelAnime, this->skelAnime.animFrameCount)) {
+        } else if (Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame)) {
             if (this->unk_3F0 == 15) {
                 this->unk_3F0 = 16;
                 func_800BDC5C(&this->skelAnime, sAnimations, 16);
@@ -1113,7 +1113,7 @@ s32 func_80BA7DC8(EnRailgibud* this, GlobalContext* globalCtx) {
                 break;
 
             case 5:
-                if (func_801378B8(&this->skelAnime, this->skelAnime.animFrameCount)) {
+                if (Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame)) {
                     if (globalCtx->csCtx.frames < 280) {
                         Audio_PlayActorSound2(&this->actor, NA_SE_EN_REDEAD_CRY);
                     } else {
@@ -1136,5 +1136,5 @@ void func_80BA8050(Actor* thisx, GlobalContext* globalCtx) {
 
     this->actionFunc(this, globalCtx);
     func_80BA7DC8(this, globalCtx);
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
 }
diff --git a/src/overlays/actors/ovl_En_Rd/z_en_rd.c b/src/overlays/actors/ovl_En_Rd/z_en_rd.c
index ff35322f1..c6359ba89 100644
--- a/src/overlays/actors/ovl_En_Rd/z_en_rd.c
+++ b/src/overlays/actors/ovl_En_Rd/z_en_rd.c
@@ -163,9 +163,11 @@ void EnRd_Init(Actor* thisx, GlobalContext* globalCtx) {
     }
 
     if (this->actor.params >= ENRD_GET_MINUS_1) {
-        SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_06010B88, &D_0600ABE0, this->jointTable, this->morphTable, 26);
+        SkelAnime_InitFlex(globalCtx, &this->skelAnime, &D_06010B88, &D_0600ABE0, this->jointTable, this->morphTable,
+                           26);
     } else {
-        SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_060053E8, &D_0600ABE0, this->jointTable, this->morphTable, 26);
+        SkelAnime_InitFlex(globalCtx, &this->skelAnime, &D_060053E8, &D_0600ABE0, this->jointTable, this->morphTable,
+                           26);
     }
 
     Collider_InitCylinder(globalCtx, &this->collider);
@@ -217,7 +219,7 @@ void EnRd_Init(Actor* thisx, GlobalContext* globalCtx) {
         func_808D4DC4(this);
     }
 
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
 
     if (this->actor.params == ENRD_GET_3) {
         this->actor.flags |= 0x80;
@@ -279,9 +281,9 @@ void func_808D4260(EnRd* this, GlobalContext* globalCtx) {
 
 void func_808D4308(EnRd* this) {
     if (this->actor.params != ENRD_GET_2) {
-        SkelAnime_ChangeAnimTransitionRepeat(&this->skelAnime, &D_0600ABE0, -6.0f);
+        Animation_MorphToLoop(&this->skelAnime, &D_0600ABE0, -6.0f);
     } else {
-        SkelAnime_ChangeAnimDefaultRepeat(&this->skelAnime, &D_060081A8);
+        Animation_PlayLoop(&this->skelAnime, &D_060081A8);
     }
 
     this->unk_3EF = 0;
@@ -292,20 +294,20 @@ void func_808D4308(EnRd* this) {
 }
 
 void func_808D43AC(EnRd* this, GlobalContext* globalCtx) {
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     Math_SmoothStepToS(&this->unk_3D8, 0, 1, 100, 0);
     Math_SmoothStepToS(&this->unk_3DA, 0, 1, 100, 0);
-    if ((this->actor.params == ENRD_GET_2) && func_801378B8(&this->skelAnime, 0.0f)) {
+    if ((this->actor.params == ENRD_GET_2) && Animation_OnFrame(&this->skelAnime, 0.0f)) {
         if (Rand_ZeroOne() >= 0.5f) {
-            SkelAnime_ChangeAnimDefaultRepeat(&this->skelAnime, &D_060081A8);
+            Animation_PlayLoop(&this->skelAnime, &D_060081A8);
         } else {
-            SkelAnime_ChangeAnimDefaultRepeat(&this->skelAnime, &D_06007BBC);
+            Animation_PlayLoop(&this->skelAnime, &D_06007BBC);
         }
     } else {
         this->unk_3D6--;
         if (this->unk_3D6 == 0) {
             this->unk_3D6 = (Rand_ZeroOne() * 10.0f) + 10.0f;
-            this->skelAnime.animCurrentFrame = 0.0f;
+            this->skelAnime.curFrame = 0.0f;
         }
     }
 
@@ -342,7 +344,7 @@ void func_808D43AC(EnRd* this, GlobalContext* globalCtx) {
 }
 
 void func_808D45D4(EnRd* this) {
-    SkelAnime_ChangeAnimTransitionRepeat(&this->skelAnime, &D_0601216C, -6.0f);
+    Animation_MorphToLoop(&this->skelAnime, &D_0601216C, -6.0f);
     this->unk_3EF = 14;
     this->unk_3D6 = (Rand_ZeroOne() * 10.0f) + 5.0f;
     this->unk_3E4 = 0;
@@ -352,7 +354,7 @@ void func_808D45D4(EnRd* this) {
 }
 
 void func_808D4660(EnRd* this, GlobalContext* globalCtx) {
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     Math_SmoothStepToS(&this->unk_3D8, 0, 1, 100, 0);
     Math_SmoothStepToS(&this->unk_3DA, 0, 1, 100, 0);
     if (this->unk_3EC != 0) {
@@ -366,7 +368,7 @@ void func_808D4660(EnRd* this, GlobalContext* globalCtx) {
         } else {
             this->actor.hintId = 0x2A;
         }
-        SkelAnime_ChangeAnim(&this->skelAnime, &D_060073A4, 0.0f, 0.0f, 19.0f, 2, -10.0f);
+        Animation_Change(&this->skelAnime, &D_060073A4, 0.0f, 0.0f, 19.0f, 2, -10.0f);
         this->actionFunc = func_808D49E4;
     }
 
@@ -385,7 +387,7 @@ void func_808D4660(EnRd* this, GlobalContext* globalCtx) {
 }
 
 void func_808D47DC(EnRd* this) {
-    SkelAnime_ChangeAnimTransitionRepeat(&this->skelAnime, &D_06011DB8, -6.0f);
+    Animation_MorphToLoop(&this->skelAnime, &D_06011DB8, -6.0f);
     this->unk_3EF = 15;
     this->unk_3D6 = (Rand_ZeroOne() * 10.0f) + 5.0f;
     this->unk_3E4 = 0;
@@ -395,7 +397,7 @@ void func_808D47DC(EnRd* this) {
 }
 
 void func_808D4868(EnRd* this, GlobalContext* globalCtx) {
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     Math_SmoothStepToS(&this->unk_3D8, 0, 1, 100, 0);
     Math_SmoothStepToS(&this->unk_3DA, 0, 1, 100, 0);
     if (this->unk_3EC != 0) {
@@ -409,7 +411,7 @@ void func_808D4868(EnRd* this, GlobalContext* globalCtx) {
         } else {
             this->actor.hintId = 0x2A;
         }
-        SkelAnime_ChangeAnim(&this->skelAnime, &D_060073A4, 0.0f, 0.0f, 19.0f, 2, -10.0f);
+        Animation_Change(&this->skelAnime, &D_060073A4, 0.0f, 0.0f, 19.0f, 2, -10.0f);
         this->actionFunc = func_808D49E4;
     }
 
@@ -428,7 +430,7 @@ void func_808D4868(EnRd* this, GlobalContext* globalCtx) {
 }
 
 void func_808D49E4(EnRd* this, GlobalContext* globalCtx) {
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     if ((globalCtx->gameplayFrames & 0x5F) == 0) {
         Audio_PlayActorSound2(&this->actor, NA_SE_EN_REDEAD_CRY);
     }
@@ -445,7 +447,7 @@ void func_808D49E4(EnRd* this, GlobalContext* globalCtx) {
 }
 
 void func_808D4A90(EnRd* this) {
-    SkelAnime_ChangeAnimTransitionRepeat(&this->skelAnime, &D_060118D8, -6.0f);
+    Animation_MorphToLoop(&this->skelAnime, &D_060118D8, -6.0f);
     this->unk_3EF = 16;
     this->unk_3D6 = (Rand_ZeroOne() * 10.0f) + 5.0f;
     this->unk_3E4 = 4370;
@@ -455,7 +457,7 @@ void func_808D4A90(EnRd* this) {
 }
 
 void func_808D4B20(EnRd* this, GlobalContext* globalCtx) {
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     Math_SmoothStepToS(&this->unk_3D8, 0, 1, 100, 0);
     Math_SmoothStepToS(&this->unk_3DA, 0, 1, 100, 0);
     if (this->unk_3EC != 0) {
@@ -485,9 +487,9 @@ void func_808D4B20(EnRd* this, GlobalContext* globalCtx) {
         Audio_PlayActorSound2(&this->actor, NA_SE_EN_REDEAD_CRY);
     }
 
-    if (func_801378B8(&this->skelAnime, this->skelAnime.animFrameCount)) {
+    if (Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame)) {
         this->unk_3E4 = 4370;
-    } else if (func_801378B8(&this->skelAnime, 15.0f)) {
+    } else if (Animation_OnFrame(&this->skelAnime, 15.0f)) {
         this->unk_3E4 = 6554;
     }
 
@@ -496,7 +498,7 @@ void func_808D4B20(EnRd* this, GlobalContext* globalCtx) {
 }
 
 void func_808D4CA8(EnRd* this, GlobalContext* globalCtx) {
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     if ((globalCtx->gameplayFrames & 0x5F) == 0) {
         Audio_PlayActorSound2(&this->actor, NA_SE_EN_REDEAD_CRY);
     }
@@ -506,7 +508,7 @@ void func_808D4CA8(EnRd* this, GlobalContext* globalCtx) {
 
     this->unk_3E4 -= 100;
     if ((this->unk_3E4 < 2100) && (this->unk_3E4 >= 2000)) {
-        SkelAnime_ChangeAnim(&this->skelAnime, &D_060073A4, 0.0f, 0.0f, 19.0f, 2, -10.0f);
+        Animation_Change(&this->skelAnime, &D_060073A4, 0.0f, 0.0f, 19.0f, 2, -10.0f);
     } else if (this->unk_3E4 < 1000) {
         if ((this->actor.params != ENRD_GET_2) && (this->unk_3EC == 0)) {
             func_808D5C54(this);
@@ -517,8 +519,7 @@ void func_808D4CA8(EnRd* this, GlobalContext* globalCtx) {
 }
 
 void func_808D4DC4(EnRd* this) {
-    SkelAnime_ChangeAnim(&this->skelAnime, &D_0600ABE0, 0.0f, 0.0f, SkelAnime_GetFrameCount(&D_0600ABE0.common), 0,
-                         -6.0f);
+    Animation_Change(&this->skelAnime, &D_0600ABE0, 0.0f, 0.0f, Animation_GetLastFrame(&D_0600ABE0), 0, -6.0f);
     this->unk_3EF = 13;
     this->unk_3D6 = 6;
     this->actor.shape.rot.x = -0x4000;
@@ -552,9 +553,9 @@ void func_808D4E60(EnRd* this, GlobalContext* globalCtx) {
 }
 
 void func_808D4FE0(EnRd* this, GlobalContext* globalCtx) {
-    f32 frameCount = SkelAnime_GetFrameCount(&D_060113EC.common);
+    f32 frameCount = Animation_GetLastFrame(&D_060113EC);
 
-    SkelAnime_ChangeAnim(&this->skelAnime, &D_060113EC, 1.0f, 4.0f, frameCount, 1, -4.0f);
+    Animation_Change(&this->skelAnime, &D_060113EC, 1.0f, 4.0f, frameCount, 1, -4.0f);
     this->actor.speedXZ = 0.4f;
     this->unk_3EF = 4;
     this->actionFunc = func_808D506C;
@@ -565,12 +566,12 @@ void func_808D506C(EnRd* this, GlobalContext* globalCtx) {
     s32 pad;
     s16 sp36 = ((this->actor.yawTowardsPlayer - this->actor.shape.rot.y) - this->unk_3D8) - this->unk_3DA;
 
-    this->skelAnime.animPlaybackSpeed = this->actor.speedXZ;
+    this->skelAnime.playSpeed = this->actor.speedXZ;
     Math_SmoothStepToS(&this->actor.shape.rot.y, this->actor.yawTowardsPlayer, 1, 250, 0);
     Math_SmoothStepToS(&this->unk_3D8, 0, 1, 100, 0);
     Math_SmoothStepToS(&this->unk_3DA, 0, 1, 100, 0);
     this->actor.world.rot.y = this->actor.shape.rot.y;
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
 
     if (Actor_DistanceToPoint(&player->actor, &this->actor.home.pos) >= 150.0f) {
         func_808D53C0(this, globalCtx);
@@ -619,7 +620,7 @@ void func_808D506C(EnRd* this, GlobalContext* globalCtx) {
         }
     }
 
-    if (func_801378B8(&this->skelAnime, 10.0f) || func_801378B8(&this->skelAnime, 22.0f)) {
+    if (Animation_OnFrame(&this->skelAnime, 10.0f) || Animation_OnFrame(&this->skelAnime, 22.0f)) {
         Audio_PlayActorSound2(&this->actor, NA_SE_EN_RIZA_WALK);
     } else if ((globalCtx->gameplayFrames & 0x5F) == 0) {
         Audio_PlayActorSound2(&this->actor, NA_SE_EN_REDEAD_CRY);
@@ -627,8 +628,7 @@ void func_808D506C(EnRd* this, GlobalContext* globalCtx) {
 }
 
 void func_808D53C0(EnRd* this, GlobalContext* globalCtx) {
-    SkelAnime_ChangeAnim(&this->skelAnime, &D_060113EC, 0.5f, 0.0f, SkelAnime_GetFrameCount(&D_060113EC.common), 1,
-                         -4.0f);
+    Animation_Change(&this->skelAnime, &D_060113EC, 0.5f, 0.0f, Animation_GetLastFrame(&D_060113EC), 1, -4.0f);
     this->unk_3EF = 2;
     this->actionFunc = func_808D5440;
 }
@@ -654,7 +654,7 @@ void func_808D5440(EnRd* this, GlobalContext* globalCtx) {
     Math_SmoothStepToS(&this->unk_3D8, 0, 1, 100, 0);
     Math_SmoothStepToS(&this->unk_3DA, 0, 1, 100, 0);
     this->actor.world.rot.y = this->actor.shape.rot.y;
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
 
     if (!(player->stateFlags1 & (0x200000 | 0x80000 | 0x40000 | 0x4000 | 0x2000 | 0x80)) &&
         !(player->stateFlags2 & 0x4080) && (player->transformation != PLAYER_FORM_GORON) &&
@@ -670,7 +670,7 @@ void func_808D5440(EnRd* this, GlobalContext* globalCtx) {
         }
     }
 
-    if (func_801378B8(&this->skelAnime, 10.0f) || func_801378B8(&this->skelAnime, 22.0f)) {
+    if (Animation_OnFrame(&this->skelAnime, 10.0f) || Animation_OnFrame(&this->skelAnime, 22.0f)) {
         Audio_PlayActorSound2(&this->actor, NA_SE_EN_RIZA_WALK);
     } else if ((globalCtx->gameplayFrames & 0x5F) == 0) {
         Audio_PlayActorSound2(&this->actor, NA_SE_EN_REDEAD_CRY);
@@ -678,9 +678,9 @@ void func_808D5440(EnRd* this, GlobalContext* globalCtx) {
 }
 
 void func_808D5660(EnRd* this) {
-    f32 frameCount = SkelAnime_GetFrameCount(&D_060113EC.common);
+    f32 frameCount = Animation_GetLastFrame(&D_060113EC);
 
-    SkelAnime_ChangeAnim(&this->skelAnime, &D_060113EC, 0.5f, 0.0f, frameCount, 1, -4.0f);
+    Animation_Change(&this->skelAnime, &D_060113EC, 0.5f, 0.0f, frameCount, 1, -4.0f);
     this->unk_3EF = 3;
     this->unk_3EC = 1;
     this->actionFunc = func_808D56E4;
@@ -713,9 +713,9 @@ void func_808D56E4(EnRd* this, GlobalContext* globalCtx) {
     }
 
     this->actor.world.rot.y = this->actor.shape.rot.y;
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
 
-    if (func_801378B8(&this->skelAnime, 10.0f) || func_801378B8(&this->skelAnime, 22.0f)) {
+    if (Animation_OnFrame(&this->skelAnime, 10.0f) || Animation_OnFrame(&this->skelAnime, 22.0f)) {
         Audio_PlayActorSound2(&this->actor, NA_SE_EN_RIZA_WALK);
     } else if ((globalCtx->gameplayFrames & 0x5F) == 0) {
         Audio_PlayActorSound2(&this->actor, NA_SE_EN_REDEAD_CRY);
@@ -723,7 +723,7 @@ void func_808D56E4(EnRd* this, GlobalContext* globalCtx) {
 }
 
 void func_808D586C(EnRd* this) {
-    SkelAnime_ChangeAnimDefaultStop(&this->skelAnime, &D_06006EEC);
+    Animation_PlayOnce(&this->skelAnime, &D_06006EEC);
     this->unk_3D6 = 0;
     this->unk_3EB = 0;
     this->unk_3EA = 200;
@@ -736,13 +736,13 @@ void func_808D58CC(EnRd* this, GlobalContext* globalCtx) {
     Player* player = GET_PLAYER(globalCtx);
     s32 pad;
 
-    if (SkelAnime_FrameUpdateMatrix(&this->skelAnime)) {
+    if (SkelAnime_Update(&this->skelAnime)) {
         this->unk_3EB++;
     }
 
     switch (this->unk_3EB) {
         case 1:
-            SkelAnime_ChangeAnimDefaultRepeat(&this->skelAnime, &D_06006678);
+            Animation_PlayLoop(&this->skelAnime, &D_06006678);
             this->unk_3EB++;
             globalCtx->damagePlayer(globalCtx, -8);
             func_8013ECE0(this->actor.xzDistToPlayer, 255, 1, 12);
@@ -758,8 +758,8 @@ void func_808D58CC(EnRd* this, GlobalContext* globalCtx) {
                     player->stateFlags2 &= ~0x80;
                     player->unk_AE8 = 100;
                 }
-                SkelAnime_ChangeAnim(&this->skelAnime, &D_06006B08, 0.5f, 0.0f,
-                                     SkelAnime_GetFrameCount(&D_06006B08.common), 3, 0.0f);
+                Animation_Change(&this->skelAnime, &D_06006B08, 0.5f, 0.0f, Animation_GetLastFrame(&D_06006B08), 3,
+                                 0.0f);
                 this->unk_3EB++;
                 this->unk_3EF = 4;
                 break;
@@ -786,7 +786,7 @@ void func_808D58CC(EnRd* this, GlobalContext* globalCtx) {
                                0.0f);
             Math_SmoothStepToS(&this->actor.shape.rot.y, player->actor.shape.rot.y, 1, 6000, 0);
 
-            if (func_801378B8(&this->skelAnime, 0.0f)) {
+            if (Animation_OnFrame(&this->skelAnime, 0.0f)) {
                 Audio_PlayActorSound2(&this->actor, NA_SE_EN_REDEAD_ATTACK);
             }
 
@@ -819,8 +819,7 @@ void func_808D58CC(EnRd* this, GlobalContext* globalCtx) {
 }
 
 void func_808D5C54(EnRd* this) {
-    SkelAnime_ChangeAnim(&this->skelAnime, &D_060073A4, 0.0f, 0.0f, SkelAnime_GetFrameCount(&D_060073A4.common), 2,
-                         0.0f);
+    Animation_Change(&this->skelAnime, &D_060073A4, 0.0f, 0.0f, Animation_GetLastFrame(&D_060073A4), 2, 0.0f);
     this->unk_3EF = 7;
     this->actionFunc = func_808D5CCC;
 }
@@ -842,7 +841,7 @@ void func_808D5CCC(EnRd* this, GlobalContext* globalCtx) {
 
 void func_808D5D88(EnRd* this) {
     this->unk_3EF = 8;
-    SkelAnime_ChangeAnimTransitionStop(&this->skelAnime, &D_06009900, -6.0f);
+    Animation_MorphToPlayOnce(&this->skelAnime, &D_06009900, -6.0f);
     this->actor.speedXZ = -2.0f;
     Audio_PlayActorSound2(&this->actor, NA_SE_EN_REDEAD_DAMAGE);
     this->unk_3EF = 8;
@@ -857,16 +856,16 @@ void func_808D5DF4(EnRd* this, GlobalContext* globalCtx) {
     this->actor.world.rot.y = this->actor.yawTowardsPlayer;
     Math_SmoothStepToS(&this->unk_3D8, 0, 1, 300, 0);
     Math_SmoothStepToS(&this->unk_3DA, 0, 1, 300, 0);
-    if (SkelAnime_FrameUpdateMatrix(&this->skelAnime)) {
+    if (SkelAnime_Update(&this->skelAnime)) {
         this->actor.world.rot.y = this->actor.shape.rot.y;
         func_808D5E98(this);
     }
 }
 
 void func_808D5E98(EnRd* this) {
-    f32 frameCount = SkelAnime_GetFrameCount(&D_060113EC.common);
+    f32 frameCount = Animation_GetLastFrame(&D_060113EC);
 
-    SkelAnime_ChangeAnim(&this->skelAnime, &D_060113EC, 0.5f, 0.0f, frameCount, 1, -4.0f);
+    Animation_Change(&this->skelAnime, &D_060113EC, 0.5f, 0.0f, frameCount, 1, -4.0f);
     this->unk_3EF = 9;
     this->unk_3D4 = 0;
     this->actionFunc = func_808D5F18;
@@ -880,19 +879,19 @@ void func_808D5F18(EnRd* this, GlobalContext* globalCtx) {
         this->unk_3D4 = 0;
     } else {
         this->unk_3D8 = Math_SinS(this->unk_3D4 * 4000) * (9583.0f * ((60 - this->unk_3D4) / 60.0f));
-        SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+        SkelAnime_Update(&this->skelAnime);
         this->unk_3D4++;
     }
 }
 
 void func_808D6008(EnRd* this) {
-    SkelAnime_ChangeAnimTransitionStop(&this->skelAnime, &D_0600A450, -4.0f);
+    Animation_MorphToPlayOnce(&this->skelAnime, &D_0600A450, -4.0f);
     this->unk_3EF = 5;
     this->actionFunc = func_808D6054;
 }
 
 void func_808D6054(EnRd* this, GlobalContext* globalCtx) {
-    if (SkelAnime_FrameUpdateMatrix(&this->skelAnime)) {
+    if (SkelAnime_Update(&this->skelAnime)) {
         if (this->actor.parent != NULL) {
             func_808D5660(this);
         } else {
@@ -902,21 +901,20 @@ void func_808D6054(EnRd* this, GlobalContext* globalCtx) {
 }
 
 void func_808D60B0(EnRd* this) {
-    SkelAnime_ChangeAnim(&this->skelAnime, &D_0600A450, -1.0f, SkelAnime_GetFrameCount(&D_0600A450.common), 0.0f, 2,
-                         -4.0f);
+    Animation_Change(&this->skelAnime, &D_0600A450, -1.0f, Animation_GetLastFrame(&D_0600A450), 0.0f, 2, -4.0f);
     this->unk_3EF = 6;
     this->actionFunc = func_808D6130;
 }
 
 void func_808D6130(EnRd* this, GlobalContext* globalCtx) {
-    if (SkelAnime_FrameUpdateMatrix(&this->skelAnime)) {
+    if (SkelAnime_Update(&this->skelAnime)) {
         func_808D4308(this);
     }
 }
 
 void func_808D616C(EnRd* this) {
     this->actor.shape.yOffset = 0.0f;
-    SkelAnime_ChangeAnimTransitionStop(&this->skelAnime, &D_06009900, -6.0f);
+    Animation_MorphToPlayOnce(&this->skelAnime, &D_06009900, -6.0f);
     if (this->actor.bgCheckFlags & 1) {
         this->actor.speedXZ = -2.0f;
     }
@@ -938,7 +936,7 @@ void func_808D6200(EnRd* this, GlobalContext* globalCtx) {
     Math_SmoothStepToS(&this->unk_3D8, 0, 1, 300, 0);
     Math_SmoothStepToS(&this->unk_3DA, 0, 1, 300, 0);
 
-    if (SkelAnime_FrameUpdateMatrix(&this->skelAnime)) {
+    if (SkelAnime_Update(&this->skelAnime)) {
         this->actor.world.rot.y = this->actor.shape.rot.y;
         if (this->actor.parent != NULL) {
             func_808D5660(this);
@@ -952,7 +950,7 @@ void func_808D6200(EnRd* this, GlobalContext* globalCtx) {
 }
 
 void func_808D6310(EnRd* this) {
-    SkelAnime_ChangeAnimTransitionStop(&this->skelAnime, &D_06009298, -1.0f);
+    Animation_MorphToPlayOnce(&this->skelAnime, &D_06009298, -1.0f);
     this->unk_3EF = 12;
     this->unk_3D6 = 300;
     this->actor.flags &= ~1;
@@ -969,7 +967,7 @@ void func_808D6388(EnRd* this, GlobalContext* globalCtx) {
     Math_SmoothStepToS(&this->unk_3D8, 0, 1, 2000, 0);
     Math_SmoothStepToS(&this->unk_3DA, 0, 1, 2000, 0);
 
-    if (SkelAnime_FrameUpdateMatrix(&this->skelAnime)) {
+    if (SkelAnime_Update(&this->skelAnime)) {
         if (this->unk_3D6 == 0) {
             if (!Flags_GetSwitch(globalCtx, this->unk_3DC & 0x7F)) {
                 Actor_SetSwitchFlag(globalCtx, this->unk_3DC & 0x7F);
@@ -987,7 +985,7 @@ void func_808D6388(EnRd* this, GlobalContext* globalCtx) {
         } else {
             this->unk_3D6--;
         }
-    } else if (func_801378B8(&this->skelAnime, 33.0f) || func_801378B8(&this->skelAnime, 40.0f)) {
+    } else if (Animation_OnFrame(&this->skelAnime, 33.0f) || Animation_OnFrame(&this->skelAnime, 40.0f)) {
         Audio_PlayActorSound2(&this->actor, NA_SE_EN_GERUDOFT_DOWN);
     }
 }
@@ -1224,7 +1222,7 @@ void EnRd_PostLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec
         ((limbIndex == 3) || (limbIndex == 4) || (limbIndex == 6) || (limbIndex == 8) || (limbIndex == 9) ||
          (limbIndex == 11) || (limbIndex == 14) || (limbIndex == 16) || (limbIndex == 17) || (limbIndex == 18) ||
          (limbIndex == 20) || (limbIndex == 21) || (limbIndex == 22) || (limbIndex == 24) || (limbIndex == 25))) {
-        SysMatrix_GetStateTranslation(&this->unk_1DC[this->unk_290]);
+        Matrix_GetStateTranslation(&this->unk_1DC[this->unk_290]);
         this->unk_290++;
     }
 }
@@ -1245,9 +1243,9 @@ void EnRd_Draw(Actor* thisx, GlobalContext* globalCtx) {
         gDPSetEnvColor(POLY_OPA_DISP++, 0, 0, 0, this->unk_3DE);
         gSPSegment(POLY_OPA_DISP++, 0x08, D_801AEFA0);
 
-        POLY_OPA_DISP = SkelAnime_DrawSV2(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl,
-                                          this->skelAnime.dListCount, EnRd_OverrideLimbDraw, EnRd_PostLimbDraw,
-                                          &this->actor, POLY_OPA_DISP);
+        POLY_OPA_DISP = SkelAnime_DrawFlex(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable,
+                                           this->skelAnime.dListCount, EnRd_OverrideLimbDraw, EnRd_PostLimbDraw,
+                                           &this->actor, POLY_OPA_DISP);
 
         func_800BC620(&sp54, &D_808D7138, 255, globalCtx);
     } else {
@@ -1257,8 +1255,8 @@ void EnRd_Draw(Actor* thisx, GlobalContext* globalCtx) {
         gSPSegment(POLY_XLU_DISP++, 0x08, D_801AEF88);
 
         POLY_XLU_DISP =
-            SkelAnime_DrawSV2(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl,
-                              this->skelAnime.dListCount, EnRd_OverrideLimbDraw, NULL, &this->actor, POLY_XLU_DISP);
+            SkelAnime_DrawFlex(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable,
+                               this->skelAnime.dListCount, EnRd_OverrideLimbDraw, NULL, &this->actor, POLY_XLU_DISP);
         func_800BC620(&sp54, &D_808D7138, this->unk_3DE, globalCtx);
     }
 
diff --git a/src/overlays/actors/ovl_En_Rsn/z_en_rsn.c b/src/overlays/actors/ovl_En_Rsn/z_en_rsn.c
index 94db2b4bc..a5e91243b 100644
--- a/src/overlays/actors/ovl_En_Rsn/z_en_rsn.c
+++ b/src/overlays/actors/ovl_En_Rsn/z_en_rsn.c
@@ -42,7 +42,7 @@ void EnRsn_Init(Actor* thisx, GlobalContext* globalCtx) {
     EnRsn* this = THIS;
 
     ActorShape_Init(&this->actor.shape, 0.0f, func_800B3FC0, 20.0f);
-    SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_06009220, &D_06009120, NULL, NULL, 0);
+    SkelAnime_InitFlex(globalCtx, &this->skelAnime, &D_06009220, &D_06009120, NULL, NULL, 0);
     this->actor.flags &= ~1;
     func_80C25D40(this);
 }
@@ -58,36 +58,37 @@ void EnRsn_Update(Actor* thisx, GlobalContext* globalCtx) {
 
     this->actionFunc(this, globalCtx);
     Actor_SetVelocityAndMoveYRotationAndGravity(&this->actor);
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     func_800E9250(globalCtx, &this->actor, &this->unk1D8, &this->unk1DE, this->actor.focus.pos);
 }
 
-s32 EnRsn_OverrideLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3f* pos, Vec3s* rot, Actor* thisx) {
-    EnRsn* this = THIS;
+s32 EnRsn_OverrideLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3f* pos, Vec3s* rot, Actor* arg) {
+    EnRsn* this = (EnRsn*)arg;
 
     if (limbIndex == 14) {
-        SysMatrix_InsertXRotation_s(this->unk1D8.y, 1);
+        Matrix_InsertXRotation_s(this->unk1D8.y, 1);
     }
     return 0;
 }
 
 static Vec3f D_80C26028 = { 0.0f, 0.0f, 0.0f };
 
-void EnRsn_PostLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3s* rot, Actor* thisx) {
-    EnRsn* this = THIS;
+void EnRsn_PostLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Vec3s* rot, Actor* arg) {
+    EnRsn* this = (EnRsn*)arg;
     Vec3f sp18 = D_80C26028;
 
     if (limbIndex == 14) {
-        SysMatrix_MultiplyVector3fByState(&sp18, &this->actor.focus.pos);
+        Matrix_MultiplyVector3fByState(&sp18, &this->actor.focus.pos);
     }
 }
 
 void EnRsn_Draw(Actor* thisx, GlobalContext* globalCtx) {
     EnRsn* this = THIS;
+
     OPEN_DISPS(globalCtx->state.gfxCtx);
     func_8012C5B0(globalCtx->state.gfxCtx);
     gSPSegment(POLY_OPA_DISP++, 0x08, Lib_SegmentedToVirtual(D_06005458));
-    SkelAnime_DrawSV(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl, this->skelAnime.dListCount,
-                     EnRsn_OverrideLimbDraw, EnRsn_PostLimbDraw, &this->actor);
+    SkelAnime_DrawFlexOpa(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable, this->skelAnime.dListCount,
+                          EnRsn_OverrideLimbDraw, EnRsn_PostLimbDraw, &this->actor);
     CLOSE_DISPS(globalCtx->state.gfxCtx);
 }
diff --git a/src/overlays/actors/ovl_En_Sb/z_en_sb.c b/src/overlays/actors/ovl_En_Sb/z_en_sb.c
index 691efcdf7..a860e49fb 100644
--- a/src/overlays/actors/ovl_En_Sb/z_en_sb.c
+++ b/src/overlays/actors/ovl_En_Sb/z_en_sb.c
@@ -117,8 +117,7 @@ void EnSb_Init(Actor* thisx, GlobalContext* globalCtx) {
     this->actor.colChkInfo.damageTable = &sDamageTable;
     this->actor.colChkInfo.mass = 0xA;
     this->actor.colChkInfo.health = 2;
-    SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_06002BF0, &D_06000194, this->limbDrawTable,
-                     this->transitionDrawTable, 9);
+    SkelAnime_InitFlex(globalCtx, &this->skelAnime, &D_06002BF0, &D_06000194, this->jointTable, this->morphTable, 9);
     Collider_InitCylinder(globalCtx, &this->collider);
     Collider_SetCylinderType1(globalCtx, &this->collider, &this->actor, &sCylinderInit);
     this->isDead = false;
@@ -150,45 +149,45 @@ void EnSb_SpawnBubbles(GlobalContext* globalCtx, EnSb* this) {
 }
 
 void EnSb_SetupWaitClosed(EnSb* this) {
-    SkelAnime_ChangeAnim(&this->skelAnime, &D_0600004C, 1.0f, 0, SkelAnime_GetFrameCount(&D_0600004C.common), 2, 0.0f);
+    Animation_Change(&this->skelAnime, &D_0600004C, 1.0f, 0, Animation_GetLastFrame(&D_0600004C), 2, 0.0f);
     this->state = SHELLBLADE_WAIT_CLOSED;
     this->actionFunc = EnSb_Idle;
 }
 
 void EnSb_SetupOpen(EnSb* this) {
-    SkelAnime_ChangeAnim(&this->skelAnime, &D_06000194, 1.0f, 0, SkelAnime_GetFrameCount(&D_06000194.common), 2, 0.0f);
+    Animation_Change(&this->skelAnime, &D_06000194, 1.0f, 0, Animation_GetLastFrame(&D_06000194), 2, 0.0f);
     this->state = SHELLBLADE_OPEN;
     this->actionFunc = EnSb_Open;
     Audio_PlayActorSound2(&this->actor, NA_SE_EN_KUSAMUSHI_VIBE);
 }
 
 void EnSb_SetupWaitOpen(EnSb* this) {
-    SkelAnime_ChangeAnim(&this->skelAnime, &D_06002C8C, 1.0f, 0, SkelAnime_GetFrameCount(&D_06002C8C.common), 0, 0.0f);
+    Animation_Change(&this->skelAnime, &D_06002C8C, 1.0f, 0, Animation_GetLastFrame(&D_06002C8C), 0, 0.0f);
     this->state = SHELLBLADE_WAIT_OPEN;
     this->actionFunc = EnSb_WaitOpen;
 }
 
 void EnSb_SetupLunge(EnSb* this) {
-    f32 frameCount = SkelAnime_GetFrameCount(&D_06000124.common);
+    f32 frameCount = Animation_GetLastFrame(&D_06000124);
     f32 playbackSpeed = this->actor.yDistToWater > 0.0f ? 1.0f : 0.0f;
 
-    SkelAnime_ChangeAnim(&this->skelAnime, &D_06000124, playbackSpeed, 0.0f, frameCount, 2, 0);
+    Animation_Change(&this->skelAnime, &D_06000124, playbackSpeed, 0.0f, frameCount, 2, 0);
     this->state = SHELLBLADE_LUNGE;
     this->actionFunc = EnSb_Lunge;
     Audio_PlayActorSound2(&this->actor, NA_SE_EN_KUSAMUSHI_VIBE);
 }
 
 void EnSb_SetupBounce(EnSb* this) {
-    SkelAnime_ChangeAnim(&this->skelAnime, &D_060000B4, 1.0f, 0, SkelAnime_GetFrameCount(&D_060000B4.common), 2, 0.0f);
+    Animation_Change(&this->skelAnime, &D_060000B4, 1.0f, 0, Animation_GetLastFrame(&D_060000B4), 2, 0.0f);
     this->state = SHELLBLADE_BOUNCE;
     this->actionFunc = EnSb_Bounce;
 }
 
 void EnSb_SetupIdle(EnSb* this, s32 changeSpeed) {
-    f32 frameCount = SkelAnime_GetFrameCount(&D_0600004C.common);
+    f32 frameCount = Animation_GetLastFrame(&D_0600004C);
 
     if (this->state != SHELLBLADE_WAIT_CLOSED) {
-        SkelAnime_ChangeAnim(&this->skelAnime, &D_0600004C, 1.0f, 0, frameCount, 2, 0.0f);
+        Animation_Change(&this->skelAnime, &D_0600004C, 1.0f, 0, frameCount, 2, 0.0f);
     }
     this->state = SHELLBLADE_WAIT_CLOSED;
     if (changeSpeed) {
@@ -216,9 +215,9 @@ void EnSb_Idle(EnSb* this, GlobalContext* globalCtx) {
 }
 
 void EnSb_Open(EnSb* this, GlobalContext* globalCtx) {
-    f32 currentFrame = this->skelAnime.animCurrentFrame;
+    f32 currentFrame = this->skelAnime.curFrame;
 
-    if (SkelAnime_GetFrameCount(&D_06000194.common) <= currentFrame) {
+    if (Animation_GetLastFrame(&D_06000194) <= currentFrame) {
         this->vulnerableTimer = 20;
         EnSb_SetupWaitOpen(this);
     } else {
@@ -281,8 +280,8 @@ void EnSb_Lunge(EnSb* this, GlobalContext* globalCtx) {
 
 void EnSb_Bounce(EnSb* this, GlobalContext* globalCtx) {
     s32 pad;
-    f32 currentFrame = currentFrame = this->skelAnime.animCurrentFrame;
-    f32 frameCount = frameCount = SkelAnime_GetFrameCount(&D_060000B4.common);
+    f32 currentFrame = currentFrame = this->skelAnime.curFrame;
+    f32 frameCount = frameCount = Animation_GetLastFrame(&D_060000B4);
 
     Math_StepToF(&this->actor.speedXZ, 0.0f, 0.2f);
     if (currentFrame == frameCount) {
@@ -384,7 +383,7 @@ void EnSb_Update(Actor* thisx, GlobalContext* globalCtx) {
             }
             CollisionCheck_SetAC(globalCtx, &globalCtx->colChkCtx, &this->collider.base);
         }
-        SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+        SkelAnime_Update(&this->skelAnime);
     }
 }
 
@@ -411,8 +410,8 @@ void EnSb_Draw(Actor* thisx, GlobalContext* globalCtx) {
     s16 fireDecr;
 
     func_800B8050(&this->actor, globalCtx, 1);
-    SkelAnime_DrawSV(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl, this->skelAnime.dListCount, NULL,
-                     EnSb_PostLimbDraw, &this->actor);
+    SkelAnime_DrawFlexOpa(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable, this->skelAnime.dListCount,
+                          NULL, EnSb_PostLimbDraw, &this->actor);
     if (this->fireCount != 0) {
         this->actor.colorFilterTimer++;
         fireDecr = this->fireCount - 1;
diff --git a/src/overlays/actors/ovl_En_Sb/z_en_sb.h b/src/overlays/actors/ovl_En_Sb/z_en_sb.h
index 935a697ca..167a0c5c8 100644
--- a/src/overlays/actors/ovl_En_Sb/z_en_sb.h
+++ b/src/overlays/actors/ovl_En_Sb/z_en_sb.h
@@ -18,8 +18,8 @@ typedef enum {
 typedef struct EnSb {
     /* 0x000 */ Actor actor;
     /* 0x144 */ SkelAnime skelAnime;
-    /* 0x188 */ Vec3s limbDrawTable[9];
-    /* 0x1BE */ Vec3s transitionDrawTable[9];
+    /* 0x188 */ Vec3s jointTable[9];
+    /* 0x1BE */ Vec3s morphTable[9];
     /* 0x1F4 */ EnSbActionFunc actionFunc;
     /* 0x1F8 */ ColliderCylinder collider;
     /* 0x244 */ s16 fireCount;
diff --git a/src/overlays/actors/ovl_En_Sellnuts/z_en_sellnuts.c b/src/overlays/actors/ovl_En_Sellnuts/z_en_sellnuts.c
index 3901c8b24..badcc5501 100644
--- a/src/overlays/actors/ovl_En_Sellnuts/z_en_sellnuts.c
+++ b/src/overlays/actors/ovl_En_Sellnuts/z_en_sellnuts.c
@@ -133,7 +133,7 @@ void func_80ADADD0(EnSellnuts* this, GlobalContext* globalCtx) {
 }
 
 void func_80ADAE64(EnSellnuts* this) {
-    s16 currentFrame = this->skelAnime.animCurrentFrame;
+    s16 currentFrame = this->skelAnime.curFrame;
 
     switch (currentFrame) {
         case 10:
@@ -194,7 +194,7 @@ void func_80ADAE64(EnSellnuts* this) {
 }
 
 void func_80ADAFC0(EnSellnuts* this) {
-    s16 currentFrame = this->skelAnime.animCurrentFrame;
+    s16 currentFrame = this->skelAnime.curFrame;
 
     switch (currentFrame) {
         case 10:
@@ -244,8 +244,8 @@ f32 func_80ADB08C(GlobalContext* globalCtx) {
 }
 
 void func_80ADB0D8(EnSellnuts* this, GlobalContext* globalCtx) {
-    s16 currentFrame = this->skelAnime.animCurrentFrame;
-    s16 frameCount = SkelAnime_GetFrameCount(&D_80ADD990[this->unk_34C].animationSeg->common);
+    s16 currentFrame = this->skelAnime.curFrame;
+    s16 frameCount = Animation_GetLastFrame(D_80ADD990[this->unk_34C].animationSeg);
 
     if (currentFrame == frameCount) {
         switch (this->unk_340) {
@@ -298,8 +298,8 @@ void func_80ADB0D8(EnSellnuts* this, GlobalContext* globalCtx) {
 }
 
 void func_80ADB254(EnSellnuts* this, GlobalContext* globalCtx) {
-    s16 currentFrame = this->skelAnime.animCurrentFrame;
-    s16 frameCount = SkelAnime_GetFrameCount(&D_80ADD990[this->unk_34C].animationSeg->common);
+    s16 currentFrame = this->skelAnime.curFrame;
+    s16 frameCount = Animation_GetLastFrame(D_80ADD990[this->unk_34C].animationSeg);
 
     Math_ApproachS(&this->actor.shape.rot.y, this->actor.yawTowardsPlayer, 2, 0xE38);
     if (((this->actor.yDistToPlayer < 50.0f) && (this->actor.yDistToPlayer > -50.0f) ? true : false) &&
@@ -339,7 +339,7 @@ void func_80ADB254(EnSellnuts* this, GlobalContext* globalCtx) {
 }
 
 void func_80ADB4F4(EnSellnuts* this, GlobalContext* globalCtx) {
-    if (this->skelAnime.animCurrentFrame == this->skelAnime.animFrameCount) {
+    if (this->skelAnime.curFrame == this->skelAnime.endFrame) {
         this->actionFunc = func_80ADB544;
         func_8013BC6C(&this->skelAnime, D_80ADD990, 0);
     }
@@ -463,8 +463,8 @@ void func_80ADB924(EnSellnuts* this, GlobalContext* globalCtx) {
 
 void func_80ADBAB8(EnSellnuts* this, GlobalContext* globalCtx) {
     u8 sp27 = func_80152498(&globalCtx->msgCtx);
-    s16 currentFrame = this->skelAnime.animCurrentFrame;
-    s16 frameCount = SkelAnime_GetFrameCount(&D_80ADD990[this->unk_34C].animationSeg->common);
+    s16 currentFrame = this->skelAnime.curFrame;
+    s16 frameCount = Animation_GetLastFrame(D_80ADD990[this->unk_34C].animationSeg);
 
     if (this->unk_368 == 0x28) {
         this->unk_34C = 5;
@@ -516,8 +516,8 @@ void func_80ADBCE4(EnSellnuts* this, GlobalContext* globalCtx) {
 
 void func_80ADBD64(EnSellnuts* this, GlobalContext* globalCtx) {
     u8 sp27 = func_80152498(&globalCtx->msgCtx);
-    s16 currentFrame = this->skelAnime.animCurrentFrame;
-    s16 frameCount = SkelAnime_GetFrameCount(&D_80ADD990[this->unk_34C].animationSeg->common);
+    s16 currentFrame = this->skelAnime.curFrame;
+    s16 frameCount = Animation_GetLastFrame(D_80ADD990[this->unk_34C].animationSeg);
 
     if ((currentFrame == frameCount) && (this->unk_34C == 7)) {
         this->unk_34C = 0;
@@ -536,8 +536,8 @@ void func_80ADBD64(EnSellnuts* this, GlobalContext* globalCtx) {
 }
 
 void func_80ADBE80(EnSellnuts* this, GlobalContext* globalCtx) {
-    s16 currentFrame = this->skelAnime.animCurrentFrame;
-    s16 frameCount = SkelAnime_GetFrameCount(&D_80ADD990[this->unk_34C].animationSeg->common);
+    s16 currentFrame = this->skelAnime.curFrame;
+    s16 frameCount = Animation_GetLastFrame(D_80ADD990[this->unk_34C].animationSeg);
 
     func_80ADAE64(this);
     if (this->unk_366 == 0) {
@@ -598,8 +598,8 @@ void func_80ADC034(EnSellnuts* this, GlobalContext* globalCtx) {
 
 void func_80ADC118(EnSellnuts* this, GlobalContext* globalCtx) {
     Vec3f sp34;
-    s16 currentFrame = this->skelAnime.animCurrentFrame;
-    s16 frameCount = SkelAnime_GetFrameCount(&D_80ADD990[this->unk_34C].animationSeg->common);
+    s16 currentFrame = this->skelAnime.curFrame;
+    s16 frameCount = Animation_GetLastFrame(D_80ADD990[this->unk_34C].animationSeg);
 
     if (currentFrame == frameCount) {
         Math_SmoothStepToS(&this->unk_364, 0x1C71, 3, 0x100, 0);
@@ -817,8 +817,8 @@ void func_80ADC8C4(EnSellnuts* this, GlobalContext* globalCtx) {
 }
 
 void func_80ADCA64(EnSellnuts* this, GlobalContext* globalCtx) {
-    s16 currentFrame = this->skelAnime.animCurrentFrame;
-    s16 frameCount = SkelAnime_GetFrameCount(&D_80ADD990[this->unk_34C].animationSeg->common);
+    s16 currentFrame = this->skelAnime.curFrame;
+    s16 frameCount = Animation_GetLastFrame(D_80ADD990[this->unk_34C].animationSeg);
 
     if (this->unk_34C == 22) {
         Math_SmoothStepToS(&this->unk_364, 0, 3, 0x100, 0);
@@ -852,8 +852,8 @@ void func_80ADCA64(EnSellnuts* this, GlobalContext* globalCtx) {
 }
 
 void func_80ADCC04(EnSellnuts* this, GlobalContext* globalCtx) {
-    s16 currentFrame = this->skelAnime.animCurrentFrame;
-    s16 frameCount = SkelAnime_GetFrameCount(&D_80ADD990[this->unk_34C].animationSeg->common);
+    s16 currentFrame = this->skelAnime.curFrame;
+    s16 frameCount = Animation_GetLastFrame(D_80ADD990[this->unk_34C].animationSeg);
 
     if (this->unk_34C == 3) {
         if (currentFrame == frameCount) {
@@ -962,7 +962,7 @@ void EnSellnuts_Init(Actor* thisx, GlobalContext* globalCtx) {
     }
 
     Actor_ProcessInitChain(&this->actor, sInitChain);
-    SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_0600AC70, &D_06005488, this->jointTable, this->morphTable, 28);
+    SkelAnime_InitFlex(globalCtx, &this->skelAnime, &D_0600AC70, &D_06005488, this->jointTable, this->morphTable, 28);
     Collider_InitCylinder(globalCtx, &this->collider);
     Collider_SetCylinderType1(globalCtx, &this->collider, &this->actor, &sCylinderInit);
     ActorShape_Init(&this->actor.shape, 0.0f, func_800B3FC0, 35.0f);
@@ -1055,7 +1055,7 @@ void EnSellnuts_Update(Actor* thisx, GlobalContext* globalCtx) {
 
     Actor_SetHeight(&this->actor, 60.0f);
     Actor_SetScale(&this->actor, 0.01f);
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     Actor_SetVelocityAndMoveYRotationAndGravity(&this->actor);
     this->actionFunc(this, globalCtx);
     if (this->unk_338 & 8) {
@@ -1110,7 +1110,7 @@ s32 EnSellnuts_OverrideLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** d
     }
 
     if (limbIndex == 24) {
-        SysMatrix_InsertXRotation_s(this->unk_342, MTXMODE_APPLY);
+        Matrix_InsertXRotation_s(this->unk_342, MTXMODE_APPLY);
     }
 
     if (limbIndex == 26) {
@@ -1148,6 +1148,6 @@ void EnSellnuts_Draw(Actor* thisx, GlobalContext* globalCtx) {
     EnSellnuts* this = THIS;
 
     func_8012C28C(globalCtx->state.gfxCtx);
-    func_801343C0(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl, this->skelAnime.dListCount,
+    func_801343C0(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable, this->skelAnime.dListCount,
                   EnSellnuts_OverrideLimbDraw, EnSellnuts_PostLimbDraw, func_80ADD7CC, &this->actor);
 }
diff --git a/src/overlays/actors/ovl_En_Skb/z_en_skb.c b/src/overlays/actors/ovl_En_Skb/z_en_skb.c
index 91efc860c..3fd19ef91 100644
--- a/src/overlays/actors/ovl_En_Skb/z_en_skb.c
+++ b/src/overlays/actors/ovl_En_Skb/z_en_skb.c
@@ -297,7 +297,7 @@ void func_80994E2C(EnSkb* this) {
 }
 
 void func_80994E94(EnSkb* this, GlobalContext* globalCtx) {
-    if (this->skelAnime.animCurrentFrame < 4.0f) {
+    if (this->skelAnime.curFrame < 4.0f) {
         this->actor.world.rot.y = this->actor.yawTowardsPlayer;
         this->actor.shape.rot.y = this->actor.yawTowardsPlayer;
     } else {
@@ -310,7 +310,7 @@ void func_80994E94(EnSkb* this, GlobalContext* globalCtx) {
         func_809947B0(globalCtx, this, &this->actor.world.pos);
     }
 
-    if (func_801378B8(&this->skelAnime, this->skelAnime.animFrameCount) && (this->actor.shape.yOffset == 0.0f)) {
+    if (Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame) && (this->actor.shape.yOffset == 0.0f)) {
         func_80995A30(this);
     }
     this->unk_3D0++;
@@ -471,13 +471,13 @@ void func_809954F8(EnSkb* this) {
 void func_8099556C(EnSkb* this, GlobalContext* globalCtx) {
     s16 sp26;
 
-    if (this->skelAnime.animCurrentFrame < 15.0f) {
-        sp26 = this->skelAnime.animCurrentFrame - 7.5f;
+    if (this->skelAnime.curFrame < 15.0f) {
+        sp26 = this->skelAnime.curFrame - 7.5f;
     } else {
-        sp26 = 22.5f - this->skelAnime.animCurrentFrame;
+        sp26 = 22.5f - this->skelAnime.curFrame;
     }
 
-    if (func_801378B8(&this->skelAnime, 22.5f)) {
+    if (Animation_OnFrame(&this->skelAnime, 22.5f)) {
         this->unk_3D4 = (u32)Rand_Next() % 0x7D0;
     }
 
@@ -487,7 +487,7 @@ void func_8099556C(EnSkb* this, GlobalContext* globalCtx) {
         this->actor.flags |= (0x8 | 0x1);
         func_80994F7C(this, globalCtx);
     } else if (Actor_IsActorFacingLink(&this->actor, 0x2AAA) && (this->actor.xzDistToPlayer < 200.0f) &&
-               (this->skelAnime.animCurrentFrame > 24.0f) && (this->skelAnime.animCurrentFrame < 28.0f)) {
+               (this->skelAnime.curFrame > 24.0f) && (this->skelAnime.curFrame < 28.0f)) {
         this->actor.hintId = 0x55;
         this->actor.colChkInfo.mass = MASS_HEAVY;
         this->actor.targetArrowOffset = 2000.0f;
@@ -521,7 +521,7 @@ void func_80995818(EnSkb* this, GlobalContext* globalCtx) {
 
     Math_ApproachF(&this->actor.shape.shadowScale, 25.0f, 1.0f, 2.5f);
     Math_SmoothStepToS(&this->actor.shape.rot.x, 0, 0x10, 0x7D0, 0x64);
-    if (func_801378B8(&this->skelAnime, this->skelAnime.animFrameCount)) {
+    if (Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame)) {
         this->actor.shape.rot.x = 0;
         this->actor.gravity = -2.0f;
         func_80995A30(this);
@@ -536,8 +536,7 @@ void func_80995818(EnSkb* this, GlobalContext* globalCtx) {
 }
 
 void func_809958F4(EnSkb* this) {
-    SkelAnime_ChangeAnim(&this->skelAnime, &D_06003584, -1.0f, SkelAnime_GetFrameCount(&D_06003584.common), 0.0f, 2,
-                         -4.0f);
+    Animation_Change(&this->skelAnime, &D_06003584, -1.0f, Animation_GetLastFrame(&D_06003584), 0.0f, 2, -4.0f);
     this->unk_3E4 = 0;
     this->actor.flags &= ~1;
     this->actor.speedXZ = 0.0f;
@@ -555,7 +554,7 @@ void func_8099599C(EnSkb* this, GlobalContext* globalCtx) {
 
     Math_ApproachF(&this->actor.shape.shadowScale, 0.0f, 1.0f, 2.5f);
 
-    if (func_801378B8(&this->skelAnime, this->skelAnime.animFrameCount)) {
+    if (Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame)) {
         Actor_MarkForDeath(&this->actor);
     }
 }
@@ -585,7 +584,7 @@ void func_80995A8C(EnSkb* this, GlobalContext* globalCtx) {
 
     Math_SmoothStepToS(&this->actor.shape.rot.y, this->actor.yawTowardsPlayer + this->unk_3DA, 1, 0x2EE, 0);
     this->actor.world.rot.y = this->actor.shape.rot.y;
-    if (func_801378B8(&this->skelAnime, 8.0f) || func_801378B8(&this->skelAnime, 15.0f)) {
+    if (Animation_OnFrame(&this->skelAnime, 8.0f) || Animation_OnFrame(&this->skelAnime, 15.0f)) {
         Audio_PlayActorSound2(&this->actor, 0x3830);
     }
 
@@ -605,23 +604,23 @@ void func_80995C24(EnSkb* this) {
 }
 
 void func_80995C84(EnSkb* this, GlobalContext* globalCtx) {
-    if (func_801378B8(&this->skelAnime, 3.0f) && (this->unk_3E4 == 0)) {
+    if (Animation_OnFrame(&this->skelAnime, 3.0f) && (this->unk_3E4 == 0)) {
         Audio_PlayActorSound2(&this->actor, NA_SE_EN_STALKID_ATTACK);
         this->unk_3E4 = 1;
-    } else if (func_801378B8(&this->skelAnime, 6.0f)) {
+    } else if (Animation_OnFrame(&this->skelAnime, 6.0f)) {
         this->unk_3E4 = 0;
     }
 
     if (this->collider.base.atFlags & AT_BOUNCED) {
         this->collider.base.atFlags &= ~(AT_BOUNCED | AT_HIT);
         func_80995D3C(this);
-    } else if (func_801378B8(&this->skelAnime, this->skelAnime.animFrameCount)) {
+    } else if (Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame)) {
         func_80994DA8(this, globalCtx);
     }
 }
 
 void func_80995D3C(EnSkb* this) {
-    SkelAnime_ChangeAnim(&this->skelAnime, &D_06002190, -0.4f, this->skelAnime.animCurrentFrame - 1.0f, 0.0f, 3, 0.0f);
+    Animation_Change(&this->skelAnime, &D_06002190, -0.4f, this->skelAnime.curFrame - 1.0f, 0.0f, 3, 0.0f);
     this->collider.base.atFlags &= ~AT_BOUNCED;
     this->unk_3DE = 4;
     this->unk_3E4 = 0;
@@ -629,7 +628,7 @@ void func_80995D3C(EnSkb* this) {
 }
 
 void func_80995DC4(EnSkb* this, GlobalContext* globalCtx) {
-    if (func_801378B8(&this->skelAnime, this->skelAnime.animFrameCount)) {
+    if (Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame)) {
         func_80994DA8(this, globalCtx);
     }
 }
@@ -720,7 +719,7 @@ void func_809960AC(EnSkb* this, GlobalContext* globalCtx) {
     }
 
     Math_SmoothStepToS(&this->actor.shape.rot.x, 0, 0x10, 0x7D0, 0x64);
-    if (func_801378B8(&this->skelAnime, this->skelAnime.animFrameCount) && (this->actor.bgCheckFlags & 1)) {
+    if (Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame) && (this->actor.bgCheckFlags & 1)) {
         this->actor.shape.rot.x = 0;
         this->actor.world.rot = this->actor.shape.rot;
         func_80994DA8(this, globalCtx);
@@ -1049,7 +1048,7 @@ void EnSkb_Update(Actor* thisx, GlobalContext* globalCtx) {
     this->actionFunc(this, globalCtx);
     if ((this->actionFunc != func_80995E64) && (this->actionFunc != func_80996284) &&
         (this->actionFunc != func_8099630C) && (this->actionFunc != func_809963D8)) {
-        SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+        SkelAnime_Update(&this->skelAnime);
     }
 
     func_8099672C(this, globalCtx);
@@ -1087,7 +1086,7 @@ s32 EnSkb_OverrideLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList,
     }
 
     if (limbIndex == 10) {
-        SysMatrix_GetStateTranslation(&this->actor.focus.pos);
+        Matrix_GetStateTranslation(&this->actor.focus.pos);
     }
 
     return false;
@@ -1112,10 +1111,10 @@ void EnSkb_PostLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Ve
         if ((limbIndex == 2) || (limbIndex == 4) || (limbIndex == 5) || (limbIndex == 6) || (limbIndex == 7) ||
             (limbIndex == 8) || (limbIndex == 9) || (limbIndex == 13) || (limbIndex == 14) || (limbIndex == 15) ||
             (limbIndex == 16) || (limbIndex == 17) || (limbIndex == 18)) {
-            SysMatrix_GetStateTranslation(&this->unk_234[this->unk_2DC]);
+            Matrix_GetStateTranslation(&this->unk_234[this->unk_2DC]);
             this->unk_2DC++;
         } else if ((limbIndex == 11) && !(this->unk_3D8 & 2)) {
-            SysMatrix_MultiplyVector3fByState(&D_80997564, &this->unk_234[this->unk_2DC]);
+            Matrix_MultiplyVector3fByState(&D_80997564, &this->unk_234[this->unk_2DC]);
             this->unk_2DC++;
         }
     }
@@ -1126,8 +1125,8 @@ void EnSkb_Draw(Actor* thisx, GlobalContext* globalCtx) {
 
     this->unk_2DC = 0;
     func_8012C28C(globalCtx->state.gfxCtx);
-    SkelAnime_Draw(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl, EnSkb_OverrideLimbDraw,
-                   EnSkb_PostLimbDraw, &this->actor);
+    SkelAnime_DrawOpa(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable, EnSkb_OverrideLimbDraw,
+                      EnSkb_PostLimbDraw, &this->actor);
     if (this->unk_3D2 > 0) {
         func_800BE680(globalCtx, &this->actor, this->unk_234, this->unk_2DC, this->unk_230, 0.5f, this->unk_22C,
                       this->unk_3E6);
diff --git a/src/overlays/actors/ovl_En_Sob1/z_en_sob1.c b/src/overlays/actors/ovl_En_Sob1/z_en_sob1.c
index 8d501627a..8f79570b6 100644
--- a/src/overlays/actors/ovl_En_Sob1/z_en_sob1.c
+++ b/src/overlays/actors/ovl_En_Sob1/z_en_sob1.c
@@ -171,12 +171,12 @@ void EnSob1_ChangeAnim(SkelAnime* skelAnime, ActorAnimationEntryS* animations, s
 
     animations += idx;
     if (animations->frameCount < 0) {
-        frameCount = SkelAnime_GetFrameCount(&animations->animationSeg->common);
+        frameCount = Animation_GetLastFrame(animations->animationSeg);
     } else {
         frameCount = animations->frameCount;
     }
-    SkelAnime_ChangeAnim(skelAnime, animations->animationSeg, animations->playbackSpeed, animations->frame, frameCount,
-                         animations->mode, animations->transitionRate);
+    Animation_Change(skelAnime, animations->animationSeg, animations->playbackSpeed, animations->frame, frameCount,
+                     animations->mode, animations->transitionRate);
 }
 
 void EnSob1_SetupAction(EnSob1* this, EnSob1ActionFunc action) {
@@ -721,8 +721,8 @@ void EnSob1_LookToShopkeeperFromShelf(EnSob1* this, GlobalContext* globalCtx) {
 void EnSob1_EndWalk(EnSob1* this, GlobalContext* globalCtx) {
     s32 pad;
     f32 distSq;
-    s16 animCurrentFrame = this->skelAnime.animCurrentFrame / this->skelAnime.animPlaybackSpeed;
-    s16 animLastFrame = SkelAnime_GetFrameCount(&D_06009120.common) / (s16)this->skelAnime.animPlaybackSpeed;
+    s16 curFrame = this->skelAnime.curFrame / this->skelAnime.playSpeed;
+    s16 animLastFrame = Animation_GetLastFrame(&D_06009120) / (s16)this->skelAnime.playSpeed;
 
     Math_SmoothStepToS(
         &this->actor.world.rot.y,
@@ -732,7 +732,7 @@ void EnSob1_EndWalk(EnSob1* this, GlobalContext* globalCtx) {
     Math_ApproachF(&this->actor.speedXZ, 0.5f, 0.2f, 1.0f);
     if (distSq < 12.0f) {
         this->actor.speedXZ = 0.0f;
-        if (animLastFrame == animCurrentFrame) {
+        if (animLastFrame == curFrame) {
             EnSob1_ChangeAnim(&this->skelAnime, sAnimationsBombShopkeeper, 1);
             EnSob1_SetupAction(this, EnSob1_SetupIdle);
         }
@@ -741,9 +741,9 @@ void EnSob1_EndWalk(EnSob1* this, GlobalContext* globalCtx) {
 }
 
 void EnSob1_SetupIdle(EnSob1* this, GlobalContext* globalCtx) {
-    s16 animCurrentFrame = this->skelAnime.animCurrentFrame;
+    s16 curFrame = this->skelAnime.curFrame;
 
-    if (SkelAnime_GetFrameCount(&D_06008268.common) == animCurrentFrame) {
+    if (Animation_GetLastFrame(&D_06008268) == curFrame) {
         EnSob1_ChangeAnim(&this->skelAnime, sAnimationsBombShopkeeper, 2);
         EnSob1_SetupAction(this, EnSob1_Idle);
     }
@@ -1334,31 +1334,26 @@ s32 EnSob1_AreObjectsLoaded(EnSob1* this, GlobalContext* globalCtx) {
 }
 
 void EnSob1_InitZoraShopkeeper(EnSob1* this, GlobalContext* globalCtx) {
-    SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_0600D208, NULL, this->limbDrawTable, this->transitionDrawTable,
-                     20);
+    SkelAnime_InitFlex(globalCtx, &this->skelAnime, &D_0600D208, NULL, this->jointTable, this->morphTable, 20);
     gSegments[6] = PHYSICAL_TO_VIRTUAL(globalCtx->objectCtx.status[this->objIndices[2]].segment);
-    SkelAnime_ChangeAnim(&this->skelAnime, &D_0600078C, 1.0f, 0.0f, SkelAnime_GetFrameCount(&D_0600078C.common), 0,
-                         0.0f);
+    Animation_Change(&this->skelAnime, &D_0600078C, 1.0f, 0.0f, Animation_GetLastFrame(&D_0600078C), 0, 0.0f);
     this->actor.draw = EnSob1_DrawZoraShopkeeper;
     this->changeObjectFunc = EnSob1_ChangeObject;
 }
 
 void EnSob1_InitGoronShopkeeper(EnSob1* this, GlobalContext* globalCtx) {
-    SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_06011AC8, NULL, this->limbDrawTable, this->transitionDrawTable,
-                     18);
+    SkelAnime_InitFlex(globalCtx, &this->skelAnime, &D_06011AC8, NULL, this->jointTable, this->morphTable, 18);
     gSegments[6] = PHYSICAL_TO_VIRTUAL(globalCtx->objectCtx.status[this->objIndices[2]].segment);
-    SkelAnime_ChangeAnim(&this->skelAnime, &D_060000FC, 1.0f, 0.0f, SkelAnime_GetFrameCount(&D_060000FC.common), 0,
-                         0.0f);
+    Animation_Change(&this->skelAnime, &D_060000FC, 1.0f, 0.0f, Animation_GetLastFrame(&D_060000FC), 0, 0.0f);
     this->actor.draw = EnSob1_DrawGoronShopkeeper;
     this->changeObjectFunc = EnSob1_ChangeObject;
 }
 
 void EnSob1_InitBombShopkeeper(EnSob1* this, GlobalContext* globalCtx) {
-    SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_06009220, &D_06009120, this->limbDrawTable,
-                     this->transitionDrawTable, 16);
+    SkelAnime_InitFlex(globalCtx, &this->skelAnime, &D_06009220, &D_06009120, this->jointTable, this->morphTable, 16);
     this->actor.draw = EnSob1_DrawBombShopkeeper;
     this->changeObjectFunc = NULL;
-    this->skelAnime.animPlaybackSpeed = 2.0f;
+    this->skelAnime.playSpeed = 2.0f;
 }
 
 void EnSob1_InitShop(EnSob1* this, GlobalContext* globalCtx) {
@@ -1483,7 +1478,7 @@ void EnSob1_Update(Actor* thisx, GlobalContext* globalCtx) {
         if (changeObjectFunc != NULL) {
             changeObjectFunc(this, globalCtx);
         }
-        SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+        SkelAnime_Update(&this->skelAnime);
     } else {
         this->actionFunc(this, globalCtx);
     }
@@ -1613,7 +1608,7 @@ s32 EnSob1_OverrideLimbDrawBombShopkeeper(GlobalContext* globalCtx, s32 limbInde
     EnSob1* this = THIS;
 
     if (limbIndex == 15) {
-        SysMatrix_InsertXRotation_s(this->headRot, MTXMODE_APPLY);
+        Matrix_InsertXRotation_s(this->headRot, MTXMODE_APPLY);
     }
     return false;
 }
@@ -1647,8 +1642,8 @@ void EnSob1_DrawZoraShopkeeper(Actor* thisx, GlobalContext* globalCtx) {
     gDPSetEnvColor(POLY_OPA_DISP++, 0, 0, 0, 255);
     gSPSegment(POLY_OPA_DISP++, 0x0C, EnSob1_EndDList(globalCtx->state.gfxCtx));
     gSPSegment(POLY_OPA_DISP++, 0x08, Lib_SegmentedToVirtual(sZoraShopkeeperEyeTextures[this->eyeTexIndex]));
-    SkelAnime_DrawSV(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl, this->skelAnime.dListCount,
-                     EnSob1_OverrideLimbDrawZoraShopkeeper, NULL, &this->actor);
+    SkelAnime_DrawFlexOpa(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable, this->skelAnime.dListCount,
+                          EnSob1_OverrideLimbDrawZoraShopkeeper, NULL, &this->actor);
     for (i = 0; i < ARRAY_COUNT(this->items); i++) {
         this->items[i]->actor.scale.x = 0.2f;
         this->items[i]->actor.scale.y = 0.2f;
@@ -1668,8 +1663,8 @@ void EnSob1_DrawGoronShopkeeper(Actor* thisx, GlobalContext* globalCtx) {
     OPEN_DISPS(globalCtx->state.gfxCtx);
     func_8012C28C(globalCtx->state.gfxCtx);
     gSPSegment(POLY_OPA_DISP++, 0x08, Lib_SegmentedToVirtual(sGoronShopkeeperEyeTextures[this->eyeTexIndex]));
-    SkelAnime_DrawSV(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl, this->skelAnime.dListCount, NULL,
-                     NULL, &this->actor);
+    SkelAnime_DrawFlexOpa(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable, this->skelAnime.dListCount,
+                          NULL, NULL, &this->actor);
     for (i = 0; i < ARRAY_COUNT(this->items); i++) {
         this->items[i]->actor.scale.x = 0.2f;
         this->items[i]->actor.scale.y = 0.2f;
@@ -1689,8 +1684,8 @@ void EnSob1_DrawBombShopkeeper(Actor* thisx, GlobalContext* globalCtx) {
     OPEN_DISPS(globalCtx->state.gfxCtx);
     func_8012C28C(globalCtx->state.gfxCtx);
     gSPSegment(POLY_OPA_DISP++, 0x08, Lib_SegmentedToVirtual(&D_06005458));
-    SkelAnime_DrawSV(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl, this->skelAnime.dListCount,
-                     EnSob1_OverrideLimbDrawBombShopkeeper, EnSob1_PostLimbDrawBombShopkeeper, &this->actor);
+    SkelAnime_DrawFlexOpa(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable, this->skelAnime.dListCount,
+                          EnSob1_OverrideLimbDrawBombShopkeeper, EnSob1_PostLimbDrawBombShopkeeper, &this->actor);
     for (i = 0; i < ARRAY_COUNT(this->items); i++) {
         this->items[i]->actor.scale.x = 0.2f;
         this->items[i]->actor.scale.y = 0.2f;
@@ -1700,7 +1695,7 @@ void EnSob1_DrawBombShopkeeper(Actor* thisx, GlobalContext* globalCtx) {
     EnSob1_DrawStickDirectionPrompt(globalCtx, this);
     frames = globalCtx->gameplayFrames;
     func_8012C2DC(globalCtx->state.gfxCtx);
-    SysMatrix_NormalizeXYZ(&globalCtx->mf_187FC);
+    Matrix_NormalizeXYZ(&globalCtx->mf_187FC);
     Matrix_Scale(1.0f, 1.0f, 1.0f, MTXMODE_APPLY);
     gSPMatrix(POLY_XLU_DISP++, Matrix_NewMtx(globalCtx->state.gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
     gSPSegment(POLY_XLU_DISP++, 0x08,
diff --git a/src/overlays/actors/ovl_En_Sob1/z_en_sob1.h b/src/overlays/actors/ovl_En_Sob1/z_en_sob1.h
index a7f8262fe..c1dfd3849 100644
--- a/src/overlays/actors/ovl_En_Sob1/z_en_sob1.h
+++ b/src/overlays/actors/ovl_En_Sob1/z_en_sob1.h
@@ -32,8 +32,8 @@ typedef struct EnSob1 {
     /* 0x1EA */ s8 objIndices[3];
     /* 0x1EE */ s16 headRot;
     /* 0x1F0 */ s16 headRotTarget;
-    /* 0x1F2 */ Vec3s limbDrawTable[20];
-    /* 0x26A */ Vec3s transitionDrawTable[20];
+    /* 0x1F2 */ Vec3s jointTable[20];
+    /* 0x26A */ Vec3s morphTable[20];
     /* 0x2E2 */ s16 eyeTexIndex;
     /* 0x2E4 */ s16 blinkTimer;
     /* 0x2E8 */ EnSob1BlinkFunc blinkFunc;
diff --git a/src/overlays/actors/ovl_En_Suttari/z_en_suttari.c b/src/overlays/actors/ovl_En_Suttari/z_en_suttari.c
index ec18b9bd2..7449b0f5d 100644
--- a/src/overlays/actors/ovl_En_Suttari/z_en_suttari.c
+++ b/src/overlays/actors/ovl_En_Suttari/z_en_suttari.c
@@ -215,8 +215,8 @@ s32 func_80BAA904(EnSuttari* this, GlobalContext* globalCtx) {
 }
 
 void func_80BAA9B4(EnSuttari* this) {
-    s16 curFrame = this->skelAnime.animCurrentFrame;
-    s16 frameCount = SkelAnime_GetFrameCount(&sAnimations[this->animationIdx].animation->common);
+    s16 curFrame = this->skelAnime.curFrame;
+    s16 frameCount = Animation_GetLastFrame(sAnimations[this->animationIdx].animation);
 
     switch (this->textId) {
         case 0x1454:
@@ -382,8 +382,8 @@ void func_80BAAB78(EnSuttari* this, GlobalContext* globalCtx) {
 }
 
 void func_80BAAF1C(EnSuttari* this) {
-    s16 curFrame = this->skelAnime.animCurrentFrame;
-    s16 frameCount = SkelAnime_GetFrameCount(&sAnimations[this->animationIdx].animation->common);
+    s16 curFrame = this->skelAnime.curFrame;
+    s16 frameCount = Animation_GetLastFrame(sAnimations[this->animationIdx].animation);
 
     if (this->animationIdx == 5) {
         this->animationIdx = 3;
@@ -405,11 +405,11 @@ void func_80BAAFDC(EnSuttari* this, GlobalContext* globalCtx) {
         effectPos.x += Math_SinS(this->actor.world.rot.y + this->unk3F4) * 10.0f;
         effectPos.y += 60.0f;
         effectPos.z += Math_CosS(this->actor.world.rot.y + this->unk3F4) * 10.0f;
-        SysMatrix_StatePush();
+        Matrix_StatePush();
         Matrix_RotateY(this->actor.shape.rot.y, MTXMODE_NEW);
         effectVelOffset.z = 20.0f;
-        SysMatrix_MultiplyVector3fByState(&effectVelOffset, &effectVel);
-        SysMatrix_StatePop();
+        Matrix_MultiplyVector3fByState(&effectVelOffset, &effectVel);
+        Matrix_StatePop();
         if (this->unk3F0 == 0) {
             EffectSsSolderSrchBall_Spawn(globalCtx, &effectPos, &effectVel, &D_801D15B0, 50, &this->unk3F0, 1);
         }
@@ -437,11 +437,11 @@ void func_80BAB1A0(EnSuttari* this, GlobalContext* globalCtx) {
         effectPos.x += Math_SinS(this->actor.world.rot.y + this->unk3F4) * 350.0f;
         effectPos.y += 60.0f;
         effectPos.z += Math_CosS(this->actor.world.rot.y + this->unk3F4) * 350.0f;
-        SysMatrix_StatePush();
+        Matrix_StatePush();
         Matrix_RotateY(this->actor.shape.rot.y, MTXMODE_NEW);
         effectVelOffset.z = 20.0f;
-        SysMatrix_MultiplyVector3fByState(&effectVelOffset, &effectVel);
-        SysMatrix_StatePop();
+        Matrix_MultiplyVector3fByState(&effectVelOffset, &effectVel);
+        Matrix_StatePop();
         if (this->unk3F0 == 0) {
             EffectSsSolderSrchBall_Spawn(globalCtx, &effectPos, &effectVel, &D_801D15B0, 50, &this->unk3F0, 1);
         }
@@ -462,7 +462,7 @@ void func_80BAB1A0(EnSuttari* this, GlobalContext* globalCtx) {
 }
 
 void func_80BAB374(EnSuttari* this, GlobalContext* globalCtx) {
-    s16 curFrame = this->skelAnime.animCurrentFrame;
+    s16 curFrame = this->skelAnime.curFrame;
     Vec3f sp38;
 
     if ((curFrame % 3) == 0) {
@@ -490,7 +490,7 @@ void func_80BAB4F0(EnSuttari* this, GlobalContext* globalCtx) {
     if (this->flags1 & 0x80) {
         EnSuttari_UpdateCollider(this, globalCtx);
     }
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     if (!(this->flags1 & 4) && (Player_GetMask(globalCtx) != PLAYER_MASK_STONE_MASK)) {
         if (func_8013D5E8(this->actor.shape.rot.y, 0x36B0, this->actor.yawTowardsPlayer) != 0) {
             sp30.x = player->actor.world.pos.x;
@@ -816,8 +816,8 @@ s32 func_80BAC220(EnSuttari* this, GlobalContext* globalCtx) {
 
 void func_80BAC2FC(EnSuttari* this, GlobalContext* globalCtx) {
     Player* player = GET_PLAYER(globalCtx);
-    s16 curFrame = this->skelAnime.animCurrentFrame;
-    s16 frameCount = SkelAnime_GetFrameCount(&sAnimations[this->animationIdx].animation->common);
+    s16 curFrame = this->skelAnime.curFrame;
+    s16 frameCount = Animation_GetLastFrame(sAnimations[this->animationIdx].animation);
 
     switch (this->unk428) {
         case 12:
@@ -913,7 +913,7 @@ void func_80BAC2FC(EnSuttari* this, GlobalContext* globalCtx) {
 
 void func_80BAC6E8(EnSuttari* this, GlobalContext* globalCtx) {
     ActorShape_Init(&this->actor.shape, 0.0f, NULL, 0.0f);
-    SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_0600C240, &D_0600071C, this->jointTable, this->morphTable, 16);
+    SkelAnime_InitFlex(globalCtx, &this->skelAnime, &D_0600C240, &D_0600071C, this->jointTable, this->morphTable, 16);
     this->actor.draw = EnSuttari_Draw;
     this->actor.flags |= 1;
     if (globalCtx->sceneNum == SCENE_IKANA) {
@@ -1220,8 +1220,8 @@ void func_80BAD380(EnSuttari* this, GlobalContext* globalCtx) {
 void func_80BAD5F8(EnSuttari* this, GlobalContext* globalCtx) {
     u32* unk_14 = &gSaveContext.unk_14;
     struct_80133038_arg2 unkStruct;
-    s16 curFrame = this->skelAnime.animCurrentFrame;
-    s16 frameCount = SkelAnime_GetFrameCount(&sAnimations[this->animationIdx].animation->common);
+    s16 curFrame = this->skelAnime.curFrame;
+    s16 frameCount = Animation_GetLastFrame(sAnimations[this->animationIdx].animation);
 
     if ((curFrame == frameCount) && (this->animationIdx == 0) && (this->flags1 & 0x20)) {
         this->animationIdx = 2;
@@ -1256,8 +1256,8 @@ void func_80BAD5F8(EnSuttari* this, GlobalContext* globalCtx) {
 void func_80BAD7F8(EnSuttari* this, GlobalContext* globalCtx) {
     u32* unk_14 = &gSaveContext.unk_14;
     struct_80133038_arg2 unkStruct;
-    s16 curFrame = this->skelAnime.animCurrentFrame;
-    s16 frameCount = SkelAnime_GetFrameCount(&sAnimations[this->animationIdx].animation->common);
+    s16 curFrame = this->skelAnime.curFrame;
+    s16 frameCount = Animation_GetLastFrame(sAnimations[this->animationIdx].animation);
 
     if (this->enFsn == NULL) {
         this->enFsn = (EnFsn*)EnSuttari_GetActorById(globalCtx, ACTOR_EN_FSN);
@@ -1305,8 +1305,8 @@ void func_80BADA08(EnSuttari* this, GlobalContext* globalCtx) {
 
 void func_80BADA9C(EnSuttari* this, GlobalContext* globalCtx) {
     u8 talkstate = func_80152498(&globalCtx->msgCtx);
-    s16 curFrame = this->skelAnime.animCurrentFrame;
-    s16 frameCount = SkelAnime_GetFrameCount(&sAnimations[this->animationIdx].animation->common);
+    s16 curFrame = this->skelAnime.curFrame;
+    s16 frameCount = Animation_GetLastFrame(sAnimations[this->animationIdx].animation);
 
     if (this->flags1 & 1) {
         this->unk3F2 = this->unk2DE;
@@ -1460,11 +1460,11 @@ void EnSuttari_Update(Actor* thisx, GlobalContext* globalCtx) {
     }
     if (this->unk428 != 0) {
         if (this->animationIdx == 2 || this->animationIdx == 6) {
-            if (func_801378B8(&this->skelAnime, 8.0f) || func_801378B8(&this->skelAnime, 16.0f)) {
+            if (Animation_OnFrame(&this->skelAnime, 8.0f) || Animation_OnFrame(&this->skelAnime, 16.0f)) {
                 Audio_PlayActorSound2(&this->actor, NA_SE_EV_PAMERA_WALK);
             }
         } else if (this->animationIdx == 0 || this->animationIdx == 5) {
-            if (func_801378B8(&this->skelAnime, 8.0f) || func_801378B8(&this->skelAnime, 17.0f)) {
+            if (Animation_OnFrame(&this->skelAnime, 8.0f) || Animation_OnFrame(&this->skelAnime, 17.0f)) {
                 Audio_PlayActorSound2(&this->actor, NA_SE_EV_PAMERA_WALK);
             }
         }
@@ -1478,15 +1478,15 @@ s32 EnSuttari_OverrideLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dL
     if (limbIndex == 15) {
         *dList = D_0600AF90;
         if (!(this->flags1 & 4)) {
-            SysMatrix_InsertTranslation(1500.0f, 0.0f, 0.0f, MTXMODE_APPLY);
-            SysMatrix_InsertXRotation_s(this->unk3F2, MTXMODE_APPLY);
-            SysMatrix_InsertZRotation_s(-this->unk2DC, MTXMODE_APPLY);
-            SysMatrix_InsertTranslation(-1500.0f, 0.0f, 0.0f, MTXMODE_APPLY);
+            Matrix_InsertTranslation(1500.0f, 0.0f, 0.0f, MTXMODE_APPLY);
+            Matrix_InsertXRotation_s(this->unk3F2, MTXMODE_APPLY);
+            Matrix_InsertZRotation_s(-this->unk2DC, MTXMODE_APPLY);
+            Matrix_InsertTranslation(-1500.0f, 0.0f, 0.0f, MTXMODE_APPLY);
         }
     }
     if (limbIndex == 8) {
-        SysMatrix_InsertXRotation_s(-this->unk2E4, MTXMODE_APPLY);
-        SysMatrix_InsertZRotation_s(-this->unk2E2, MTXMODE_APPLY);
+        Matrix_InsertXRotation_s(-this->unk2E4, MTXMODE_APPLY);
+        Matrix_InsertZRotation_s(-this->unk2E2, MTXMODE_APPLY);
     }
     if (limbIndex == 8 || limbIndex == 9 || limbIndex == 0xC) {
         rot->y += (s16)(Math_SinS(this->unk2FA[limbIndex]) * 200.0f);
@@ -1506,8 +1506,8 @@ void EnSuttari_PostLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList
     if (((this->flags1 & 8) && (this->flags1 & 0x10)) || ((this->flags1 & 2) && !(this->flags1 & 0x20)) ||
         ((this->flags1 & 4) && !(this->flags1 & 0x20))) {
         if (limbIndex == 8) {
-            curState = SysMatrix_GetCurrentState();
-            SysMatrix_MultiplyVector3fByState(&D_80BAE95C, &this->unk3F8);
+            curState = Matrix_GetCurrentState();
+            Matrix_MultiplyVector3fByState(&D_80BAE95C, &this->unk3F8);
             if (this->actor.child == NULL) {
                 if (this->flags1 & 0x100) {
                     bombBag =
@@ -1526,7 +1526,7 @@ void EnSuttari_PostLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList
         }
     }
     if (limbIndex == 15) {
-        SysMatrix_MultiplyVector3fByState(&D_80BAE950, &this->actor.focus.pos);
+        Matrix_MultiplyVector3fByState(&D_80BAE950, &this->actor.focus.pos);
     }
 }
 
@@ -1545,7 +1545,7 @@ void EnSuttari_Draw(Actor* thisx, GlobalContext* globalCtx) {
         gSPSegment(POLY_OPA_DISP++, 0x08, Gfx_EnvColor(globalCtx->state.gfxCtx, 255, 255, 255, 0));
         gSPSegment(POLY_OPA_DISP++, 0x09, Gfx_EnvColor(globalCtx->state.gfxCtx, 55, 55, 255, 0));
         gDPPipeSync(POLY_OPA_DISP++);
-        func_801343C0(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl, this->skelAnime.dListCount,
+        func_801343C0(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable, this->skelAnime.dListCount,
                       EnSuttari_OverrideLimbDraw, EnSuttari_PostLimbDraw, EnSuttari_UnkDraw, &this->actor);
         if (this->flags1 & 0x80) {
             func_8012C2DC(globalCtx->state.gfxCtx);
diff --git a/src/overlays/actors/ovl_En_Sw/z_en_sw.c b/src/overlays/actors/ovl_En_Sw/z_en_sw.c
index d0a58410c..5bcd70b77 100644
--- a/src/overlays/actors/ovl_En_Sw/z_en_sw.c
+++ b/src/overlays/actors/ovl_En_Sw/z_en_sw.c
@@ -289,8 +289,8 @@ void func_808D90F0(EnSw* this, s32 arg1, s16 arg2) {
         temp = arg2;
     }
 
-    SysMatrix_InsertRotationAroundUnitVector_f(BINANG_TO_RAD(temp), &this->unk_368, 0);
-    SysMatrix_MultiplyVector3fByState(&this->unk_350, &sp2C);
+    Matrix_InsertRotationAroundUnitVector_f(BINANG_TO_RAD(temp), &this->unk_368, 0);
+    Matrix_MultiplyVector3fByState(&this->unk_350, &sp2C);
     Math_Vec3f_Copy(&this->unk_350, &sp2C);
     Math3D_CrossProduct(&this->unk_368, &this->unk_350, &this->unk_35C);
 }
@@ -328,8 +328,8 @@ s32 func_808D91C4(EnSw* this, CollisionPoly* arg1) {
     }
 
     Math_Vec3f_Scale(&sp2C, 1.0f / temp_f0);
-    SysMatrix_InsertRotationAroundUnitVector_f(sp4C, &sp2C, MTXMODE_NEW);
-    SysMatrix_MultiplyVector3fByState(&this->unk_35C, &sp2C);
+    Matrix_InsertRotationAroundUnitVector_f(sp4C, &sp2C, MTXMODE_NEW);
+    Matrix_MultiplyVector3fByState(&this->unk_35C, &sp2C);
     Math_Vec3f_Copy(&this->unk_35C, &sp2C);
     Math3D_CrossProduct(&this->unk_35C, &sp38, &this->unk_350);
 
@@ -488,11 +488,11 @@ void func_808D9894(EnSw* this, Vec3f* vec) {
     sp1C.zw = 0.0f;
     sp1C.ww = 0.0f;
 
-    SysMatrix_SetCurrentState(&sp1C);
+    Matrix_SetCurrentState(&sp1C);
     sp5C.x = vec->x - this->actor.world.pos.x;
     sp5C.y = vec->y - this->actor.world.pos.y;
     sp5C.z = vec->z - this->actor.world.pos.z;
-    SysMatrix_MultiplyVector3fByState(&sp5C, vec);
+    Matrix_MultiplyVector3fByState(&sp5C, vec);
 }
 
 s32 func_808D9968(EnSw* this, GlobalContext* globalCtx) {
@@ -529,8 +529,8 @@ s32 func_808D9A70(EnSw* this, GlobalContext* globalCtx) {
     f32 frame;
 
     if (DECR(this->unk_454) == 0) {
-        if (!func_801378B8(&this->skelAnime, this->skelAnime.animFrameCount)) {
-            frame = this->skelAnime.animFrameCount - this->skelAnime.animCurrentFrame;
+        if (!Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame)) {
+            frame = this->skelAnime.endFrame - this->skelAnime.curFrame;
             sp2E = (80.0f * frame) * this->unk_450;
         } else {
             if (this->unk_456 != 0) {
@@ -540,7 +540,7 @@ s32 func_808D9A70(EnSw* this, GlobalContext* globalCtx) {
                     Audio_PlayActorSound2(&this->actor, NA_SE_EN_STALGOLD_ROLL);
                 }
                 this->unk_456--;
-                this->skelAnime.animCurrentFrame = 0.0f;
+                this->skelAnime.curFrame = 0.0f;
             } else {
                 this->unk_454 = Rand_S16Offset(20, 20);
                 this->unk_456 = (Rand_ZeroOne() * 10.0f) + 3.0f;
@@ -767,15 +767,15 @@ void func_808DA3F4(EnSw* this, GlobalContext* globalCtx) {
     Vec3f sp38;
     f32 temp_f16;
 
-    if (!func_801378B8(&this->skelAnime, this->skelAnime.animFrameCount)) {
-        temp_f16 = this->skelAnime.animFrameCount - this->skelAnime.animCurrentFrame;
+    if (!Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame)) {
+        temp_f16 = this->skelAnime.endFrame - this->skelAnime.curFrame;
         temp_s1 = (s16)(80.0f * temp_f16);
         Math_Vec3f_Copy(&sp38, &this->unk_374);
         func_808D9894(this, &sp38);
 
         temp_v0 = Math_FAtan2F(sp38.z, sp38.x);
         if (ABS_ALT(temp_v0) < temp_s1) {
-            this->skelAnime.animCurrentFrame = 0.0f;
+            this->skelAnime.curFrame = 0.0f;
             Audio_PlayActorSound2(&this->actor, NA_SE_EN_STALWALL_DASH);
             this->unk_414 = 0.0f;
             if (this->unk_410 & 0x20) {
@@ -788,7 +788,7 @@ void func_808DA3F4(EnSw* this, GlobalContext* globalCtx) {
         temp_s1 *= (temp_v0 < 0) ? -1 : 1;
     } else {
         Audio_PlayActorSound2(&this->actor, NA_SE_EN_STALWALL_ROLL);
-        this->skelAnime.animCurrentFrame = 0.0f;
+        this->skelAnime.curFrame = 0.0f;
     }
     func_808D94D0(this, globalCtx, 0, 0, temp_s1);
 }
@@ -800,8 +800,8 @@ void func_808DA578(EnSw* this, GlobalContext* globalCtx) {
     s32 test2;
     Vec3f sp30;
 
-    if (!func_801378B8(&this->skelAnime, this->skelAnime.animFrameCount)) {
-        temp_f0 = this->skelAnime.animFrameCount - this->skelAnime.animCurrentFrame;
+    if (!Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame)) {
+        temp_f0 = this->skelAnime.endFrame - this->skelAnime.curFrame;
         this->unk_44C = 0.3f * temp_f0;
         func_808D94D0(this, globalCtx, 1, 0, 0);
         if ((this->actor.speedXZ == 0.0f) && (this->unk_44C != 0.0f)) {
@@ -814,7 +814,7 @@ void func_808DA578(EnSw* this, GlobalContext* globalCtx) {
         this->actionFunc = func_808DA3F4;
     } else {
         Audio_PlayActorSound2(&this->actor, NA_SE_EN_STALWALL_DASH);
-        this->skelAnime.animCurrentFrame = 0.0f;
+        this->skelAnime.curFrame = 0.0f;
     }
 
     temp_f0 = Math_Vec3f_DistXYZ(&this->actor.world.pos, &this->unk_374);
@@ -839,8 +839,8 @@ void func_808DA6FC(EnSw* this, GlobalContext* globalCtx) {
     Vec3f sp38;
     f32 temp_f0;
 
-    if (!func_801378B8(&this->skelAnime, this->skelAnime.animFrameCount)) {
-        temp_f0 = this->skelAnime.animFrameCount - this->skelAnime.animCurrentFrame;
+    if (!Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame)) {
+        temp_f0 = this->skelAnime.endFrame - this->skelAnime.curFrame;
         this->unk_44C = 0.14f * temp_f0;
         func_808D94D0(this, globalCtx, 1, 0, 0);
         if ((this->actor.speedXZ == 0.0f) && (this->unk_44C != 0.0f)) {
@@ -850,7 +850,7 @@ void func_808DA6FC(EnSw* this, GlobalContext* globalCtx) {
         }
     } else {
         Audio_PlayActorSound2(&this->actor, NA_SE_EN_STALWALL_DASH);
-        this->skelAnime.animCurrentFrame = 0.0f;
+        this->skelAnime.curFrame = 0.0f;
     }
 
     sp4C = Math_Vec3f_DistXYZ(&this->actor.world.pos, &this->unk_374);
@@ -861,7 +861,7 @@ void func_808DA6FC(EnSw* this, GlobalContext* globalCtx) {
         this->unk_454 = Rand_S16Offset(20, 20);
         this->unk_456 = (Rand_ZeroOne() * 10.0f) + 3.0f;
         this->actionFunc = func_808DA350;
-        this->skelAnime.animCurrentFrame = 0.0f;
+        this->skelAnime.curFrame = 0.0f;
     }
     this->unk_414 = sp4C;
 }
@@ -939,15 +939,15 @@ void func_808DAA60(EnSw* this, GlobalContext* globalCtx) {
     sp40 = 0;
 
     if (DECR(this->unk_454) == 0) {
-        if (func_801378B8(&this->skelAnime, this->skelAnime.animFrameCount) == 0) {
-            temp_f16 = this->skelAnime.animFrameCount - this->skelAnime.animCurrentFrame;
+        if (Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame) == 0) {
+            temp_f16 = this->skelAnime.endFrame - this->skelAnime.curFrame;
             sp40 = 80.0f * temp_f16;
             if (this->unk_45E == 0) {
                 Math_Vec3s_ToVec3f(&sp34, &sp44[this->unk_4A0]);
                 func_808D9894(this, &sp34);
                 temp_v0 = Math_FAtan2F(sp34.z, sp34.x);
                 if (ABS_ALT(temp_v0) < sp40) {
-                    this->skelAnime.animCurrentFrame = 0.0f;
+                    this->skelAnime.curFrame = 0.0f;
                     Audio_PlayActorSound2(&this->actor, NA_SE_EN_STALWALL_DASH);
                     Math_Vec3s_ToVec3f(&this->unk_374, &sp44[this->unk_4A0]);
                     this->actionFunc = func_808DACF4;
@@ -960,7 +960,7 @@ void func_808DAA60(EnSw* this, GlobalContext* globalCtx) {
             if (this->unk_456 != 0) {
                 Audio_PlayActorSound2(&this->actor, NA_SE_EN_STALGOLD_ROLL);
                 this->unk_456--;
-                this->skelAnime.animCurrentFrame = 0.0f;
+                this->skelAnime.curFrame = 0.0f;
             } else {
                 this->unk_454 = Rand_S16Offset(20, 20);
                 this->unk_456 = (Rand_ZeroOne() * 10.0f) + 3.0f;
@@ -987,11 +987,11 @@ void func_808DACF4(EnSw* this, GlobalContext* globalCtx) {
     f32 temp_f0;
     s32 temp_f6;
 
-    if (func_801378B8(&this->skelAnime, this->skelAnime.animFrameCount) == 0) {
+    if (Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame) == 0) {
         Vec3f sp38;
         f32 temp;
 
-        temp = this->skelAnime.animFrameCount - this->skelAnime.animCurrentFrame;
+        temp = this->skelAnime.endFrame - this->skelAnime.curFrame;
         this->unk_44C = 0.1f * temp;
         func_808D94D0(this, globalCtx, 1, 0, 0);
         if ((this->actor.speedXZ == 0.0f) && (this->unk_44C != 0.0f)) {
@@ -1002,7 +1002,7 @@ void func_808DACF4(EnSw* this, GlobalContext* globalCtx) {
         }
     } else {
         Audio_PlayActorSound2(&this->actor, NA_SE_EN_STALWALL_DASH);
-        this->skelAnime.animCurrentFrame = 0.0f;
+        this->skelAnime.curFrame = 0.0f;
     }
 
     sp4C = Math_Vec3f_DistXYZ(&this->actor.world.pos, &this->unk_374);
@@ -1092,7 +1092,7 @@ void func_808DB100(EnSw* this, GlobalContext* globalCtx) {
         this->unk_498 = this->actor.parent->id;
         this->unk_456 = 0;
         this->unk_454 = 0;
-        this->skelAnime.animCurrentFrame = 0.0f;
+        this->skelAnime.curFrame = 0.0f;
         func_800BC154(globalCtx, &globalCtx->actorCtx, &this->actor, 4);
         this->actionFunc = func_808DB25C;
         return;
@@ -1103,7 +1103,7 @@ void func_808DB100(EnSw* this, GlobalContext* globalCtx) {
         return;
     }
 
-    if ((DECR(this->unk_454) == 0) && func_801378B8(&this->skelAnime, this->skelAnime.animFrameCount)) {
+    if ((DECR(this->unk_454) == 0) && Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame)) {
         if (this->unk_456 != 0) {
             if (!ENSW_GET_3(&this->actor)) {
                 Audio_PlayActorSound2(&this->actor, NA_SE_EN_STALWALL_ROLL);
@@ -1111,7 +1111,7 @@ void func_808DB100(EnSw* this, GlobalContext* globalCtx) {
                 Audio_PlayActorSound2(&this->actor, NA_SE_EN_STALGOLD_ROLL);
             }
             this->unk_456--;
-            this->skelAnime.animCurrentFrame = 0.0f;
+            this->skelAnime.curFrame = 0.0f;
         } else {
             this->unk_454 = Rand_S16Offset(20, 20);
             this->unk_456 = (Rand_ZeroOne() * 10.0f) + 3.0f;
@@ -1171,7 +1171,7 @@ void EnSw_Init(Actor* thisx, GlobalContext* globalCtx) {
         ActorShape_Init(&this->actor.shape, 0.0f, NULL, 0.0f);
         SkelAnime_Init(globalCtx, &this->skelAnime, &D_06005298, NULL, this->jointTable, this->morphTable, 30);
         func_8013BC6C(&this->skelAnime, sAnimations, 0);
-        this->skelAnime.animPlaybackSpeed = 4.0f;
+        this->skelAnime.playSpeed = 4.0f;
 
         Collider_InitAndSetSphere(globalCtx, &this->collider, &this->actor, &sSphereInit);
         if (!ENSW_GET_3(&this->actor)) {
@@ -1261,7 +1261,7 @@ void EnSw_Update(Actor* thisx, GlobalContext* globalCtx) {
     }
 
     if ((this->unk_412 != 10) || (this->unk_45A != 0)) {
-        SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+        SkelAnime_Update(&this->skelAnime);
     }
 
     Actor_SetHeight(&this->actor, 0.0f);
@@ -1327,9 +1327,9 @@ void EnSw_Draw(Actor* thisx, GlobalContext* globalCtx) {
             func_800B8050(&this->actor, globalCtx, MTXMODE_NEW);
         }
         func_8012C28C(globalCtx->state.gfxCtx);
-        SysMatrix_InsertXRotation_s(-0x3C72, MTXMODE_APPLY);
-        SkelAnime_Draw(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl, EnSw_OverrideLimbDraw, NULL,
-                       &this->actor);
+        Matrix_InsertXRotation_s(-0x3C72, MTXMODE_APPLY);
+        SkelAnime_DrawOpa(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable, EnSw_OverrideLimbDraw, NULL,
+                          &this->actor);
     }
 
     for (i = 0, count = 0; i < ARRAY_COUNT(this->unk_464); i++) {
diff --git a/src/overlays/actors/ovl_En_Syateki_Man/z_en_syateki_man.c b/src/overlays/actors/ovl_En_Syateki_Man/z_en_syateki_man.c
index e44872127..7e641a4ed 100644
--- a/src/overlays/actors/ovl_En_Syateki_Man/z_en_syateki_man.c
+++ b/src/overlays/actors/ovl_En_Syateki_Man/z_en_syateki_man.c
@@ -141,9 +141,11 @@ void EnSyatekiMan_Init(Actor* thisx, GlobalContext* globalCtx) {
     this->actor.targetMode = 1;
     Actor_SetScale(&this->actor, 0.01f);
     if (globalCtx->sceneNum == SCENE_SYATEKI_MORI) {
-        SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_0600E7D0, &D_0600DFEC, this->jointTable, this->morphTable, 16);
+        SkelAnime_InitFlex(globalCtx, &this->skelAnime, &D_0600E7D0, &D_0600DFEC, this->jointTable, this->morphTable,
+                           16);
     } else {
-        SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_0600E7D0, &D_0600D9D0, this->jointTable, this->morphTable, 16);
+        SkelAnime_InitFlex(globalCtx, &this->skelAnime, &D_0600E7D0, &D_0600D9D0, this->jointTable, this->morphTable,
+                           16);
     }
 
     this->actor.colChkInfo.cylRadius = 100;
@@ -415,8 +417,8 @@ void func_809C6E30(EnSyatekiMan* this, GlobalContext* globalCtx) {
             break;
     }
 
-    if (this->skelAnime.animCurrentSeg == &D_0600D2F8) {
-        if (func_801378B8(&this->skelAnime, this->skelAnime.animFrameCount)) {
+    if (this->skelAnime.animation == &D_0600D2F8) {
+        if (Animation_OnFrame(&this->skelAnime, this->skelAnime.endFrame)) {
             func_800BDC5C(&this->skelAnime, sAnimations, 0);
         }
     }
@@ -1239,7 +1241,7 @@ void EnSyatekiMan_Update(Actor* thisx, GlobalContext* globalCtx) {
     this->actor.focus.pos.y = 70.0f;
     Actor_SetHeight(&this->actor, 70.0f);
     if (this->unk_26A != 1) {
-        SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+        SkelAnime_Update(&this->skelAnime);
         func_800E9250(globalCtx, &this->actor, &this->unk_258, &this->unk_25E, this->actor.focus.pos);
     }
 }
@@ -1253,12 +1255,12 @@ s32 EnSyatekiMan_OverrideLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx**
     }
 
     if (limbIndex == 15) {
-        SysMatrix_InsertTranslation(3000.0f, 0.0f, 0.0f, MTXMODE_APPLY);
-        SysMatrix_InsertZRotation_s(this->unk_258.x, MTXMODE_APPLY);
-        SysMatrix_InsertXRotation_s(this->unk_258.y, MTXMODE_APPLY);
-        SysMatrix_InsertTranslation(-3000.0f, 0.0f, 0.0f, MTXMODE_APPLY);
+        Matrix_InsertTranslation(3000.0f, 0.0f, 0.0f, MTXMODE_APPLY);
+        Matrix_InsertZRotation_s(this->unk_258.x, MTXMODE_APPLY);
+        Matrix_InsertXRotation_s(this->unk_258.y, MTXMODE_APPLY);
+        Matrix_InsertTranslation(-3000.0f, 0.0f, 0.0f, MTXMODE_APPLY);
     } else if (limbIndex == 8) {
-        SysMatrix_InsertXRotation_s(-this->unk_25E.y, MTXMODE_APPLY);
+        Matrix_InsertXRotation_s(-this->unk_25E.y, MTXMODE_APPLY);
     }
 
     return false;
@@ -1269,7 +1271,7 @@ void EnSyatekiMan_PostLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dL
     Vec3f sp18 = { 1600.0f, 0.0f, 0.0f };
 
     if (limbIndex == 15) {
-        SysMatrix_MultiplyVector3fByState(&sp18, &this->actor.focus.pos);
+        Matrix_MultiplyVector3fByState(&sp18, &this->actor.focus.pos);
     }
 }
 
@@ -1299,7 +1301,7 @@ void EnSyatekiMan_Draw(Actor* thisx, GlobalContext* globalCtx) {
     gSPSegment(POLY_OPA_DISP++, 0x08, Lib_SegmentedToVirtual(D_809C94B8[this->unk_264]));
     gSPSegment(POLY_OPA_DISP++, 0x09, Lib_SegmentedToVirtual(D_809C94B8[this->unk_264]));
 
-    SkelAnime_DrawSV(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl, this->skelAnime.dListCount,
+    SkelAnime_DrawFlexOpa(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable, this->skelAnime.dListCount,
                      EnSyatekiMan_OverrideLimbDraw, EnSyatekiMan_PostLimbDraw, &this->actor);
 
     CLOSE_DISPS(globalCtx->state.gfxCtx);
diff --git a/src/overlays/actors/ovl_En_Thiefbird/z_en_thiefbird.c b/src/overlays/actors/ovl_En_Thiefbird/z_en_thiefbird.c
index d98657a29..b303ed877 100644
--- a/src/overlays/actors/ovl_En_Thiefbird/z_en_thiefbird.c
+++ b/src/overlays/actors/ovl_En_Thiefbird/z_en_thiefbird.c
@@ -37,17 +37,14 @@ extern AnimationHeader D_06000278;
 extern AnimationHeader D_06000604;
 extern Gfx D_06003060[];
 extern Gfx D_060030D8[];
-extern UNK_PTR D_060033B0;
-extern UNK_PTR D_06003D58;
-extern UNK_TYPE D_06004348;
-extern UNK_TYPE D_06004B88;
-extern UNK_TYPE D_060055E0;
+extern Gfx D_060033B0[];
+extern Gfx D_06003D58[];
+extern Gfx D_06004348[];
+extern Gfx D_06004B88[];
+extern Gfx D_060055E0[];
 extern FlexSkeletonHeader D_060061A0;
 extern AnimationHeader D_060063C4;
 
-static Vec3f D_80C13920;
-static s32 D_80C1392C;
-
 const ActorInit En_Thiefbird_InitVars = {
     ACTOR_EN_THIEFBIRD,
     ACTORCAT_ENEMY,
@@ -156,13 +153,16 @@ static InitChainEntry sInitChain[] = {
     ICHAIN_F32(targetArrowOffset, 500, ICHAIN_STOP),
 };
 
+static Vec3f D_80C13920;
+static s32 D_80C1392C;
+
 void EnThiefbird_Init(Actor* thisx, GlobalContext* globalCtx) {
     EnThiefbird* this = THIS;
     s32 i;
     ColliderJntSphElementDim* dim;
 
     Actor_ProcessInitChain(&this->actor, sInitChain);
-    SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_060061A0, &D_06000604, this->jointTable, this->morphTable, 17);
+    SkelAnime_InitFlex(globalCtx, &this->skelAnime, &D_060061A0, &D_06000604, this->jointTable, this->morphTable, 17);
     Collider_InitAndSetJntSph(globalCtx, &this->collider, &this->actor, &sJntSphInit, this->colliderElements);
 
     for (i = 0; i < ARRAY_COUNT(this->colliderElements); i++) {
@@ -217,7 +217,7 @@ void func_80C10984(EnThiefbird* this, s32 arg1) {
 }
 
 s32 func_80C10B0C(EnThiefbird* this, GlobalContext* globalCtx) {
-    static UNK_TYPE D_80C13680[] = { &D_06004348, &D_06004B88, &D_060055E0 };
+    static Gfx* D_80C13680[] = { D_06004348, D_06004B88, D_060055E0 };
     s32 isItemFound = false;
     s32 phi_a3 = 0;
     s32 i = 18;
@@ -249,7 +249,7 @@ s32 func_80C10B0C(EnThiefbird* this, GlobalContext* globalCtx) {
 
     if (isItemFound) {
         func_801149A0(sp1E, i);
-        this->unk_3E8 = &D_060033B0;
+        this->unk_3E8 = D_060033B0;
         if (!func_80152498(&globalCtx->msgCtx)) {
             func_801518B0(globalCtx, 0xF4, NULL);
         }
@@ -266,7 +266,7 @@ s32 func_80C10B0C(EnThiefbird* this, GlobalContext* globalCtx) {
         phi_t0_3 = phi_a3 + 0x4C;
         if (phi_a3 == 4) {
             func_801149A0(16, 16);
-            this->unk_3E8 = &D_06003D58;
+            this->unk_3E8 = D_06003D58;
             phi_t0_3 = 0x10;
         } else {
             CUR_FORM_EQUIP(EQUIP_SLOT_B) = ITEM_NONE;
@@ -471,7 +471,7 @@ void func_80C114C0(EnThiefbird* this, GlobalContext* globalCtx) {
 }
 
 void func_80C11538(EnThiefbird* this) {
-    SkelAnime_ChangeAnimTransitionRepeat(&this->skelAnime, &D_06000604, -4.0f);
+    Animation_MorphToLoop(&this->skelAnime, &D_06000604, -4.0f);
     this->unk_18E = 60;
     this->collider.base.acFlags |= AC_ON;
     this->actionFunc = func_80C11590;
@@ -481,8 +481,8 @@ void func_80C11590(EnThiefbird* this, GlobalContext* globalCtx) {
     Player* player = GET_PLAYER(globalCtx);
     s32 sp38;
 
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
-    sp38 = func_801378B8(&this->skelAnime, 0.0f);
+    SkelAnime_Update(&this->skelAnime);
+    sp38 = Animation_OnFrame(&this->skelAnime, 0.0f);
     this->actor.speedXZ = (Rand_ZeroOne() * 1.5f) + 3.0f;
 
     if (this->actor.bgCheckFlags & 8) {
@@ -535,7 +535,7 @@ void func_80C11590(EnThiefbird* this, GlobalContext* globalCtx) {
 }
 
 void func_80C118E4(EnThiefbird* this) {
-    SkelAnime_ChangeAnimTransitionRepeat(&this->skelAnime, &D_060063C4, -10.0f);
+    Animation_MorphToLoop(&this->skelAnime, &D_060063C4, -10.0f);
     this->unk_18E = 300;
     this->actionFunc = func_80C1193C;
     this->actor.speedXZ = 5.0f;
@@ -545,8 +545,8 @@ void func_80C1193C(EnThiefbird* this, GlobalContext* globalCtx) {
     Player* player = GET_PLAYER(globalCtx);
     s16 pitch;
 
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
-    if (func_801378B8(&this->skelAnime, 1.0f)) {
+    SkelAnime_Update(&this->skelAnime);
+    if (Animation_OnFrame(&this->skelAnime, 1.0f)) {
         Audio_PlayActorSound2(&this->actor, NA_SE_EN_KAICHO_FLUTTER);
     }
 
@@ -602,7 +602,7 @@ void func_80C1193C(EnThiefbird* this, GlobalContext* globalCtx) {
 void func_80C11C60(EnThiefbird* this) {
     this->actor.speedXZ = 0.0f;
     this->actor.velocity.y = 0.0f;
-    SkelAnime_ChangeAnimDefaultStop(&this->skelAnime, &D_06000088);
+    Animation_PlayOnce(&this->skelAnime, &D_06000088);
     this->actor.bgCheckFlags &= ~1;
     this->actor.shape.rot.x = 0;
     this->unk_18E = 40;
@@ -674,7 +674,7 @@ void func_80C11DF0(EnThiefbird* this, GlobalContext* globalCtx) {
 }
 
 void func_80C11F6C(EnThiefbird* this, GlobalContext* globalCtx) {
-    SkelAnime_ChangeAnimTransitionRepeat(&this->skelAnime, &D_06000278, -4.0f);
+    Animation_MorphToLoop(&this->skelAnime, &D_06000278, -4.0f);
     func_80C10984(this, 15);
     if (this->actor.colChkInfo.damageEffect != 3) {
         this->actor.speedXZ = 4.0f;
@@ -732,7 +732,7 @@ void func_80C1215C(EnThiefbird* this, GlobalContext* globalCtx) {
         }
     }
 
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     if (this->actor.bgCheckFlags & 8) {
         this->unk_192 = this->actor.wallYaw;
     } else if (this->unk_3E8 == 0) {
@@ -758,7 +758,7 @@ void func_80C1215C(EnThiefbird* this, GlobalContext* globalCtx) {
 }
 
 void func_80C12308(EnThiefbird* this) {
-    SkelAnime_ChangeAnimTransitionRepeat(&this->skelAnime, &D_06000278, -4.0f);
+    Animation_MorphToLoop(&this->skelAnime, &D_06000278, -4.0f);
     func_80C10984(this, 15);
     this->unk_190 = -0x1000;
     this->unk_192 = BINANG_ROT180(this->actor.yawTowardsPlayer);
@@ -771,7 +771,7 @@ void func_80C12378(EnThiefbird* this, GlobalContext* globalCtx) {
         this->unk_18E--;
     }
 
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     if (this->actor.bgCheckFlags & 8) {
         this->unk_192 = this->actor.wallYaw;
     } else {
@@ -787,7 +787,7 @@ void func_80C12378(EnThiefbird* this, GlobalContext* globalCtx) {
 }
 
 void func_80C1242C(EnThiefbird* this) {
-    SkelAnime_ChangeAnim(&this->skelAnime, &D_06000278, 2.0f, 0.0f, 0.0f, 0, -4.0f);
+    Animation_Change(&this->skelAnime, &D_06000278, 2.0f, 0.0f, 0.0f, 0, -4.0f);
     this->actor.flags |= 0x10;
     this->collider.base.acFlags |= AC_ON;
     this->actionFunc = func_80C124B0;
@@ -798,7 +798,7 @@ void func_80C124B0(EnThiefbird* this, GlobalContext* globalCtx) {
     Actor* temp_v0;
     s16 temp_v1;
 
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     if (this->actor.bgCheckFlags & 8) {
         this->unk_192 = this->actor.wallYaw;
     } else {
@@ -839,7 +839,7 @@ void func_80C126A8(EnThiefbird* this) {
 }
 
 void func_80C126D8(EnThiefbird* this, GlobalContext* globalCtx) {
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     Math_ApproachS(&this->actor.shape.rot.x, 0x3000, 6, 0x1000);
     if (this->actor.yDistToPlayer > 100.0f) {
         Actor_MarkForDeath(&this->actor);
@@ -847,14 +847,14 @@ void func_80C126D8(EnThiefbird* this, GlobalContext* globalCtx) {
 }
 
 void func_80C12744(EnThiefbird* this) {
-    SkelAnime_ChangeAnimTransitionRepeat(&this->skelAnime, &D_06000604, -4.0f);
-    SkelAnime_ChangeAnim(&this->skelAnime, &D_06000604, 1.0f, 0.0f, 0.0f, 1, -4.0f);
+    Animation_MorphToLoop(&this->skelAnime, &D_06000604, -4.0f);
+    Animation_Change(&this->skelAnime, &D_06000604, 1.0f, 0.0f, 0.0f, 1, -4.0f);
     this->unk_190 = 0;
     this->collider.base.acFlags |= AC_ON;
     this->actor.flags |= 0x10;
     this->actionFunc = func_80C127F4;
     this->actor.speedXZ = 4.0f;
-    this->skelAnime.animPlaybackSpeed = 3.0f;
+    this->skelAnime.playSpeed = 3.0f;
 }
 
 void func_80C127F4(EnThiefbird* this, GlobalContext* globalCtx) {
@@ -862,7 +862,7 @@ void func_80C127F4(EnThiefbird* this, GlobalContext* globalCtx) {
     s16 temp_v0;
     f32 temp_f0;
 
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     if ((this->unk_3EC != NULL) && ((this->unk_3EC->actor.update == NULL) || (this->unk_3EC->unk152 == 0) ||
                                     (Actor_XZDistanceBetweenActors(&player->actor, &this->unk_3EC->actor) <= 10.0f))) {
         this->unk_3EC = NULL;
@@ -1041,8 +1041,8 @@ void EnThiefbird_Update(Actor* thisx, GlobalContext* globalCtx2) {
     }
 
     func_80C12D00(this);
-    if (((this->skelAnime.animCurrentSeg == &D_06000604) && func_801378B8(&this->skelAnime, 13.0f)) ||
-        ((this->skelAnime.animCurrentSeg == &D_06000278) && func_801378B8(&this->skelAnime, 1.0f))) {
+    if (((this->skelAnime.animation == &D_06000604) && Animation_OnFrame(&this->skelAnime, 13.0f)) ||
+        ((this->skelAnime.animation == &D_06000278) && Animation_OnFrame(&this->skelAnime, 1.0f))) {
         Audio_PlayActorSound2(&this->actor, NA_SE_EN_KAICHO_FLUTTER);
     }
 }
@@ -1077,17 +1077,17 @@ void EnThiefbird_PostLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dLi
         OPEN_DISPS(globalCtx->state.gfxCtx);
 
         gfx = POLY_OPA_DISP;
-        SysMatrix_NormalizeXYZ(&globalCtx->mf_187FC);
+        Matrix_NormalizeXYZ(&globalCtx->mf_187FC);
         gSPMatrix(&gfx[0], Matrix_NewMtx(globalCtx->state.gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
         gSPDisplayList(&gfx[1], this->unk_3E4);
         POLY_OPA_DISP = &gfx[2];
 
         CLOSE_DISPS(globalCtx->state.gfxCtx);
     } else if (limbIndex == 16) {
-        if (this->unk_3E8 != 0) {
+        if (this->unk_3E8 != NULL) {
             OPEN_DISPS(globalCtx->state.gfxCtx);
 
-            if (this->unk_3E8 == &D_060033B0) {
+            if (this->unk_3E8 == D_060033B0) {
                 gfx = POLY_XLU_DISP;
             } else {
                 gfx = POLY_OPA_DISP;
@@ -1096,7 +1096,7 @@ void EnThiefbird_PostLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dLi
             gSPMatrix(&gfx[0], Matrix_NewMtx(globalCtx->state.gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
             gSPDisplayList(&gfx[1], this->unk_3E8);
 
-            if (this->unk_3E8 == &D_060033B0) {
+            if (this->unk_3E8 == D_060033B0) {
                 POLY_XLU_DISP = &gfx[2];
             } else {
                 POLY_OPA_DISP = &gfx[2];
@@ -1109,11 +1109,11 @@ void EnThiefbird_PostLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dLi
     idx = D_80C13698[limbIndex];
     if (idx != -1) {
         if (idx == 9) {
-            SysMatrix_GetStateTranslationAndScaledX(1000.0f, &this->unk_350[idx]);
+            Matrix_GetStateTranslationAndScaledX(1000.0f, &this->unk_350[idx]);
         } else {
-            SysMatrix_GetStateTranslation(&this->unk_350[idx]);
+            Matrix_GetStateTranslation(&this->unk_350[idx]);
             if ((idx == 3) || (idx == 5)) {
-                SysMatrix_GetStateTranslationAndScaledX(2000.0f, &this->unk_350[idx + 1]);
+                Matrix_GetStateTranslationAndScaledX(2000.0f, &this->unk_350[idx + 1]);
             }
         }
     }
@@ -1134,11 +1134,11 @@ void func_80C13354(EnThiefbird* this, GlobalContext* globalCtx2) {
 
     for (i = 0; i < ARRAY_COUNT(this->unk_3F0); i++, ptr++) {
         if (ptr->unk_22 != 0) {
-            SysMatrix_InsertTranslation(ptr->unk_00.x, ptr->unk_00.y, ptr->unk_00.z, MTXMODE_NEW);
-            SysMatrix_NormalizeXYZ(&globalCtx->mf_187FC);
+            Matrix_InsertTranslation(ptr->unk_00.x, ptr->unk_00.y, ptr->unk_00.z, MTXMODE_NEW);
+            Matrix_NormalizeXYZ(&globalCtx->mf_187FC);
             Matrix_RotateY(ptr->unk_1E, MTXMODE_APPLY);
-            SysMatrix_InsertZRotation_s(ptr->unk_20, MTXMODE_APPLY);
-            SysMatrix_InsertTranslation(0.0f, -10.0f, 0.0f, MTXMODE_APPLY);
+            Matrix_InsertZRotation_s(ptr->unk_20, MTXMODE_APPLY);
+            Matrix_InsertTranslation(0.0f, -10.0f, 0.0f, MTXMODE_APPLY);
             Matrix_Scale(ptr->unk_18, ptr->unk_18, 1.0f, MTXMODE_APPLY);
 
             gSPMatrix(&gfx[0], Matrix_NewMtx(globalCtx->state.gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
@@ -1155,8 +1155,8 @@ void EnThiefbird_Draw(Actor* thisx, GlobalContext* globalCtx) {
     EnThiefbird* this = THIS;
 
     func_8012C28C(globalCtx->state.gfxCtx);
-    SkelAnime_DrawSV(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl, this->skelAnime.dListCount,
-                     EnThiefbird_OverrideLimbDraw, EnThiefbird_PostLimbDraw, &this->actor);
+    SkelAnime_DrawFlexOpa(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable, this->skelAnime.dListCount,
+                          EnThiefbird_OverrideLimbDraw, EnThiefbird_PostLimbDraw, &this->actor);
     if (this->actor.colorFilterTimer > 0) {
         func_800AE5A0(globalCtx);
     }
diff --git a/src/overlays/actors/ovl_En_Thiefbird/z_en_thiefbird.h b/src/overlays/actors/ovl_En_Thiefbird/z_en_thiefbird.h
index 7e3e3c32a..5581f1155 100644
--- a/src/overlays/actors/ovl_En_Thiefbird/z_en_thiefbird.h
+++ b/src/overlays/actors/ovl_En_Thiefbird/z_en_thiefbird.h
@@ -37,7 +37,7 @@ typedef struct EnThiefbird {
     /* 0x03DC */ f32 unk_3DC;
     /* 0x03E0 */ f32 unk_3E0;
     /* 0x03E4 */ Gfx* unk_3E4;
-    /* 0x03E8 */ UNK_PTR unk_3E8;
+    /* 0x03E8 */ Gfx* unk_3E8;
     /* 0x03EC */ EnItem00* unk_3EC;
     /* 0x03F0 */ EnThiefbirdUnkStruct unk_3F0[40];
 } EnThiefbird; // size = 0x990
diff --git a/src/overlays/actors/ovl_En_Toto/z_en_toto.c b/src/overlays/actors/ovl_En_Toto/z_en_toto.c
index d15af5517..0fd8d2564 100644
--- a/src/overlays/actors/ovl_En_Toto/z_en_toto.c
+++ b/src/overlays/actors/ovl_En_Toto/z_en_toto.c
@@ -205,8 +205,9 @@ void EnToto_Init(Actor* thisx, GlobalContext* globalCtx) {
     }
     ActorShape_Init(&this->actor.shape, 0.0f, func_800B3FC0, 30.0f);
     this->actor.bgCheckFlags |= 0x400;
-    SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_0600A978, globalCtx->sceneNum == 0x12 ? &D_06003AA8 : &D_0600C880,
-                     this->limbDrawTbl, this->transitionDrawTbl, 18);
+    SkelAnime_InitFlex(globalCtx, &this->skelAnime, &D_0600A978,
+                       ((globalCtx->sceneNum == 0x12) ? &D_06003AA8 : &D_0600C880), this->jointTable, this->morphTable,
+                       18);
     func_80BA36C0(this, globalCtx, 0);
     this->actor.shape.rot.x = 0;
 }
@@ -218,14 +219,13 @@ void EnToto_Destroy(Actor* thisx, GlobalContext* globalCtx) {
 }
 
 void func_80BA383C(EnToto* this, GlobalContext* globalCtx) {
-    if (SkelAnime_FrameUpdateMatrix(&this->skelAnime) && this->actionFuncIndex == 1 &&
-        this->skelAnime.animCurrentSeg != &D_06000C80) {
+    if (SkelAnime_Update(&this->skelAnime) && this->actionFuncIndex == 1 && this->skelAnime.animation != &D_06000C80) {
         if (globalCtx->msgCtx.unk11F04 != 0x2A98 && globalCtx->msgCtx.unk11F04 != 0x2A99) {
             if (this->unk2B4 & 1 || Rand_ZeroOne() > 0.5f) {
                 this->unk2B4 = (this->unk2B4 + 1) & 3;
             }
         }
-        SkelAnime_ChangeAnimDefaultStop(&this->skelAnime, D_80BA5078[this->unk2B4]);
+        Animation_PlayOnce(&this->skelAnime, D_80BA5078[this->unk2B4]);
     }
     func_800BBB74(&this->unk260, 0x14, 0x50, 3);
 }
@@ -236,7 +236,7 @@ void func_80BA3930(EnToto* this, GlobalContext* globalCtx) {
     if (globalCtx->sceneNum == 0x12) {
         animationHeader = &D_06003AA8;
     }
-    SkelAnime_ChangeAnimTransitionRepeat(&this->skelAnime, animationHeader, -4.0f);
+    Animation_MorphToLoop(&this->skelAnime, animationHeader, -4.0f);
 }
 
 s32 func_80BA397C(EnToto* this, s16 arg1) {
@@ -298,13 +298,13 @@ void func_80BA39C8(EnToto* this, GlobalContext* globalCtx) {
 
 void func_80BA3BFC(EnToto* this, GlobalContext* globalCtx) {
     if (globalCtx->sceneNum == 0x12) {
-        SkelAnime_ChangeAnimTransitionStop(&this->skelAnime, &D_06000C80, -4.0f);
+        Animation_MorphToPlayOnce(&this->skelAnime, &D_06000C80, -4.0f);
         this->unk2B4 = 0;
     } else {
         if (this->text->unk0 == 4) {
             func_80151BB4(globalCtx, 9);
         }
-        SkelAnime_ChangeAnimTransitionRepeat(&this->skelAnime, &D_0600B3E0, -4.0f);
+        Animation_MorphToLoop(&this->skelAnime, &D_0600B3E0, -4.0f);
     }
 }
 
@@ -652,7 +652,7 @@ s32 func_80BA4B24(EnToto* this, GlobalContext* globalCtx) {
 
     if (func_80BA40D4(this, globalCtx)) {
         player = GET_PLAYER(globalCtx);
-        SkelAnime_ChangeAnimTransitionStop(&this->skelAnime, &D_060028B8, -4.0f);
+        Animation_MorphToPlayOnce(&this->skelAnime, &D_060028B8, -4.0f);
         if (player->transformation == PLAYER_FORM_ZORA) {
             if (!Flags_GetSwitch(globalCtx, this->actor.params & 0x7F)) {
                 Actor_SetSwitchFlag(globalCtx, this->actor.params & 0x7F);
@@ -695,9 +695,9 @@ void func_80BA4CB4(EnToto* this, GlobalContext* globalCtx) {
         this->unk2B5 = action->unk0;
         if (this->unk2B5 != 4) {
             if (this->unk2B5 == 3) {
-                SkelAnime_ChangeAnimTransitionStop(&this->skelAnime, &D_06001DF0, -4.0f);
+                Animation_MorphToPlayOnce(&this->skelAnime, &D_06001DF0, -4.0f);
             } else {
-                SkelAnime_ChangeAnimDefaultStop(&this->skelAnime, this->unk2B5 == 1 ? &D_060016A4 : &D_060022C8);
+                Animation_PlayOnce(&this->skelAnime, this->unk2B5 == 1 ? &D_060016A4 : &D_060022C8);
                 if (this->unk2B5 == 2 && this->unk2B3 != 0xF) {
                     func_80151BB4(globalCtx, 9);
                     func_80151BB4(globalCtx, 10);
@@ -706,9 +706,9 @@ void func_80BA4CB4(EnToto* this, GlobalContext* globalCtx) {
         }
     }
     Math_ScaledStepToS(&this->actor.shape.rot.y, this->actor.home.rot.y, 0x320);
-    if (SkelAnime_FrameUpdateMatrix(&this->skelAnime)) {
+    if (SkelAnime_Update(&this->skelAnime)) {
         if (this->unk2B5 != 3) {
-            SkelAnime_ChangeAnimDefaultRepeat(&this->skelAnime, this->unk2B5 == 1 ? &D_0600C880 : &D_06001324);
+            Animation_PlayLoop(&this->skelAnime, this->unk2B5 == 1 ? &D_0600C880 : &D_06001324);
         }
     }
     if (this->unk2B5 == 4 && !Actor_HasParent(&this->actor, globalCtx)) {
@@ -743,8 +743,8 @@ void EnToto_Draw(Actor* thisx, GlobalContext* globalCtx) {
     func_8012C28C(globalCtx->state.gfxCtx);
     gSPSegment(POLY_OPA_DISP++, 0x08, Lib_SegmentedToVirtual(sp4C[this->unk260]));
     Scene_SetRenderModeXlu(globalCtx, 0, 1);
-    SkelAnime_DrawSV(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl, this->skelAnime.dListCount, NULL,
-                     NULL, &this->actor);
+    SkelAnime_DrawFlexOpa(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable, this->skelAnime.dListCount,
+                          NULL, NULL, &this->actor);
 
     CLOSE_DISPS(globalCtx->state.gfxCtx);
 }
diff --git a/src/overlays/actors/ovl_En_Toto/z_en_toto.h b/src/overlays/actors/ovl_En_Toto/z_en_toto.h
index 01f036880..aa9628426 100644
--- a/src/overlays/actors/ovl_En_Toto/z_en_toto.h
+++ b/src/overlays/actors/ovl_En_Toto/z_en_toto.h
@@ -24,8 +24,8 @@ typedef struct EnTotoUnkStruct2 {
 typedef struct EnToto {
     /* 0x000 */ Actor actor;
     /* 0x144 */ SkelAnime skelAnime;
-    /* 0x188 */ Vec3s limbDrawTbl[18];
-    /* 0x1F4 */ Vec3s transitionDrawTbl[18];
+    /* 0x188 */ Vec3s jointTable[18];
+    /* 0x1F4 */ Vec3s morphTable[18];
     /* 0x260 */ s16 unk260;
     /* 0x264 */ ColliderCylinder collider;
     /* 0x2B0 */ u8 actionFuncIndex;
diff --git a/src/overlays/actors/ovl_En_Trt/z_en_trt.c b/src/overlays/actors/ovl_En_Trt/z_en_trt.c
index 06fe1bfd4..0291851a1 100644
--- a/src/overlays/actors/ovl_En_Trt/z_en_trt.c
+++ b/src/overlays/actors/ovl_En_Trt/z_en_trt.c
@@ -112,12 +112,12 @@ void EnTrt_ChangeAnim(SkelAnime* skelAnime, ActorAnimationEntryS* animations, s3
 
     animations += idx;
     if (animations->frameCount < 0) {
-        frameCount = SkelAnime_GetFrameCount(&animations->animationSeg->common);
+        frameCount = Animation_GetLastFrame(animations->animationSeg);
     } else {
         frameCount = animations->frameCount;
     }
-    SkelAnime_ChangeAnim(skelAnime, animations->animationSeg, animations->playbackSpeed, animations->frame, frameCount,
-                         animations->mode, animations->transitionRate);
+    Animation_Change(skelAnime, animations->animationSeg, animations->playbackSpeed, animations->frame, frameCount,
+                     animations->mode, animations->transitionRate);
 }
 
 s32 EnTrt_TestItemSelected(GlobalContext* globalCtx) {
@@ -851,8 +851,8 @@ void EnTrt_IdleAwake(EnTrt* this, GlobalContext* globalCtx) {
 }
 
 void EnTrt_BeginInteraction(EnTrt* this, GlobalContext* globalCtx) {
-    s16 animCurrentFrame = this->skelAnime.animCurrentFrame / this->skelAnime.animPlaybackSpeed;
-    s16 animLastFrame = SkelAnime_GetFrameCount(&D_060030EC.common) / (s16)this->skelAnime.animPlaybackSpeed;
+    s16 curFrame = this->skelAnime.curFrame / this->skelAnime.playSpeed;
+    s16 animLastFrame = Animation_GetLastFrame(&D_060030EC) / (s16)this->skelAnime.playSpeed;
 
     if (this->cutsceneState == ENTRT_CUTSCENESTATE_WAITING) {
         if (ActorCutscene_GetCanPlayNext(this->cutscene)) {
@@ -863,7 +863,7 @@ void EnTrt_BeginInteraction(EnTrt* this, GlobalContext* globalCtx) {
         }
     } else if (this->cutsceneState == ENTRT_CUTSCENESTATE_PLAYING_SPECIAL) {
         if (this->animationIdx != 5) {
-            if (animCurrentFrame == animLastFrame) {
+            if (curFrame == animLastFrame) {
                 EnTrt_ChangeAnim(&this->skelAnime, sAnimations, 3);
                 this->animationIdx = 3;
                 this->blinkFunc = EnTrt_OpenEyesThenSetToBlink;
@@ -1341,11 +1341,11 @@ void EnTrt_NodOff(EnTrt* this) {
 }
 
 void EnTrt_OpenThenCloseEyes(EnTrt* this) {
-    if (this->skelAnime.animCurrentFrame >= 40.0f) {
+    if (this->skelAnime.curFrame >= 40.0f) {
         EnTrt_CloseEyes(this);
-    } else if (this->skelAnime.animCurrentFrame >= 35.0f) {
+    } else if (this->skelAnime.curFrame >= 35.0f) {
         this->eyeTextureIdx = 1;
-    } else if (this->skelAnime.animCurrentFrame >= 10.0f) {
+    } else if (this->skelAnime.curFrame >= 10.0f) {
         EnTrt_OpenEyes(this);
     }
 }
@@ -1359,7 +1359,7 @@ void EnTrt_OpenEyes2(EnTrt* this) {
 }
 
 void EnTrt_OpenEyesThenSetToBlink(EnTrt* this) {
-    if (this->skelAnime.animCurrentFrame >= 7.0f) {
+    if (this->skelAnime.curFrame >= 7.0f) {
         EnTrt_OpenEyes(this);
         if (this->eyeTextureIdx == 0) {
             this->blinkFunc = EnTrt_Blink;
@@ -1452,7 +1452,7 @@ void EnTrt_LookToShopkeeperFromShelf(EnTrt* this, GlobalContext* globalCtx) {
 }
 
 void EnTrt_InitShopkeeper(EnTrt* this, GlobalContext* globalCtx) {
-    SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_0600FEF0, &D_0600FD34, NULL, NULL, 0);
+    SkelAnime_InitFlex(globalCtx, &this->skelAnime, &D_0600FEF0, &D_0600FD34, NULL, NULL, 0);
     if (!(gSaveContext.weekEventReg[0xC] & 8) && !(gSaveContext.weekEventReg[0x54] & 0x40) && gSaveContext.day >= 2) {
         this->actor.draw = NULL;
     } else {
@@ -1691,7 +1691,7 @@ void EnTrt_Update(Actor* thisx, GlobalContext* globalCtx) {
     EnTrt_UpdateHeadYawAndPitch(this, globalCtx);
     this->actionFunc(this, globalCtx);
     Actor_SetHeight(&this->actor, 90.0f);
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     EnTrt_UpdateCollider(this, globalCtx);
 }
 
@@ -1716,8 +1716,8 @@ void EnTrt_UpdateHeadPosAndRot(s16 pitch, s16 yaw, Vec3f* pos, Vec3s* rot, s32 i
     Vec3s newRot;
     MtxF currentState;
 
-    SysMatrix_MultiplyVector3fByState(&D_801D15B0tmp, &newPos);
-    SysMatrix_CopyCurrentState(&currentState);
+    Matrix_MultiplyVector3fByState(&D_801D15B0tmp, &newPos);
+    Matrix_CopyCurrentState(&currentState);
     func_8018219C(&currentState, &newRot, MTXMODE_NEW);
     *pos = newPos;
     if (isFullyAwake) {
@@ -1759,11 +1759,11 @@ void EnTrt_PostLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Ve
     }
     if (limbIndex == 21) {
         EnTrt_UpdateHeadPosAndRot(this->headPitch, this->headYaw, &this->headPos, &this->headRot, isFullyAwake);
-        SysMatrix_InsertTranslation(this->headPos.x, this->headPos.y, this->headPos.z, MTXMODE_NEW);
+        Matrix_InsertTranslation(this->headPos.x, this->headPos.y, this->headPos.z, MTXMODE_NEW);
         Matrix_Scale(this->actor.scale.x, this->actor.scale.y, this->actor.scale.z, MTXMODE_APPLY);
         Matrix_RotateY(this->headRot.y, MTXMODE_APPLY);
-        SysMatrix_InsertXRotation_s(this->headRot.x, MTXMODE_APPLY);
-        SysMatrix_InsertZRotation_s(this->headRot.z, MTXMODE_APPLY);
+        Matrix_InsertXRotation_s(this->headRot.x, MTXMODE_APPLY);
+        Matrix_InsertZRotation_s(this->headRot.z, MTXMODE_APPLY);
     }
 }
 
@@ -1771,11 +1771,11 @@ void EnTrt_UnkActorDraw(GlobalContext* globalCtx, s32 limbIndex, Actor* thisx) {
     EnTrt* this = THIS;
 
     if (limbIndex == 21) {
-        SysMatrix_InsertTranslation(this->headPos.x, this->headPos.y, this->headPos.z, MTXMODE_NEW);
+        Matrix_InsertTranslation(this->headPos.x, this->headPos.y, this->headPos.z, MTXMODE_NEW);
         Matrix_Scale(this->actor.scale.x, this->actor.scale.y, this->actor.scale.z, MTXMODE_APPLY);
         Matrix_RotateY(this->headRot.y, MTXMODE_APPLY);
-        SysMatrix_InsertXRotation_s(this->headRot.x, MTXMODE_APPLY);
-        SysMatrix_InsertZRotation_s(this->headRot.z, MTXMODE_APPLY);
+        Matrix_InsertXRotation_s(this->headRot.x, MTXMODE_APPLY);
+        Matrix_InsertZRotation_s(this->headRot.z, MTXMODE_APPLY);
     }
 }
 
@@ -1789,7 +1789,7 @@ void EnTrt_Draw(Actor* thisx, GlobalContext* globalCtx) {
     func_8012C28C(globalCtx->state.gfxCtx);
     gSPSegment(POLY_OPA_DISP++, 0x08, Lib_SegmentedToVirtual(sEyeTextures[this->eyeTextureIdx]));
     gSPSegment(POLY_OPA_DISP++, 0x09, Lib_SegmentedToVirtual(sEyeTextures[this->eyeTextureIdx]));
-    func_801343C0(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl, this->skelAnime.dListCount,
+    func_801343C0(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable, this->skelAnime.dListCount,
                   EnTrt_OverrideLimbDraw, EnTrt_PostLimbDraw, EnTrt_UnkActorDraw, &this->actor);
     EnTrt_DrawCursor(globalCtx, this, this->cursorPos.x, this->cursorPos.y, this->cursorPos.z, this->drawCursor);
     EnTrt_DrawStickDirectionPrompt(globalCtx, this);
diff --git a/src/overlays/actors/ovl_En_Warp_Uzu/z_en_warp_uzu.c b/src/overlays/actors/ovl_En_Warp_Uzu/z_en_warp_uzu.c
index dc8ea9ad1..8dd30eec2 100644
--- a/src/overlays/actors/ovl_En_Warp_Uzu/z_en_warp_uzu.c
+++ b/src/overlays/actors/ovl_En_Warp_Uzu/z_en_warp_uzu.c
@@ -82,7 +82,7 @@ void func_80A66208(EnWarpUzu* this, GlobalContext* globalCtx) {
 
     this->actor.textId = 0;
     Matrix_RotateY(this->actor.shape.rot.y, 0);
-    SysMatrix_MultiplyVector3fByState(&D_80A664FC, &sp24);
+    Matrix_MultiplyVector3fByState(&D_80A664FC, &sp24);
     Math_Vec3f_Sum(&this->actor.world.pos, &sp24, &this->actor.focus.pos);
     Math_Vec3s_Copy(&this->actor.focus.rot, &this->actor.shape.rot);
     this->actionFunc = func_80A66278;
diff --git a/src/overlays/actors/ovl_En_Zot/z_en_zot.c b/src/overlays/actors/ovl_En_Zot/z_en_zot.c
index 24ca09489..c1f0b3351 100644
--- a/src/overlays/actors/ovl_En_Zot/z_en_zot.c
+++ b/src/overlays/actors/ovl_En_Zot/z_en_zot.c
@@ -100,8 +100,8 @@ void EnZot_Init(Actor* thisx, GlobalContext* globalCtx2) {
     ActorShape_Init(&this->actor.shape, 0.0f, func_800B3FC0, 20.0f);
     Actor_SetScale(&this->actor, 0.01f);
     this->actionFunc = func_80B97100;
-    SkelAnime_InitSV(globalCtx, &this->skelAnime, &D_0600D208, &D_06004248, this->jointTable, this->morphTable, 20);
-    SkelAnime_ChangeAnimDefaultRepeat(&this->skelAnime, &D_0600DE20);
+    SkelAnime_InitFlex(globalCtx, &this->skelAnime, &D_0600D208, &D_06004248, this->jointTable, this->morphTable, 20);
+    Animation_PlayLoop(&this->skelAnime, &D_0600DE20);
     this->unk_2F0 = 0;
     Collider_InitAndSetCylinder(globalCtx, &this->collider, &this->actor, &sCylinderInit);
 
@@ -255,10 +255,10 @@ void func_80B96BEC(EnZot* this, s16 arg1, u8 arg2) {
 
     if ((arg1 >= 0) && (arg1 < 10)) {
         if (arg1 >= 8) {
-            SkelAnime_ChangeAnim(&this->skelAnime, sAnimations[arg1], 0.0f, arg1 - 8, arg1 - 8, arg2, 0.0f);
+            Animation_Change(&this->skelAnime, sAnimations[arg1], 0.0f, arg1 - 8, arg1 - 8, arg2, 0.0f);
         } else {
-            SkelAnime_ChangeAnim(&this->skelAnime, sAnimations[arg1], 1.0f, 0.0f,
-                                 SkelAnime_GetFrameCount(&sAnimations[arg1]->common), arg2, -5.0f);
+            Animation_Change(&this->skelAnime, sAnimations[arg1], 1.0f, 0.0f, Animation_GetLastFrame(sAnimations[arg1]),
+                             arg2, -5.0f);
         }
         this->unk_2F0 = arg1;
     }
@@ -754,7 +754,7 @@ void func_80B97D6C(EnZot* this, GlobalContext* globalCtx) {
         this->actor.speedXZ = 8.0f;
     }
 
-    if (func_801378B8(&this->skelAnime, 0.0f) || func_801378B8(&this->skelAnime, 5.0f)) {
+    if (Animation_OnFrame(&this->skelAnime, 0.0f) || Animation_OnFrame(&this->skelAnime, 5.0f)) {
         Audio_PlayActorSound2(&this->actor, NA_SE_EV_ZORA_WALK);
     }
 }
@@ -1329,7 +1329,7 @@ void EnZot_Update(Actor* thisx, GlobalContext* globalCtx) {
     Actor_UpdateBgCheckInfo(globalCtx, &this->actor, 30.0f, 15.0f, 30.0f, 5);
 
     this->unk_2F2 &= ~0x40;
-    if (SkelAnime_FrameUpdateMatrix(&this->skelAnime) && (this->unk_2F0 != 0)) {
+    if (SkelAnime_Update(&this->skelAnime) && (this->unk_2F0 != 0)) {
         this->unk_2F2 |= 0x40;
     }
 
@@ -1368,15 +1368,15 @@ s32 EnZot_OverrideLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList,
     s32 pad;
 
     if (limbIndex == 15) {
-        SysMatrix_InsertTranslation(1500.0f, 0.0f, 0.0f, MTXMODE_APPLY);
-        SysMatrix_InsertXRotation_s(this->unk_2C4.y, MTXMODE_APPLY);
-        SysMatrix_InsertZRotation_s(this->unk_2C4.x, MTXMODE_APPLY);
-        SysMatrix_InsertTranslation(-1500.0f, 0.0f, 0.0f, MTXMODE_APPLY);
+        Matrix_InsertTranslation(1500.0f, 0.0f, 0.0f, MTXMODE_APPLY);
+        Matrix_InsertXRotation_s(this->unk_2C4.y, MTXMODE_APPLY);
+        Matrix_InsertZRotation_s(this->unk_2C4.x, MTXMODE_APPLY);
+        Matrix_InsertTranslation(-1500.0f, 0.0f, 0.0f, MTXMODE_APPLY);
     }
 
     if (limbIndex == 8) {
-        SysMatrix_InsertXRotation_s(this->unk_2CA.y * -1, MTXMODE_APPLY);
-        SysMatrix_InsertZRotation_s(this->unk_2CA.x * -1, MTXMODE_APPLY);
+        Matrix_InsertXRotation_s(this->unk_2CA.y * -1, MTXMODE_APPLY);
+        Matrix_InsertZRotation_s(this->unk_2CA.x * -1, MTXMODE_APPLY);
     }
 
     if (((this->unk_2F0 == 8) || (this->unk_2F0 == 9)) &&
@@ -1392,7 +1392,7 @@ void EnZot_PostLimbDraw(GlobalContext* globalCtx, s32 limbIndex, Gfx** dList, Ve
     EnZot* this = THIS;
 
     if (limbIndex == 15) {
-        SysMatrix_MultiplyVector3fByState(&D_80B99934, &this->actor.focus.pos);
+        Matrix_MultiplyVector3fByState(&D_80B99934, &this->actor.focus.pos);
     }
 }
 
@@ -1412,8 +1412,8 @@ void EnZot_Draw(Actor* thisx, GlobalContext* globalCtx) {
     gSPSegment(POLY_OPA_DISP++, 0x08, Lib_SegmentedToVirtual(sp4C[this->unk_2EC]));
     gSPSegment(POLY_OPA_DISP++, 0x0C, func_80B99580(globalCtx->state.gfxCtx));
 
-    SkelAnime_DrawSV(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl, this->skelAnime.dListCount,
-                     EnZot_OverrideLimbDraw, EnZot_PostLimbDraw, &this->actor);
+    SkelAnime_DrawFlexOpa(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable, this->skelAnime.dListCount,
+                          EnZot_OverrideLimbDraw, EnZot_PostLimbDraw, &this->actor);
 
     CLOSE_DISPS(globalCtx->state.gfxCtx);
 }
diff --git a/src/overlays/actors/ovl_Obj_Aqua/z_obj_aqua.c b/src/overlays/actors/ovl_Obj_Aqua/z_obj_aqua.c
index 5c0aa5cb1..2111f1d0f 100644
--- a/src/overlays/actors/ovl_Obj_Aqua/z_obj_aqua.c
+++ b/src/overlays/actors/ovl_Obj_Aqua/z_obj_aqua.c
@@ -285,9 +285,9 @@ void ObjAqua_Draw(Actor* thisx, GlobalContext* globalCtx) {
     if (actionFuncTemp) {
         s16 rotation = Math_SinS(this->unk_198) * 8000.0f;
 
-        SysMatrix_InsertZRotation_s(rotation, 1);
+        Matrix_InsertZRotation_s(rotation, 1);
         Matrix_Scale(1.3f, 1.0f, 1.0f, 1);
-        SysMatrix_InsertZRotation_s(rotation * -1, 1);
+        Matrix_InsertZRotation_s(rotation * -1, 1);
         Matrix_Scale(10.0f / 13.0f, 1.0f, 1.0f, 1);
     }
     Matrix_RotateY(yaw, 1);
diff --git a/src/overlays/actors/ovl_Obj_Bell/z_obj_bell.c b/src/overlays/actors/ovl_Obj_Bell/z_obj_bell.c
index a0d90123f..de7f30fbd 100644
--- a/src/overlays/actors/ovl_Obj_Bell/z_obj_bell.c
+++ b/src/overlays/actors/ovl_Obj_Bell/z_obj_bell.c
@@ -223,13 +223,13 @@ void func_80A358FC(ObjBell* this, GlobalContext* globalCtx) {
 }
 
 void func_80A359B4(Actor* thisx, GlobalContext* globalCtx) {
-    SysMatrix_InsertTranslation(thisx->world.pos.x, thisx->world.pos.y, thisx->world.pos.z, MTXMODE_NEW);
+    Matrix_InsertTranslation(thisx->world.pos.x, thisx->world.pos.y, thisx->world.pos.z, MTXMODE_NEW);
     Matrix_Scale(thisx->scale.x, thisx->scale.y, thisx->scale.z, MTXMODE_APPLY);
-    SysMatrix_InsertTranslation(0.0f, 2600.0f, 0.0f, MTXMODE_APPLY);
+    Matrix_InsertTranslation(0.0f, 2600.0f, 0.0f, MTXMODE_APPLY);
     Matrix_RotateY(thisx->world.rot.y, MTXMODE_APPLY);
-    SysMatrix_InsertXRotation_s(thisx->world.rot.x, MTXMODE_APPLY);
+    Matrix_InsertXRotation_s(thisx->world.rot.x, MTXMODE_APPLY);
     Matrix_RotateY(-thisx->world.rot.y, MTXMODE_APPLY);
-    SysMatrix_InsertTranslation(0.0f, -2600.0f, 0.0f, MTXMODE_APPLY);
+    Matrix_InsertTranslation(0.0f, -2600.0f, 0.0f, MTXMODE_APPLY);
     OPEN_DISPS(globalCtx->state.gfxCtx);
     func_8012C28C(globalCtx->state.gfxCtx);
     gSPMatrix(POLY_OPA_DISP++, Matrix_NewMtx(globalCtx->state.gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
@@ -241,7 +241,7 @@ void func_80A359B4(Actor* thisx, GlobalContext* globalCtx) {
 }
 
 void func_80A35B18(Actor* thisx, GlobalContext* globalCtx) {
-    SysMatrix_InsertTranslation(thisx->world.pos.x, thisx->world.pos.y, thisx->world.pos.z, MTXMODE_NEW);
+    Matrix_InsertTranslation(thisx->world.pos.x, thisx->world.pos.y, thisx->world.pos.z, MTXMODE_NEW);
     Matrix_Scale(thisx->scale.x, thisx->scale.y, thisx->scale.z, MTXMODE_APPLY);
     Matrix_RotateY(thisx->shape.rot.y, MTXMODE_APPLY);
     OPEN_DISPS(globalCtx->state.gfxCtx);
@@ -252,7 +252,7 @@ void func_80A35B18(Actor* thisx, GlobalContext* globalCtx) {
 }
 
 void func_80A35BD4(Actor* thisx, GlobalContext* globalCtx) {
-    SysMatrix_InsertTranslation(thisx->world.pos.x, thisx->world.pos.y - 4.0f, thisx->world.pos.z, MTXMODE_NEW);
+    Matrix_InsertTranslation(thisx->world.pos.x, thisx->world.pos.y - 4.0f, thisx->world.pos.z, MTXMODE_NEW);
     Matrix_Scale(thisx->scale.x, thisx->scale.y, thisx->scale.z, MTXMODE_APPLY);
     OPEN_DISPS(globalCtx->state.gfxCtx);
     func_8012C2DC(globalCtx->state.gfxCtx);
@@ -300,9 +300,9 @@ void ObjBell_Draw(Actor* thisx, GlobalContext* globalCtx) {
     func_80A35BD4(thisx, globalCtx);
     func_80A359B4(thisx, globalCtx);
     Math_Vec3s_ToVec3f(&sp30, &this->collider1.dim.modelSphere.center);
-    SysMatrix_MultiplyVector3fByState(&sp30, &sp24);
+    Matrix_MultiplyVector3fByState(&sp30, &sp24);
     Math_Vec3f_ToVec3s(&this->collider1.dim.worldSphere.center, &sp24);
     Math_Vec3s_ToVec3f(&sp30, &this->collider2.dim.modelSphere.center);
-    SysMatrix_MultiplyVector3fByState(&sp30, &sp24);
+    Matrix_MultiplyVector3fByState(&sp30, &sp24);
     Math_Vec3f_ToVec3s(&this->collider2.dim.worldSphere.center, &sp24);
 }
diff --git a/src/overlays/actors/ovl_Obj_Etcetera/z_obj_etcetera.c b/src/overlays/actors/ovl_Obj_Etcetera/z_obj_etcetera.c
index 4a74a3c80..f252efbd5 100644
--- a/src/overlays/actors/ovl_Obj_Etcetera/z_obj_etcetera.c
+++ b/src/overlays/actors/ovl_Obj_Etcetera/z_obj_etcetera.c
@@ -120,8 +120,7 @@ void ObjEtcetera_DoNormalOscillation(ObjEtcetera* this, GlobalContext* globalCtx
 }
 
 void ObjEtcetera_StartSmallFlutterAnimation(ObjEtcetera* this) {
-    SkelAnime_ChangeAnim(&this->skelAnime, &D_040117A8, 1.0f, 0.0f, SkelAnime_GetFrameCount(&D_040117A8.common), 2,
-                         0.0f);
+    Animation_Change(&this->skelAnime, &D_040117A8, 1.0f, 0.0f, Animation_GetLastFrame(&D_040117A8), 2, 0.0f);
     this->dyna.actor.draw = ObjEtcetera_DrawAnimated;
     this->actionFunc = ObjEtcetera_PlaySmallFlutterAnimation;
 }
@@ -132,8 +131,7 @@ void ObjEtcetera_Idle(ObjEtcetera* this, GlobalContext* globalCtx) {
 
     if ((player->stateFlags3 & 0x200) && (this->dyna.actor.xzDistToPlayer < 20.0f)) {
         // Player is launching out of the Deku Flower
-        SkelAnime_ChangeAnim(&this->skelAnime, &D_0400EB7C, 1.0f, 0.0f, SkelAnime_GetFrameCount(&D_0400EB7C.common), 2,
-                             0.0f);
+        Animation_Change(&this->skelAnime, &D_0400EB7C, 1.0f, 0.0f, Animation_GetLastFrame(&D_0400EB7C), 2, 0.0f);
         this->dyna.actor.draw = ObjEtcetera_DrawAnimated;
         this->actionFunc = ObjEtcetera_DoIntenseOscillation;
         Actor_SetScale(&this->dyna.actor, 0.01f);
@@ -182,7 +180,7 @@ void ObjEtcetera_PlaySmallFlutterAnimation(ObjEtcetera* this, GlobalContext* glo
     } else {
         this->burrowFlag &= ~1;
     }
-    if (SkelAnime_FrameUpdateMatrix(&this->skelAnime)) {
+    if (SkelAnime_Update(&this->skelAnime)) {
         this->dyna.actor.draw = ObjEtcetera_DrawIdle;
         this->actionFunc = ObjEtcetera_Idle;
     }
@@ -201,7 +199,7 @@ void ObjEtcetera_DoIntenseOscillation(ObjEtcetera* this, GlobalContext* globalCt
     } else {
         this->burrowFlag &= ~1;
     }
-    SkelAnime_FrameUpdateMatrix(&this->skelAnime);
+    SkelAnime_Update(&this->skelAnime);
     if (this->oscillationTimer > 0) {
         this->oscillationTimer--;
     } else {
@@ -272,8 +270,8 @@ void ObjEtcetera_Setup(ObjEtcetera* this, GlobalContext* globalCtx) {
                 break;
             case DEKU_FLOWER_TYPE_PINK_SPAWNED_FROM_MAD_SCRUB:
             case DEKU_FLOWER_TYPE_GOLD_SPAWNED_FROM_MAD_SCRUB:
-                SkelAnime_ChangeAnim(&this->skelAnime, &D_0400EB7C, 1.0f, 0.0f,
-                                     SkelAnime_GetFrameCount(&D_0400EB7C.common), 2, 0.0f);
+                Animation_Change(&this->skelAnime, &D_0400EB7C, 1.0f, 0.0f, Animation_GetLastFrame(&D_0400EB7C), 2,
+                                 0.0f);
                 this->dyna.actor.draw = ObjEtcetera_DrawAnimated;
                 this->actionFunc = ObjEtcetera_DoIntenseOscillation;
                 Actor_SetScale(&this->dyna.actor, 0.0f);
@@ -317,5 +315,5 @@ void ObjEtcetera_DrawAnimated(Actor* thisx, GlobalContext* globalCtx) {
     ObjEtcetera* this = THIS;
 
     func_8012C5B0(globalCtx->state.gfxCtx);
-    SkelAnime_Draw(globalCtx, this->skelAnime.skeleton, this->skelAnime.limbDrawTbl, NULL, NULL, &this->dyna.actor);
+    SkelAnime_DrawOpa(globalCtx, this->skelAnime.skeleton, this->skelAnime.jointTable, NULL, NULL, &this->dyna.actor);
 }
diff --git a/src/overlays/actors/ovl_Obj_Lightswitch/z_obj_lightswitch.c b/src/overlays/actors/ovl_Obj_Lightswitch/z_obj_lightswitch.c
index c6b2daf66..4237e0992 100644
--- a/src/overlays/actors/ovl_Obj_Lightswitch/z_obj_lightswitch.c
+++ b/src/overlays/actors/ovl_Obj_Lightswitch/z_obj_lightswitch.c
@@ -89,10 +89,10 @@ void ObjLightswitch_InitCollider(ObjLightswitch* this, GlobalContext* globalCtx)
     Collider_InitJntSph(globalCtx, &this->collider);
     Collider_SetJntSph(globalCtx, &this->collider, &this->actor, &sJntSphInit, &this->elements);
     this->actor.colChkInfo.mass = MASS_IMMOVABLE;
-    SysMatrix_SetStateRotationAndTranslation(
-        this->actor.world.pos.x, this->actor.world.pos.y + (this->actor.shape.yOffset * this->actor.scale.y),
-        this->actor.world.pos.z, &this->actor.shape.rot);
-    Matrix_Scale(this->actor.scale.x, this->actor.scale.y, this->actor.scale.z, 1);
+    Matrix_SetStateRotationAndTranslation(this->actor.world.pos.x,
+                                          this->actor.world.pos.y + (this->actor.shape.yOffset * this->actor.scale.y),
+                                          this->actor.world.pos.z, &this->actor.shape.rot);
+    Matrix_Scale(this->actor.scale.x, this->actor.scale.y, this->actor.scale.z, MTXMODE_APPLY);
     Collider_UpdateSpheres(0, &this->collider);
 }
 
@@ -384,13 +384,13 @@ void ObjLightSwitch_DrawOpa(ObjLightswitch* this, GlobalContext* globalCtx) {
     tempRot.x = this->actor.shape.rot.x;
     tempRot.y = this->actor.shape.rot.y;
     tempRot.z = this->actor.shape.rot.z + this->edgeRot;
-    SysMatrix_SetStateRotationAndTranslation(tempPos.x, tempPos.y, tempPos.z, &tempRot);
+    Matrix_SetStateRotationAndTranslation(tempPos.x, tempPos.y, tempPos.z, &tempRot);
     Matrix_Scale(this->actor.scale.x, this->actor.scale.y, this->actor.scale.z, MTXMODE_APPLY);
     gSPMatrix(POLY_OPA_DISP++, Matrix_NewMtx(globalCtx->state.gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
     gSPDisplayList(POLY_OPA_DISP++, D_06000398);
 
     tempRot.z = this->actor.shape.rot.z - this->edgeRot;
-    SysMatrix_SetStateRotationAndTranslation(tempPos.x, tempPos.y, tempPos.z, &tempRot);
+    Matrix_SetStateRotationAndTranslation(tempPos.x, tempPos.y, tempPos.z, &tempRot);
     Matrix_Scale(this->actor.scale.x, this->actor.scale.y, this->actor.scale.z, MTXMODE_APPLY);
     gSPMatrix(POLY_OPA_DISP++, Matrix_NewMtx(globalCtx->state.gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
     gSPDisplayList(POLY_OPA_DISP++, D_06000408);
@@ -420,13 +420,13 @@ void ObjLightSwitch_DrawXlu(ObjLightswitch* this, GlobalContext* globalCtx) {
     tempRot.x = this->actor.shape.rot.x;
     tempRot.y = this->actor.shape.rot.y;
     tempRot.z = this->actor.shape.rot.z + this->edgeRot;
-    SysMatrix_SetStateRotationAndTranslation(tempPos.x, tempPos.y, tempPos.z, &tempRot);
+    Matrix_SetStateRotationAndTranslation(tempPos.x, tempPos.y, tempPos.z, &tempRot);
     Matrix_Scale(this->actor.scale.x, this->actor.scale.y, this->actor.scale.z, MTXMODE_APPLY);
     gSPMatrix(POLY_XLU_DISP++, Matrix_NewMtx(globalCtx->state.gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
     gSPDisplayList(POLY_XLU_DISP++, D_06000398);
 
     tempRot.z = this->actor.shape.rot.z - this->edgeRot;
-    SysMatrix_SetStateRotationAndTranslation(tempPos.x, tempPos.y, tempPos.z, &tempRot);
+    Matrix_SetStateRotationAndTranslation(tempPos.x, tempPos.y, tempPos.z, &tempRot);
     Matrix_Scale(this->actor.scale.x, this->actor.scale.y, this->actor.scale.z, MTXMODE_APPLY);
     gSPMatrix(POLY_XLU_DISP++, Matrix_NewMtx(globalCtx->state.gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
     gSPDisplayList(POLY_XLU_DISP++, D_06000408);
diff --git a/src/overlays/actors/ovl_Obj_Moon_Stone/z_obj_moon_stone.c b/src/overlays/actors/ovl_Obj_Moon_Stone/z_obj_moon_stone.c
index 3a803bc61..13379e5f0 100644
--- a/src/overlays/actors/ovl_Obj_Moon_Stone/z_obj_moon_stone.c
+++ b/src/overlays/actors/ovl_Obj_Moon_Stone/z_obj_moon_stone.c
@@ -156,7 +156,7 @@ void ObjMoonStone_Draw(Actor* thisx, GlobalContext* globalCtx) {
     AnimatedMat_Draw(globalCtx, Lib_SegmentedToVirtual(&D_06001C60));
     gSPMatrix(POLY_OPA_DISP++, Matrix_NewMtx(globalCtx->state.gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
     gSPDisplayList(POLY_OPA_DISP++, D_06000D78);
-    SysMatrix_NormalizeXYZ(&globalCtx->mf_187FC);
+    Matrix_NormalizeXYZ(&globalCtx->mf_187FC);
     gSPMatrix(POLY_XLU_DISP++, Matrix_NewMtx(globalCtx->state.gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
     gSPDisplayList(POLY_XLU_DISP++, D_06000C80);
     CLOSE_DISPS(globalCtx->state.gfxCtx);
diff --git a/src/overlays/actors/ovl_Obj_Syokudai/z_obj_syokudai.c b/src/overlays/actors/ovl_Obj_Syokudai/z_obj_syokudai.c
index 597d47033..fb7074693 100644
--- a/src/overlays/actors/ovl_Obj_Syokudai/z_obj_syokudai.c
+++ b/src/overlays/actors/ovl_Obj_Syokudai/z_obj_syokudai.c
@@ -310,7 +310,7 @@ void ObjSyokudai_Draw(Actor* thisx, GlobalContext* globalCtx) {
                                     (this->flameTexScroll * -OBJ_SYOKUDAI_SNUFF_DEFAULT) & 0x1FF, 0x20, 0x80));
         gDPSetPrimColor(POLY_XLU_DISP++, 0x80, 0x80, 255, 255, 0, 255);
         gDPSetEnvColor(POLY_XLU_DISP++, 255, 0, 0, 0);
-        SysMatrix_InsertTranslation(0.0f, OBJ_SYOKUDAI_FLAME_HEIGHT, 0.0f, MTXMODE_APPLY);
+        Matrix_InsertTranslation(0.0f, OBJ_SYOKUDAI_FLAME_HEIGHT, 0.0f, MTXMODE_APPLY);
         Matrix_RotateY(BINANG_ROT180(func_800DFCDC(GET_ACTIVE_CAM(globalCtx)) - thisx->shape.rot.y), MTXMODE_APPLY);
         Matrix_Scale(flameScale, flameScale, flameScale, MTXMODE_APPLY);
         gSPMatrix(POLY_XLU_DISP++, Matrix_NewMtx(globalCtx->state.gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
diff --git a/src/overlays/actors/ovl_Obj_Tokei_Step/z_obj_tokei_step.c b/src/overlays/actors/ovl_Obj_Tokei_Step/z_obj_tokei_step.c
index f6b0da869..22bcddc57 100644
--- a/src/overlays/actors/ovl_Obj_Tokei_Step/z_obj_tokei_step.c
+++ b/src/overlays/actors/ovl_Obj_Tokei_Step/z_obj_tokei_step.c
@@ -56,7 +56,7 @@ extern CollisionHeader D_06000968;
 void ObjTokeiStep_SetSysMatrix(ObjTokeiStepPanel* panel) {
     MtxF* sysMatrix;
 
-    sysMatrix = SysMatrix_GetCurrentState();
+    sysMatrix = Matrix_GetCurrentState();
     sysMatrix->wx = panel->pos.x;
     sysMatrix->wy = panel->pos.y;
     sysMatrix->wz = panel->pos.z;
@@ -85,7 +85,7 @@ void ObjTokeiStep_SpawnDust(ObjTokeiStep* this, ObjTokeiStepPanel* panel, Global
     dustSpawnOffset.z = -10.0f;
     for (i = 0; i < 7; i++) {
         dustSpawnOffset.x = dustSpawnXOffsets[i];
-        SysMatrix_MultiplyVector3fByState(&dustSpawnOffset, &dustSpawnPos);
+        Matrix_MultiplyVector3fByState(&dustSpawnOffset, &dustSpawnPos);
         dustSpawnPos.x += panel->pos.x;
         dustSpawnPos.y += panel->pos.y;
         dustSpawnPos.z += panel->pos.z;
@@ -100,15 +100,15 @@ void ObjTokeiStep_InitSteps(ObjTokeiStep* this) {
     Vec3f panelOffset;
     s32 pad;
 
-    SysMatrix_SetStateRotationAndTranslation(this->dyna.actor.world.pos.x, this->dyna.actor.world.pos.y,
-                                             this->dyna.actor.world.pos.z, &this->dyna.actor.shape.rot);
+    Matrix_SetStateRotationAndTranslation(this->dyna.actor.world.pos.x, this->dyna.actor.world.pos.y,
+                                          this->dyna.actor.world.pos.z, &this->dyna.actor.shape.rot);
 
     panelOffset.x = 0.0f;
     panelOffset.y = 0.0f;
     for (i = 0; i < 7; i++) {
         panel = &this->panels[i];
         panelOffset.z = i * -20.0f;
-        SysMatrix_MultiplyVector3fByState(&panelOffset, &panel->pos);
+        Matrix_MultiplyVector3fByState(&panelOffset, &panel->pos);
         panel->posChangeY = 0.0f;
         panel->numBounces = 0;
     }
@@ -119,15 +119,15 @@ void ObjTokeiStep_InitStepsOpen(ObjTokeiStep* this) {
     ObjTokeiStepPanel* panel;
     Vec3f panelOffset;
 
-    SysMatrix_SetStateRotationAndTranslation(this->dyna.actor.world.pos.x, this->dyna.actor.world.pos.y,
-                                             this->dyna.actor.world.pos.z, &this->dyna.actor.shape.rot);
+    Matrix_SetStateRotationAndTranslation(this->dyna.actor.world.pos.x, this->dyna.actor.world.pos.y,
+                                          this->dyna.actor.world.pos.z, &this->dyna.actor.shape.rot);
 
     panelOffset.x = 0.0f;
     for (i = 0; i < 7; i++) {
         panel = &this->panels[i];
         panelOffset.y = panelXOffsets[i];
         panelOffset.z = i * -20.0f;
-        SysMatrix_MultiplyVector3fByState(&panelOffset, &panel->pos);
+        Matrix_MultiplyVector3fByState(&panelOffset, &panel->pos);
     }
 }
 
diff --git a/src/overlays/actors/ovl_Obj_Warpstone/z_obj_warpstone.c b/src/overlays/actors/ovl_Obj_Warpstone/z_obj_warpstone.c
index 8d9511df8..496259853 100644
--- a/src/overlays/actors/ovl_Obj_Warpstone/z_obj_warpstone.c
+++ b/src/overlays/actors/ovl_Obj_Warpstone/z_obj_warpstone.c
@@ -170,21 +170,21 @@ void ObjWarpstone_Draw(Actor* thisx, GlobalContext* globalCtx2) {
     if (this->dyna.actor.home.rot.x != 0) {
         OPEN_DISPS(globalCtx->state.gfxCtx);
         func_8012C2DC(globalCtx->state.gfxCtx);
-        SysMatrix_InsertTranslation(this->dyna.actor.world.pos.x, this->dyna.actor.world.pos.y + 34.0f,
-                                    this->dyna.actor.world.pos.z, MTXMODE_NEW);
-        SysMatrix_InsertMatrix(&globalCtx->mf_187FC, MTXMODE_APPLY);
-        SysMatrix_InsertTranslation(0.0f, 0.0f, 30.0f, MTXMODE_APPLY);
+        Matrix_InsertTranslation(this->dyna.actor.world.pos.x, this->dyna.actor.world.pos.y + 34.0f,
+                                 this->dyna.actor.world.pos.z, MTXMODE_NEW);
+        Matrix_InsertMatrix(&globalCtx->mf_187FC, MTXMODE_APPLY);
+        Matrix_InsertTranslation(0.0f, 0.0f, 30.0f, MTXMODE_APPLY);
         Matrix_Scale(this->dyna.actor.velocity.x, this->dyna.actor.velocity.x, this->dyna.actor.velocity.x,
                      MTXMODE_APPLY);
-        SysMatrix_StatePush();
+        Matrix_StatePush();
         gDPPipeSync(POLY_XLU_DISP++);
         gDPSetPrimColor(POLY_XLU_DISP++, 128, 128, 255, 255, 200, this->dyna.actor.home.rot.x);
         gDPSetEnvColor(POLY_XLU_DISP++, 100, 200, 0, 255);
-        SysMatrix_InsertZRotation_f((((globalCtx->gameplayFrames * 1500) & 0xFFFF) * M_PI) / 0x8000, MTXMODE_APPLY);
+        Matrix_InsertZRotation_f((((globalCtx->gameplayFrames * 1500) & 0xFFFF) * M_PI) / 0x8000, MTXMODE_APPLY);
         gSPMatrix(POLY_XLU_DISP++, Matrix_NewMtx(globalCtx->state.gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
         gSPDisplayList(POLY_XLU_DISP++, D_04023210);
-        SysMatrix_StatePop();
-        SysMatrix_InsertZRotation_f((~((globalCtx->gameplayFrames * 1200) & 0xFFFF) * M_PI) / 0x8000, MTXMODE_APPLY);
+        Matrix_StatePop();
+        Matrix_InsertZRotation_f((~((globalCtx->gameplayFrames * 1200) & 0xFFFF) * M_PI) / 0x8000, MTXMODE_APPLY);
         gSPMatrix(POLY_XLU_DISP++, Matrix_NewMtx(globalCtx->state.gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
         gSPDisplayList(POLY_XLU_DISP++, D_04023210);
         CLOSE_DISPS(globalCtx->state.gfxCtx);
diff --git a/src/overlays/effects/ovl_Effect_Ss_D_Fire/z_eff_ss_d_fire.h b/src/overlays/effects/ovl_Effect_Ss_D_Fire/z_eff_ss_d_fire.h
index 1d199eee6..09298249d 100644
--- a/src/overlays/effects/ovl_Effect_Ss_D_Fire/z_eff_ss_d_fire.h
+++ b/src/overlays/effects/ovl_Effect_Ss_D_Fire/z_eff_ss_d_fire.h
@@ -11,8 +11,8 @@ typedef struct {
     /* 0x26 */ s16 scaleStep;
     /* 0x28 */ s16 alpha;
     /* 0x2A */ s16 fadeDelay;
-    /* 0x2C */ s16 life;
-    /* 0x30 */ s32 unk_30;
+    /* 0x2C */ s16 unk_2C;
+    /* 0x30 */ s32 life;
 } EffectSsDFireInitParams; // size = 0x34
 
 extern const EffectSsInit Effect_Ss_D_Fire_InitVars;
diff --git a/src/overlays/gamestates/ovl_daytelop/z_daytelop.c b/src/overlays/gamestates/ovl_daytelop/z_daytelop.c
index d4c729d56..9069a6aca 100644
--- a/src/overlays/gamestates/ovl_daytelop/z_daytelop.c
+++ b/src/overlays/gamestates/ovl_daytelop/z_daytelop.c
@@ -226,7 +226,7 @@ void Daytelop_Init(GameState* thisx) {
     DaytelopContext* this = (DaytelopContext*)thisx;
 
     Game_SetFramerateDivisor(thisx, 1);
-    SysMatrix_StateAlloc(thisx);
+    Matrix_StateAlloc(thisx);
     ShrinkWindow_Destroy();
     View_Init(&this->view, thisx->gfxCtx);
     thisx->main = Daytelop_Main;
diff --git a/src/overlays/gamestates/ovl_opening/z_opening.c b/src/overlays/gamestates/ovl_opening/z_opening.c
index f3279db4e..96fe615fc 100644
--- a/src/overlays/gamestates/ovl_opening/z_opening.c
+++ b/src/overlays/gamestates/ovl_opening/z_opening.c
@@ -50,7 +50,7 @@ void Opening_Init(GameState* thisx) {
     OpeningContext* this = (OpeningContext*)thisx;
 
     Game_SetFramerateDivisor(&this->gameState, 1);
-    SysMatrix_StateAlloc(&this->gameState);
+    Matrix_StateAlloc(&this->gameState);
     ShrinkWindow_Init();
     View_Init(&this->view, this->gameState.gfxCtx);
     this->gameState.main = Opening_Main;
diff --git a/src/overlays/gamestates/ovl_title/z_title.c b/src/overlays/gamestates/ovl_title/z_title.c
index c8027fcbe..ed732fc3d 100644
--- a/src/overlays/gamestates/ovl_title/z_title.c
+++ b/src/overlays/gamestates/ovl_title/z_title.c
@@ -80,9 +80,9 @@ void Title_Draw(GameState* thisx) {
 
     Title_RenderView(this, 0.0f, 150.0f, 300.0f);
     func_8012C28C(this->gameState.gfxCtx);
-    SysMatrix_InsertTranslation(-53.0f, -5.0f, 0.0f, MTXMODE_NEW);
+    Matrix_InsertTranslation(-53.0f, -5.0f, 0.0f, MTXMODE_NEW);
     Matrix_Scale(1.0f, 1.0f, 1.0f, MTXMODE_APPLY);
-    SysMatrix_InsertRotation(0, titleRotation, 0, MTXMODE_APPLY);
+    Matrix_InsertRotation(0, titleRotation, 0, MTXMODE_APPLY);
 
     gSPMatrix(POLY_OPA_DISP++, Matrix_NewMtx(this->gameState.gfxCtx), G_MTX_LOAD);
     gSPDisplayList(POLY_OPA_DISP++, gNintendo64LogoNDL);
@@ -158,7 +158,7 @@ void Title_Init(GameState* thisx) {
     DmaMgr_SendRequest0(this->staticSegment, (uintptr_t)_nintendo_rogo_staticSegmentRomStart, segmentSize);
 
     Game_SetFramerateDivisor(thisx, 1);
-    SysMatrix_StateAlloc(thisx);
+    Matrix_StateAlloc(thisx);
     ShrinkWindow_Init();
     View_Init(&this->view, thisx->gfxCtx);