summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--src/actors/mario_sign/render.inc.c5
-rw-r--r--src/actors/mario_sign/update.inc.c4
-rw-r--r--src/engine/Matrix.cpp2
-rw-r--r--src/enhancements/collision_viewer.c2
-rw-r--r--src/gbiMacro.c2
-rw-r--r--src/port/interpolation/FrameInterpolation.cpp86
-rw-r--r--src/port/interpolation/FrameInterpolation.h14
-rw-r--r--src/port/interpolation/matrix.c450
-rw-r--r--src/port/interpolation/matrix.h94
-rw-r--r--src/racing/framebuffer_effects.c4
-rw-r--r--src/racing/math_util.c11
-rw-r--r--src/racing/math_util.h10
-rw-r--r--src/racing/skybox_and_splitscreen.c12
13 files changed, 652 insertions, 44 deletions
diff --git a/src/actors/mario_sign/render.inc.c b/src/actors/mario_sign/render.inc.c
index 1c72c8394..7914a283f 100644
--- a/src/actors/mario_sign/render.inc.c
+++ b/src/actors/mario_sign/render.inc.c
@@ -14,7 +14,7 @@ void render_actor_mario_sign(Camera* arg0, UNUSED Mat4 arg1, struct Actor* arg2)
Mat4 sp40;
f32 unk;
s16 temp = arg2->flags;
-
+ FrameInterpolation_RecordOpenChild(arg2, 0);
if (temp & 0x800) {
return;
}
@@ -31,4 +31,7 @@ void render_actor_mario_sign(Camera* arg0, UNUSED Mat4 arg1, struct Actor* arg2)
gSPDisplayList(gDisplayListHead++, d_course_mario_raceway_dl_sign);
}
}
+
+ FrameInterpolation_RecordCloseChild();
+
}
diff --git a/src/actors/mario_sign/update.inc.c b/src/actors/mario_sign/update.inc.c
index 6a061eddd..7a85e8ac5 100644
--- a/src/actors/mario_sign/update.inc.c
+++ b/src/actors/mario_sign/update.inc.c
@@ -11,10 +11,10 @@ void update_actor_mario_sign(struct Actor* arg0) {
arg0->pos[1] += 4.0f;
if (arg0->pos[1] > 800.0f) {
arg0->flags |= 0x800;
- arg0->rot[1] += 1820;
+ arg0->rot[1] += 4;
}
} else {
- arg0->rot[1] += 182;
+ arg0->rot[1] += 4;
}
}
}
diff --git a/src/engine/Matrix.cpp b/src/engine/Matrix.cpp
index 1f2301258..44e5f081d 100644
--- a/src/engine/Matrix.cpp
+++ b/src/engine/Matrix.cpp
@@ -1,6 +1,7 @@
#include <libultraship.h>
#include <libultra/gbi.h>
#include "engine/World.h"
+#include "src/port/interpolation/FrameInterpolation.h"
extern "C" {
#include "common_structs.h"
@@ -16,6 +17,7 @@ void AddMatrix(std::vector<Mtx>& stack, Mat4 mtx, s32 flags) {
stack.emplace_back();
// Convert to a fixed-point matrix
+ FrameInterpolation_RecordMatrixMtxFToMtx((MtxF*)mtx, &stack.back());
guMtxF2L(mtx, &stack.back());
// Load the matrix
diff --git a/src/enhancements/collision_viewer.c b/src/enhancements/collision_viewer.c
index fd7c542e0..f45a9872f 100644
--- a/src/enhancements/collision_viewer.c
+++ b/src/enhancements/collision_viewer.c
@@ -4,6 +4,8 @@
#include "code_800029B0.h"
#include "mk64.h"
#include "main.h"
+#include <port/interpolation/FrameInterpolation.h>
+#include <port/interpolation/matrix.h>
#include "collision_viewer.h"
#include "math_util.h"
diff --git a/src/gbiMacro.c b/src/gbiMacro.c
index 5fa0ab171..007d7d281 100644
--- a/src/gbiMacro.c
+++ b/src/gbiMacro.c
@@ -18,5 +18,5 @@ UNUSED void gfx_func_80040D00(void) {
guOrtho(&gGfxPool->mtxScreen, 0.0f, SCREEN_WIDTH, 0.0f, SCREEN_HEIGHT, -1.0f, 1.0f, 1.0f);
gSPPerspNormalize(gDisplayListHead++, 0xFFFF);
gSPMatrix(gDisplayListHead++, VIRTUAL_TO_PHYSICAL(gGfxPool), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_PROJECTION);
- gSPMatrix(gDisplayListHead++, VIRTUAL_TO_PHYSICAL(&gIdentityMatrix), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
+ //gSPMatrix(gDisplayListHead++, VIRTUAL_TO_PHYSICAL(&gIdentityMatrix), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
}
diff --git a/src/port/interpolation/FrameInterpolation.cpp b/src/port/interpolation/FrameInterpolation.cpp
index 12b57f4a9..9064cdb04 100644
--- a/src/port/interpolation/FrameInterpolation.cpp
+++ b/src/port/interpolation/FrameInterpolation.cpp
@@ -8,6 +8,7 @@
#include <math_util.h>
#include <math_util_2.h>
#include "FrameInterpolation.h"
+#include "matrix.h"
/*
Frame interpolation.
@@ -59,6 +60,8 @@ enum class Op {
MatrixTranslate,
MatrixScale,
MatrixRotate1Coord,
+ MatrixMult4x4,
+ MatrixPosRotXYZ,
MatrixMultVec3fNoTranslate,
MatrixMultVec3f,
MatrixMtxFToMtx,
@@ -90,14 +93,13 @@ union Data {
struct {
Mat4* matrix;
- Vec3f b;
+ Vec3fInterp b;
} matrix_translate, matrix_scale;
struct {
Mat4* matrix;
u32 coord;
- f32 value;
- u8 mode;
+ s16 value;
} matrix_rotate_1_coord;
struct {
@@ -113,6 +115,17 @@ union Data {
} matrix_vec_no_translate;
struct {
+ Mat4* dest;
+ Mat4 mtx1;
+ Mat4 mtx2;
+ } matrix_mult_4x4;
+
+ struct {
+ Vec3fInterp pos;
+ Vec3sInterp orientation;
+ } matrix_pos_rot_xyz;
+
+ struct {
Mat4* matrix;
Vec3f translation;
Vec3s rotation;
@@ -215,6 +228,10 @@ struct InterpolateCtx {
return w * o + step * n;
}
+ s16 lerp_s16(s16 o, s16 n) {
+ return w * o + step * n;
+ }
+
void lerp_vec3f(Vec3f* res, Vec3f* o, Vec3f* n) {
*res[0] = lerp(*o[0], *n[0]);
*res[1] = lerp(*o[1], *n[1]);
@@ -332,20 +349,29 @@ struct InterpolateCtx {
break;
case Op::MatrixTranslate:
- // Matrix_Translate(gInterpolationMatrix, lerp(old_op.matrix_translate.x,
- // new_op.matrix_translate.x),
- // lerp(old_op.matrix_translate.y, new_op.matrix_translate.y),
- // lerp(old_op.matrix_translate.z, new_op.matrix_translate.z),
- // new_op.matrix_translate.mode);
Vec3f temp;
- temp[0] = lerp(old_op.matrix_translate.b[0], new_op.matrix_translate.b[0]);
- temp[1] = lerp(old_op.matrix_translate.b[1], new_op.matrix_translate.b[1]);
- temp[2] = lerp(old_op.matrix_translate.b[2], new_op.matrix_translate.b[2]);
+ temp[0] = lerp(old_op.matrix_translate.b.x, new_op.matrix_translate.b.x);
+ temp[1] = lerp(old_op.matrix_translate.b.y, new_op.matrix_translate.b.y);
+ temp[2] = lerp(old_op.matrix_translate.b.z, new_op.matrix_translate.b.z);
mtxf_translate(*gInterpolationMatrix, temp);
break;
+ case Op::MatrixPosRotXYZ:
+ Vec3f tempF;
+ Vec3s tempS;
+
+ tempF[0] = lerp(old_op.matrix_pos_rot_xyz.pos.x, new_op.matrix_pos_rot_xyz.pos.x);
+ tempF[1] = lerp(old_op.matrix_pos_rot_xyz.pos.y, new_op.matrix_pos_rot_xyz.pos.y);
+ tempF[2] = lerp(old_op.matrix_pos_rot_xyz.pos.z, new_op.matrix_pos_rot_xyz.pos.z);
+
+ tempS[0] = lerp(old_op.matrix_pos_rot_xyz.orientation.x, new_op.matrix_pos_rot_xyz.orientation.x);
+ tempS[1] = lerp(old_op.matrix_pos_rot_xyz.orientation.y, new_op.matrix_pos_rot_xyz.orientation.y);
+ tempS[2] = lerp(old_op.matrix_pos_rot_xyz.orientation.z, new_op.matrix_pos_rot_xyz.orientation.z);
+
+ mtxf_pos_rotation_xyz(*gInterpolationMatrix, tempF, tempS);
+ break;
case Op::MatrixScale:
// Matrix_Scale(gInterpolationMatrix, lerp(old_op.matrix_scale.x, new_op.matrix_scale.x),
@@ -355,20 +381,19 @@ struct InterpolateCtx {
break;
case Op::MatrixRotate1Coord: {
- float v = interpolate_angle(old_op.matrix_rotate_1_coord.value,
+ s16 v = interpolate_angle(old_op.matrix_rotate_1_coord.value,
new_op.matrix_rotate_1_coord.value);
- u8 mode = new_op.matrix_rotate_1_coord.mode;
switch (new_op.matrix_rotate_1_coord.coord) {
case 0:
- // Matrix_RotateX(gInterpolationMatrix, v, mode);
+ mtxf_rotate_x(*gInterpolationMatrix, v);
break;
case 1:
- // Matrix_RotateY(gInterpolationMatrix, v, mode);
+ mtxf_rotate_y(*gInterpolationMatrix, v);
break;
case 2:
- // Matrix_RotateZ(gInterpolationMatrix, v, mode);
+ mtxf_s16_rotate_z(*gInterpolationMatrix, v);
break;
}
break;
@@ -445,12 +470,12 @@ void FrameInterpolation_StartRecord(void) {
current_recording = {};
current_path.clear();
current_path.push_back(&current_recording.root_path);
- if (!camera_interpolation) {
- // default to interpolating
- camera_interpolation = true;
- is_recording = false;
- return;
- }
+ // if (!camera_interpolation) {
+ // // default to interpolating
+ // camera_interpolation = true;
+ // is_recording = false;
+ // return;
+ // }
if (GameEngine::GetInterpolationFPS() != 20) {
is_recording = true;
}
@@ -530,7 +555,7 @@ void FrameInterpolation_RecordMatrixTranslate(Mat4* matrix, Vec3f b) {
if (!is_recording)
return;
- append(Op::MatrixTranslate).matrix_translate = { matrix, b[0] };
+ append(Op::MatrixTranslate).matrix_translate = { matrix, *((Vec3fInterp*) &b) };
}
void FrameInterpolation_RecordMatrixScale(Mat4* matrix, f32 x, f32 y, f32 z, u8 mode) {
@@ -542,7 +567,16 @@ void FrameInterpolation_RecordMatrixScale(Mat4* matrix, f32 x, f32 y, f32 z, u8
void FrameInterpolation_RecordMatrixMultVec3fNoTranslate(Mat4* matrix, Vec3f src, Vec3f dest) {
if (!is_recording)
return;
- // append(Op::MatrixMultVec3fNoTranslate).matrix_vec_no_translate = { matrix, src, dest };
+ //append(Op::MatrixMultVec3fNoTranslate).matrix_vec_no_translate = { matrix, src, dest };
+}
+
+// Make a template for deref
+
+
+void FrameInterpolation_RecordMatrixPosRotXYZ(Mat4 out, Vec3f pos, Vec3s orientation) {
+ if (!is_recording)
+ return;
+ append(Op::MatrixPosRotXYZ).matrix_pos_rot_xyz = { *((Vec3fInterp*) &pos), *((Vec3sInterp*) &orientation) };
}
void FrameInterpolation_RecordMatrixMultVec3f(Mat4* matrix, Vec3f src, Vec3f dest) {
@@ -551,10 +585,10 @@ void FrameInterpolation_RecordMatrixMultVec3f(Mat4* matrix, Vec3f src, Vec3f des
// append(Op::MatrixMultVec3f).matrix_vec_translate = { matrix, src, dest };
}
-void FrameInterpolation_RecordMatrixRotate1Coord(Mat4* matrix, u32 coord, f32 value, u8 mode) {
+void FrameInterpolation_RecordMatrixRotate1Coord(Mat4* matrix, u32 coord, s16 value) {
if (!is_recording)
return;
- append(Op::MatrixRotate1Coord).matrix_rotate_1_coord = { matrix, coord, value, mode };
+ append(Op::MatrixRotate1Coord).matrix_rotate_1_coord = { matrix, coord, value };
}
void FrameInterpolation_RecordMatrixMtxFToMtx(MtxF* src, Mtx* dest) {
diff --git a/src/port/interpolation/FrameInterpolation.h b/src/port/interpolation/FrameInterpolation.h
index 72a1c9146..7d2df76a8 100644
--- a/src/port/interpolation/FrameInterpolation.h
+++ b/src/port/interpolation/FrameInterpolation.h
@@ -1,4 +1,5 @@
-#pragma once
+#ifndef __FRAME_INTERPOLATION_H
+#define __FRAME_INTERPOLATION_H
// #include "sf64math.h"
#include <libultraship.h>
@@ -12,11 +13,8 @@
std::unordered_map<Mtx*, MtxF> FrameInterpolation_Interpolate(float step);
extern "C" {
-
#endif
-
-
void FrameInterpolation_ShouldInterpolateFrame(bool shouldInterpolate);
void FrameInterpolation_StartRecord(void);
@@ -35,6 +33,8 @@ int FrameInterpolation_GetCameraEpoch(void);
void FrameInterpolation_RecordActorPosRotMatrix(void);
+void FrameInterpolation_RecordMatrixPosRotXYZ(Mat4 out, Vec3f pos, Vec3s orientation);
+
//void FrameInterpolation_RecordMatrixPush(Matrix** mtx);
//void FrameInterpolation_RecordMatrixPop(Matrix** mtx);
@@ -45,7 +45,7 @@ void FrameInterpolation_RecordMatrixTranslate(Mat4* matrix, Vec3f b);
//void FrameInterpolation_RecordMatrixScale(Matrix* matrix, f32 x, f32 y, f32 z, u8 mode);
-//void FrameInterpolation_RecordMatrixRotate1Coord(Matrix* matrix, u32 coord, f32 value, u8 mode);
+void FrameInterpolation_RecordMatrixRotate1Coord(Mat4* matrix, u32 coord, s16 value);
void FrameInterpolation_RecordMatrixMtxFToMtx(MtxF* src, Mtx* dest);
@@ -63,4 +63,6 @@ void FrameInterpolation_RecordSkinMatrixMtxFToMtx(MtxF* src, Mtx* dest);
#ifdef __cplusplus
}
-#endif \ No newline at end of file
+#endif
+
+#endif // __FRAME_INTERPOLATION_H \ No newline at end of file
diff --git a/src/port/interpolation/matrix.c b/src/port/interpolation/matrix.c
new file mode 100644
index 000000000..4f8a7839b
--- /dev/null
+++ b/src/port/interpolation/matrix.c
@@ -0,0 +1,450 @@
+#include <libultraship.h>
+#include <math.h>
+#include "matrix.h"
+#include "common_structs.h"
+
+Mtx gIdentityMtx = gdSPDefMtx(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);
+Matrix gIdentityMatrix = { {
+ { 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 },
+} };
+
+Matrix* gGfxMatrix;
+Matrix sGfxMatrixStack[0x20];
+Matrix* gCalcMatrix;
+Matrix sCalcMatrixStack[0x20];
+
+Mtx gMainMatrixStack[0x480];
+Mtx* gGfxMtx;
+
+void Matrix_InitPerspective(Gfx** dList) {
+ u16 norm;
+ float near = 10.0f;
+ float far = 12800.0f;
+ float fov = 45.0f;
+
+ guPerspective(gGfxMtx, &norm, fov, 320.0f / 240.0f, near, far, 1.0f);
+ gSPPerspNormalize((*dList)++, norm);
+ gSPMatrix((*dList)++, gGfxMtx++, G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_PROJECTION);
+ guLookAt(gGfxMtx, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, -12800.0f, 0.0f, 1.0f, 0.0f);
+ gSPMatrix((*dList)++, gGfxMtx++, G_MTX_NOPUSH | G_MTX_MUL | G_MTX_PROJECTION);
+ Matrix_Copy(gGfxMatrix, &gIdentityMatrix);
+}
+
+void Matrix_InitOrtho(Gfx** dList) {
+ FrameInterpolation_RecordOpenChild("ortho", 0);
+ FrameInterpolation_RecordMarker(__FILE__, __LINE__);
+ guOrtho(gGfxMtx, -320.0f / 2, 320.0f / 2, -240.0f / 2, 240.0f / 2, 0.0f, 5.0f, 1.0f);
+ gSPMatrix((*dList)++, gGfxMtx++, G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_PROJECTION);
+ guLookAt(gGfxMtx, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, -12800.0f, 0.0f, 1.0f, 0.0f);
+ gSPMatrix((*dList)++, gGfxMtx++, G_MTX_NOPUSH | G_MTX_MUL | G_MTX_PROJECTION);
+ Matrix_Copy(gGfxMatrix, &gIdentityMatrix);
+ FrameInterpolation_RecordCloseChild();
+}
+
+
+// Copies src Matrix into dst
+void Matrix_Copy(Matrix* dst, Matrix* src) {
+ int32_t i;
+
+ for (i = 0; i < 4; i++) {
+ dst->mf[i][0] = src->mf[i][0];
+ dst->mf[i][1] = src->mf[i][1];
+ dst->mf[i][2] = src->mf[i][2];
+ dst->mf[i][3] = src->mf[i][3];
+ }
+}
+
+// Makes a copy of the stack's current matrix and puts it on the top of the stack
+void Matrix_Push(Matrix** mtxStack) {
+ Matrix_Copy(*mtxStack + 1, *mtxStack);
+ (*mtxStack)++;
+}
+
+// Removes the top matrix of the stack
+void Matrix_Pop(Matrix** mtxStack) {
+ (*mtxStack)--;
+}
+
+// Copies tf into mtx (MTXF_NEW) or applies it to mtx (MTXF_APPLY)
+void Matrix_Mult(Matrix* mtx, Matrix* tf, u8 mode) {
+ f32 rx;
+ f32 ry;
+ f32 rz;
+ f32 rw;
+ s32 i0;
+ s32 i1;
+ s32 i2;
+ s32 i3;
+
+ if (mode == 1) {
+ rx = mtx->mf[0][0];
+ ry = mtx->mf[1][0];
+ rz = mtx->mf[2][0];
+ rw = mtx->mf[3][0];
+
+ for (i0 = 0; i0 < 4; i0++) {
+ mtx->mf[i0][0] = (rx * tf->mf[i0][0]) + (ry * tf->mf[i0][1]) + (rz * tf->mf[i0][2]) + (rw * tf->mf[i0][3]);
+ }
+
+ rx = mtx->mf[0][1];
+ ry = mtx->mf[1][1];
+ rz = mtx->mf[2][1];
+ rw = mtx->mf[3][1];
+
+ for (i1 = 0; i1 < 4; i1++) {
+ mtx->mf[i1][1] = (rx * tf->mf[i1][0]) + (ry * tf->mf[i1][1]) + (rz * tf->mf[i1][2]) + (rw * tf->mf[i1][3]);
+ }
+
+ rx = mtx->mf[0][2];
+ ry = mtx->mf[1][2];
+ rz = mtx->mf[2][2];
+ rw = mtx->mf[3][2];
+
+ for (i2 = 0; i2 < 4; i2++) {
+ mtx->mf[i2][2] = (rx * tf->mf[i2][0]) + (ry * tf->mf[i2][1]) + (rz * tf->mf[i2][2]) + (rw * tf->mf[i2][3]);
+ }
+
+ rx = mtx->mf[0][3];
+ ry = mtx->mf[1][3];
+ rz = mtx->mf[2][3];
+ rw = mtx->mf[3][3];
+
+ for (i3 = 0; i3 < 4; i3++) {
+ mtx->mf[i3][3] = (rx * tf->mf[i3][0]) + (ry * tf->mf[i3][1]) + (rz * tf->mf[i3][2]) + (rw * tf->mf[i3][3]);
+ }
+ } else {
+ Matrix_Copy(mtx, tf);
+ }
+}
+
+// Creates a translation matrix in mtx (MTXF_NEW) or applies one to mtx (MTXF_APPLY)
+void Matrix_Translate(Matrix* mtx, f32 x, f32 y, f32 z, u8 mode) {
+ f32 rx;
+ f32 ry;
+ s32 i;
+
+ if (mode == 1) {
+ for (i = 0; i < 4; i++) {
+ rx = mtx->mf[0][i];
+ ry = mtx->mf[1][i];
+
+ mtx->mf[3][i] += (rx * x) + (ry * y) + (mtx->mf[2][i] * z);
+ }
+ } else {
+ mtx->mf[3][0] = x;
+ mtx->mf[3][1] = y;
+ mtx->mf[3][2] = z;
+ mtx->mf[0][1] = mtx->mf[0][2] = mtx->mf[0][3] = mtx->mf[1][0] = mtx->mf[1][2] = mtx->mf[1][3] = mtx->mf[2][0] =
+ mtx->mf[2][1] = mtx->mf[2][3] = 0.0f;
+ mtx->mf[0][0] = mtx->mf[1][1] = mtx->mf[2][2] = mtx->mf[3][3] = 1.0f;
+ }
+}
+
+// Creates a scale matrix in mtx (MTXF_NEW) or applies one to mtx (MTXF_APPLY)
+void Matrix_Scale(Matrix* mtx, f32 xScale, f32 yScale, f32 zScale, u8 mode) {
+ f32 rx;
+ f32 ry;
+ s32 i;
+
+ if (mode == 1) {
+ for (i = 0; i < 4; i++) {
+ rx = mtx->mf[0][i];
+ ry = mtx->mf[1][i];
+
+ mtx->mf[0][i] = rx * xScale;
+ mtx->mf[1][i] = ry * yScale;
+ mtx->mf[2][i] *= zScale;
+ }
+ } else {
+ mtx->mf[0][0] = xScale;
+ mtx->mf[1][1] = yScale;
+ mtx->mf[2][2] = zScale;
+ mtx->mf[0][1] = mtx->mf[0][2] = mtx->mf[0][3] = mtx->mf[1][0] = mtx->mf[1][2] = mtx->mf[1][3] = mtx->mf[2][0] =
+ mtx->mf[2][1] = mtx->mf[2][3] = mtx->mf[3][0] = mtx->mf[3][1] = mtx->mf[3][2] = 0.0f;
+ mtx->mf[3][3] = 1.0f;
+ }
+}
+
+// Creates rotation matrix about the X axis in mtx (MTXF_NEW) or applies one to mtx (MTXF_APPLY)
+void Matrix_RotateX(Matrix* mtx, f32 angle, u8 mode) {
+ f32 cs;
+ f32 sn;
+ f32 ry;
+ f32 rz;
+ s32 i;
+
+ sn = sinf(angle);
+ cs = cosf(angle);
+ if (mode == 1) {
+ for (i = 0; i < 4; i++) {
+ ry = mtx->mf[1][i];
+ rz = mtx->mf[2][i];
+
+ mtx->mf[1][i] = (ry * cs) + (rz * sn);
+ mtx->mf[2][i] = (rz * cs) - (ry * sn);
+ }
+ } else {
+ mtx->mf[1][1] = mtx->mf[2][2] = cs;
+ mtx->mf[1][2] = sn;
+ mtx->mf[2][1] = -sn;
+ mtx->mf[0][0] = mtx->mf[3][3] = 1.0f;
+ mtx->mf[0][1] = mtx->mf[0][2] = mtx->mf[0][3] = mtx->mf[1][0] = mtx->mf[1][3] = mtx->mf[2][0] = mtx->mf[2][3] =
+ mtx->mf[3][0] = mtx->mf[3][1] = mtx->mf[3][2] = 0.0f;
+ }
+}
+
+// Creates rotation matrix about the Y axis in mtx (MTXF_NEW) or applies one to mtx (MTXF_APPLY)
+void Matrix_RotateY(Matrix* mtx, f32 angle, u8 mode) {
+ f32 cs;
+ f32 sn;
+ f32 rx;
+ f32 rz;
+ s32 i;
+
+ sn = sinf(angle);
+ cs = cosf(angle);
+ if (mode == 1) {
+ for (i = 0; i < 4; i++) {
+ rx = mtx->mf[0][i];
+ rz = mtx->mf[2][i];
+
+ mtx->mf[0][i] = (rx * cs) - (rz * sn);
+ mtx->mf[2][i] = (rx * sn) + (rz * cs);
+ }
+ } else {
+ mtx->mf[0][0] = mtx->mf[2][2] = cs;
+ mtx->mf[0][2] = -sn;
+ mtx->mf[2][0] = sn;
+ mtx->mf[1][1] = mtx->mf[3][3] = 1.0f;
+ mtx->mf[0][1] = mtx->mf[0][3] = mtx->mf[1][0] = mtx->mf[1][2] = mtx->mf[1][3] = mtx->mf[2][1] = mtx->mf[2][3] =
+ mtx->mf[3][0] = mtx->mf[3][1] = mtx->mf[3][2] = 0.0f;
+ }
+}
+
+// Creates rotation matrix about the Z axis in mtx (MTXF_NEW) or applies one to mtx (MTXF_APPLY)
+void Matrix_RotateZ(Matrix* mtx, f32 angle, u8 mode) {
+ f32 cs;
+ f32 sn;
+ f32 rx;
+ f32 ry;
+ s32 i;
+
+ sn = sinf(angle);
+ cs = cosf(angle);
+ if (mode == 1) {
+ for (i = 0; i < 4; i++) {
+ rx = mtx->mf[0][i];
+ ry = mtx->mf[1][i];
+
+ mtx->mf[0][i] = (rx * cs) + (ry * sn);
+ mtx->mf[1][i] = (ry * cs) - (rx * sn);
+ }
+ } else {
+ mtx->mf[0][0] = mtx->mf[1][1] = cs;
+ mtx->mf[0][1] = sn;
+ mtx->mf[1][0] = -sn;
+ mtx->mf[2][2] = mtx->mf[3][3] = 1.0f;
+ mtx->mf[0][2] = mtx->mf[0][3] = mtx->mf[1][2] = mtx->mf[1][3] = mtx->mf[2][0] = mtx->mf[2][1] = mtx->mf[2][3] =
+ mtx->mf[3][0] = mtx->mf[3][1] = mtx->mf[3][2] = 0.0f;
+ }
+}
+
+// Creates rotation matrix about a given vector axis in mtx (MTXF_NEW) or applies one to mtx (MTXF_APPLY).
+// The vector specifying the axis does not need to be a unit vector.
+void Matrix_RotateAxis(Matrix* mtx, f32 angle, f32 axisX, f32 axisY, f32 axisZ, u8 mode) {
+ f32 rx;
+ f32 ry;
+ f32 rz;
+ f32 norm;
+ f32 cxx;
+ f32 cyx;
+ f32 czx;
+ f32 cxy;
+ f32 cyy;
+ f32 czy;
+ f32 cxz;
+ f32 cyz;
+ f32 czz;
+ f32 xx;
+ f32 yy;
+ f32 zz;
+ f32 xy;
+ f32 yz;
+ f32 xz;
+ f32 sinA;
+ f32 cosA;
+
+ norm = sqrtf((axisX * axisX) + (axisY * axisY) + (axisZ * axisZ));
+ if (norm != 0.0) {
+ axisX /= norm;
+ axisY /= norm;
+ axisZ /= norm;
+ sinA = sinf(angle);
+ cosA = cosf(angle);
+ xx = axisX * axisX;
+ yy = axisY * axisY;
+ zz = axisZ * axisZ;
+ xy = axisX * axisY;
+ yz = axisY * axisZ;
+ xz = axisX * axisZ;
+
+ if (mode == 1) {
+ cxx = (1.0f - xx) * cosA + xx;
+ cyx = (1.0f - cosA) * xy + axisZ * sinA;
+ czx = (1.0f - cosA) * xz - axisY * sinA;
+
+ cxy = (1.0f - cosA) * xy - axisZ * sinA;
+ cyy = (1.0f - yy) * cosA + yy;
+ czy = (1.0f - cosA) * yz + axisX * sinA;
+
+ cxz = (1.0f - cosA) * xz + axisY * sinA;
+ cyz = (1.0f - cosA) * yz - axisX * sinA;
+ czz = (1.0f - zz) * cosA + zz;
+
+ // loop doesn't seem to work here.
+ rx = mtx->mf[0][0];
+ ry = mtx->mf[0][1];
+ rz = mtx->mf[0][2];
+ mtx->mf[0][0] = (rx * cxx) + (ry * cxy) + (rz * cxz);
+ mtx->mf[0][1] = (rx * cyx) + (ry * cyy) + (rz * cyz);
+ mtx->mf[0][2] = (rx * czx) + (ry * czy) + (rz * czz);
+
+ rx = mtx->mf[1][0];
+ ry = mtx->mf[1][1];
+ rz = mtx->mf[1][2];
+ mtx->mf[1][0] = (rx * cxx) + (ry * cxy) + (rz * cxz);
+ mtx->mf[1][1] = (rx * cyx) + (ry * cyy) + (rz * cyz);
+ mtx->mf[1][2] = (rx * czx) + (ry * czy) + (rz * czz);
+
+ rx = mtx->mf[2][0];
+ ry = mtx->mf[2][1];
+ rz = mtx->mf[2][2];
+ mtx->mf[2][0] = (rx * cxx) + (ry * cxy) + (rz * cxz);
+ mtx->mf[2][1] = (rx * cyx) + (ry * cyy) + (rz * cyz);
+ mtx->mf[2][2] = (rx * czx) + (ry * czy) + (rz * czz);
+ } else {
+ mtx->mf[0][0] = (1.0f - xx) * cosA + xx;
+ mtx->mf[0][1] = (1.0f - cosA) * xy + axisZ * sinA;
+ mtx->mf[0][2] = (1.0f - cosA) * xz - axisY * sinA;
+ mtx->mf[0][3] = 0.0f;
+
+ mtx->mf[1][0] = (1.0f - cosA) * xy - axisZ * sinA;
+ mtx->mf[1][1] = (1.0f - yy) * cosA + yy;
+ mtx->mf[1][2] = (1.0f - cosA) * yz + axisX * sinA;
+ mtx->mf[1][3] = 0.0f;
+
+ mtx->mf[2][0] = (1.0f - cosA) * xz + axisY * sinA;
+ mtx->mf[2][1] = (1.0f - cosA) * yz - axisX * sinA;
+ mtx->mf[2][2] = (1.0f - zz) * cosA + zz;
+ mtx->mf[2][3] = 0.0f;
+
+ mtx->mf[3][0] = mtx->mf[3][1] = mtx->mf[3][2] = 0.0f;
+ mtx->mf[3][3] = 1.0f;
+ }
+ }
+}
+
+// Converts the current Gfx matrix to a Mtx
+void Matrix_ToMtx(Mtx* dest) {
+ // LTODO: We need to validate this
+ guMtxF2L(gGfxMatrix->mf, dest);
+}
+
+// Converts the Mtx src to a Matrix, putting the result in dest
+void Matrix_FromMtx(Mtx* src, Matrix* dest) {
+ guMtxF2L(src->m, dest->mf);
+}
+
+// Applies the transform matrix mtx to the vector src, putting the result in dest
+void Matrix_MultVec3f(Matrix* mtx, Vec3f* src, Vec3f* dest) {
+ *dest[0] = (mtx->mf[0][0] * *src[0]) + (mtx->mf[1][0] * *src[1]) + (mtx->mf[2][0] * *src[2]) + mtx->mf[3][0];
+ *dest[1] = (mtx->mf[0][1] * *src[0]) + (mtx->mf[1][1] * *src[1]) + (mtx->mf[2][1] * *src[2]) + mtx->mf[3][1];
+ *dest[2] = (mtx->mf[0][2] * *src[0]) + (mtx->mf[1][2] * *src[1]) + (mtx->mf[2][2] * *src[2]) + mtx->mf[3][2];
+}
+
+// Applies the linear part of the transformation matrix mtx to the vector src, ignoring any translation that mtx might
+// have. Puts the result in dest.
+void Matrix_MultVec3fNoTranslate(Matrix* mtx, Vec3f* src, Vec3f* dest) {
+ *dest[0] = (mtx->mf[0][0] * *src[0]) + (mtx->mf[1][0] * *src[1]) + (mtx->mf[2][0] * *src[2]);
+ *dest[1] = (mtx->mf[0][1] * *src[0]) + (mtx->mf[1][1] * *src[1]) + (mtx->mf[2][1] * *src[2]);
+ *dest[2] = (mtx->mf[0][2] * *src[0]) + (mtx->mf[1][2] * *src[1]) + (mtx->mf[2][2] * *src[2]);
+}
+
+// Expresses the rotational part of the transform mtx as Tait-Bryan angles, in the yaw-pitch-roll (intrinsic YXZ)
+// convention used in worldspace calculations
+void Matrix_GetYRPAngles(Matrix* mtx, Vec3f* rot) {
+ Matrix invYP;
+ Vec3f origin = { 0.0f, 0.0f, 0.0f };
+ Vec3f originP;
+ Vec3f zHat = { 0.0f, 0.0f, 1.0f };
+ Vec3f zHatP;
+ Vec3f xHat = { 1.0f, 0.0f, 0.0f };
+ Vec3f xHatP;
+
+ Matrix_MultVec3fNoTranslate(mtx, &origin, &originP);
+ Matrix_MultVec3fNoTranslate(mtx, &zHat, &zHatP);
+ Matrix_MultVec3fNoTranslate(mtx, &xHat, &xHatP);
+ zHatP[0] -= originP[0];
+ zHatP[1] -= originP[1];
+ zHatP[2] -= originP[2];
+ xHatP[0] -= originP[0];
+ xHatP[1] -= originP[1];
+ xHatP[2] -= originP[2];
+ *rot[1] = atan2f(zHatP[0], zHatP[2]);
+ *rot[0] = -atan2f(zHatP[1], sqrtf(SQ(zHatP[0]) + SQ(zHatP[2])));
+ Matrix_RotateX(&invYP, -*rot[0], MTXF_NEW);
+ Matrix_RotateY(&invYP, -*rot[1], MTXF_APPLY);
+ Matrix_MultVec3fNoTranslate(&invYP, &xHatP, &xHat);
+ *rot[0] *= M_RTOD;
+ *rot[1] *= M_RTOD;
+ *rot[2] = atan2f(xHat[1], xHat[0]) * M_RTOD;
+}
+
+// Expresses the rotational part of the transform mtx as Tait-Bryan angles, in the extrinsic XYZ convention used in
+// modelspace calculations
+void Matrix_GetXYZAngles(Matrix* mtx, Vec3f* rot) {
+ Matrix invYZ;
+ Vec3f origin = { 0.0f, 0.0f, 0.0f };
+ Vec3f originP;
+ Vec3f xHat = { 1.0f, 0.0f, 0.0f };
+ Vec3f xHatP;
+ Vec3f yHat = { 0.0f, 1.0f, 0.0f };
+ Vec3f yHatP;
+
+ Matrix_MultVec3fNoTranslate(mtx, &origin, &originP);
+ Matrix_MultVec3fNoTranslate(mtx, &xHat, &xHatP);
+ Matrix_MultVec3fNoTranslate(mtx, &yHat, &yHatP);
+ xHatP[0] -= originP[0];
+ xHatP[1] -= originP[1];
+ xHatP[2] -= originP[2];
+ yHatP[0] -= originP[0];
+ yHatP[1] -= originP[1];
+ yHatP[2] -= originP[2];
+ *rot[2] = atan2f(xHatP[1], xHatP[0]);
+ *rot[1] = -atan2f(xHatP[2], sqrtf(SQ(xHatP[0]) + SQ(xHatP[1])));
+ Matrix_RotateY(&invYZ, -*rot[1], MTXF_NEW);
+ Matrix_RotateZ(&invYZ, -*rot[2], MTXF_APPLY);
+ Matrix_MultVec3fNoTranslate(&invYZ, &yHatP, &yHat);
+ *rot[0] = atan2f(yHat[2], yHat[1]) * M_RTOD;
+ *rot[1] *= M_RTOD;
+ *rot[2] *= M_RTOD;
+}
+
+// Creates a look-at matrix from Eye, At, and Up in mtx (MTXF_NEW) or applies one to mtx (MTXF_APPLY).
+// A look-at matrix is a rotation-translation matrix that maps y to Up, z to (At - Eye), and translates to Eye
+void Matrix_LookAt(Matrix* mtx, f32 xEye, f32 yEye, f32 zEye, f32 xAt, f32 yAt, f32 zAt, f32 xUp, f32 yUp, f32 zUp,
+ u8 mode) {
+ Matrix lookAt;
+
+ guLookAtF(lookAt.mf, xEye, yEye, zEye, xAt, yAt, zAt, xUp, yUp, zUp);
+ Matrix_Mult(mtx, &lookAt, mode);
+}
+
+// Converts the current Gfx matrix to a Mtx and sets it to the display list
+void Matrix_SetGfxMtx(Gfx** gfx) {
+ Matrix_ToMtx(gGfxMtx);
+ gSPMatrix((*gfx)++, gGfxMtx++, G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
+} \ No newline at end of file
diff --git a/src/port/interpolation/matrix.h b/src/port/interpolation/matrix.h
new file mode 100644
index 000000000..f71ef6ab0
--- /dev/null
+++ b/src/port/interpolation/matrix.h
@@ -0,0 +1,94 @@
+#pragma once
+
+#define MTXF_NEW 0
+#define MTXF_APPLY 1
+#include "common_structs.h"
+
+typedef struct {
+ float r;
+ float g;
+ float b;
+} Color;
+
+typedef struct {
+ float x;
+ float y;
+ float z;
+} Vec3fInterp;
+
+typedef struct {
+ s16 x;
+ s16 y;
+ s16 z;
+} Vec3sInterp;
+
+typedef struct {
+ f32 m1; f32 m2; f32 m3; f32 m4;
+ f32 m5; f32 m6; f32 m7; f32 m8;
+} Mat4Interp;
+
+#define M_PI 3.14159265358979323846f
+#define M_RTOD (180.0f / M_PI)
+#define SQ(val) ((val) * (val))
+
+#define qs1616(e) ((s32) ((e) *0x00010000))
+
+#define IPART(x) ((qs1616(x) >> 16) & 0xFFFF)
+#define FPART(x) (qs1616(x) & 0xFFFF)
+
+#define gdSPDefMtx(xx, yx, zx, wx, xy, yy, zy, wy, xz, yz, zz, wz, xw, yw, zw, ww) \
+ { \
+ { \
+ (IPART(xx) << 0x10) | IPART(xy), (IPART(xz) << 0x10) | IPART(xw), (IPART(yx) << 0x10) | IPART(yy), \
+ (IPART(yz) << 0x10) | IPART(yw), (IPART(zx) << 0x10) | IPART(zy), (IPART(zz) << 0x10) | IPART(zw), \
+ (IPART(wx) << 0x10) | IPART(wy), (IPART(wz) << 0x10) | IPART(ww), (FPART(xx) << 0x10) | FPART(xy), \
+ (FPART(xz) << 0x10) | FPART(xw), (FPART(yx) << 0x10) | FPART(yy), (FPART(yz) << 0x10) | FPART(yw), \
+ (FPART(zx) << 0x10) | FPART(zy), (FPART(zz) << 0x10) | FPART(zw), (FPART(wx) << 0x10) | FPART(wy), \
+ (FPART(wz) << 0x10) | FPART(ww), \
+ } \
+ }
+
+
+typedef MtxF Matrix;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern Mtx gIdentityMtx;
+extern Matrix gIdentityMatrix;
+
+extern Matrix* gGfxMatrix;
+extern Matrix sGfxMatrixStack[];
+extern Matrix* gCalcMatrix;
+extern Matrix sCalcMatrixStack[];
+
+extern Mtx gMainMatrixStack[];
+extern Mtx* gGfxMtx;
+
+void Matrix_InitPerspective(Gfx** dList);
+void Matrix_InitOrtho(Gfx** dList);
+void Matrix_Copy(Matrix* dst, Matrix* src);
+void Matrix_Push(Matrix** mtxStack);
+void Matrix_Pop(Matrix** mtxStack);
+void Matrix_Mult(Matrix* mtx, Matrix* tf, u8 mode);
+void Matrix_Translate(Matrix* mtx, f32 x, f32 y, f32 z, u8 mode);
+void Matrix_Scale(Matrix* mtx, f32 xScale, f32 yScale, f32 zScale, u8 mode);
+void Matrix_RotateX(Matrix* mtx, f32 angle, u8 mode);
+void Matrix_RotateY(Matrix* mtx, f32 angle, u8 mode);
+void Matrix_RotateZ(Matrix* mtx, f32 angle, u8 mode);
+void Matrix_RotateAxis(Matrix* mtx, f32 angle, f32 axisX, f32 axisY, f32 axisZ, u8 mode);
+void Matrix_ToMtx(Mtx* dest);
+void Matrix_FromMtx(Mtx* src, Matrix* dest);
+void Matrix_MultVec3f(Matrix* mtx, Vec3f* src, Vec3f* dest);
+void Matrix_MultVec3fNoTranslate(Matrix* mtx, Vec3f* src, Vec3f* dest);
+void Matrix_GetYRPAngles(Matrix* mtx, Vec3f* rot);
+void Matrix_GetXYZAngles(Matrix* mtx, Vec3f* rot);
+void Matrix_LookAt(Matrix* mtx, f32 xEye, f32 yEye, f32 zEye, f32 xAt, f32 yAt, f32 zAt, f32 xUp, f32 yUp, f32 zUp,
+ u8 mode);
+void Matrix_SetGfxMtx(Gfx** gfx);
+void Lights_SetOneLight(Gfx** dList, s32 dirX, s32 dirY, s32 dirZ, s32 colR, s32 colG, s32 colB, s32 ambR, s32 ambG, s32 ambB);
+
+#ifdef __cplusplus
+}
+#endif \ No newline at end of file
diff --git a/src/racing/framebuffer_effects.c b/src/racing/framebuffer_effects.c
index 9a166b448..a89df5b40 100644
--- a/src/racing/framebuffer_effects.c
+++ b/src/racing/framebuffer_effects.c
@@ -37,7 +37,7 @@ void FB_CreateFramebuffers(void) {
void FB_CopyToFramebuffer(Gfx** gfxP, s32 fb_src, s32 fb_dest, u8 oncePerFrame, u8* hasCopied) {
Gfx* gfx = *gfxP;
- gSPMatrix(gfx++, &gIdentityMatrix, G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
+ // gSPMatrix(gfx++, &gIdentityMatrix, G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
gDPSetOtherMode(gfx++,
G_AD_DISABLE | G_CD_DISABLE | G_CK_NONE | G_TC_FILT | G_TF_POINT | G_TT_NONE | G_TL_TILE |
@@ -110,7 +110,7 @@ void FB_WriteFramebufferSliceToCPU(Gfx** gfxP, void* buffer, u8 byteSwap) {
void FB_DrawFromFramebuffer(Gfx** gfxP, s32 fb, u8 alpha) {
Gfx* gfx = *gfxP;
- gSPMatrix(gfx++, &gIdentityMatrix, G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
+ //gSPMatrix(gfx++, &gIdentityMatrix, G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
gDPSetEnvColor(gfx++, 255, 255, 255, alpha);
diff --git a/src/racing/math_util.c b/src/racing/math_util.c
index 934865b08..f1dd6bf5d 100644
--- a/src/racing/math_util.c
+++ b/src/racing/math_util.c
@@ -9,15 +9,17 @@
#include "memory.h"
#include "engine/Matrix.h"
#include "port/Game.h"
+#include <port/interpolation/FrameInterpolation.h>
+#include <port/interpolation/matrix.h>
#pragma intrinsic(sqrtf, fabs)
s32 D_802B91C0[2] = { 13, 13 };
Vec3f D_802B91C8 = { 0.0f, 0.0f, 0.0f };
-Mtx gIdentityMatrix = {
- toFixedPointMatrix(1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0),
-};
+// Mtx gIdentityMatrix = {
+// toFixedPointMatrix(1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0),
+// };
// This functions looks similar to a segment of code from func_802A4A0C in skybox_and_splitscreen.c
UNUSED s32 func_802B4F60(UNUSED s32 arg0, Vec3f arg1, UNUSED s32 arg2, UNUSED f32 arg3, UNUSED f32 arg4) {
@@ -349,6 +351,7 @@ void mtxf_rotate_x(Mat4 mat, s16 angle) {
// create a rotation matrix around the y axis
void mtxf_rotate_y(Mat4 mat, s16 angle) {
+ FrameInterpolation_RecordMatrixRotate1Coord(&mat, 1, angle);
f32 sin_theta = sins(angle);
f32 cos_theta = coss(angle);
@@ -368,6 +371,7 @@ void mtxf_rotate_y(Mat4 mat, s16 angle) {
// create a rotation matrix around the z axis
void mtxf_s16_rotate_z(Mat4 mat, s16 angle) {
+ FrameInterpolation_RecordMatrixRotate1Coord(&mat, 2, angle);
f32 sin_theta = sins(angle);
f32 cos_theta = coss(angle);
@@ -480,6 +484,7 @@ void mtxf_pos_rotation_xyz(Mat4 out, Vec3f pos, Vec3s orientation) {
f32 cosine2;
f32 sine3;
f32 cosine3;
+ FrameInterpolation_RecordMatrixPosRotXYZ(out, pos, orientation);
sine1 = sins(orientation[0]);
cosine1 = coss(orientation[0]);
diff --git a/src/racing/math_util.h b/src/racing/math_util.h
index b767e9068..ec6c2f3c9 100644
--- a/src/racing/math_util.h
+++ b/src/racing/math_util.h
@@ -10,6 +10,10 @@
// #define min(a, b) ((a) <= (b) ? (a) : (b))
// #define max(a, b) ((a) > (b) ? (a) : (b))
+#ifdef __cplusplus
+extern "C" {
+#endif
+
#define sqr(x) ((x) * (x))
// Here to appease the pragma gods
@@ -70,6 +74,10 @@ f32 is_within_render_distance(Vec3f, Vec3f, u16, f32, f32, f32);
extern s32 D_802B91C0[];
extern Vec3f D_802B91C8;
-extern Mtx gIdentityMatrix;
+//extern Mtx gIdentityMatrix;
+
+#ifdef __cplusplus
+}
+#endif
#endif // MATH_UTIL_H
diff --git a/src/racing/skybox_and_splitscreen.c b/src/racing/skybox_and_splitscreen.c
index 77b1c03ff..be56d22f1 100644
--- a/src/racing/skybox_and_splitscreen.c
+++ b/src/racing/skybox_and_splitscreen.c
@@ -397,6 +397,10 @@ void func_802A450C(Vtx* skybox) {
skybox[7].v.cn[2] = prop->FloorTopLeft.b;
}
+Mtx gIdentityMatrix2 = {
+ toFixedPointMatrix(1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0),
+};
+
void func_802A487C(Vtx* arg0, UNUSED struct UnkStruct_800DC5EC* arg1, UNUSED s32 arg2, UNUSED s32 arg3,
UNUSED f32* arg4) {
@@ -409,7 +413,7 @@ void func_802A487C(Vtx* arg0, UNUSED struct UnkStruct_800DC5EC* arg1, UNUSED s32
gSPPerspNormalize(gDisplayListHead++, 0xFFFF);
gSPMatrix(gDisplayListHead++, VIRTUAL_TO_PHYSICAL(&gGfxPool->mtxScreen),
G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_PROJECTION);
- gSPMatrix(gDisplayListHead++, &gIdentityMatrix, G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
+ gSPMatrix(gDisplayListHead++, &gIdentityMatrix2, G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
gSPVertex(gDisplayListHead++, &arg0[4], 4, 0);
gSP2Triangles(gDisplayListHead++, 0, 3, 1, 0, 1, 3, 2, 0);
}
@@ -476,7 +480,7 @@ void func_802A4A0C(Vtx* vtx, struct UnkStruct_800DC5EC* arg1, UNUSED s32 arg2, U
gSPPerspNormalize(gDisplayListHead++, 0xFFFF);
gSPMatrix(gDisplayListHead++, VIRTUAL_TO_PHYSICAL(&gGfxPool->mtxScreen),
G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_PROJECTION);
- gSPMatrix(gDisplayListHead++, &gIdentityMatrix, G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
+ gSPMatrix(gDisplayListHead++, &gIdentityMatrix2, G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
gSPVertex(gDisplayListHead++, &vtx[0], 4, 0);
gSP2Triangles(gDisplayListHead++, 0, 3, 1, 0, 1, 3, 2, 0);
if (GetCourse() == GetRainbowRoad()) {
@@ -760,6 +764,8 @@ void render_screens(s32 mode, s32 cameraId, s32 playerId) {
s32 screenId = 0;
s32 screenMode = SCREEN_MODE_1P;
+ FrameInterpolation_StartRecord();
+
switch (mode) {
case RENDER_SCREEN_MODE_1P_PLAYER_ONE:
func_802A53A4();
@@ -902,6 +908,8 @@ void render_screens(s32 mode, s32 cameraId, s32 playerId) {
if (mode != RENDER_SCREEN_MODE_1P_PLAYER_ONE) {
gNumScreens += 1;
}
+
+ FrameInterpolation_StopRecord();
}
void func_802A74BC(void) {
generated by cgit v1.2.3 (git 2.25.1) at 2026-08-03 01:51:24 +0000