Interpolate guScale, guRotate, SetTextMatrix

9 files changed, 146 insertions, 35 deletions

diff --git a/src/code_800AF9B0.c b/src/code_800AF9B0.c
index 9876a40cb..855f2808e 100644
--- a/src/code_800AF9B0.c
+++ b/src/code_800AF9B0.c
@@ -170,41 +170,37 @@ void func_800AFF58(Vtx* arg0) {
     }
 }
 
-#ifdef NON_MATCHING
-// Credit to SpazzyLemon for the updated and better attempt
 void func_800B0004(void) {
-    Vtx* vtxs;
-    s32 res1, res2;
-    UNUSED u32 pad[0x5];
-    s32 i, j;
-
+    Vtx *vtxs;
+    s32 res1;
+    s32 res2;
+    UNUSED u32 pad[0x4];
+    s32 i;
+    s32 j;
+    s32 k;
+    s16 idx;
+    idx = 4;
     gSPLight(gDisplayListHead++, VIRTUAL_TO_PHYSICAL2(&D_800E8680.l[0]), LIGHT_1);
     gSPLight(gDisplayListHead++, VIRTUAL_TO_PHYSICAL2(&D_800E8680.a), LIGHT_2);
     gSPNumLights(gDisplayListHead++, NUMLIGHTS_1);
     gSPSetGeometryMode(gDisplayListHead++, G_SHADE | G_SHADING_SMOOTH);
-    gDPSetCombineLERP(gDisplayListHead++, PRIMITIVE, 0, SHADE, 0, 0, 0, 0, SHADE, PRIMITIVE, 0, SHADE, 0, 0, 0, 0,
-                      SHADE);
+    gDPSetCombineLERP(gDisplayListHead++, PRIMITIVE, 0, SHADE, 0, 0, 0, 0, SHADE, PRIMITIVE, 0, SHADE, 0, 0, 0, 0, SHADE);
     gSPClearGeometryMode(gDisplayListHead++, G_CULL_BACK);
     gSPSetGeometryMode(gDisplayListHead++, G_LIGHTING);
-
-    vtxs = D_8018EDB4 % 2 ? D_8018EDB8 : D_8018EDBC;
+    vtxs = (D_8018EDB4 % 2) ? (D_8018EDB8) : (D_8018EDBC);
     D_8018EDB2 = 0x9C0;
     for (i = 0; i < 10; i++) {
-        for (j = 0; j < 12; j++) {
-            res1 = sins(D_8018EDB0 - (j * D_8018EDB2)) * 84.0f * j * 0.18f;
-            res2 = sins(D_8018EDB0 - ((j + 1) * D_8018EDB2)) * 84.0f * (j + 1) * 0.18f;
-            func_800AF9E4(&vtxs[j * 4 + i * 48], j, i, 84, res1, res2, (j * 84), 84);
+        for (k = 0, j = 0; j < 12; j++, k += 84) {
+        res1 = ((sins(D_8018EDB0 - (j * D_8018EDB2)) * 84.0f) * j) * 0.18f;
+        res2 = ((sins(D_8018EDB0 - ((j + 1) * D_8018EDB2)) * 84.0f) * (j + 1)) * 0.18f;
+        func_800AF9E4(&(&vtxs[j * idx])[i * 48], j, i, 84, res1, res2, k, 84);
         }
     }
+
     func_800AFF58(vtxs);
-    if (gTickVisuals) {
-        D_8018EDB0 += D_8018EDB2;
-        ++D_8018EDB4;
-    }
+    D_8018EDB0 += D_8018EDB2;
+    ++D_8018EDB4;
     gSPSetGeometryMode(gDisplayListHead++, G_CULL_BACK);
     gSPNumLights(gDisplayListHead++, NUMLIGHTS_1);
     gSPClearGeometryMode(gDisplayListHead++, G_LIGHTING);
 }
-#else
-GLOBAL_ASM("asm/non_matchings/code_800AF9B0/func_800B0004.s")
-#endif
diff --git a/src/engine/Matrix.cpp b/src/engine/Matrix.cpp
index e01df8954..2586d1614 100644
--- a/src/engine/Matrix.cpp
+++ b/src/engine/Matrix.cpp
@@ -35,8 +35,8 @@ void AddMatrixFixed(std::vector<Mtx>& stack, s32 flags) {
 }
 
 // Used in func_80095BD0
-Mtx* SetTextMatrix(f32 arg1, f32 arg2, f32 arg3, f32 arg4) {
-    Mat4 matrix;
+Mtx* SetTextMatrix(Mat4 matrix, f32 x, f32 y, f32 arg3, f32 arg4) {
+    FrameInterpolation_Record_SetTextMatrix((Mat4*)&matrix, x, y, arg3, arg4);
     matrix[0][0] = arg3;
     matrix[0][1] = 0.0f;
     matrix[0][2] = 0.0f;
@@ -49,11 +49,12 @@ Mtx* SetTextMatrix(f32 arg1, f32 arg2, f32 arg3, f32 arg4) {
     matrix[2][1] = 0.0f;
     matrix[2][2] = 1.0f;
     matrix[2][3] = 0.0f;
-    matrix[3][0] = arg1;
-    matrix[3][1] = arg2;
+    matrix[3][0] = x;
+    matrix[3][1] = y;
     matrix[3][2] = 0.0f;
     matrix[3][3] = 1.0f;
     Mtx* mtx = GetMatrix(gWorldInstance.Mtx.Effects);
+    FrameInterpolation_RecordMatrixMtxFToMtx((MtxF*)mtx, &stack.back());
     guMtxF2L(matrix, mtx);
 
     return mtx;
@@ -177,6 +178,10 @@ extern "C" {
         return GetMatrix(gWorldInstance.Mtx.Effects);
     }
 
+    Mtx* GetObjectMatrix(void) {
+        return GetMatrix(gWorldInstance.Mtx.Objects);
+    }
+
 
     /**
      * Note that the game doesn't seem to clear all of these at the beginning of a new frame.
diff --git a/src/engine/Matrix.h b/src/engine/Matrix.h
index 180ebfb16..cada8c267 100644
--- a/src/engine/Matrix.h
+++ b/src/engine/Matrix.h
@@ -17,8 +17,9 @@ void AddObjectMatrix(Mat4 mtx, s32 flags);
 void AddEffectMatrix(Mat4 mtx, s32 flags);
 void AddEffectMatrixOrtho(void);
 void AddEffectMatrixFixed(s32 flags);
-Mtx* SetTextMatrix(f32 arg1, f32 arg2, f32 arg3, f32 arg4);
+Mtx* SetTextMatrix(Mat4 mtx, f32 x, f32 y, f32 arg3, f32 arg4);
 Mtx* GetEffectMatrix(void);
+Mtx* GetObjectMatrix(void);
 void ClearHudMatrixPool(void);
 void ClearEffectsMatrixPool(void);
 void ClearObjectsMatrixPool(void);
diff --git a/src/menu_items.c b/src/menu_items.c
index d65e4b2a4..c0ca438a5 100644
--- a/src/menu_items.c
+++ b/src/menu_items.c
@@ -2216,18 +2216,23 @@ void func_800942D0(void) {
     s32 i;
     s32 alpha;
 
+//    FrameInterpolation_RecordOpenChild("logo", 0);
     gSPMatrix(gDisplayListHead++, &gGfxPool->mtxScreen, G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_PROJECTION);
     gSPMatrix(gDisplayListHead++, &gGfxPool->mtxLookAt[0], G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
     guRotate(mtx, gIntroModelRotX, 1.0f, 0.0f, 0.0f);
     guRotate(mtx + 1, gIntroModelRotY, 0.0f, 1.0f, 0.0f);
     guScale(mtx + 2, 1.0f, 1.0f, gIntroModelScale);
+//    FrameInterpolation_RecordMatrixToMtx(mtx);
     gSPMatrix(gDisplayListHead++, mtx++, G_MTX_NOPUSH | G_MTX_MUL | G_MTX_MODELVIEW);
+//    FrameInterpolation_RecordMatrixToMtx(mtx);
     gSPMatrix(gDisplayListHead++, mtx++, G_MTX_NOPUSH | G_MTX_MUL | G_MTX_MODELVIEW);
+//    FrameInterpolation_RecordMatrixToMtx(mtx);
     gSPMatrix(gDisplayListHead++, mtx++, G_MTX_PUSH | G_MTX_MUL | G_MTX_MODELVIEW);
     gDPSetRenderMode(gDisplayListHead++, G_RM_AA_ZB_OPA_SURF, G_RM_AA_ZB_OPA_SURF2);
     gDPSetEnvColor(gDisplayListHead++, 0x00, 0x00, 0x00, 0x00);
     gSPDisplayList(gDisplayListHead++, D_02007F60);
     gSPPopMatrix(gDisplayListHead++, G_MTX_MODELVIEW);
+//    FrameInterpolation_RecordCloseChild();
 
     if (sIntroModelMotionSpeed > 0) {
         introModelSpeed = sIntroModelSpeed;
@@ -2236,21 +2241,27 @@ void func_800942D0(void) {
         }
 
         for (i = 0, alpha = 192; i < 12; i++, alpha -= 16) {
+//            FrameInterpolation_RecordOpenChild("logo", i + 1);
             guRotate(mtx, 0.0f, 1.0f, 0.0f, 0.0f);
             guRotate(mtx + 1, (i + 1) * sIntroModelMotionSpeed * introModelSpeed, 0.0f, 1.0f, 0.0f);
             guScale(mtx + 2, 1.0f, 1.0f, 2.0f);
+//            FrameInterpolation_RecordMatrixToMtx(mtx);
             gSPMatrix(gDisplayListHead++, mtx++, G_MTX_PUSH | G_MTX_MUL | G_MTX_MODELVIEW);
+//            FrameInterpolation_RecordMatrixToMtx(mtx);
             gSPMatrix(gDisplayListHead++, mtx++, G_MTX_NOPUSH | G_MTX_MUL | G_MTX_MODELVIEW);
+//            FrameInterpolation_RecordMatrixToMtx(mtx);
             gSPMatrix(gDisplayListHead++, mtx++, G_MTX_NOPUSH | G_MTX_MUL | G_MTX_MODELVIEW);
             gDPSetRenderMode(gDisplayListHead++, G_RM_AA_ZB_XLU_SURF, G_RM_AA_ZB_XLU_SURF2);
             gDPSetEnvColor(gDisplayListHead++, 0x00, 0x00, 0x00, alpha);
             gSPDisplayList(gDisplayListHead++, startup_texture_dl4);
             gSPPopMatrix(gDisplayListHead++, G_MTX_MODELVIEW);
+
+//            FrameInterpolation_RecordCloseChild();
         }
     }
 }
 
-void func_80094660(struct GfxPool* arg0, UNUSED s32 arg1) {
+void setup_intro_camera(struct GfxPool* arg0, UNUSED s32 arg1) {
     u16 perspNorm;
 
     move_segment_table_to_dmem();
@@ -2267,6 +2278,7 @@ void func_80094660(struct GfxPool* arg0, UNUSED s32 arg1) {
 void render_checkered_flag(struct GfxPool* arg0, UNUSED s32 arg1) {
     u16 perspNorm;
 
+    FrameInterpolation_RecordOpenChild("start_flag", 0);
     move_segment_table_to_dmem();
     guPerspective(&arg0->mtxPersp[0], &perspNorm, 45.0f, 1.3333334f, 100.0f, 12800.0f, 1.0f);
     gSPPerspNormalize(gDisplayListHead++, perspNorm);
@@ -2276,16 +2288,24 @@ void render_checkered_flag(struct GfxPool* arg0, UNUSED s32 arg1) {
     guRotate(&arg0->mtxObject[2], gIntroModelRotZ, 0, 0, 1.0f);
     guScale(&arg0->mtxObject[3], gIntroModelScale, gIntroModelScale, gIntroModelScale);
     guTranslate(&arg0->mtxObject[4], gIntroModelPosX, gIntroModelPosY, gIntroModelPosZ);
+    FrameInterpolation_RecordMatrixToMtx(arg0->mtxPersp[0]);
     gSPMatrix(gDisplayListHead++, &arg0->mtxPersp[0], G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_PROJECTION);
+    FrameInterpolation_RecordMatrixToMtx(arg0->mtxLookAt[1]);
     gSPMatrix(gDisplayListHead++, &arg0->mtxLookAt[1], G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
+    FrameInterpolation_RecordMatrixToMtx(arg0->mtxObject[0]);
     gSPMatrix(gDisplayListHead++, &arg0->mtxObject[0], G_MTX_NOPUSH | G_MTX_MUL | G_MTX_MODELVIEW);
+    FrameInterpolation_RecordMatrixToMtx(arg0->mtxObject[1]);
     gSPMatrix(gDisplayListHead++, &arg0->mtxObject[1], G_MTX_NOPUSH | G_MTX_MUL | G_MTX_MODELVIEW);
+    FrameInterpolation_RecordMatrixToMtx(arg0->mtxObject[2]);
     gSPMatrix(gDisplayListHead++, &arg0->mtxObject[2], G_MTX_NOPUSH | G_MTX_MUL | G_MTX_MODELVIEW);
+    FrameInterpolation_RecordMatrixToMtx(arg0->mtxObject[3]);
     gSPMatrix(gDisplayListHead++, &arg0->mtxObject[3], G_MTX_NOPUSH | G_MTX_MUL | G_MTX_MODELVIEW);
+    FrameInterpolation_RecordMatrixToMtx(arg0->mtxObject[4]);
     gSPMatrix(gDisplayListHead++, &arg0->mtxObject[4], G_MTX_NOPUSH | G_MTX_MUL | G_MTX_MODELVIEW);
     gSPDisplayList(gDisplayListHead++, D_02007FC8);
     func_800B0004();
     gSPDisplayList(gDisplayListHead++, D_02007650);
+    FrameInterpolation_RecordCloseChild();
 }
 
 void func_80094A64(struct GfxPool* pool) {
@@ -2706,7 +2726,7 @@ void func_80095AE0(MTX_TYPE* arg0, f32 arg1, f32 arg2, f32 arg3, f32 arg4) {
 
 #undef MTX_TYPE
 
-Gfx* func_80095BD0(Gfx* displayListHead, u8* arg1, f32 arg2, f32 arg3, u32 arg4, u32 arg5, f32 arg6, f32 arg7) {
+Gfx* func_80095BD0(Gfx* displayListHead, u8* arg1, f32 x, f32 y, u32 arg4, u32 arg5, f32 arg6, f32 arg7) {
     Vtx* var_a1;
     // A match is a match, but why are goto's required here?
     if (gMatrixEffectCount >= 0x2F7) {
@@ -2717,7 +2737,10 @@ Gfx* func_80095BD0(Gfx* displayListHead, u8* arg1, f32 arg2, f32 arg3, u32 arg4,
         rmonPrintf("effectcount < 0 !!!!!!(kawano)\n");
     }
     // func_80095AE0(&gGfxPool->mtxEffect[gMatrixEffectCount], arg2, arg3, arg6, arg7);
-    Mtx* mtx = SetTextMatrix(arg2, arg3, arg6, arg7);
+
+    FrameInterpolation_RecordOpenChild("flashing_text", ((s32)x) | ((s32)y) | arg4 | arg5);
+    Mat4 matrix;
+    Mtx* mtx = SetTextMatrix(matrix, x, y, arg6, arg7);
     gSPMatrix(displayListHead++, mtx, G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
     gMKLoadTextureTile_4b(displayListHead++, arg1, G_IM_FMT_I, arg4, 0, 0, 0, arg4, arg5, 0, G_TX_NOMIRROR | G_TX_WRAP,
                           G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOMASK, G_TX_NOLOD, G_TX_NOLOD);
@@ -2735,8 +2758,9 @@ Gfx* func_80095BD0(Gfx* displayListHead, u8* arg1, f32 arg2, f32 arg3, u32 arg4,
             var_a1 = D_02007DF8;
             break;
     }
-
-    return func_800959F8(displayListHead, var_a1);
+    Gfx* gfx = func_800959F8(displayListHead, var_a1);
+    FrameInterpolation_RecordCloseChild();
+    return gfx;
 }
 
 Gfx* func_80095BD0_wide_right(Gfx* displayListHead, u8* arg1, f32 arg2, f32 arg3, u32 arg4, u32 arg5, f32 arg6,
@@ -5985,7 +6009,7 @@ void render_menus(MenuItem* arg0) {
                 HM_DrawIntro();
                 break;
             case MENU_ITEM_UI_LOGO_INTRO:
-                func_80094660(gGfxPool, arg0->param1);
+                setup_intro_camera(gGfxPool, arg0->param1);
                 break;
             case START_MENU_FLAG:
                 render_checkered_flag(gGfxPool, arg0->param1);
diff --git a/src/menu_items.h b/src/menu_items.h
index 39de188eb..9f6a28e06 100644
--- a/src/menu_items.h
+++ b/src/menu_items.h
@@ -392,7 +392,7 @@ void func_80093E60(void);
 void func_80093F10(void);
 void func_800940EC(s32);
 void func_800942D0(void);
-void func_80094660(struct GfxPool*, s32);
+void setup_intro_camera(struct GfxPool*, s32);
 void render_checkered_flag(struct GfxPool*, s32);
 void func_80094A64(struct GfxPool*);
 void setup_menus(void);
diff --git a/src/os/guRotateF.c b/src/os/guRotateF.c
index aaebf6cfe..0bdfad841 100644
--- a/src/os/guRotateF.c
+++ b/src/os/guRotateF.c
@@ -1,4 +1,5 @@
 #include "libultra_internal.h"
+#include "port/interpolation/FrameInterpolation.h"
 
 void guRotateF(float m[4][4], float a, float x, float y, float z) {
     float sin_a;
@@ -38,5 +39,7 @@ void guRotateF(float m[4][4], float a, float x, float y, float z) {
 void guRotate(Mtx* m, float a, float x, float y, float z) {
     float mf[4][4];
     guRotateF(mf, a, x, y, z);
+    FrameInterpolation_Record_guRotate(mf, a, x, y, z);
+    FrameInterpolation_RecordMatrixMtxFToMtx(mf, m);
     guMtxF2L(mf, m);
 }
diff --git a/src/os/guScaleF.c b/src/os/guScaleF.c
index 51ee2ac8f..51aa4dfa4 100644
--- a/src/os/guScaleF.c
+++ b/src/os/guScaleF.c
@@ -1,4 +1,5 @@
 #include "libultra_internal.h"
+#include "port/interpolation/FrameInterpolation.h"
 
 void guScaleF(float mf[4][4], float x, float y, float z) {
     guMtxIdentF(mf);
@@ -11,5 +12,7 @@ void guScaleF(float mf[4][4], float x, float y, float z) {
 void guScale(Mtx* m, float x, float y, float z) {
     float mf[4][4];
     guScaleF(mf, x, y, z);
+    FrameInterpolation_Record_guScale(mf, x, y, z);
+    FrameInterpolation_RecordMatrixMtxFToMtx(mf, m);
     guMtxF2L(mf, m);
 }
diff --git a/src/port/interpolation/FrameInterpolation.cpp b/src/port/interpolation/FrameInterpolation.cpp
index 836e6c70c..c1f4a67b6 100644
--- a/src/port/interpolation/FrameInterpolation.cpp
+++ b/src/port/interpolation/FrameInterpolation.cpp
@@ -7,6 +7,7 @@
 #include "port/Engine.h"
 #include "FrameInterpolation.h"
 #include "matrix.h"
+#include "src/engine/Matrix.h"
 
 extern "C" {
 #include "math_util.h"
@@ -81,7 +82,10 @@ enum class Op {
     SkinMatrixMtxFToMtx,
     SetTransformMatrix,
     SetMatrixTransformation,
-    SetTranslateRotate
+    SetTranslateRotate,
+    guRotate,
+    guScale,
+    SetTextMatrix,
 };
 
 typedef pair<const void*, uintptr_t> label;
@@ -117,6 +121,29 @@ union Data {
 
     struct {
         Mat4* matrix;
+        f32 a;
+        f32 x;
+        f32 y;
+        f32 z;
+    } matrix_gu_rotate;
+
+    struct {
+        Mat4* matrix;
+        f32 x;
+        f32 y;
+        f32 z;
+    } matrix_scale_xyz;
+
+    struct {
+        Mat4* matrix;
+        f32 x;
+        f32 y;
+        f32 arg3;
+        f32 arg4;
+    } matrix_text;
+
+    struct {
+        Mat4* matrix;
         u32 coord;
         s16 value;
     } matrix_rotate_1_coord;
@@ -249,6 +276,7 @@ MtxF* Matrix_GetCurrent() {
 struct InterpolateCtx {
     float step;
     float w;
+    float tmp_f;
     unordered_map<Mtx*, MtxF> mtx_replacements;
     MtxF tmp_mtxf, tmp_mtxf2;
     Mat3 tmp_mat3;
@@ -533,6 +561,33 @@ struct InterpolateCtx {
                             mtxf_translate_rotate(*gInterpolationMatrix, tmp_vec3f, tmp_vec3s);
                             break;
                         }
+                        case Op::guRotate: {
+                            tmp_f = lerp(old_op.matrix_gu_rotate.a, new_op.matrix_gu_rotate.a);
+
+                            tmp_vec3f[0] = lerp(old_op.matrix_gu_rotate.x, new_op.matrix_gu_rotate.x);
+                            tmp_vec3f[1] = lerp(old_op.matrix_gu_rotate.y, new_op.matrix_gu_rotate.y);
+                            tmp_vec3f[2] = lerp(old_op.matrix_gu_rotate.z, new_op.matrix_gu_rotate.z);
+
+                            guRotateF(*gInterpolationMatrix, tmp_f, tmp_vec3f[0], tmp_vec3f[1], tmp_vec3f[2]);
+                            break;
+                        }
+                        case Op::guScale: {
+                            tmp_vec3f[0] = lerp(old_op.matrix_scale_xyz.x, new_op.matrix_scale_xyz.x);
+                            tmp_vec3f[1] = lerp(old_op.matrix_scale_xyz.y, new_op.matrix_scale_xyz.y);
+                            tmp_vec3f[2] = lerp(old_op.matrix_scale_xyz.z, new_op.matrix_scale_xyz.z);
+                            guScaleF(*gInterpolationMatrix, tmp_vec3f[0], tmp_vec3f[1], tmp_vec3f[2]);
+                            break;
+                        }
+                        case Op::SetTextMatrix: {
+
+                            tmp_vec3f[0] = lerp(old_op.matrix_text.x, new_op.matrix_text.x);
+                            tmp_vec3f[1] = lerp(old_op.matrix_text.y, new_op.matrix_text.y);
+                            tmp_vec3f[2] = lerp(old_op.matrix_text.arg3, new_op.matrix_text.arg3);
+                            tmp_f = lerp(old_op.matrix_text.arg4, new_op.matrix_text.arg4);
+
+                            SetTextMatrix(*gInterpolationMatrix, tmp_vec3f[0], tmp_vec3f[1], tmp_vec3f[2], tmp_f);
+                            break;
+                        }
                     }
                 }
             }
@@ -656,6 +711,24 @@ void FrameInterpolation_RecordMatrixScale(Mat4* matrix, f32 scale) {
     append(Op::MatrixScale).matrix_scale = { matrix, scale };
 }
 
+void FrameInterpolation_Record_guRotate(Mat4* matrix, f32 a, f32 x, f32 y, f32 z) {
+    if (!is_recording)
+        return;
+    append(Op::guRotate).matrix_gu_rotate = {matrix, a, x, y, z};
+}
+
+void FrameInterpolation_Record_guScale(Mat4* matrix, f32 x, f32 y, f32 z) {
+    if (!is_recording)
+        return;
+    append(Op::guScale).matrix_scale_xyz = {matrix, x, y, z};
+}
+
+void FrameInterpolation_Record_SetTextMatrix(Mat4* matrix, f32 x, f32 y, f32 arg3, f32 arg4) {
+    if (!is_recording)
+        return;
+    append(Op::SetTextMatrix).matrix_text = {matrix, x, y, arg3, arg4};
+}
+
 void FrameInterpolation_RecordMatrixMultVec3fNoTranslate(Mat4* matrix, Vec3f src, Vec3f dest) {
     if (!is_recording)
         return;
diff --git a/src/port/interpolation/FrameInterpolation.h b/src/port/interpolation/FrameInterpolation.h
index c59743681..742dec470 100644
--- a/src/port/interpolation/FrameInterpolation.h
+++ b/src/port/interpolation/FrameInterpolation.h
@@ -51,6 +51,12 @@ void FrameInterpolation_RecordMatrixTranslate(Mat4* matrix, Vec3f b);
 
 void FrameInterpolation_RecordMatrixScale(Mat4* matrix, f32 scale);
 
+void FrameInterpolation_Record_guRotate(Mat4* matrix, f32 a, f32 x, f32 y, f32 z);
+
+void FrameInterpolation_Record_guScale(Mat4* matrix, f32 x, f32 y, f32 z);
+
+void FrameInterpolation_Record_SetTextMatrix(Mat4* matrix, f32 x, f32 y, f32 arg3, f32 arg4);
+
 void FrameInterpolation_RecordMatrixRotate1Coord(Mat4* matrix, u32 coord, s16 value);
 
 void FrameInterpolation_RecordMatrixMtxFToMtx(MtxF* src, Mtx* dest);