z_skin_matrix.c decompiled (1 non matching, 1 non equivalent) (#243)

* func_800A7BE4 and func_800A7C20 done

- func_800A7BE4 copy of "Math_Vec3f_ToVec3s" in z_lib.c
- func_800A7C20 copy of "Math_Vec3s_ToVec3f" in z_lib.c

* done func_800A7A24

* func_800A76A4 done

* func_800A6E10 done

* func_800A6EF4 done

* func_800A6FA0 done

* func_800A72FC done

* Deleted z_skin_matrix.data.s and updated spec

* func_800A730C done

* func_800A735C done

* func_800A7E70 done, func_800A7C60 matching but I'm not happy with it (weird types in function params)

* Corrections. func_800A7C60 in skin_matrix done, Matrix_MtxFToMtx in sys_matrix done.

* func_800A7EC0 nonmatching

* func_800A8030 nonmatching but VERY close (two registers swapped)

* func_800A8030 done

* updating comments

* func_800A7704 done

* func_800A7894 done

* halfway through deciphering mips_to_c for func_800A73E0

* func_800A73E0 functional but non-matching (saved register differences and probably regalloc)

* Renaming some arguments and rewriting comments

* Renamed files across whole project and deleted asm nonmatchings

* ran format.sh

* fixed function name

* fixing multiplcation order in SkinMatrix_MtxFMtxFMult

* Corrections in SkinMatrix_MtxFMtxFMult

* Formatting changes after review

* Changes as per code review

* fixing rename error

* fixing rename error

* rename fixes

* fixing function rename error

* ran ./format.sh

* last couple of changes as per code review

* renamed SetScaling -> SetScale

* Skin_Matrix_Invert -> SkinMatrix_Invert

* Renaming and fixing debug message print

* Renamed argument "mf" to more specific "clear" in SkinMatrix_GetClear

* renamed again to "mfp"

* snake case to camel case changes

9 files changed, 790 insertions, 109 deletions

diff --git a/src/code/code_8006BA00.c b/src/code/code_8006BA00.c
index af2c68814..ee5677ad3 100644
--- a/src/code/code_8006BA00.c
+++ b/src/code/code_8006BA00.c
@@ -20,7 +20,7 @@ void func_8006BA30(GlobalContext* globalCtx) {
             if (DECR(source->countdown) == 0) {
                 func_800F89E8(&source->relativePos);
             } else {
-                func_800A6EF4(&globalCtx->mf_11D60, &source->originPos, &source->relativePos);
+                SkinMatrix_Vec3fMtxFMultXYZ(&globalCtx->mf_11D60, &source->originPos, &source->relativePos);
             }
         }
 
@@ -60,6 +60,6 @@ void Audio_PlaySoundAtPosition(GlobalContext* globalCtx, Vec3f* pos, s32 duratio
     source->originPos = *pos;
     source->countdown = duration;
 
-    func_800A6EF4(&globalCtx->mf_11D60, &source->originPos, &source->relativePos);
+    SkinMatrix_Vec3fMtxFMultXYZ(&globalCtx->mf_11D60, &source->originPos, &source->relativePos);
     Audio_PlaySoundGeneral(sfxId, &source->relativePos, 4, &D_801333E0, &D_801333E0, &D_801333E8);
 }
diff --git a/src/code/sys_matrix.c b/src/code/sys_matrix.c
index 46a2944c8..87a1708f4 100644
--- a/src/code/sys_matrix.c
+++ b/src/code/sys_matrix.c
@@ -53,7 +53,7 @@ void Matrix_Mult(MtxF* mf, u8 mode) {
     MtxF* cmf = Matrix_GetCurrent();
 
     if (mode == MTXMODE_APPLY) {
-        func_800A6FA0(cmf, mf, cmf);
+        SkinMatrix_MtxFMtxFMult(cmf, mf, cmf);
     } else {
         Matrix_MtxFCopy(sCurrentMatrix, mf);
     }
@@ -78,7 +78,7 @@ void Matrix_Translate(f32 x, f32 y, f32 z, u8 mode) {
         ty = cmf->yw;
         cmf->ww += tx * x + ty * y + cmf->zw * z;
     } else {
-        func_800A7A24(cmf, x, y, z);
+        SkinMatrix_SetTranslate(cmf, x, y, z);
     }
 }
 
@@ -99,7 +99,7 @@ void Matrix_Scale(f32 x, f32 y, f32 z, u8 mode) {
         cmf->yw *= y;
         cmf->zw *= z;
     } else {
-        func_800A76A4(cmf, x, y, z);
+        SkinMatrix_SetScale(cmf, x, y, z);
     }
 }
 
@@ -382,7 +382,7 @@ void Matrix_RotateRPY(s16 x, s16 y, s16 z, u8 mode) {
             cmf->zw = temp2 * cos - temp1 * sin;
         }
     } else {
-        func_800A7704(cmf, x, y, z);
+        SkinMatrix_SetRotateRPY(cmf, x, y, z);
     }
 }
 
@@ -540,82 +540,76 @@ void func_800D1694(f32 x, f32 y, f32 z, Vec3s* vec) {
 #pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/func_800D1694.s")
 #endif
 
-#ifdef NON_MATCHING
-// mostly regalloc differences
 Mtx* Matrix_MtxFToMtx(MtxF* src, Mtx* dest) {
+    s32 temp;
     u16* m1 = (u16*)&dest->m[0][0];
     u16* m2 = (u16*)&dest->m[2][0];
-    s32 temp;
 
-    temp = src->xx * 65536.0f;
-    m1[0] = (temp >> 0x10) & 0xFFFF;
-    m2[0] = temp & 0xFFFF;
+    temp = src->xx * 0x10000;
+    m1[0] = (temp >> 0x10);
+    m1[16 + 0] = temp & 0xFFFF;
 
-    temp = src->xy * 65536.0f;
-    m1[1] = (temp >> 0x10) & 0xFFFF;
-    m2[1] = temp & 0xFFFF;
+    temp = src->xy * 0x10000;
+    m1[1] = (temp >> 0x10);
+    m1[16 + 1] = temp & 0xFFFF;
 
-    temp = src->xz * 65536.0f;
-    m1[2] = (temp >> 0x10) & 0xFFFF;
-    m2[2] = temp & 0xFFFF;
+    temp = src->xz * 0x10000;
+    m1[2] = (temp >> 0x10);
+    m1[16 + 2] = temp & 0xFFFF;
 
-    temp = src->xw * 65536.0f;
-    m1[3] = (temp >> 0x10) & 0xFFFF;
-    m2[3] = temp & 0xFFFF;
+    temp = src->xw * 0x10000;
+    m1[3] = (temp >> 0x10);
+    m1[16 + 3] = temp & 0xFFFF;
 
-    temp = src->yx * 65536.0f;
-    m1[4] = (temp >> 0x10) & 0xFFFF;
-    m2[4] = temp & 0xFFFF;
+    temp = src->yx * 0x10000;
+    m1[4] = (temp >> 0x10);
+    m1[16 + 4] = temp & 0xFFFF;
 
-    temp = src->yy * 65536.0f;
-    m1[5] = (temp >> 0x10) & 0xFFFF;
-    m2[5] = temp & 0xFFFF;
+    temp = src->yy * 0x10000;
+    m1[5] = (temp >> 0x10);
+    m1[16 + 5] = temp & 0xFFFF;
 
-    temp = src->yz * 65536.0f;
-    m1[6] = (temp >> 0x10) & 0xFFFF;
-    m2[6] = temp & 0xFFFF;
+    temp = src->yz * 0x10000;
+    m1[6] = (temp >> 0x10);
+    m1[16 + 6] = temp & 0xFFFF;
 
-    temp = src->yw * 65536.0f;
-    m1[7] = (temp >> 0x10) & 0xFFFF;
-    m2[7] = temp & 0xFFFF;
+    temp = src->yw * 0x10000;
+    m1[7] = (temp >> 0x10);
+    m1[16 + 7] = temp & 0xFFFF;
 
-    temp = src->zx * 65536.0f;
-    m1[8] = (temp >> 0x10) & 0xFFFF;
-    m2[8] = temp & 0xFFFF;
+    temp = src->zx * 0x10000;
+    m1[8] = (temp >> 0x10);
+    m1[16 + 8] = temp & 0xFFFF;
 
-    temp = src->zy * 65536.0f;
-    m1[9] = (temp >> 0x10) & 0xFFFF;
+    temp = src->zy * 0x10000;
+    m1[9] = (temp >> 0x10);
     m2[9] = temp & 0xFFFF;
 
-    temp = src->zz * 65536.0f;
-    m1[10] = (temp >> 0x10) & 0xFFFF;
+    temp = src->zz * 0x10000;
+    m1[10] = (temp >> 0x10);
     m2[10] = temp & 0xFFFF;
 
-    temp = src->zw * 65536.0f;
-    m1[11] = (temp >> 0x10) & 0xFFFF;
+    temp = src->zw * 0x10000;
+    m1[11] = (temp >> 0x10);
     m2[11] = temp & 0xFFFF;
 
-    temp = src->wx * 65536.0f;
-    m1[12] = (temp >> 0x10) & 0xFFFF;
+    temp = src->wx * 0x10000;
+    m1[12] = (temp >> 0x10);
     m2[12] = temp & 0xFFFF;
 
-    temp = src->wy * 65536.0f;
-    m1[13] = (temp >> 0x10) & 0xFFFF;
+    temp = src->wy * 0x10000;
+    m1[13] = (temp >> 0x10);
     m2[13] = temp & 0xFFFF;
 
-    temp = src->wz * 65536.0f;
-    m1[14] = (temp >> 0x10) & 0xFFFF;
+    temp = src->wz * 0x10000;
+    m1[14] = (temp >> 0x10);
     m2[14] = temp & 0xFFFF;
 
-    temp = src->ww * 65536.0f;
-    m1[15] = (temp >> 0x10) & 0xFFFF;
+    temp = src->ww * 0x10000;
+    m1[15] = (temp >> 0x10);
     m2[15] = temp & 0xFFFF;
-
     return dest;
 }
-#else
-#pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/Matrix_MtxFToMtx.s")
-#endif
 
 Mtx* Matrix_ToMtx(Mtx* dest, char* file, s32 line) {
     return Matrix_MtxFToMtx(Matrix_CheckFloats(sCurrentMatrix, file, line), dest);
@@ -625,7 +619,7 @@ Mtx* Matrix_NewMtx(GraphicsContext* gfxCtx, char* file, s32 line) {
     return Matrix_ToMtx(Graph_Alloc(gfxCtx, sizeof(Mtx)), file, line);
 }
 
-Mtx* Matrix_MtxFToNewMtx(MtxF* src, GraphicsContext* gfxCtx) {
+Mtx* Matrix_SkinMatrix_MtxFToNewMtx(MtxF* src, GraphicsContext* gfxCtx) {
     return Matrix_MtxFToMtx(src, Graph_Alloc(gfxCtx, sizeof(Mtx)));
 }
 
diff --git a/src/code/z_actor.c b/src/code/z_actor.c
index 6f4973a3d..fc9a8e362 100644
--- a/src/code/z_actor.c
+++ b/src/code/z_actor.c
@@ -228,7 +228,7 @@ void func_8002BDB0(Actor* actor, s32 arg1, s32 arg2, UNK_PTR arg3, s32 arg4, UNK
 }
 
 void func_8002BE04(GlobalContext* globalCtx, Vec3f* arg1, Vec3f* arg2, f32* arg3) {
-    func_800A6E10(&globalCtx->mf_11D60, arg1, arg2, arg3);
+    SkinMatrix_Vec3fMtxFMultXYZW(&globalCtx->mf_11D60, arg1, arg2, arg3);
     *arg3 = (*arg3 < 1.0f) ? 1.0f : (1.0f / *arg3);
 }
 
@@ -2400,7 +2400,8 @@ void func_800315AC(GlobalContext* globalCtx, ActorContext* actorCtx) {
             HREG(66) = i;
 
             if ((HREG(64) != 1) || ((HREG(65) != -1) && (HREG(65) != HREG(66))) || (HREG(68) == 0)) {
-                func_800A6E10(&globalCtx->mf_11D60, &actor->posRot.pos, &actor->projectedPos, &actor->projectedW);
+                SkinMatrix_Vec3fMtxFMultXYZW(&globalCtx->mf_11D60, &actor->posRot.pos, &actor->projectedPos,
+                                             &actor->projectedW);
             }
 
             if ((HREG(64) != 1) || ((HREG(65) != -1) && (HREG(65) != HREG(66))) || (HREG(69) == 0)) {
diff --git a/src/code/z_eff_blure.c b/src/code/z_eff_blure.c
index e6d9b5232..c5a7ead89 100644
--- a/src/code/z_eff_blure.c
+++ b/src/code/z_eff_blure.c
@@ -47,13 +47,13 @@ void EffectBlure_AddVertex(EffectBlure* this, Vec3f* p1, Vec3f* p2) {
                 scale = 1.0f / scale;
                 Math_Vec3f_Scale(&sp154, scale);
 
-                func_800A7A24(&sp110, sp160.x, sp160.y, sp160.z);
+                SkinMatrix_SetTranslate(&sp110, sp160.x, sp160.y, sp160.z);
                 func_800A7EC0(&spD0, this->addAngle, sp154.x, sp154.y, sp154.z);
-                func_800A6FA0(&sp110, &spD0, &sp90);
-                func_800A7A24(&sp110, -sp160.x, -sp160.y, -sp160.z);
-                func_800A6FA0(&sp90, &sp110, &sp50);
-                func_800A6EF4(&sp50, p1, &sp38);
-                func_800A6EF4(&sp50, p2, &sp44);
+                SkinMatrix_MtxFMtxFMult(&sp110, &spD0, &sp90);
+                SkinMatrix_SetTranslate(&sp110, -sp160.x, -sp160.y, -sp160.z);
+                SkinMatrix_MtxFMtxFMult(&sp90, &sp110, &sp50);
+                SkinMatrix_Vec3fMtxFMultXYZ(&sp50, p1, &sp38);
+                SkinMatrix_Vec3fMtxFMultXYZ(&sp50, p2, &sp44);
 
                 elem->p1.x = sp38.x;
                 elem->p1.y = sp38.y;
@@ -715,11 +715,11 @@ void EffectBlure_DrawSmooth(EffectBlure* this, GraphicsContext* gfxCtx) {
     this->elements[this->numElements - 1].flags |= 2;
 
     EffectBlure_SetupSmooth(this, gfxCtx);
-    func_800A7A24(&spDC, this->elements[0].p2.x, this->elements[0].p2.y, this->elements[0].p2.z);
-    func_800A76A4(&sp9C, 0.1f, 0.1f, 0.1f);
-    func_800A6FA0(&spDC, &sp9C, &sp5C);
+    SkinMatrix_SetTranslate(&spDC, this->elements[0].p2.x, this->elements[0].p2.y, this->elements[0].p2.z);
+    SkinMatrix_SetScale(&sp9C, 0.1f, 0.1f, 0.1f);
+    SkinMatrix_MtxFMtxFMult(&spDC, &sp9C, &sp5C);
 
-    mtx = func_800A7E70(gfxCtx, &sp5C);
+    mtx = SkinMatrix_MtxFToNewMtx(gfxCtx, &sp5C);
     if (mtx == NULL) {
         return;
     }
@@ -844,13 +844,13 @@ void EffectBlure_DrawSimpleVertices(GraphicsContext* gfxCtx, EffectBlure* this,
                 scale = 1.0f / scale;
                 Math_Vec3f_Scale(&sp198, scale);
 
-                func_800A7A24(&sp154, sp1B0.x, sp1B0.y, sp1B0.z);
+                SkinMatrix_SetTranslate(&sp154, sp1B0.x, sp1B0.y, sp1B0.z);
                 func_800A7EC0(&sp114, 0x3FFF, sp198.x, sp198.y, sp198.z);
-                func_800A6FA0(&sp154, &sp114, &spD4);
-                func_800A7A24(&sp154, -sp1B0.x, -sp1B0.y, -sp1B0.z);
-                func_800A6FA0(&spD4, &sp154, &sp94);
+                SkinMatrix_MtxFMtxFMult(&sp154, &sp114, &spD4);
+                SkinMatrix_SetTranslate(&sp154, -sp1B0.x, -sp1B0.y, -sp1B0.z);
+                SkinMatrix_MtxFMtxFMult(&spD4, &sp154, &sp94);
 
-                mtx = func_800A7E70(gfxCtx, &sp94);
+                mtx = SkinMatrix_MtxFToNewMtx(gfxCtx, &sp94);
                 if (mtx == NULL) {
                     // Translates to: "Forced termination because a matrix cannot be taken"
                     osSyncPrintf("EffectBlureInfo2_disp_makeDisplayList()マトリックス取れないので,強制終了\n");
diff --git a/src/code/z_eff_shield_particle.c b/src/code/z_eff_shield_particle.c
index b3be66f79..855161765 100644
--- a/src/code/z_eff_shield_particle.c
+++ b/src/code/z_eff_shield_particle.c
@@ -203,17 +203,17 @@ void EffectShieldParticle_Draw(void* thisx, GraphicsContext* gfxCtx) {
                 temp3 = 1.0f;
             }
 
-            func_800A7A24(&spC4, this->position.x, this->position.y, this->position.z);
-            func_800A7704(&sp104, 0, elem->yaw, 0);
-            func_800A6FA0(&spC4, &sp104, &sp84);
-            func_800A7704(&sp104, 0, 0, elem->pitch);
-            func_800A6FA0(&sp84, &sp104, &spC4);
-            func_800A7A24(&sp104, temp1, 0.0f, 0.0f);
-            func_800A6FA0(&spC4, &sp104, &sp84);
-            func_800A76A4(&sp104, temp3 * 0.02f, 0.02f, 0.02f);
-            func_800A6FA0(&sp84, &sp104, &spC4);
-
-            mtx = func_800A7E70(gfxCtx, &spC4);
+            SkinMatrix_SetTranslate(&spC4, this->position.x, this->position.y, this->position.z);
+            SkinMatrix_SetRotateRPY(&sp104, 0, elem->yaw, 0);
+            SkinMatrix_MtxFMtxFMult(&spC4, &sp104, &sp84);
+            SkinMatrix_SetRotateRPY(&sp104, 0, 0, elem->pitch);
+            SkinMatrix_MtxFMtxFMult(&sp84, &sp104, &spC4);
+            SkinMatrix_SetTranslate(&sp104, temp1, 0.0f, 0.0f);
+            SkinMatrix_MtxFMtxFMult(&spC4, &sp104, &sp84);
+            SkinMatrix_SetScale(&sp104, temp3 * 0.02f, 0.02f, 0.02f);
+            SkinMatrix_MtxFMtxFMult(&sp84, &sp104, &spC4);
+
+            mtx = SkinMatrix_MtxFToNewMtx(gfxCtx, &spC4);
             if (mtx == NULL) {
                 break;
             }
diff --git a/src/code/z_eff_spark.c b/src/code/z_eff_spark.c
index 08d123893..6c3a659bb 100644
--- a/src/code/z_eff_spark.c
+++ b/src/code/z_eff_spark.c
@@ -215,11 +215,11 @@ void EffectSpark_Draw(void* thisx, GraphicsContext* gfxCtx) {
 
             elem = &this->elements[i];
 
-            func_800A7A24(&spEC, elem->position.x, elem->position.y, elem->position.z);
+            SkinMatrix_SetTranslate(&spEC, elem->position.x, elem->position.y, elem->position.z);
             temp = ((Math_Rand_ZeroOne() * 2.5f) + 1.5f) * 0.015625f;
-            func_800A76A4(&spAC, temp, temp, 1.0f);
-            func_800A6FA0(&spEC, &globalCtx->mf_11DA0, &sp6C);
-            func_800A6FA0(&sp6C, &spAC, &sp12C);
+            SkinMatrix_SetScale(&spAC, temp, temp, 1.0f);
+            SkinMatrix_MtxFMtxFMult(&spEC, &globalCtx->mf_11DA0, &sp6C);
+            SkinMatrix_MtxFMtxFMult(&sp6C, &spAC, &sp12C);
 
             vertices[j].v.ob[0] = -32;
             vertices[j].v.ob[1] = -32;
@@ -269,7 +269,7 @@ void EffectSpark_Draw(void* thisx, GraphicsContext* gfxCtx) {
 
             if (this) {}
 
-            mtx = func_800A7E70(gfxCtx, &sp12C);
+            mtx = SkinMatrix_MtxFToNewMtx(gfxCtx, &sp12C);
             if (mtx == NULL) {
                 break;
             }
diff --git a/src/code/z_player_lib.c b/src/code/z_player_lib.c
index fab2d296b..1b1190629 100644
--- a/src/code/z_player_lib.c
+++ b/src/code/z_player_lib.c
@@ -572,7 +572,7 @@ void func_80090AFC(GlobalContext* globalCtx, Player* player, f32 arg2) {
 
         gfxCtx->overlay.p = Gfx_CallSetupDL(gfxCtx->overlay.p, 7);
 
-        func_800A6E10(&globalCtx->mf_11D60, &sp74, &sp68, &sp64);
+        SkinMatrix_Vec3fMtxFMultXYZW(&globalCtx->mf_11D60, &sp74, &sp68, &sp64);
 
         sp60 = (sp64 < 200.0f) ? 0.07999999821186066f : (sp64 / 200.0f) * 0.07999999821186066f;
 
diff --git a/src/code/z_room.c b/src/code/z_room.c
index 487e96964..129b6c2f5 100644
--- a/src/code/z_room.c
+++ b/src/code/z_room.c
@@ -138,7 +138,7 @@ void func_80095D04(GlobalContext* globalCtx, Room* room, u32 flags) {
         sp90.x = polygonDlist->pos.x;
         sp90.y = polygonDlist->pos.y;
         sp90.z = polygonDlist->pos.z;
-        func_800A6E10(&globalCtx->mf_11D60, &sp90, &sp84, &sp80);
+        SkinMatrix_Vec3fMtxFMultXYZW(&globalCtx->mf_11D60, &sp90, &sp84, &sp80);
         temp_f0 = polygonDlist->unk_06;
         if (-temp_f0 < sp84.z) {
             temp_f2 = sp84.z - temp_f0;
diff --git a/src/code/z_skin_matrix.c b/src/code/z_skin_matrix.c
index 27d703f30..9920fe76e 100644
--- a/src/code/z_skin_matrix.c
+++ b/src/code/z_skin_matrix.c
@@ -1,42 +1,728 @@
 #include <ultra64.h>
 #include <global.h>
+#include <vt.h>
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skin_matrix/func_800A6E10.s")
+// clang-format off
+MtxF sMtxFClear = {
+    1.0f, 0.0f, 0.0f, 0.0f,
+    0.0f, 1.0f, 0.0f, 0.0f,
+    0.0f, 0.0f, 1.0f, 0.0f,
+    0.0f, 0.0f, 0.0f, 1.0f,
+};
+// clang-format on
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skin_matrix/func_800A6EF4.s")
+/**
+ * Multiplies a 4 component row vector [ src , 1 ] by the matrix mf and writes the resulting 4 components to xyzDest
+ * and wDest.
+ *
+ * \f[ [\texttt{xyzDest}, \texttt{wDest}] = [\texttt{src}, 1] \cdot [mf] \f]
+ */
+void SkinMatrix_Vec3fMtxFMultXYZW(MtxF* mf, Vec3f* src, Vec3f* xyzDest, f32* wDest) {
+    xyzDest->x = mf->wx + ((src->x * mf->xx) + (src->y * mf->yx) + (src->z * mf->zx));
+    xyzDest->y = mf->wy + ((src->x * mf->xy) + (src->y * mf->yy) + (src->z * mf->zy));
+    xyzDest->z = mf->wz + ((src->x * mf->xz) + (src->y * mf->yz) + (src->z * mf->zz));
+    *wDest = mf->ww + ((src->x * mf->xw) + (src->y * mf->yw) + (src->z * mf->zw));
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skin_matrix/func_800A6FA0.s")
+/**
+ * Multiplies a 4 component row vector [ src , 1 ] by the matrix mf and writes the resulting xyz components to dest.
+ *
+ * \f[ [\texttt{dest}, -] = [\texttt{src}, 1] \cdot [mf] \f]
+ */
+void SkinMatrix_Vec3fMtxFMultXYZ(MtxF* mf, Vec3f* src, Vec3f* dest) {
+    f32 mx;
+    f32 my;
+    f32 mz;
+    f32 mw;
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skin_matrix/func_800A72FC.s")
+    mx = mf->xx;
+    my = mf->yx;
+    mz = mf->zx;
+    mw = mf->wx;
+    dest->x = mw + ((src->x * mx) + (src->y * my) + (src->z * mz));
+    mx = mf->xy;
+    my = mf->yy;
+    mz = mf->zy;
+    mw = mf->wy;
+    dest->y = mw + ((src->x * mx) + (src->y * my) + (src->z * mz));
+    mx = mf->xz;
+    my = mf->yz;
+    mz = mf->zz;
+    mw = mf->wz;
+    dest->z = mw + ((src->x * mx) + (src->y * my) + (src->z * mz));
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skin_matrix/func_800A730C.s")
+/**
+ * Matrix multiplication, dest = mfA * mfB.
+ * mfA and dest should not be the same matrix.
+ */
+void SkinMatrix_MtxFMtxFMult(MtxF* mfB, MtxF* mfA, MtxF* dest) {
+    f32 rx;
+    f32 ry;
+    f32 rz;
+    f32 rw;
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skin_matrix/func_800A735C.s")
+    f32 cx;
+    f32 cy;
+    f32 cz;
+    f32 cw;
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skin_matrix/func_800A73E0.s")
+    //---COL1---
+    cx = mfB->xx;
+    cy = mfB->yx;
+    cz = mfB->zx;
+    cw = mfB->wx;
+    //--------
+    rx = mfA->xx;
+    ry = mfA->xy;
+    rz = mfA->xz;
+    rw = mfA->xw;
+    dest->xx = (cx * rx) + (cy * ry) + (cz * rz) + (cw * rw);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skin_matrix/func_800A76A4.s")
+    rx = mfA->yx;
+    ry = mfA->yy;
+    rz = mfA->yz;
+    rw = mfA->yw;
+    dest->yx = (cx * rx) + (cy * ry) + (cz * rz) + (cw * rw);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skin_matrix/func_800A7704.s")
+    rx = mfA->zx;
+    ry = mfA->zy;
+    rz = mfA->zz;
+    rw = mfA->zw;
+    dest->zx = (cx * rx) + (cy * ry) + (cz * rz) + (cw * rw);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skin_matrix/func_800A7894.s")
+    rx = mfA->wx;
+    ry = mfA->wy;
+    rz = mfA->wz;
+    rw = mfA->ww;
+    dest->wx = (cx * rx) + (cy * ry) + (cz * rz) + (cw * rw);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skin_matrix/func_800A7A24.s")
+    //---COL2---
+    cx = mfB->xy;
+    cy = mfB->yy;
+    cz = mfB->zy;
+    cw = mfB->wy;
+    //--------
+    rx = mfA->xx;
+    ry = mfA->xy;
+    rz = mfA->xz;
+    rw = mfA->xw;
+    dest->xy = (cx * rx) + (cy * ry) + (cz * rz) + (cw * rw);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skin_matrix/func_800A7A84.s")
+    rx = mfA->yx;
+    ry = mfA->yy;
+    rz = mfA->yz;
+    rw = mfA->yw;
+    dest->yy = (cx * rx) + (cy * ry) + (cz * rz) + (cw * rw);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skin_matrix/func_800A7B04.s")
+    rx = mfA->zx;
+    ry = mfA->zy;
+    rz = mfA->zz;
+    rw = mfA->zw;
+    dest->zy = (cx * rx) + (cy * ry) + (cz * rz) + (cw * rw);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skin_matrix/func_800A7B84.s")
+    rx = mfA->wx;
+    ry = mfA->wy;
+    rz = mfA->wz;
+    rw = mfA->ww;
+    dest->wy = (cx * rx) + (cy * ry) + (cz * rz) + (cw * rw);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skin_matrix/func_800A7BE4.s")
+    //---COL3---
+    cx = mfB->xz;
+    cy = mfB->yz;
+    cz = mfB->zz;
+    cw = mfB->wz;
+    //--------
+    rx = mfA->xx;
+    ry = mfA->xy;
+    rz = mfA->xz;
+    rw = mfA->xw;
+    dest->xz = (cx * rx) + (cy * ry) + (cz * rz) + (cw * rw);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skin_matrix/func_800A7C20.s")
+    rx = mfA->yx;
+    ry = mfA->yy;
+    rz = mfA->yz;
+    rw = mfA->yw;
+    dest->yz = (cx * rx) + (cy * ry) + (cz * rz) + (cw * rw);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skin_matrix/func_800A7C60.s")
+    rx = mfA->zx;
+    ry = mfA->zy;
+    rz = mfA->zz;
+    rw = mfA->zw;
+    dest->zz = (cx * rx) + (cy * ry) + (cz * rz) + (cw * rw);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skin_matrix/func_800A7E70.s")
+    rx = mfA->wx;
+    ry = mfA->wy;
+    rz = mfA->wz;
+    rw = mfA->ww;
+    dest->wz = (cx * rx) + (cy * ry) + (cz * rz) + (cw * rw);
 
+    //---COL4---
+    cx = mfB->xw;
+    cy = mfB->yw;
+    cz = mfB->zw;
+    cw = mfB->ww;
+    //--------
+    rx = mfA->xx;
+    ry = mfA->xy;
+    rz = mfA->xz;
+    rw = mfA->xw;
+    dest->xw = (cx * rx) + (cy * ry) + (cz * rz) + (cw * rw);
+
+    rx = mfA->yx;
+    ry = mfA->yy;
+    rz = mfA->yz;
+    rw = mfA->yw;
+    dest->yw = (cx * rx) + (cy * ry) + (cz * rz) + (cw * rw);
+
+    rx = mfA->zx;
+    ry = mfA->zy;
+    rz = mfA->zz;
+    rw = mfA->zw;
+    dest->zw = (cx * rx) + (cy * ry) + (cz * rz) + (cw * rw);
+
+    rx = mfA->wx;
+    ry = mfA->wy;
+    rz = mfA->wz;
+    rw = mfA->ww;
+    dest->ww = (cx * rx) + (cy * ry) + (cz * rz) + (cw * rw);
+}
+
+/**
+ * "Clear" in this file means the identity matrix.
+ */
+void SkinMatrix_GetClear(MtxF** mfp) {
+    *mfp = &sMtxFClear;
+}
+
+void SkinMatrix_Clear(MtxF* mf) {
+    mf->xx = 1.0f;
+    mf->yy = 1.0f;
+    mf->zz = 1.0f;
+    mf->ww = 1.0f;
+    mf->xy = 0.0f;
+    mf->xz = 0.0f;
+    mf->xw = 0.0f;
+    mf->yx = 0.0f;
+    mf->yz = 0.0f;
+    mf->yw = 0.0f;
+    mf->zx = 0.0f;
+    mf->zy = 0.0f;
+    mf->zw = 0.0f;
+    mf->wx = 0.0f;
+    mf->wy = 0.0f;
+    mf->wz = 0.0f;
+}
+
+void SkinMatrix_MtxFCopy(MtxF* src, MtxF* dest) {
+    dest->xx = src->xx;
+    dest->xy = src->xy;
+    dest->xz = src->xz;
+    dest->xw = src->xw;
+    dest->yx = src->yx;
+    dest->yy = src->yy;
+    dest->yz = src->yz;
+    dest->yw = src->yw;
+    dest->zx = src->zx;
+    dest->zy = src->zy;
+    dest->zz = src->zz;
+    dest->zw = src->zw;
+    dest->wx = src->wx;
+    dest->wy = src->wy;
+    dest->wz = src->wz;
+    dest->ww = src->ww;
+}
+
+/**
+ * Inverts a matrix using a slight modification of the Gauss-Jordan method
+ * (column operations instead of row operations).
+ * returns 0 if successfully inverted
+ * returns 2 if matrix non-invertible (0 determinant)
+ */
+#ifdef NON_MATCHING
+// Saved register usage differences and probably regalloc
+s32 SkinMatrix_Invert(MtxF* src, MtxF* dest) {
+    MtxF mfCopy;
+    s32 i;
+    s32 k;
+    f32 temp1;
+    f32 temp2;
+    f32 diagElement;
+    s32 thisRow;
+    s32 thisCol;
+    u32 pad;
+
+    SkinMatrix_MtxFCopy(src, &mfCopy);
+    SkinMatrix_Clear(dest);
+    for (thisRow = 0; thisRow != 4; thisRow++) {
+        for (thisCol = thisRow; (thisCol < 4) && (fabsf(mfCopy.mf[thisRow][thisCol]) < 0.0005f); thisCol++) {}
+        if (thisCol == 4) {
+            // reaching col = 4 means the row is either all 0 or a duplicate row.
+            // therefore singular matrix (0 determinant).
+            osSyncPrintf(VT_COL(YELLOW, BLACK));
+            osSyncPrintf("Skin_Matrix_InverseMatrix():逆行列つくれません\n");
+            osSyncPrintf(VT_RST);
+            return 2;
+        }
+
+        if (thisCol != thisRow) { // responsible for swapping columns if zero on diagonal
+            for (i = 0; i != 4; i++) {
+                temp1 = mfCopy.mf[i][thisCol];
+                mfCopy.mf[i][thisCol] = mfCopy.mf[i][thisRow];
+                mfCopy.mf[i][thisRow] = temp1;
+
+                temp1 = dest->mf[i][thisCol];
+                dest->mf[i][thisCol] = dest->mf[i][thisRow];
+                dest->mf[i][thisRow] = temp1;
+            }
+        }
+
+        diagElement = mfCopy.mf[thisRow][thisRow];
+        // Scale this whole column s.t. the diag element = 1
+        mfCopy.mf[0][thisRow] = mfCopy.mf[0][thisRow] / diagElement;
+        dest->mf[0][thisRow] = dest->mf[0][thisRow] / diagElement;
+        mfCopy.mf[1][thisRow] = mfCopy.mf[1][thisRow] / diagElement;
+        dest->mf[1][thisRow] = dest->mf[1][thisRow] / diagElement;
+        mfCopy.mf[2][thisRow] = mfCopy.mf[2][thisRow] / diagElement;
+        dest->mf[2][thisRow] = dest->mf[2][thisRow] / diagElement;
+        mfCopy.mf[3][thisRow] = mfCopy.mf[3][thisRow] / diagElement;
+        dest->mf[3][thisRow] = dest->mf[3][thisRow] / diagElement;
+
+        // col i = col i - a * col j
+        for (k = 0; k != 4; k++) {
+            if (k != thisRow) {
+                temp2 = mfCopy.mf[thisRow][k];
+                mfCopy.mf[0][k] = mfCopy.mf[0][k] - (mfCopy.mf[0][thisRow] * temp2);
+                dest->mf[0][k] = dest->mf[0][k] - (dest->mf[0][thisRow] * temp2);
+                mfCopy.mf[1][k] = mfCopy.mf[1][k] - (mfCopy.mf[1][thisRow] * temp2);
+                dest->mf[1][k] = dest->mf[1][k] - (dest->mf[1][thisRow] * temp2);
+                mfCopy.mf[2][k] = mfCopy.mf[2][k] - (mfCopy.mf[2][thisRow] * temp2);
+                dest->mf[2][k] = dest->mf[2][k] - (dest->mf[2][thisRow] * temp2);
+                mfCopy.mf[3][k] = mfCopy.mf[3][k] - (mfCopy.mf[3][thisRow] * temp2);
+                dest->mf[3][k] = dest->mf[3][k] - (dest->mf[3][thisRow] * temp2);
+            }
+        }
+    }
+    return 0;
+}
+#else
+#pragma GLOBAL_ASM("asm/non_matchings/code/z_skin_matrix/SkinMatrix_Invert.s")
+#endif
+
+/**
+ * Produces a matrix which scales x,y,z components of vectors or x,y,z rows of matrices (when applied on LHS)
+ */
+void SkinMatrix_SetScale(MtxF* mf, f32 x, f32 y, f32 z) {
+    mf->xy = 0.0f;
+    mf->xz = 0.0f;
+    mf->xw = 0.0f;
+    mf->yx = 0.0f;
+    mf->yz = 0.0f;
+    mf->yw = 0.0f;
+    mf->zx = 0.0f;
+    mf->zy = 0.0f;
+    mf->zw = 0.0f;
+    mf->wx = 0.0f;
+    mf->wy = 0.0f;
+    mf->wz = 0.0f;
+    mf->ww = 1.0f;
+    mf->xx = x;
+    mf->yy = y;
+    mf->zz = z;
+}
+
+/**
+ * Produces a rotation matrix = (roll rotation matrix) * (pitch rotation matrix) * (yaw rotation matrix)
+ */
+void SkinMatrix_SetRotateRPY(MtxF* mf, s16 roll, s16 pitch, s16 yaw) {
+    f32 cos2;
+    f32 sin;
+    f32 cos;
+    f32 yx;
+    f32 sin2;
+    f32 zx;
+    f32 yy;
+    f32 zy;
+
+    sin = Math_Sins(yaw);
+    cos = Math_Coss(yaw);
+    mf->yy = cos;
+    mf->yx = -sin;
+    mf->xw = mf->yw = mf->zw = 0;
+    mf->wx = mf->wy = mf->wz = 0;
+    mf->ww = 1;
+
+    if (pitch != 0) {
+        sin2 = Math_Sins(pitch);
+        cos2 = Math_Coss(pitch);
+
+        mf->xx = cos * cos2;
+        mf->zx = cos * sin2;
+
+        mf->xy = sin * cos2;
+        mf->zy = sin * sin2;
+        mf->xz = -sin2;
+        mf->zz = cos2;
+
+    } else {
+        mf->xx = cos;
+        if (1) {}
+        if (1) {}
+        zx = sin; // required to match
+        mf->xy = sin;
+        mf->xz = mf->zx = mf->zy = 0;
+        mf->zz = 1;
+    }
+
+    if (roll != 0) {
+        sin2 = Math_Sins(roll);
+        cos2 = Math_Coss(roll);
+
+        yx = mf->yx;
+        zx = mf->zx;
+        mf->yx = (yx * cos2) + (zx * sin2);
+        mf->zx = (zx * cos2) - (yx * sin2);
+
+        if (1) {}
+        zy = mf->zy;
+        yy = mf->yy;
+        mf->yy = (yy * cos2) + (zy * sin2);
+        mf->zy = (zy * cos2) - (yy * sin2);
+
+        if (cos2) {}
+        mf->yz = mf->zz * sin2;
+        mf->zz = mf->zz * cos2;
+    } else {
+        mf->yz = 0;
+    }
+}
+
+/**
+ * Produces a rotation matrix = (yaw rotation matrix) * (roll rotation matrix) * (pitch rotation matrix)
+ */
+void SkinMatrix_SetRotateYRP(MtxF* mf, s16 yaw, s16 roll, s16 pitch) {
+    f32 cos2;
+    f32 sin;
+    f32 cos;
+    f32 xz;
+    f32 sin2;
+    f32 yz;
+    f32 xx;
+    f32 yx;
+    sin = Math_Sins(roll);
+    cos = Math_Coss(roll);
+    mf->xx = cos;
+    mf->xz = -sin;
+    mf->zw = 0;
+    mf->yw = 0;
+    mf->xw = 0;
+    mf->wz = 0;
+    mf->wy = 0;
+    mf->wx = 0;
+    mf->ww = 1;
+
+    if (yaw != 0) {
+        sin2 = Math_Sins(yaw);
+        cos2 = Math_Coss(yaw);
+
+        mf->zz = cos * cos2;
+        mf->yz = cos * sin2;
+
+        mf->zx = sin * cos2;
+        mf->yx = sin * sin2;
+        mf->zy = -sin2;
+        mf->yy = cos2;
+
+    } else {
+        mf->zz = cos;
+        if (1) {}
+        if (1) {}
+        yx = sin; // required to match
+        mf->zx = sin;
+        mf->yx = mf->yz = mf->zy = 0;
+        mf->yy = 1;
+    }
+
+    if (pitch != 0) {
+        sin2 = Math_Sins(pitch);
+        cos2 = Math_Coss(pitch);
+        xx = mf->xx;
+        yx = mf->yx;
+        mf->xx = (xx * cos2) + (yx * sin2);
+        mf->yx = yx * cos2 - (xx * sin2);
+        if (1) {}
+        yz = mf->yz;
+        xz = mf->xz;
+        mf->xz = (xz * cos2) + (yz * sin2);
+        mf->yz = (yz * cos2) - (xz * sin2);
+        if (cos2) {}
+        mf->xy = mf->yy * sin2;
+        mf->yy = mf->yy * cos2;
+    } else {
+        mf->xy = 0;
+    }
+}
+
+/**
+ * Produces a matrix which translates a vector by amounts in the x, y and z directions
+ */
+void SkinMatrix_SetTranslate(MtxF* mf, f32 x, f32 y, f32 z) {
+    mf->xy = 0.0f;
+    mf->xz = 0.0f;
+    mf->xw = 0.0f;
+    mf->yx = 0.0f;
+    mf->yz = 0.0f;
+    mf->yw = 0.0f;
+    mf->zx = 0.0f;
+    mf->zy = 0.0f;
+    mf->zw = 0.0f;
+    mf->xx = 1.0f;
+    mf->yy = 1.0f;
+    mf->zz = 1.0f;
+    mf->ww = 1.0f;
+    mf->wx = x;
+    mf->wy = y;
+    mf->wz = z;
+}
+
+/**
+ * Produces a matrix which scales, then rotates (RPY), then translates a vector
+ */
+void SkinMatrix_SetScaleRotateRPYTranslate(MtxF* mf, f32 scaleX, f32 scaleY, f32 scaleZ, s16 roll, s16 pitch, s16 yaw,
+                                           f32 dx, f32 dy, f32 dz) {
+    MtxF mft1;
+    MtxF mft2;
+
+    SkinMatrix_SetTranslate(mf, dx, dy, dz);
+    SkinMatrix_SetRotateRPY(&mft1, roll, pitch, yaw);
+    SkinMatrix_MtxFMtxFMult(mf, &mft1, &mft2);
+    SkinMatrix_SetScale(&mft1, scaleX, scaleY, scaleZ);
+    SkinMatrix_MtxFMtxFMult(&mft2, &mft1, mf);
+}
+
+/**
+ * Produces a matrix which scales, then rotates (YRP), then translates a vector
+ */
+void SkinMatrix_SetScaleRotateYRPTranslate(MtxF* mf, f32 scaleX, f32 scaleY, f32 scaleZ, s16 yaw, s16 roll, s16 pitch,
+                                           f32 dx, f32 dy, f32 dz) {
+    MtxF mft1;
+    MtxF mft2;
+
+    SkinMatrix_SetTranslate(mf, dx, dy, dz);
+    SkinMatrix_SetRotateYRP(&mft1, yaw, roll, pitch);
+    SkinMatrix_MtxFMtxFMult(mf, &mft1, &mft2);
+    SkinMatrix_SetScale(&mft1, scaleX, scaleY, scaleZ);
+    SkinMatrix_MtxFMtxFMult(&mft2, &mft1, mf);
+}
+
+/**
+ * Produces a matrix which rotates (RPY), then translates a vector
+ */
+void SkinMatrix_SetRotateRPYTranslate(MtxF* mf, s16 roll, s16 pitch, s16 yaw, f32 dx, f32 dy, f32 dz) {
+    MtxF mft1;
+    MtxF mft2;
+
+    SkinMatrix_SetTranslate(&mft2, dx, dy, dz);
+    SkinMatrix_SetRotateRPY(&mft1, roll, pitch, yaw);
+    SkinMatrix_MtxFMtxFMult(&mft2, &mft1, mf);
+}
+
+void SkinMatrix_Vec3fToVec3s(Vec3f* src, Vec3s* dest) {
+    dest->x = src->x;
+    dest->y = src->y;
+    dest->z = src->z;
+}
+
+void SkinMatrix_Vec3sToVec3f(Vec3s* src, Vec3f* dest) {
+    dest->x = src->x;
+    dest->y = src->y;
+    dest->z = src->z;
+}
+
+void SkinMatrix_MtxFToMtx(MtxF* src, Mtx* dest) {
+    s32 temp;
+    u16* m1 = (u16*)&dest->m[0][0];
+    u16* m2 = (u16*)&dest->m[2][0];
+
+    temp = src->xx * 0x10000;
+    m1[0] = (temp >> 0x10);
+    m1[16 + 0] = temp & 0xFFFF;
+
+    temp = src->xy * 0x10000;
+    m1[1] = (temp >> 0x10);
+    m1[16 + 1] = temp & 0xFFFF;
+
+    temp = src->xz * 0x10000;
+    m1[2] = (temp >> 0x10);
+    m1[16 + 2] = temp & 0xFFFF;
+
+    temp = src->xw * 0x10000;
+    m1[3] = (temp >> 0x10);
+    m1[16 + 3] = temp & 0xFFFF;
+
+    temp = src->yx * 0x10000;
+    m1[4] = (temp >> 0x10);
+    m1[16 + 4] = temp & 0xFFFF;
+
+    temp = src->yy * 0x10000;
+    m1[5] = (temp >> 0x10);
+    m1[16 + 5] = temp & 0xFFFF;
+
+    temp = src->yz * 0x10000;
+    m1[6] = (temp >> 0x10);
+    m1[16 + 6] = temp & 0xFFFF;
+
+    temp = src->yw * 0x10000;
+    m1[7] = (temp >> 0x10);
+    m1[16 + 7] = temp & 0xFFFF;
+
+    temp = src->zx * 0x10000;
+    m1[8] = (temp >> 0x10);
+    m1[16 + 8] = temp & 0xFFFF;
+
+    temp = src->zy * 0x10000;
+    m1[9] = (temp >> 0x10);
+    m2[9] = temp & 0xFFFF;
+
+    temp = src->zz * 0x10000;
+    m1[10] = (temp >> 0x10);
+    m2[10] = temp & 0xFFFF;
+
+    temp = src->zw * 0x10000;
+    m1[11] = (temp >> 0x10);
+    m2[11] = temp & 0xFFFF;
+
+    temp = src->wx * 0x10000;
+    m1[12] = (temp >> 0x10);
+    m2[12] = temp & 0xFFFF;
+
+    temp = src->wy * 0x10000;
+    m1[13] = (temp >> 0x10);
+    m2[13] = temp & 0xFFFF;
+
+    temp = src->wz * 0x10000;
+    m1[14] = (temp >> 0x10);
+    m2[14] = temp & 0xFFFF;
+
+    temp = src->ww * 0x10000;
+    m1[15] = (temp >> 0x10);
+    m2[15] = temp & 0xFFFF;
+}
+
+Mtx* SkinMatrix_MtxFToNewMtx(GraphicsContext* gfxCtx, MtxF* src) {
+    Mtx* mtx = Graph_Alloc(gfxCtx, sizeof(Mtx));
+
+    if (mtx == NULL) {
+        osSyncPrintf("Skin_Matrix_to_Mtx_new() 確保失敗:NULLを返して終了\n", mtx);
+        return NULL;
+    }
+    SkinMatrix_MtxFToMtx(src, mtx);
+    return mtx;
+}
+
+/**
+ * Produces a matrix which rotates vectors by angle a around the vector with components (x,y,z)
+ */
+#ifdef NON_EQUIVALENT
+// I think this is functionally correct but I cannot be 100% sure of equivalence because diff output is not very close
+void func_800A7EC0(MtxF* mf, s16 a, f32 x, f32 y, f32 z) {
+    f32 sin;
+    f32 cos;
+    f32 ct;
+    f32 xx;
+    f32 yy;
+    f32 zz;
+    f32 xy;
+    f32 xz;
+    f32 yz;
+    f32 sx;
+    f32 sy;
+    f32 sz;
+
+    sin = Math_Sins(a);
+    cos = Math_Coss(a);
+
+    ct = 1.0f - cos;
+    sx = sin * x;
+    sy = sin * y;
+    sz = sin * z;
+
+    xx = x * x;
+    xy = x * y;
+    xz = x * z;
+    yy = y * y;
+    yz = y * z;
+    zz = z * z;
+
+    mf->xx = (f32)ct * xx + cos;
+    mf->xy = (f32)((ct * xy) + sz);
+    mf->xz = (f32)((ct * xz) - sy);
+    mf->xw = 0.0f;
+
+    mf->yx = (f32)((ct * (xy)) - sz);
+    mf->yy = (f32)ct * yy + cos;
+    mf->yz = (f32)((ct * (yz)) + sx);
+    mf->yw = 0.0f;
+
+    mf->zx = (f32)((ct * (xz)) + sy);
+    mf->zy = (f32)((ct * (yz)) - sx);
+    mf->zz = (f32)ct * zz + cos;
+
+    mf->zw = 0.0f;
+
+    mf->wx = 0.0f;
+    mf->wy = 0.0f;
+    mf->wz = 0.0f;
+    mf->ww = 1.0f;
+}
+#else
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_skin_matrix/func_800A7EC0.s")
+#endif
+
+void func_800A8030(MtxF* mf, f32* arg1) {
+    f32 n;
+    f32 xNorm;
+    f32 yNorm;
+    f32 zNorm;
+    f32 wxNorm;
+    f32 wyNorm;
+    f32 wzNorm;
+    f32 xxNorm;
+    f32 xyNorm;
+    f32 xzNorm;
+    f32 yyNorm;
+    f32 yzNorm;
+    f32 zzNorm;
+
+    n = 2.0f / ((arg1[3] * arg1[3]) + ((arg1[2] * arg1[2]) + ((arg1[1] * arg1[1]) + (arg1[0] * arg1[0]))));
+    xNorm = arg1[0] * n;
+    yNorm = arg1[1] * n;
+    zNorm = arg1[2] * n;
+
+    wxNorm = arg1[3] * xNorm;
+    wyNorm = arg1[3] * yNorm;
+    wzNorm = arg1[3] * zNorm;
+    xxNorm = arg1[0] * xNorm;
+    xyNorm = arg1[0] * yNorm;
+    xzNorm = arg1[0] * zNorm;
+    yyNorm = arg1[1] * yNorm;
+    yzNorm = arg1[1] * zNorm;
+    zzNorm = arg1[2] * zNorm;
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/z_skin_matrix/func_800A8030.s")
+    mf->xx = (1.0f - (yyNorm + zzNorm));
+    mf->xy = (xyNorm + wzNorm);
+    mf->xz = (xzNorm - wyNorm);
+    mf->xw = 0.0f;
+    mf->yx = (xyNorm - wzNorm);
+    mf->yy = (1.0f - (xxNorm + zzNorm));
+    mf->yz = (yzNorm + wxNorm);
+    mf->yw = 0.0f;
+    mf->zx = (yzNorm + wyNorm);
+    mf->zy = (yzNorm - wxNorm);
+    mf->zz = (1.0f - (xxNorm + yyNorm));
+    mf->zw = 0.0f;
+    mf->wx = 0.0f;
+    mf->wy = 0.0f;
+    mf->ww = 1.0f;
+    mf->wz = 0.0f;
+}