From afa9c0a4b56abae96eb8dac23ab021cd1732ec7b Mon Sep 17 00:00:00 2001 From: CreateSource Date: Fri, 9 Aug 2024 23:53:58 -0400 Subject: [PATCH] rename PSVEC to VEC This is the correct name for the Vec functions for Dolphin. This also applies to PSMTX... --- src/REL/bootDll/main.c | 6 +- src/REL/instDll/main.c | 6 +- src/REL/m402Dll/main.c | 6 +- src/REL/m403Dll/main.c | 26 ++--- src/REL/m403Dll/scene.c | 40 ++++---- src/REL/m404Dll/main.c | 2 +- src/REL/m405Dll/main.c | 36 +++---- src/REL/m406Dll/main.c | 16 +-- src/REL/m406Dll/map.c | 80 +++++++-------- src/REL/m406Dll/player.c | 160 ++++++++++++++--------------- src/REL/m409Dll/main.c | 16 +-- src/REL/m410Dll/game.c | 104 +++++++++---------- src/REL/m410Dll/main.c | 12 +-- src/REL/m410Dll/player.c | 6 +- src/REL/m411Dll/main.c | 2 +- src/REL/m412Dll/main.c | 6 +- src/REL/m414Dll/main.c | 2 +- src/REL/m417Dll/player.c | 64 ++++++------ src/REL/m417Dll/sequence.c | 12 +-- src/REL/m417Dll/water.c | 64 ++++++------ src/REL/m426Dll/main.c | 32 +++--- src/REL/m429Dll/main.c | 2 +- src/REL/m438Dll/main.c | 92 ++++++++--------- src/REL/m440Dll/main.c | 24 ++--- src/REL/m441Dll/main.c | 2 +- src/REL/m442Dll/main.c | 82 +++++++-------- src/REL/m444dll/main.c | 6 +- src/REL/m447dll/player.c | 4 +- src/REL/messDll/main.c | 6 +- src/REL/mgmodedll/mgmode.c | 6 +- src/REL/modeltestDll/main.c | 6 +- src/REL/modeltestDll/modeltest00.c | 6 +- src/REL/modeltestDll/modeltest01.c | 2 +- src/REL/modeseldll/main.c | 6 +- src/REL/resultDll/main.c | 6 +- src/REL/w01Dll/main.c | 92 ++++++++--------- src/REL/w01Dll/mg_coin.c | 10 +- src/REL/w01Dll/mg_item.c | 20 ++-- src/REL/w02Dll/roulette.c | 22 ++-- src/REL/w03Dll/condor.c | 22 ++-- src/REL/w03Dll/mg_coin.c | 8 +- src/REL/w03Dll/mg_item.c | 12 +-- src/REL/w03Dll/river.c | 14 +-- src/REL/w03Dll/statue.c | 6 +- src/REL/w04Dll/boo_event.c | 38 +++---- src/REL/w04Dll/bridge.c | 6 +- src/REL/w04Dll/mg_coin.c | 42 ++++---- src/REL/w04Dll/mg_item.c | 30 +++--- src/REL/w05Dll/dolphin.c | 58 +++++------ src/REL/w05Dll/hotel.c | 24 ++--- src/REL/w05Dll/mg_coin.c | 14 +-- src/REL/w05Dll/mg_item.c | 12 +-- src/REL/w05Dll/monkey.c | 40 ++++---- src/REL/w06Dll/bowser.c | 30 +++--- src/REL/w06Dll/bridge.c | 2 +- src/REL/w06Dll/fire.c | 6 +- src/REL/w06Dll/mg_coin.c | 12 +-- src/REL/w06Dll/mg_item.c | 6 +- src/REL/ztardll/main.c | 12 +-- src/game/EnvelopeExec.c | 4 +- src/game/board/boo.c | 6 +- src/game/board/boo_house.c | 8 +- src/game/board/com.c | 2 +- src/game/board/item.c | 58 +++++------ src/game/board/lottery.c | 34 +++--- src/game/board/mg_setup.c | 8 +- src/game/board/mushroom.c | 6 +- src/game/board/pause.c | 4 +- src/game/board/player.c | 14 +-- src/game/board/roll.c | 8 +- src/game/board/shop.c | 8 +- src/game/board/star.c | 6 +- src/game/board/start.c | 4 +- src/game/board/ui.c | 40 ++++---- src/game/board/view.c | 10 +- src/game/chrman.c | 32 +++--- src/game/hsfanim.c | 56 +++++----- src/game/hsfdraw.c | 24 ++--- src/game/hsfex.c | 44 ++++---- src/game/hsfman.c | 20 ++-- src/game/hsfmotion.c | 6 +- src/game/mapspace.c | 48 ++++----- 82 files changed, 968 insertions(+), 968 deletions(-) diff --git a/src/REL/bootDll/main.c b/src/REL/bootDll/main.c index 9e9ccda2..6855ce34 100644 --- a/src/REL/bootDll/main.c +++ b/src/REL/bootDll/main.c @@ -432,15 +432,15 @@ void fn_1_152C(void) { + (dir.x * (offset.x * offset.z * (1.0 - cosd(z_rot)) - offset.y * sind(z_rot)) + dir.y * (offset.y * offset.z * (1.0 - cosd(z_rot)) + offset.x * sind(z_rot))); - PSVECCrossProduct(&dir, &offset, &offset); - PSVECNormalize(&offset, &offset); + VECCrossProduct(&dir, &offset, &offset); + VECNormalize(&offset, &offset); stick_pos = (HuPadSubStkX[0] & 0xF8); if (stick_pos != 0) { lbl_1_bss_24[0].x += 0.05f * (offset.x * stick_pos); lbl_1_bss_24[0].y += 0.05f * (offset.y * stick_pos); lbl_1_bss_24[0].z += 0.05f * (offset.z * stick_pos); } - PSVECNormalize(&y_offset, &offset); + VECNormalize(&y_offset, &offset); stick_pos = -(HuPadSubStkY[0] & 0xF8); if (stick_pos != 0) { lbl_1_bss_24[0].x += 0.05f * (offset.x * stick_pos); diff --git a/src/REL/instDll/main.c b/src/REL/instDll/main.c index dfc11906..a57a08af 100644 --- a/src/REL/instDll/main.c +++ b/src/REL/instDll/main.c @@ -1023,15 +1023,15 @@ static void fn_1_4528(omObjData *object) + (dir.x * (offset.x * offset.z * (1.0 - cosd(z_rot)) - offset.y * sind(z_rot)) + dir.y * (offset.y * offset.z * (1.0 - cosd(z_rot)) + offset.x * sind(z_rot))); - PSVECCrossProduct(&dir, &offset, &offset); - PSVECNormalize(&offset, &offset); + VECCrossProduct(&dir, &offset, &offset); + VECNormalize(&offset, &offset); stick_pos = (HuPadSubStkX[0] & 0xF8); if (stick_pos != 0) { lbl_1_bss_28[0].x += 0.05f * (offset.x * stick_pos); lbl_1_bss_28[0].y += 0.05f * (offset.y * stick_pos); lbl_1_bss_28[0].z += 0.05f * (offset.z * stick_pos); } - PSVECNormalize(&y_offset, &offset); + VECNormalize(&y_offset, &offset); stick_pos = -(HuPadSubStkY[0] & 0xF8); if (stick_pos != 0) { lbl_1_bss_28[0].x += 0.05f * (offset.x * stick_pos); diff --git a/src/REL/m402Dll/main.c b/src/REL/m402Dll/main.c index cdc19ce8..2373f657 100755 --- a/src/REL/m402Dll/main.c +++ b/src/REL/m402Dll/main.c @@ -778,7 +778,7 @@ static void fn_1_1FC4(Vec *arg0, float *arg1, s32 arg2, s32 arg3) { var_r30 = 1; } } - PSVECAdd((Vec*) &arg0, &sp18, (Vec*) &arg0); + VECAdd((Vec*) &arg0, &sp18, (Vec*) &arg0); } #include "src/REL/executor.c" @@ -1501,7 +1501,7 @@ static void fn_1_70E4(omObjData *arg0) { PSMTXIdentity(sp18); mtxRot(sp18, temp_r31->unk24.x, temp_r31->unk24.y, 0.0f); PSMTXMultVec(sp18, &spC, &spC); - PSVECAdd(&spC, &temp_r31->unk00, &temp_r31->unk00); + VECAdd(&spC, &temp_r31->unk00, &temp_r31->unk00); omSetTra(arg0, temp_r31->unk00.x, temp_r31->unk00.y, temp_r31->unk00.z); Hu3DModelTPLvlSet(arg0->model[0], temp_r31->unk30); temp_r31->unk30 -= 0.02f; @@ -1883,7 +1883,7 @@ void ObjectSetup(void) { fn_1_8048(); Hu3DShadowCreate(30.0f, 20.0f, 20000.0f); Hu3DShadowTPLvlSet(0.5f); - PSVECNormalize(&lbl_1_data_60, &sp20); + VECNormalize(&lbl_1_data_60, &sp20); Hu3DShadowPosSet(&lbl_1_data_60, &sp20, &lbl_1_data_6C); omMakeGroupEx(lbl_1_bss_1E8, 0, 4); lbl_1_bss_54 = omGetGroupMemberListEx(lbl_1_bss_1E8, 0); diff --git a/src/REL/m403Dll/main.c b/src/REL/m403Dll/main.c index 3550b015..d40fbf68 100755 --- a/src/REL/m403Dll/main.c +++ b/src/REL/m403Dll/main.c @@ -934,8 +934,8 @@ static void fn_1_2598(omObjData *arg0) { case 4: temp_r24 = fn_1_82D0(&sp38[0]); for (i = 0; i < temp_r24; i++) { - PSVECSubtract(&sp38[i], &temp_r31->unk2C, &sp8); - sp20[i] = PSVECMag(&sp8); + VECSubtract(&sp38[i], &temp_r31->unk2C, &sp8); + sp20[i] = VECMag(&sp8); } for (i = 0; i < temp_r24 - 1; i++) { for (var_r29 = i + 1; var_r29 < temp_r24; var_r29++) { @@ -1127,14 +1127,14 @@ static s32 fn_1_3894(void) { for (j = i + 1; j < 4; j++) { temp_r27 = lbl_1_bss_34[j]->data; if (temp_r27->unk07 != 0) { - PSVECSubtract(&temp_r28->unk2C, &temp_r27->unk2C, &sp8); - var_f31 = PSVECMag(&sp8); + VECSubtract(&temp_r28->unk2C, &temp_r27->unk2C, &sp8); + var_f31 = VECMag(&sp8); if (var_f31 < 80.0f) { - PSVECNormalize(&sp8, &sp8); + VECNormalize(&sp8, &sp8); var_f30 = 0.0001f + 0.5f * (80.0f - var_f31); - PSVECScale(&sp8, &sp8, var_f30); - PSVECAdd(&sp14[i], &sp8, &sp14[i]); - PSVECSubtract(&sp14[j], &sp8, &sp14[j]); + VECScale(&sp8, &sp8, var_f30); + VECAdd(&sp14[i], &sp8, &sp14[i]); + VECSubtract(&sp14[j], &sp8, &sp14[j]); temp_r28->unk0E++; temp_r27->unk0E++; var_r26++; @@ -1147,7 +1147,7 @@ static s32 fn_1_3894(void) { temp_r25 = lbl_1_bss_34[i]; temp_r31 = temp_r25->data; if (temp_r31->unk07 != 0) { - PSVECAdd(&temp_r31->unk2C, &sp14[i], &temp_r31->unk2C); + VECAdd(&temp_r31->unk2C, &sp14[i], &temp_r31->unk2C); if (temp_r31->unk2C.x > 660.0f) { temp_r31->unk2C.x = 660.0f; } @@ -1204,8 +1204,8 @@ static void fn_1_3D6C(Vec *arg0, Vec *arg1) { temp_r30 = fn_1_8470(sp18); var_f31 = 2000.0f; for (i = 0; i < temp_r30; i++) { - PSVECSubtract(&sp18[i], arg0, &spC); - var_f30 = PSVECMag(&spC); + VECSubtract(&sp18[i], arg0, &spC); + var_f30 = VECMag(&spC); if (var_f30 >= var_f31) { continue; } @@ -1489,8 +1489,8 @@ static void fn_1_5400(float *arg0, Vec *arg1, float arg2[][3], s32 arg3) { arg0[0] = 0.0f; for (i = 1; i < arg3; i++) { - PSVECSubtract(&arg1[i], &arg1[i - 1], &sp8); - arg0[i] = arg0[i - 1] + PSVECMag(&sp8); + VECSubtract(&arg1[i], &arg1[i - 1], &sp8); + arg0[i] = arg0[i - 1] + VECMag(&sp8); } for (j = 0; j < 3; j++) { for (i = 0; i < arg3; i++) { diff --git a/src/REL/m403Dll/scene.c b/src/REL/m403Dll/scene.c index dfe0a620..ba268596 100755 --- a/src/REL/m403Dll/scene.c +++ b/src/REL/m403Dll/scene.c @@ -932,7 +932,7 @@ s32 fn_1_86A0(Vec *arg0, Vec *arg1) { if (temp_r28->rot.x > 0.0f || temp_r28->rot.x <= -90.0f) { return 0; } - PSVECSubtract(arg0, &temp_r28->trans, &sp3C); + VECSubtract(arg0, &temp_r28->trans, &sp3C); sp3C.z /= cosd(temp_r28->rot.x); temp_r17 = fn_1_7B20(arg0->x, arg0->z); temp_r24 = fn_1_7C20(temp_r18, temp_r17); @@ -941,50 +941,50 @@ s32 fn_1_86A0(Vec *arg0, Vec *arg1) { } temp_r24 -= 6; sp48 = lbl_1_data_A88[temp_r17]; - PSVECSubtract(&sp3C, &sp48, &sp3C); + VECSubtract(&sp3C, &sp48, &sp3C); temp_r30 = lbl_1_data_B74[temp_r24][0]; temp_r29 = lbl_1_data_B74[temp_r24][1]; temp_r21 = lbl_1_data_BA4[temp_r24]; for (i = 0; i < temp_r21; i++) { temp_r27 = (i + 1) % temp_r21; - PSVECSubtract(&temp_r30[temp_r27], &temp_r30[i], &sp24); - PSVECSubtract(&sp3C, &temp_r30[temp_r27], &sp18); - PSVECCrossProduct(&sp24, &sp18, &spC); + VECSubtract(&temp_r30[temp_r27], &temp_r30[i], &sp24); + VECSubtract(&sp3C, &temp_r30[temp_r27], &sp18); + VECCrossProduct(&sp24, &sp18, &spC); if (spC.y < 0.0f) { continue; } - PSVECSubtract(&temp_r29[temp_r27], &temp_r30[temp_r27], &sp24); - PSVECSubtract(&sp3C, &temp_r29[temp_r27], &sp18); - PSVECCrossProduct(&sp24, &sp18, &spC); + VECSubtract(&temp_r29[temp_r27], &temp_r30[temp_r27], &sp24); + VECSubtract(&sp3C, &temp_r29[temp_r27], &sp18); + VECCrossProduct(&sp24, &sp18, &spC); if (spC.y < 0.0f) { continue; } - PSVECSubtract(&temp_r29[i], &temp_r29[temp_r27], &sp24); - PSVECSubtract(&sp3C, &temp_r29[i], &sp18); - PSVECCrossProduct(&sp24, &sp18, &spC); + VECSubtract(&temp_r29[i], &temp_r29[temp_r27], &sp24); + VECSubtract(&sp3C, &temp_r29[i], &sp18); + VECCrossProduct(&sp24, &sp18, &spC); if (spC.y < 0.0f) { continue; } - PSVECSubtract(&temp_r30[i], &temp_r29[i], &sp24); - PSVECSubtract(&sp3C, &temp_r30[i], &sp18); - PSVECCrossProduct(&sp24, &sp18, &spC); + VECSubtract(&temp_r30[i], &temp_r29[i], &sp24); + VECSubtract(&sp3C, &temp_r30[i], &sp18); + VECCrossProduct(&sp24, &sp18, &spC); if (spC.y < 0.0f) { continue; } - PSVECSubtract(&temp_r30[temp_r27], &temp_r30[i], &sp24); + VECSubtract(&temp_r30[temp_r27], &temp_r30[i], &sp24); temp_f30 = (sp3C.x * sp24.x - sp24.x * temp_r30[i].x + sp3C.y * sp24.y - sp24.y * temp_r30[i].y + sp3C.z * sp24.z - sp24.z * temp_r30[i].z) / (sp24.x * sp24.x + sp24.y * sp24.y + sp24.z * sp24.z); sp30.x = temp_r30[i].x + temp_f30 * sp24.x; sp30.y = temp_r30[i].y + temp_f30 * sp24.y; sp30.z = temp_r30[i].z + temp_f30 * sp24.z; - PSVECSubtract(&sp30, &sp3C, &spC); - temp_f28 = PSVECMag(&spC); - PSVECSubtract(&temp_r29[temp_r27], &temp_r29[i], &sp18); + VECSubtract(&sp30, &sp3C, &spC); + temp_f28 = VECMag(&spC); + VECSubtract(&temp_r29[temp_r27], &temp_r29[i], &sp18); temp_f29 = (sp3C.x * sp18.x - sp18.x * temp_r29[i].x + sp3C.y * sp18.y - sp18.y * temp_r29[i].y + sp3C.z * sp18.z - sp18.z * temp_r29[i].z) / (sp18.x * sp18.x + sp18.y * sp18.y + sp18.z * sp18.z); sp30.x = temp_r29[i].x + temp_f29 * sp18.x; sp30.y = temp_r29[i].y + temp_f29 * sp18.y; sp30.z = temp_r29[i].z + temp_f29 * sp18.z; - PSVECSubtract(&sp30, &sp3C, &spC); - temp_f27 = PSVECMag(&spC); + VECSubtract(&sp30, &sp3C, &spC); + temp_f27 = VECMag(&spC); if (temp_f28 == 0.0f) { var_f31 = temp_f30; } else if (temp_f27 == 0.0f) { diff --git a/src/REL/m404Dll/main.c b/src/REL/m404Dll/main.c index bcfef460..b4f8dcce 100644 --- a/src/REL/m404Dll/main.c +++ b/src/REL/m404Dll/main.c @@ -250,7 +250,7 @@ void ObjectSetup(void) lbl_1_bss_10.x = lbl_1_data_77C.x - lbl_1_data_770.x; lbl_1_bss_10.y = lbl_1_data_77C.y - lbl_1_data_770.y; lbl_1_bss_10.z = lbl_1_data_77C.z - lbl_1_data_770.z; - PSVECNormalize(&lbl_1_bss_10, &lbl_1_bss_10); + VECNormalize(&lbl_1_bss_10, &lbl_1_bss_10); var_r29 = Hu3DGLightCreateV(&lbl_1_data_770, &lbl_1_bss_10, &lbl_1_data_788); Hu3DGLightInfinitytSet(var_r29); Hu3DGLightStaticSet(var_r29, 1); diff --git a/src/REL/m405Dll/main.c b/src/REL/m405Dll/main.c index 1950ce88..fc733b71 100755 --- a/src/REL/m405Dll/main.c +++ b/src/REL/m405Dll/main.c @@ -668,7 +668,7 @@ void fn_1_1FC4(Vec *arg0, float *arg1, s32 arg2, s32 arg3) { var_r30 = 1; } } - PSVECAdd((Vec*) &arg0, &sp18, (Vec*) &arg0); + VECAdd((Vec*) &arg0, &sp18, (Vec*) &arg0); } s32 fn_1_23B4(Vec *arg0) { @@ -715,7 +715,7 @@ void fn_1_2508(UnkFn2480Struct *arg0) { var_r30 = arg0->unk30; for (i = 0; i < arg0->unk28; i++, var_r28++, var_r30++) { temp_r29 = &lbl_1_bss_5AC.unk00[*var_r28]; - PSVECSubtract(temp_r29, &arg0->unk0C, &spC); + VECSubtract(temp_r29, &arg0->unk0C, &spC); *var_r30 = VECMagXZ(&spC); if (arg0->unk2D == 0 && arg0->unk0C.z > temp_r29->z) { *var_r30 *= -1.0f; @@ -756,7 +756,7 @@ void fn_1_280C(omObjData *arg0) { var_r26 = lbl_1_bss_5AC.unk04; var_r25 = lbl_1_bss_5AC.unk14; for (i = 0; i < 900; i++) { - PSVECAdd(var_r27, var_r26, var_r25); + VECAdd(var_r27, var_r26, var_r25); var_r27++; var_r26++; var_r25++; @@ -766,23 +766,23 @@ void fn_1_280C(omObjData *arg0) { var_r30 = lbl_1_bss_5AC.unk18; memset(lbl_1_bss_5AC.unk18, 0, 900 * sizeof(*lbl_1_bss_5AC.unk18)); for (i = 0; i < 841; i++) { - PSVECSubtract(&temp_r28[(*var_r31)[1]], &temp_r28[(*var_r31)[0]], &sp2C); - PSVECSubtract(&temp_r28[(*var_r31)[3]], &temp_r28[(*var_r31)[0]], &sp20); - PSVECSubtract(&temp_r28[(*var_r31)[2]], &temp_r28[(*var_r31)[0]], &sp14); - PSVECCrossProduct(&sp2C, &sp20, &sp8); - PSVECNormalize(&sp8, &sp8); - PSVECAdd(&sp8, &var_r30[(*var_r31)[0]], &var_r30[(*var_r31)[0]]); - PSVECAdd(&sp8, &var_r30[(*var_r31)[1]], &var_r30[(*var_r31)[1]]); - PSVECAdd(&sp8, &var_r30[(*var_r31)[3]], &var_r30[(*var_r31)[3]]); - PSVECCrossProduct(&sp20, &sp14, &sp8); - PSVECNormalize(&sp8, &sp8); - PSVECAdd(&sp8, &var_r30[(*var_r31)[0]], &var_r30[(*var_r31)[0]]); - PSVECAdd(&sp8, &var_r30[(*var_r31)[3]], &var_r30[(*var_r31)[3]]); - PSVECAdd(&sp8, &var_r30[(*var_r31)[2]], &var_r30[(*var_r31)[2]]); + VECSubtract(&temp_r28[(*var_r31)[1]], &temp_r28[(*var_r31)[0]], &sp2C); + VECSubtract(&temp_r28[(*var_r31)[3]], &temp_r28[(*var_r31)[0]], &sp20); + VECSubtract(&temp_r28[(*var_r31)[2]], &temp_r28[(*var_r31)[0]], &sp14); + VECCrossProduct(&sp2C, &sp20, &sp8); + VECNormalize(&sp8, &sp8); + VECAdd(&sp8, &var_r30[(*var_r31)[0]], &var_r30[(*var_r31)[0]]); + VECAdd(&sp8, &var_r30[(*var_r31)[1]], &var_r30[(*var_r31)[1]]); + VECAdd(&sp8, &var_r30[(*var_r31)[3]], &var_r30[(*var_r31)[3]]); + VECCrossProduct(&sp20, &sp14, &sp8); + VECNormalize(&sp8, &sp8); + VECAdd(&sp8, &var_r30[(*var_r31)[0]], &var_r30[(*var_r31)[0]]); + VECAdd(&sp8, &var_r30[(*var_r31)[3]], &var_r30[(*var_r31)[3]]); + VECAdd(&sp8, &var_r30[(*var_r31)[2]], &var_r30[(*var_r31)[2]]); var_r31++; } for (i = 0; i < 900; i++, var_r30++) { - PSVECNormalize(var_r30, var_r30); + VECNormalize(var_r30, var_r30); } DCStoreRangeNoSync(lbl_1_bss_5AC.unk14, 900 * sizeof(*lbl_1_bss_5AC.unk14)); DCStoreRangeNoSync(lbl_1_bss_5AC.unk18, 900 * sizeof(*lbl_1_bss_5AC.unk18)); @@ -2410,7 +2410,7 @@ void ObjectSetup(void) { Hu3DGLightInfinitytSet(temp_r29); Hu3DShadowCreate(30.0f, 20.0f, 20000.0f); Hu3DShadowTPLvlSet(0.8f); - PSVECNormalize(&lbl_1_data_170, &sp8); + VECNormalize(&lbl_1_data_170, &sp8); Hu3DShadowPosSet(&lbl_1_data_170, &sp8, &lbl_1_data_17C); lbl_1_bss_90 = HuSprAnimReadFile(DATA_MAKE_NUM(DATADIR_M405, 57)); HuSprAnimLock(lbl_1_bss_90); diff --git a/src/REL/m406Dll/main.c b/src/REL/m406Dll/main.c index dcd78522..826eb1a5 100644 --- a/src/REL/m406Dll/main.c +++ b/src/REL/m406Dll/main.c @@ -124,8 +124,8 @@ void ObjectSetup(void) sp14.x = Center.x + (CZoom * (sind(CRot.y) * cosd(CRot.x))); sp14.y = Center.y + (CZoom * -sind(CRot.x)); sp14.z = Center.z + (CZoom * (cosd(CRot.y) * cosd(CRot.x))); - PSVECSubtract(&Center, &sp14, &sp8); - PSVECNormalize(&sp8, &sp8); + VECSubtract(&Center, &sp14, &sp8); + VECNormalize(&sp8, &sp8); HuAudFXListnerSetEX(&sp14, &sp8, 100000.0f, 4166.6665f, 0.0f, 300.0f, 300.0f); Hu3DLightAllKill(); Hu3DLighInit(); @@ -287,8 +287,8 @@ void fn_1_40C(omObjData *object) sp14.x = Center.x + (CZoom * (sind(CRot.y) * cosd(CRot.x))); sp14.y = Center.y + (CZoom * -sind(CRot.x)); sp14.z = Center.z + (CZoom * (cosd(CRot.y) * cosd(CRot.x))); - PSVECSubtract(&Center, &sp14, &sp8); - PSVECNormalize(&sp8, &sp8); + VECSubtract(&Center, &sp14, &sp8); + VECNormalize(&sp8, &sp8); HuAudFXListnerUpdate(&sp14, &sp8); fn_1_6B5C(); fn_1_3064(1); @@ -462,8 +462,8 @@ void fn_1_15D0(float arg8) sp14.x = Center.x + (CZoom * (sind(CRot.y) * cosd(CRot.x))); sp14.y = Center.y + (CZoom * -sind(CRot.x)); sp14.z = Center.z + (CZoom * (cosd(CRot.y) * cosd(CRot.x))); - PSVECSubtract(&Center, &sp14, &sp8); - PSVECNormalize(&sp8, &sp8); + VECSubtract(&Center, &sp14, &sp8); + VECNormalize(&sp8, &sp8); HuAudFXListnerUpdate(&sp14, &sp8); } @@ -482,8 +482,8 @@ void fn_1_183C(float arg8) sp14.x = Center.x + (CZoom * (sind(CRot.y) * cosd(CRot.x))); sp14.y = Center.y + (CZoom * -sind(CRot.x)); sp14.z = Center.z + (CZoom * (cosd(CRot.y) * cosd(CRot.x))); - PSVECSubtract(&Center, &sp14, &sp8); - PSVECNormalize(&sp8, &sp8); + VECSubtract(&Center, &sp14, &sp8); + VECNormalize(&sp8, &sp8); HuAudFXListnerUpdate(&sp14, &sp8); } diff --git a/src/REL/m406Dll/map.c b/src/REL/m406Dll/map.c index 6ad24ea4..ef320c6a 100644 --- a/src/REL/m406Dll/map.c +++ b/src/REL/m406Dll/map.c @@ -1408,17 +1408,17 @@ void fn_1_6174(ModelData *arg0) var_r31 = arg0->unk_120; memset(var_r31->unk_88, 0, var_r31->unk_80 * sizeof(Vec)); for (var_r29 = 0, var_r30 = var_r31->unk_9C; var_r29 < var_r31->unk_98; var_r29++, var_r30++) { - PSVECSubtract(&var_r31->unk_84[(*var_r30)[1]], &var_r31->unk_84[(*var_r30)[0]], &sp14); - PSVECSubtract(&var_r31->unk_84[(*var_r30)[2]], &var_r31->unk_84[(*var_r30)[1]], &sp8); - PSVECCrossProduct(&sp14, &sp8, &sp20); + VECSubtract(&var_r31->unk_84[(*var_r30)[1]], &var_r31->unk_84[(*var_r30)[0]], &sp14); + VECSubtract(&var_r31->unk_84[(*var_r30)[2]], &var_r31->unk_84[(*var_r30)[1]], &sp8); + VECCrossProduct(&sp14, &sp8, &sp20); - PSVECAdd(&var_r31->unk_88[(*var_r30)[0]], &sp20, &var_r31->unk_88[(*var_r30)[0]]); - PSVECAdd(&var_r31->unk_88[(*var_r30)[1]], &sp20, &var_r31->unk_88[(*var_r30)[1]]); - PSVECAdd(&var_r31->unk_88[(*var_r30)[2]], &sp20, &var_r31->unk_88[(*var_r30)[2]]); - PSVECAdd(&var_r31->unk_88[(*var_r30)[3]], &sp20, &var_r31->unk_88[(*var_r30)[3]]); + VECAdd(&var_r31->unk_88[(*var_r30)[0]], &sp20, &var_r31->unk_88[(*var_r30)[0]]); + VECAdd(&var_r31->unk_88[(*var_r30)[1]], &sp20, &var_r31->unk_88[(*var_r30)[1]]); + VECAdd(&var_r31->unk_88[(*var_r30)[2]], &sp20, &var_r31->unk_88[(*var_r30)[2]]); + VECAdd(&var_r31->unk_88[(*var_r30)[3]], &sp20, &var_r31->unk_88[(*var_r30)[3]]); } for (var_r29 = 0, var_r28 = var_r31->unk_88; var_r29 < var_r31->unk_80; var_r29++) { - PSVECNormalize(var_r28, var_r28); + VECNormalize(var_r28, var_r28); } } @@ -1458,9 +1458,9 @@ void fn_1_64F8(UnkM406Struct2 *arg0) for (var_r30 = 0, var_r31 = arg0; var_r30 < lbl_1_bss_B4; var_r30++, var_r31++) { if (var_r30 < lbl_1_bss_B4 - 1) { var_r28 = &arg0[var_r30 + 1]; - PSVECSubtract(&var_r28->unk_14, &var_r31->unk_14, &var_r31->unk_08); - var_r31->unk_00 = PSVECMag(&var_r31->unk_08); - PSVECNormalize(&var_r31->unk_08, &var_r31->unk_08); + VECSubtract(&var_r28->unk_14, &var_r31->unk_14, &var_r31->unk_08); + var_r31->unk_00 = VECMag(&var_r31->unk_08); + VECNormalize(&var_r31->unk_08, &var_r31->unk_08); } else { var_r31->unk_00 = 100000.0f; @@ -1568,10 +1568,10 @@ s32 fn_1_6A44(Vec arg0) } var_r29 = &Hu3DData[lbl_1_data_7A4]; var_r31 = var_r29->unk_120; - PSVECAdd(&var_r31->unk_34, &var_r31->unk_40, &sp8); - PSVECScale(&sp8, &sp8, 0.5f); - PSVECSubtract(&var_r31->unk_34, &sp8, &sp20); - PSVECSubtract(&var_r31->unk_40, &sp8, &sp14); + VECAdd(&var_r31->unk_34, &var_r31->unk_40, &sp8); + VECScale(&sp8, &sp8, 0.5f); + VECSubtract(&var_r31->unk_34, &sp8, &sp20); + VECSubtract(&var_r31->unk_40, &sp8, &sp14); var_f31 = fn_1_D5CC(&sp20, &sp14, arg0.x - sp8.x, arg0.z - sp8.z); if (var_f31 <= 0.0f) { return 0; @@ -2979,27 +2979,27 @@ void fn_1_BC18(ModelData *arg0, float (*arg1)[4]) else if (!var_r29->unk_2C) { var_r27 = &sp98[0]; var_r24 = &sp38[0]; - PSVECScale(var_r24++, var_r27, var_r29->unk_28); - PSVECAdd(var_r27++, &var_r29->unk_30, var_r30++); - PSVECScale(var_r24++, var_r27, var_r29->unk_28); - PSVECAdd(var_r27++, &var_r29->unk_30, var_r30++); - PSVECScale(var_r24++, var_r27, var_r29->unk_28); - PSVECAdd(var_r27++, &var_r29->unk_30, var_r30++); - PSVECScale(var_r24++, var_r27, var_r29->unk_28); - PSVECAdd(var_r27++, &var_r29->unk_30, var_r30++); + VECScale(var_r24++, var_r27, var_r29->unk_28); + VECAdd(var_r27++, &var_r29->unk_30, var_r30++); + VECScale(var_r24++, var_r27, var_r29->unk_28); + VECAdd(var_r27++, &var_r29->unk_30, var_r30++); + VECScale(var_r24++, var_r27, var_r29->unk_28); + VECAdd(var_r27++, &var_r29->unk_30, var_r30++); + VECScale(var_r24++, var_r27, var_r29->unk_28); + VECAdd(var_r27++, &var_r29->unk_30, var_r30++); } else { - PSVECScale(lbl_1_data_8E0, &sp98[0], var_r29->unk_28); - PSVECScale(&lbl_1_data_8E0[1], &sp98[1], var_r29->unk_28); - PSVECScale(&lbl_1_data_8E0[2], &sp98[2], var_r29->unk_28); - PSVECScale(&lbl_1_data_8E0[3], &sp98[3], var_r29->unk_28); + VECScale(lbl_1_data_8E0, &sp98[0], var_r29->unk_28); + VECScale(&lbl_1_data_8E0[1], &sp98[1], var_r29->unk_28); + VECScale(&lbl_1_data_8E0[2], &sp98[2], var_r29->unk_28); + VECScale(&lbl_1_data_8E0[3], &sp98[3], var_r29->unk_28); PSMTXRotRad(spC8, 90, var_r29->unk_2C); PSMTXConcat(sp128, spC8, spF8); PSMTXMultVecArray(spF8, &sp98[0], &sp68[0], 4); - PSVECAdd(&sp68[0], &var_r29->unk_30, var_r30++); - PSVECAdd(&sp68[1], &var_r29->unk_30, var_r30++); - PSVECAdd(&sp68[2], &var_r29->unk_30, var_r30++); - PSVECAdd(&sp68[3], &var_r29->unk_30, var_r30++); + VECAdd(&sp68[0], &var_r29->unk_30, var_r30++); + VECAdd(&sp68[1], &var_r29->unk_30, var_r30++); + VECAdd(&sp68[2], &var_r29->unk_30, var_r30++); + VECAdd(&sp68[3], &var_r29->unk_30, var_r30++); } } var_r29 = var_r31->unk_3C; @@ -3192,14 +3192,14 @@ void fn_1_C86C(ModelData *arg0, Mtx arg1) else { var_r28 = (Vec *)&sp6C; var_r27 = (Vec *)&sp3C; - PSVECScale(var_r27++, var_r28, var_r29->unk_28); - PSVECAdd(var_r28++, &var_r29->unk_30, var_r30++); - PSVECScale(var_r27++, var_r28, var_r29->unk_28); - PSVECAdd(var_r28++, &var_r29->unk_30, var_r30++); - PSVECScale(var_r27++, var_r28, var_r29->unk_28); - PSVECAdd(var_r28++, &var_r29->unk_30, var_r30++); - PSVECScale(var_r27++, var_r28, var_r29->unk_28); - PSVECAdd(var_r28++, &var_r29->unk_30, var_r30++); + VECScale(var_r27++, var_r28, var_r29->unk_28); + VECAdd(var_r28++, &var_r29->unk_30, var_r30++); + VECScale(var_r27++, var_r28, var_r29->unk_28); + VECAdd(var_r28++, &var_r29->unk_30, var_r30++); + VECScale(var_r27++, var_r28, var_r29->unk_28); + VECAdd(var_r28++, &var_r29->unk_30, var_r30++); + VECScale(var_r27++, var_r28, var_r29->unk_28); + VECAdd(var_r28++, &var_r29->unk_30, var_r30++); } } DCFlushRangeNoSync(var_r31->unk_40, var_r31->unk_26 * 0xC * 4); @@ -3352,7 +3352,7 @@ void fn_1_D13C(LightData *arg0, s16 arg1, Mtx arg2, Mtx arg3, float arg8) GXInitLightAttn(&sp30, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f); GXInitLightSpot(&sp30, 20.0f, GX_SP_COS); GXInitLightAttnK(&sp30, 1.0f, 0.0f, 0.0f); - PSVECScale(&arg0->unk_28, &arg0->unk_1C, -1000000.0f); + VECScale(&arg0->unk_28, &arg0->unk_1C, -1000000.0f); break; case 2: GXInitLightAttn(&sp30, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f); diff --git a/src/REL/m406Dll/player.c b/src/REL/m406Dll/player.c index 9de7b554..e6852e93 100644 --- a/src/REL/m406Dll/player.c +++ b/src/REL/m406Dll/player.c @@ -595,17 +595,17 @@ void fn_1_E214(omObjData *object) if (var_r31->unk_58 == 5) { HuAudFXPlay(0x540); fn_1_117BC(var_r31->unk_14.x, 10.0f, &var_r31->unk_44, &sp1C); - PSVECAdd(&var_r31->unk_2C, &sp1C, &var_r31->unk_2C); + VECAdd(&var_r31->unk_2C, &sp1C, &var_r31->unk_2C); } } if (var_r31->unk_00_field2 == 0) { if (var_r31->unk_44.unk_08 == 1) { var_r31->unk_00_field2 = 1; var_r31->unk_60 = 0x14; - PSVECScale(&var_r31->unk_2C, &var_r31->unk_2C, 1.5f); - if (PSVECMag(&var_r31->unk_2C) > 50.0f) { - PSVECNormalize(&var_r31->unk_2C, &var_r31->unk_2C); - PSVECScale(&var_r31->unk_2C, &var_r31->unk_2C, 50.0f); + VECScale(&var_r31->unk_2C, &var_r31->unk_2C, 1.5f); + if (VECMag(&var_r31->unk_2C) > 50.0f) { + VECNormalize(&var_r31->unk_2C, &var_r31->unk_2C); + VECScale(&var_r31->unk_2C, &var_r31->unk_2C, 50.0f); } HuAudFXPlay(0x53E); HuAudFXVolSet(var_r31->unk_7C[0], 0); @@ -665,7 +665,7 @@ void fn_1_E214(omObjData *object) var_f30 = 1.0f; } Hu3DModelScaleSet(object->model[5], var_f30, var_f30, var_f30); - var_r31->unk_50 += PSVECMag(&var_r31->unk_2C) / 3.125f; + var_r31->unk_50 += VECMag(&var_r31->unk_2C) / 3.125f; PSMTXTrans(sp94, -var_r31->unk_68, -var_r31->unk_6C, -var_r31->unk_70); PSMTXRotRad(sp64, 0x78, 0.017453292f * var_r31->unk_50); PSMTXConcat(sp64, sp94, sp34); @@ -775,26 +775,26 @@ void fn_1_F194(omObjData *object) sp44.y = -0.27222222f; sp44.z = 0.0f; var_f28 = 0.27222222f * var_r31->unk_44.unk_00[3].y; - PSVECScale(&var_r31->unk_44.unk_00[3], &sp38, var_f28); - PSVECAdd(&sp44, &sp38, &sp2C); - PSVECAdd(&var_r31->unk_2C, &sp2C, &var_r31->unk_2C); + VECScale(&var_r31->unk_44.unk_00[3], &sp38, var_f28); + VECAdd(&sp44, &sp38, &sp2C); + VECAdd(&var_r31->unk_2C, &sp2C, &var_r31->unk_2C); sp20.x = sp20.y = sp20.z = 0.0f; sp14.x = sp14.y = sp14.z = 0.0f; - var_f29 = PSVECMag(&var_r31->unk_2C); + var_f29 = VECMag(&var_r31->unk_2C); if (var_f29 > 0.0f && fn_1_122C() == 4) { - PSVECNormalize(&var_r31->unk_2C, &sp8); + VECNormalize(&var_r31->unk_2C, &sp8); sp20.x = -sp8.x; sp20.y = -sp8.y; sp20.z = -sp8.z; if (var_r31->unk_62 < 120.0f) { - PSVECScale(&sp20, &sp20, var_f28 * var_f27); + VECScale(&sp20, &sp20, var_f28 * var_f27); } else { - PSVECScale(&sp20, &sp20, (0.15f * (var_r31->unk_62 / 240.0f)) + (var_f28 * var_f27)); + VECScale(&sp20, &sp20, (0.15f * (var_r31->unk_62 / 240.0f)) + (var_f28 * var_f27)); } if (!var_r31->unk_00_field3) { fn_1_117BC(var_r31->unk_14.x, 1.0f, &var_r31->unk_44, &sp44); - var_f30 = PSVECDotProduct(&sp44, &sp8); + var_f30 = VECDotProduct(&sp44, &sp8); var_f31 = 0.02f * var_f29; sp14.x = (-sp8.x * var_f31) - (var_f30 * (-sp44.x * var_f31)); sp14.y = (-sp8.y * var_f31) - (var_f30 * (-sp44.y * var_f31)); @@ -802,7 +802,7 @@ void fn_1_F194(omObjData *object) if ((var_f30 < 0.9f) && (var_f29 >= 20.0f)) { mtxRot(sp80, var_r30->rot.x, var_r30->rot.y, var_r30->rot.z); mtxTransCat(sp80, var_r30->pos.x, var_r30->pos.y, var_r30->pos.z); - PSVECCrossProduct(&sp44, &sp8, &sp44); + VECCrossProduct(&sp44, &sp8, &sp44); if (sp44.y >= 0.0f) { PSMTXTrans(sp50, -10.0f, 0.0f, 0.0f); PSMTXConcat(sp50, sp80, sp80); @@ -816,12 +816,12 @@ void fn_1_F194(omObjData *object) } } } - PSVECAdd(&sp20, &sp14, &sp2C); - if (PSVECMag(&sp2C) > var_f29) { + VECAdd(&sp20, &sp14, &sp2C); + if (VECMag(&sp2C) > var_f29) { var_r31->unk_2C.x = var_r31->unk_2C.y = var_r31->unk_2C.z = 0.0f; return; } - PSVECAdd(&var_r31->unk_2C, &sp2C, &var_r31->unk_2C); + VECAdd(&var_r31->unk_2C, &sp2C, &var_r31->unk_2C); return; } var_r31->unk_2C.y += -0.27222222f; @@ -859,14 +859,14 @@ void fn_1_F694(omObjData *object) sp2C.z += var_f30 * var_r31->unk_44.unk_00[3].z; if (!var_r31->unk_00_field3) { fn_1_117BC(var_r31->unk_14.x, 1.0f, &var_r31->unk_44, &sp20); - PSVECNormalize(&sp2C, &sp14); - var_f29 = PSVECDotProduct(&sp20, &sp14); + VECNormalize(&sp2C, &sp14); + var_f29 = VECDotProduct(&sp20, &sp14); var_f31 = var_f29 * var_f29; var_f31 *= var_f31; - if (var_f31 < 0.999f && PSVECMag(&var_r31->unk_2C) >= 10.0f) { + if (var_f31 < 0.999f && VECMag(&var_r31->unk_2C) >= 10.0f) { mtxRot(sp68, var_r30->rot.x, var_r30->rot.y, var_r30->rot.z); mtxTransCat(sp68, var_r30->pos.x, var_r30->pos.y, var_r30->pos.z); - PSVECCrossProduct(&sp20, &sp14, &sp8); + VECCrossProduct(&sp20, &sp14, &sp8); if (sp8.y >= 0.0f) { PSMTXTrans(sp38, -10.0f, 0.0f, 0.0f); PSMTXConcat(sp38, sp68, sp68); @@ -878,8 +878,8 @@ void fn_1_F694(omObjData *object) fn_1_94C0(sp68, 10, 1); } } - var_f28 = PSVECMag(&sp2C); - PSVECScale(&sp20, &sp20, var_f28); + var_f28 = VECMag(&sp2C); + VECScale(&sp20, &sp20, var_f28); var_r31->unk_2C.x = sp2C.x + (0.9f * (sp20.x - sp2C.x)); var_r31->unk_2C.y = sp2C.y + (0.9f * (sp20.y - sp2C.y)); var_r31->unk_2C.z = sp2C.z + (0.9f * (sp20.z - sp2C.z)); @@ -888,9 +888,9 @@ void fn_1_F694(omObjData *object) var_r31->unk_2C.x = sp2C.x; var_r31->unk_2C.y = sp2C.y; var_r31->unk_2C.z = sp2C.z; - PSVECScale(&var_r31->unk_2C, &var_r31->unk_2C, var_r31->unk_54); + VECScale(&var_r31->unk_2C, &var_r31->unk_2C, var_r31->unk_54); } - PSVECScale(&var_r31->unk_2C, &var_r31->unk_2C, 0.98f); + VECScale(&var_r31->unk_2C, &var_r31->unk_2C, 0.98f); } } @@ -980,14 +980,14 @@ void fn_1_FA50(ModelData *model, Mtx mtx) var_r30 = var_r28[var_r29]; var_r31 = var_r28[var_r29]->data; if (!var_r31->unk_00_field0) { - var_r31->unk_14.y = PSVECMag(&var_r31->unk_2C); + var_r31->unk_14.y = VECMag(&var_r31->unk_2C); if (!var_r31->unk_00_field3 && !var_r31->unk_00_field2 && (var_r31->unk_14.y > var_r31->unk_14.z)) { var_r31->unk_14.y = var_r31->unk_14.z; - PSVECNormalize(&var_r31->unk_2C, &var_r31->unk_2C); - PSVECScale(&var_r31->unk_2C, &var_r31->unk_2C, var_r31->unk_14.y); + VECNormalize(&var_r31->unk_2C, &var_r31->unk_2C); + VECScale(&var_r31->unk_2C, &var_r31->unk_2C, var_r31->unk_14.y); } var_f31 = var_r31->unk_14.y; - PSVECNormalize(&var_r31->unk_2C, &sp14); + VECNormalize(&var_r31->unk_2C, &sp14); while (var_f31 > 0.0f) { if (var_f31 < 50.0f) { @@ -1007,8 +1007,8 @@ void fn_1_FA50(ModelData *model, Mtx mtx) var_r30->trans.x = sp8.x; var_r30->trans.z = sp8.z; if (var_r31->unk_00_field2 == 0) { - PSVECNormalize(&var_r31->unk_2C, &sp14); - var_f26 = PSVECDotProduct(&sp14, &sp20); + VECNormalize(&var_r31->unk_2C, &sp14); + var_f26 = VECDotProduct(&sp14, &sp20); if (var_f26 < -0.2f && var_r31->unk_14.y >= 10.0f) { omVibrate(var_r31->unk_02, 12, 6, 6); } @@ -1079,8 +1079,8 @@ void fn_1_FA50(ModelData *model, Mtx mtx) sp20.x = sp2C[var_r27 - 1]->trans.x - lbl_1_bss_E0[1].x; sp20.y = sp2C[var_r27 - 1]->trans.y - lbl_1_bss_E0[1].y; sp20.z = sp2C[var_r27 - 1]->trans.z - lbl_1_bss_E0[1].z; - var_f29 = PSVECMag(&sp20); - PSVECNormalize(&sp20, &sp20); + var_f29 = VECMag(&sp20); + VECNormalize(&sp20, &sp20); if (var_f29 < 100.0f) { lbl_1_bss_E0[1].x = sp2C[var_r27 - 1]->trans.x; lbl_1_bss_E0[1].y = sp2C[var_r27 - 1]->trans.y; @@ -1373,7 +1373,7 @@ void fn_1_117BC(float arg8, float arg9, UnkM406PlayerStruct2 *arg0, Vec *arg1) sp10.z = var_r31->y * cosd((180.0f + arg8)); var_f30 = 1.0f - (var_r31->y * var_r31->y); sp10.y = -sqrtf(var_f30); - PSVECScale(&sp10, arg1, arg9); + VECScale(&sp10, arg1, arg9); } s32 fn_1_119E4(Vec *arg0, UnkM406PlayerStruct *arg1) { @@ -1566,9 +1566,9 @@ void fn_1_12270(omObjData *object) sp1C.z = -61000.0f; block_12270: - PSVECSubtract(&sp1C, &object->trans, &sp10); - if (PSVECMag(&sp10) > 0.0f) { - PSVECNormalize(&sp10, &sp10); + VECSubtract(&sp1C, &object->trans, &sp10); + if (VECMag(&sp10) > 0.0f) { + VECNormalize(&sp10, &sp10); var_r31->unk_06 = 72.0 * ((sp10.x * cosd(CRot.y)) - sp10.z * sind(CRot.y)); var_r31->unk_07 = 72.0 * -((sp10.x * sind(CRot.y)) + sp10.z * cosd(CRot.y)); } @@ -1623,14 +1623,14 @@ s32 fn_1_127B8(void) var_r25 = var_r29[var_r30]; var_r22 = var_r25->data; if (!var_r22->unk_00_field0) { - PSVECSubtract(&var_r26->trans, &var_r25->trans, &sp8); - var_f31 = PSVECMag(&sp8); + VECSubtract(&var_r26->trans, &var_r25->trans, &sp8); + var_f31 = VECMag(&sp8); if (var_f31 < 100.0f) { - PSVECNormalize(&sp8, &sp8); + VECNormalize(&sp8, &sp8); var_f30 = 0.01f + (0.5f * (100.0f - var_f31)); - PSVECScale(&sp8, &sp8, var_f30); - PSVECAdd(&sp14[var_r31], &sp8, &sp14[var_r31]); - PSVECSubtract(&sp14[var_r30], &sp8, &sp14[var_r30]); + VECScale(&sp8, &sp8, var_f30); + VECAdd(&sp14[var_r31], &sp8, &sp14[var_r31]); + VECSubtract(&sp14[var_r30], &sp8, &sp14[var_r30]); var_r27++; } } @@ -1641,7 +1641,7 @@ s32 fn_1_127B8(void) var_r28 = var_r29[var_r31]; var_r24 = var_r28->data; if (!var_r24->unk_00_field0) { - PSVECAdd(&var_r28->trans, &sp14[var_r31], &var_r28->trans); + VECAdd(&var_r28->trans, &sp14[var_r31], &var_r28->trans); } } return var_r27; @@ -1660,8 +1660,8 @@ s32 fn_1_129E4(omObjData *object) var_r30 = omGetGroupMemberListEx(HuPrcCurrentGet(), 3); for (var_r31 = 0; var_r31 < var_r30[0]->mdlcnt; var_r31++) { var_r29 = &Hu3DData[(*var_r30)->model[var_r31]]; - PSVECSubtract(&var_r29->pos, &object->trans, &spC); - var_f31 = PSVECMag(&spC); + VECSubtract(&var_r29->pos, &object->trans, &spC); + var_f31 = VECMag(&spC); if (var_f31 < 100.0f) { return 1; } @@ -1792,8 +1792,8 @@ void fn_1_12BC4(omObjData *object) sp84.x = Center.x + (CZoom * (sind(CRot.y) * cosd(CRot.x))); sp84.y = Center.y + (CZoom * -sind(CRot.x)); sp84.z = Center.z + (CZoom * (cosd(CRot.y) * cosd(CRot.x))); - PSVECSubtract(&Center, &sp84, &sp78); - PSVECNormalize(&sp78, &sp78); + VECSubtract(&Center, &sp84, &sp78); + VECNormalize(&sp78, &sp78); HuAudFXListnerUpdate(&sp84, &sp78); } } @@ -1916,7 +1916,7 @@ s32 fn_1_13C10(Vec *arg0, Vec *arg1) sp24.x = -var_r31->nbt.x; sp24.y = 0.0f; sp24.z = -var_r31->nbt.z; - PSVECNormalize(&sp24, &sp24); + VECNormalize(&sp24, &sp24); var_f31 = (var_f28 + (((-var_r31->nbt.x * arg0->x) - (var_r31->nbt.y * arg0->y)) - (var_r31->nbt.z * arg0->z))) / ((var_r31->nbt.x * sp24.x) + (var_r31->nbt.z * sp24.z)); if (var_f31 <= 0.0) { @@ -1925,18 +1925,18 @@ s32 fn_1_13C10(Vec *arg0, Vec *arg1) spC.x = arg0->x + (sp24.x * var_f31); spC.y = arg0->y; spC.z = arg0->z + (sp24.z * var_f31); - PSVECSubtract(sp48[1], sp48[0], &sp3C); - PSVECSubtract(&spC, sp48[1], &sp30); - PSVECCrossProduct(&sp3C, &sp30, &sp24); - if (!(PSVECDotProduct(&var_r31->nbt, &sp24) < 0.0f)) { - PSVECSubtract(sp48[2], sp48[1], &sp3C); - PSVECSubtract(&spC, sp48[2], &sp30); - PSVECCrossProduct(&sp3C, &sp30, &sp24); - if (!(PSVECDotProduct(&var_r31->nbt, &sp24) < 0.0f)) { - PSVECSubtract(sp48[0], sp48[2], &sp3C); - PSVECSubtract(&spC, sp48[0], &sp30); - PSVECCrossProduct(&sp3C, &sp30, &sp24); - if (!(PSVECDotProduct(&var_r31->nbt, &sp24) < 0.0f) && (var_f31 < var_f29)) { + VECSubtract(sp48[1], sp48[0], &sp3C); + VECSubtract(&spC, sp48[1], &sp30); + VECCrossProduct(&sp3C, &sp30, &sp24); + if (!(VECDotProduct(&var_r31->nbt, &sp24) < 0.0f)) { + VECSubtract(sp48[2], sp48[1], &sp3C); + VECSubtract(&spC, sp48[2], &sp30); + VECCrossProduct(&sp3C, &sp30, &sp24); + if (!(VECDotProduct(&var_r31->nbt, &sp24) < 0.0f)) { + VECSubtract(sp48[0], sp48[2], &sp3C); + VECSubtract(&spC, sp48[0], &sp30); + VECCrossProduct(&sp3C, &sp30, &sp24); + if (!(VECDotProduct(&var_r31->nbt, &sp24) < 0.0f) && (var_f31 < var_f29)) { var_f29 = var_f31; sp18 = spC; var_r28 = var_r31; @@ -1948,15 +1948,15 @@ s32 fn_1_13C10(Vec *arg0, Vec *arg1) if (var_r22 > 2) { var_r22 = 0; } - PSVECSubtract(sp48[var_r22], sp48[var_r29], &sp3C); + VECSubtract(sp48[var_r22], sp48[var_r29], &sp3C); if (sp3C.y != 0.0f) { var_f30 = (arg0->y - sp48[var_r29]->y) / sp3C.y; if ((var_f30 >= 0.0f) && (var_f30 < 1.0f)) { spC.x = sp48[var_r29]->x + (var_f30 * sp3C.x); spC.z = sp48[var_r29]->z + (var_f30 * sp3C.z); - PSVECSubtract(&spC, arg0, &sp3C); + VECSubtract(&spC, arg0, &sp3C); sp3C.y = 0.0f; - var_f31 = PSVECMag(&sp3C); + var_f31 = VECMag(&sp3C); if (var_f31 < var_f29) { var_f29 = var_f31; sp18 = spC; @@ -1972,9 +1972,9 @@ s32 fn_1_13C10(Vec *arg0, Vec *arg1) if ((sp30.y >= arg0->y) && (sp30.y < (150.0f + arg0->y))) { sp30.x = sp48[var_r29]->x + (var_f30 * sp3C.x); sp30.z = sp48[var_r29]->z + (var_f30 * sp3C.z); - PSVECSubtract(&sp30, arg0, &sp3C); + VECSubtract(&sp30, arg0, &sp3C); sp3C.y = 0.0f; - var_f31 = PSVECMag(&sp3C); + var_f31 = VECMag(&sp3C); if (var_f31 < var_f29) { var_f29 = var_f31; sp18 = sp30; @@ -1984,9 +1984,9 @@ s32 fn_1_13C10(Vec *arg0, Vec *arg1) } } if ((sp48[var_r29]->y >= arg0->y) && (sp48[var_r29]->y < (150.0f + arg0->y))) { - PSVECSubtract(arg0, sp48[var_r29], &sp3C); + VECSubtract(arg0, sp48[var_r29], &sp3C); sp3C.y = 0.0f; - var_f31 = PSVECMag(&sp3C); + var_f31 = VECMag(&sp3C); if (var_f31 < var_f29) { var_f29 = var_f31; sp18.x = sp48[var_r29]->x; @@ -1998,9 +1998,9 @@ s32 fn_1_13C10(Vec *arg0, Vec *arg1) } } if (var_f29 < 100.0f) { - PSVECSubtract(arg0, &sp18, &sp3C); + VECSubtract(arg0, &sp18, &sp3C); sp3C.y = 0.0f; - PSVECNormalize(&sp3C, &sp3C); + VECNormalize(&sp3C, &sp3C); arg0->x = sp18.x + (100.001f * sp3C.x); arg0->z = sp18.z + (100.001f * sp3C.z); arg1->x = var_r28->nbt.x; @@ -2052,21 +2052,21 @@ float fn_1_143F4(Vec *arg0, UnkM406PlayerStruct2 *arg1) sp34[0] = &((Vec *)var_r28->data)[var_r31->indices[0][0]]; sp34[1] = &((Vec *)var_r28->data)[var_r31->indices[1][0]]; sp34[2] = &((Vec *)var_r28->data)[var_r31->indices[2][0]]; - PSVECSubtract(sp34[1], sp34[0], &sp28); - PSVECSubtract(arg0, sp34[1], &sp1C); - PSVECCrossProduct(&sp28, &sp1C, &sp10); + VECSubtract(sp34[1], sp34[0], &sp28); + VECSubtract(arg0, sp34[1], &sp1C); + VECCrossProduct(&sp28, &sp1C, &sp10); if (sp10.y < 0.0f) { continue; } - PSVECSubtract(sp34[2], sp34[1], &sp28); - PSVECSubtract(arg0, sp34[2], &sp1C); - PSVECCrossProduct(&sp28, &sp1C, &sp10); + VECSubtract(sp34[2], sp34[1], &sp28); + VECSubtract(arg0, sp34[2], &sp1C); + VECCrossProduct(&sp28, &sp1C, &sp10); if (sp10.y < 0.0f) { continue; } - PSVECSubtract(sp34[0], sp34[2], &sp28); - PSVECSubtract(arg0, sp34[0], &sp1C); - PSVECCrossProduct(&sp28, &sp1C, &sp10); + VECSubtract(sp34[0], sp34[2], &sp28); + VECSubtract(arg0, sp34[0], &sp1C); + VECCrossProduct(&sp28, &sp1C, &sp10); if (sp10.y < 0.0f) { continue; } diff --git a/src/REL/m409Dll/main.c b/src/REL/m409Dll/main.c index bb73b325..805f5708 100644 --- a/src/REL/m409Dll/main.c +++ b/src/REL/m409Dll/main.c @@ -1410,20 +1410,20 @@ void fn_1_602C(ModelData *arg0, f32 (*arg1)[4]) else { if (var_r29->unk30 == 0.0f) { fn_1_6778(&sp68[0], &sp38, &var_r29->unk34, 4); - PSVECAdd(&sp38, &var_r29->unk40, var_r31++); - PSVECAdd(&sp44, &var_r29->unk40, var_r31++); - PSVECAdd(&sp50, &var_r29->unk40, var_r31++); - PSVECAdd(&sp5C, &var_r29->unk40, var_r31++); + VECAdd(&sp38, &var_r29->unk40, var_r31++); + VECAdd(&sp44, &var_r29->unk40, var_r31++); + VECAdd(&sp50, &var_r29->unk40, var_r31++); + VECAdd(&sp5C, &var_r29->unk40, var_r31++); } else { fn_1_6778(&temp_r30->unk2C, &sp38, &var_r29->unk34, 4); PSMTXRotRad(spC8, 0x5A, 0.017453292f * var_r29->unk30); PSMTXConcat(sp128, spC8, sp98); PSMTXMultVecArray(sp98, &sp38, &sp8, 4); - PSVECAdd(&sp8, &var_r29->unk40, var_r31++); - PSVECAdd(&sp14, &var_r29->unk40, var_r31++); - PSVECAdd(&sp20, &var_r29->unk40, var_r31++); - PSVECAdd(&sp2C, &var_r29->unk40, var_r31++); + VECAdd(&sp8, &var_r29->unk40, var_r31++); + VECAdd(&sp14, &var_r29->unk40, var_r31++); + VECAdd(&sp20, &var_r29->unk40, var_r31++); + VECAdd(&sp2C, &var_r29->unk40, var_r31++); } if (var_r29->unk4C != -1) { fn_1_66D4(var_r26, temp_r30->unk5C, var_r29->unk4C, temp_r30->unk60, temp_r30->unk64); diff --git a/src/REL/m410Dll/game.c b/src/REL/m410Dll/game.c index 04cd0c6b..37a73771 100644 --- a/src/REL/m410Dll/game.c +++ b/src/REL/m410Dll/game.c @@ -369,7 +369,7 @@ void fn_1_3BE0(s16 arg0) // what happens with the argument? sp1B0[var_r29].unk_0C_unk->unk_40 = sp1B0[var_r29].unk_08; sp1B0[var_r29].unk_08->unk_3C++; sp1B0[var_r29].unk_08->unk_44 = 2; - if (PSVECMag(&sp1B0[var_r29].unk_08->unk_1C) > 10.0f) { + if (VECMag(&sp1B0[var_r29].unk_08->unk_1C) > 10.0f) { HuAudFXPlay(1377); } break; @@ -395,11 +395,11 @@ void fn_1_3BE0(s16 arg0) // what happens with the argument? } for (var_r29 = 0; var_r29 < var_r25; var_r29++) { var_r30 = spC0[var_r29]; - PSVECSubtract(&var_r30->unk_04, &var_r30->unk_10, &spB4); + VECSubtract(&var_r30->unk_04, &var_r30->unk_10, &spB4); var_r28 = lbl_1_bss_54->data; for (var_r26 = 0; var_r26 < 18; var_r26++, var_r28++) { - PSVECSubtract(&var_r28->unk_04, &var_r28->unk_10, &spA8); + VECSubtract(&var_r28->unk_04, &var_r28->unk_10, &spA8); if (fn_1_598C(&var_r30->unk_10, &spB4, var_r30->unk_28, &var_r28->unk_10, &spA8, var_r28->unk_28, var_r28->unk_2C) && !var_r30->unk_00_field1 && var_r28->unk_38 == NULL) { var_r30->unk_00_field1 = 1; @@ -490,9 +490,9 @@ float fn_1_4C04(Vec arg0, Vec arg1, float arg8, Vec arg2, Vec arg3, float arg9) float var_f22; float var_f21; - PSVECSubtract(&arg2, &arg0, &arg2); - PSVECSubtract(&arg3, &arg1, &arg3); - if (PSVECMag(&arg2) > arg9 + (arg8 + PSVECMag(&arg3))) { + VECSubtract(&arg2, &arg0, &arg2); + VECSubtract(&arg3, &arg1, &arg3); + if (VECMag(&arg2) > arg9 + (arg8 + VECMag(&arg3))) { return -1.0f; } var_f22 = (arg8 + arg9) * (arg8 + arg9); @@ -533,10 +533,10 @@ float fn_1_4FEC(Vec arg0, Vec arg1, float arg8, Vec arg2, Vec arg3, float arg9, float var_f21; float var_f18; - PSVECSubtract(&arg0, &arg2, &arg0); - PSVECSubtract(&arg1, &arg3, &arg1); + VECSubtract(&arg0, &arg2, &arg0); + VECSubtract(&arg1, &arg3, &arg1); - if (PSVECMag(&arg0) > (arg8) + PSVECMag(&arg1) + arg9 + argA) { + if (VECMag(&arg0) > (arg8) + VECMag(&arg1) + arg9 + argA) { return -1.0f; } arg8 += arg9; @@ -580,10 +580,10 @@ float fn_1_55C8(Vec arg0, Vec arg1, float arg8, Vec arg2, float arg9) float var_f22; float var_f21; - PSVECSubtract(&arg0, &arg2, &arg0); + VECSubtract(&arg0, &arg2, &arg0); arg0.y = 0.0f; arg1.y = 0.0f; - if (PSVECMag(&arg0) > arg8 + PSVECMag(&arg1) + arg9) { + if (VECMag(&arg0) > arg8 + VECMag(&arg1) + arg9) { return -1.0f; } var_f22 = (arg8 + arg9) * (arg8 + arg9); @@ -618,9 +618,9 @@ s32 fn_1_598C(Vec *arg0, Vec *arg1, float arg8, Vec *arg2, Vec *arg3, float arg9 Vec sp20; float var_f31; - PSVECSubtract(arg0, arg2, &sp38); - PSVECSubtract(arg1, arg3, &sp2C); - if (PSVECMag(&sp38) > arg8 + PSVECMag(&sp2C) + arg9 + argA) { + VECSubtract(arg0, arg2, &sp38); + VECSubtract(arg1, arg3, &sp2C); + if (VECMag(&sp38) > arg8 + VECMag(&sp2C) + arg9 + argA) { return 0; } if (sp2C.y < 0.0f) { @@ -629,7 +629,7 @@ s32 fn_1_598C(Vec *arg0, Vec *arg1, float arg8, Vec *arg2, Vec *arg3, float arg9 sp20.x = var_f31 * sp2C.x + sp38.x; sp20.y = var_f31 * sp2C.y + sp38.y; sp20.z = var_f31 * sp2C.z + sp38.z; - if (PSVECMag(&sp20) < argA) { + if (VECMag(&sp20) < argA) { return 1; } } @@ -675,17 +675,17 @@ void fn_1_5CA0(Vec arg0, Vec arg1, Vec arg2, Vec *arg3, Vec *arg4) float var_f28; sp34 = arg1; - var_f31 = PSVECMag(&sp34); + var_f31 = VECMag(&sp34); if (var_f31 < 0.001f) { arg3->x = arg3->y = arg3->z = 0.0f; arg4->x = arg4->y = arg4->z = 0.0f; return; } - PSVECNormalize(&sp34, &sp34); + VECNormalize(&sp34, &sp34); var_f31 *= 0.9f; - PSVECSubtract(&arg2, &arg0, &sp28); - PSVECNormalize(&sp28, &sp28); - var_f28 = PSVECDotProduct(&sp34, &sp28); + VECSubtract(&arg2, &arg0, &sp28); + VECNormalize(&sp28, &sp28); + var_f28 = VECDotProduct(&sp34, &sp28); if (var_f28 < 0.0f) { arg3->x = arg1.x; arg3->y = arg1.y; @@ -698,10 +698,10 @@ void fn_1_5CA0(Vec arg0, Vec arg1, Vec arg2, Vec *arg3, Vec *arg4) if (var_f30 < 0.001f) { arg3->x = arg3->y = arg3->z = 0.0f; } else { - PSVECCrossProduct(&sp34, &sp28, &sp10); - PSVECNormalize(&sp10, &sp10); - PSVECCrossProduct(&sp28, &sp10, &sp1C); - PSVECNormalize(&sp1C, &sp1C); + VECCrossProduct(&sp34, &sp28, &sp10); + VECNormalize(&sp10, &sp10); + VECCrossProduct(&sp28, &sp10, &sp1C); + VECNormalize(&sp1C, &sp1C); arg3->x = sp1C.x * var_f30; arg3->y = sp1C.y * var_f30; arg3->z = sp1C.z * var_f30; @@ -722,17 +722,17 @@ void fn_1_5EDC(UnkM410Struct2 *arg0, UnkM410Struct2 *arg1) arg0->unk_1C.x *= 0.9f; arg0->unk_1C.y *= 0.9f; arg0->unk_1C.z *= 0.9f; - PSVECSubtract(&arg0->unk_04, &arg1->unk_04, &sp14); - PSVECNormalize(&sp14, &sp8); - var_f30 = (arg0->unk_28 + arg1->unk_28) - PSVECMag(&sp14); + VECSubtract(&arg0->unk_04, &arg1->unk_04, &sp14); + VECNormalize(&sp14, &sp8); + var_f30 = (arg0->unk_28 + arg1->unk_28) - VECMag(&sp14); if (var_f30 > 0.001f) { - PSVECSubtract(&arg0->unk_1C, &arg1->unk_1C, &sp14); - if (PSVECMag(&sp14) < 0.001f) { + VECSubtract(&arg0->unk_1C, &arg1->unk_1C, &sp14); + if (VECMag(&sp14) < 0.001f) { arg0->unk_04.x += sp8.x * var_f30; arg0->unk_04.y += sp8.y * var_f30; arg0->unk_04.z += sp8.z * var_f30; } else { - PSVECNormalize(&sp14, &sp14); + VECNormalize(&sp14, &sp14); arg0->unk_04.x -= sp14.x * var_f30; arg0->unk_04.y -= sp14.y * var_f30; arg0->unk_04.z -= sp14.z * var_f30; @@ -744,13 +744,13 @@ void fn_1_5EDC(UnkM410Struct2 *arg0, UnkM410Struct2 *arg1) arg0->unk_1C.y += 2.0f * sp8.y * var_f31; arg0->unk_1C.z += 2.0f * sp8.z * var_f31; } - PSVECSubtract(&arg1->unk_1C, &arg0->unk_1C, &sp14); - var_f29 = PSVECMag(&sp14); + VECSubtract(&arg1->unk_1C, &arg0->unk_1C, &sp14); + var_f29 = VECMag(&sp14); if (var_f29 < 0.001f) { return; } - PSVECNormalize(&sp14, &sp14); - var_f31 = PSVECDotProduct(&sp8, &sp14); + VECNormalize(&sp14, &sp14); + var_f31 = VECDotProduct(&sp8, &sp14); if (var_f31 > 0.0f) { arg0->unk_1C.x += sp8.x * var_f31 * var_f29; arg0->unk_1C.y += sp8.y * var_f31 * var_f29; @@ -788,8 +788,8 @@ void fn_1_61DC(UnkM410Struct2 *arg0, UnkM410Struct2 *arg1) } fn_1_5CA0(arg0->unk_04, arg0->unk_1C, arg1->unk_04, &sp68, &sp74); fn_1_5CA0(arg1->unk_04, arg1->unk_1C, arg0->unk_04, &sp50, &sp5C); - PSVECAdd(&sp68, &sp5C, &arg0->unk_1C); - PSVECAdd(&sp74, &sp50, &arg1->unk_1C); + VECAdd(&sp68, &sp5C, &arg0->unk_1C); + VECAdd(&sp74, &sp50, &arg1->unk_1C); } void fn_1_6364(UnkM410Struct2 *arg0, UnkM410Struct2 *arg1) @@ -804,27 +804,27 @@ void fn_1_6364(UnkM410Struct2 *arg0, UnkM410Struct2 *arg1) arg0->unk_1C.x *= 0.7f; arg0->unk_1C.y *= 0.7f; arg0->unk_1C.z *= 0.7f; - PSVECSubtract(&arg0->unk_04, &arg1->unk_04, &sp14); + VECSubtract(&arg0->unk_04, &arg1->unk_04, &sp14); sp14.y = 0.0f; - PSVECNormalize(&sp14, &sp14); + VECNormalize(&sp14, &sp14); sp20.x = sp14.x * arg1->unk_2C + arg1->unk_04.x; sp20.y = arg1->unk_04.y; sp20.z = sp14.z * arg1->unk_2C + arg1->unk_04.z; - PSVECSubtract(&arg0->unk_04, &sp20, &sp14); - PSVECNormalize(&sp14, &sp8); - var_f31 = (arg0->unk_28 + arg1->unk_28) - PSVECMag(&sp14); + VECSubtract(&arg0->unk_04, &sp20, &sp14); + VECNormalize(&sp14, &sp8); + var_f31 = (arg0->unk_28 + arg1->unk_28) - VECMag(&sp14); if (var_f31 > 0.001f) { - PSVECSubtract(&arg0->unk_1C, &arg1->unk_1C, &sp14); - if (PSVECMag(&sp14) < 0.001f) { + VECSubtract(&arg0->unk_1C, &arg1->unk_1C, &sp14); + if (VECMag(&sp14) < 0.001f) { arg0->unk_04.x += sp8.x * var_f31; arg0->unk_04.y += sp8.y * var_f31; arg0->unk_04.z += sp8.z * var_f31; } else { - PSVECNormalize(&sp14, &sp14); + VECNormalize(&sp14, &sp14); arg0->unk_04.x -= sp14.x * var_f31; arg0->unk_04.y -= sp14.y * var_f31; arg0->unk_04.z -= sp14.z * var_f31; @@ -836,11 +836,11 @@ void fn_1_6364(UnkM410Struct2 *arg0, UnkM410Struct2 *arg1) arg0->unk_1C.y += 2.0f * sp8.y * var_f30; arg0->unk_1C.z += 2.0f * sp8.z * var_f30; } - PSVECSubtract(&arg1->unk_1C, &arg0->unk_1C, &sp14); - var_f31 = PSVECMag(&sp14); + VECSubtract(&arg1->unk_1C, &arg0->unk_1C, &sp14); + var_f31 = VECMag(&sp14); if (!(var_f31 < 0.001f)) { - PSVECNormalize(&sp14, &sp14); - var_f30 = PSVECDotProduct(&sp8, &sp14); + VECNormalize(&sp14, &sp14); + var_f30 = VECDotProduct(&sp8, &sp14); if (var_f30 > 0.0f) { arg0->unk_1C.x += sp8.x * var_f30 * var_f31; arg0->unk_1C.y += sp8.y * var_f30 * var_f31; @@ -854,9 +854,9 @@ void fn_1_66B8(UnkM410Struct2 *arg0, UnkM410Struct2 *arg1) // TODO maybe UnkM410 Vec spC; float var_f31; - PSVECSubtract(&arg0->unk_04, (Vec *)&arg1->unk_10.z, &spC); + VECSubtract(&arg0->unk_04, (Vec *)&arg1->unk_10.z, &spC); spC.y = 0.0f; - PSVECNormalize(&spC, &spC); + VECNormalize(&spC, &spC); var_f31 = -arg0->unk_1C.x * spC.x - arg0->unk_1C.z * spC.z; arg0->unk_1C.x += 2.0f * spC.x * var_f31; arg0->unk_1C.z += 2.0f * spC.z * var_f31; @@ -911,7 +911,7 @@ void fn_1_6968(omObjData *object) } if (var_r31->unk_00_field1) { Hu3DModelObjPosGet(var_r31->unk_38->unk_30, "i_hook", &sp8); - PSVECSubtract(&sp8, &var_r31->unk_04, &sp8); + VECSubtract(&sp8, &var_r31->unk_04, &sp8); if (var_r31->unk_36 != 0) { var_f31 = cosd(90.0f * var_r31->unk_36 / 10.0f); var_r31->unk_1C.x = var_f31 * sp8.x; @@ -936,7 +936,7 @@ void fn_1_6968(omObjData *object) sp8.x = var_r31->unk_1C.z; sp8.y = 0.0f; sp8.z = -var_r31->unk_1C.x; - var_f30 = PSVECMag(&sp8) / 30.000002f; + var_f30 = VECMag(&sp8) / 30.000002f; if (var_f30 >= 0.001f) { PSMTXRotAxisRad(sp14, &sp8, var_f30); var_r28 = &Hu3DData[object->model[var_r30]]; diff --git a/src/REL/m410Dll/main.c b/src/REL/m410Dll/main.c index 2b6b53a7..5b234c7b 100644 --- a/src/REL/m410Dll/main.c +++ b/src/REL/m410Dll/main.c @@ -347,17 +347,17 @@ void fn_1_1A7C(omObjData *object) } var_f31 = (float)object->work[0] / lbl_1_data_C4[object->work[1]]; - PSVECSubtract(&lbl_1_data_4C[object->work[1] + 1], &lbl_1_data_4C[object->work[1]], &sp8); - PSVECScale(&sp8, &sp8, var_f31); - PSVECAdd(&lbl_1_data_4C[object->work[1]], &sp8, &sp8); + VECSubtract(&lbl_1_data_4C[object->work[1] + 1], &lbl_1_data_4C[object->work[1]], &sp8); + VECScale(&sp8, &sp8, var_f31); + VECAdd(&lbl_1_data_4C[object->work[1]], &sp8, &sp8); Center.x = sp8.x; Center.y = sp8.y; Center.z = sp8.z; - PSVECSubtract(&lbl_1_data_88[object->work[1] + 1], &lbl_1_data_88[object->work[1]], &sp8); - PSVECScale(&sp8, &sp8, var_f31); - PSVECAdd(&lbl_1_data_88[object->work[1]], &sp8, &sp8); + VECSubtract(&lbl_1_data_88[object->work[1] + 1], &lbl_1_data_88[object->work[1]], &sp8); + VECScale(&sp8, &sp8, var_f31); + VECAdd(&lbl_1_data_88[object->work[1]], &sp8, &sp8); CRot.x = sp8.x; CRot.y = sp8.y; diff --git a/src/REL/m410Dll/player.c b/src/REL/m410Dll/player.c index 44ed28b2..fbfe99ec 100644 --- a/src/REL/m410Dll/player.c +++ b/src/REL/m410Dll/player.c @@ -503,8 +503,8 @@ void fn_1_9040(omObjData *object) if (sp20.y < 350.0f) { continue; } - PSVECSubtract(&sp20, &var_r31->unk_58, &sp2C); - var_f28 = PSVECMag(&sp2C); + VECSubtract(&sp20, &var_r31->unk_58, &sp2C); + var_f28 = VECMag(&sp2C); if (var_f28 < var_f30) { var_r28 = var_r29; var_f30 = var_f28; @@ -611,7 +611,7 @@ void fn_1_96F4(omObjData *object) var_r31->unk_44 = 0.0f; var_r31->unk_48 = 0.04f; } - PSVECAdd(&var_r31->unk_70, &var_r31->unk_7C, &var_r31->unk_70); + VECAdd(&var_r31->unk_70, &var_r31->unk_7C, &var_r31->unk_70); var_r31->unk_7C.y = var_r31->unk_7C.y + (0.0002777778f * var_f29); if ((var_r31->unk_7C.y < 0.0f) && (var_r31->unk_70.y <= var_f30)) { var_r31->unk_18 = 1; diff --git a/src/REL/m411Dll/main.c b/src/REL/m411Dll/main.c index 2f2dc72a..ec0249a3 100755 --- a/src/REL/m411Dll/main.c +++ b/src/REL/m411Dll/main.c @@ -1006,7 +1006,7 @@ void fn_1_34B0(ModelData* model, ParticleData* particle, Mtx matrix, s32 arg3) { if (var_r31->unk14.x == 0.0f) { continue; } - PSVECAdd(&var_r31->unk08, &var_r31->unk34, &var_r31->unk34); + VECAdd(&var_r31->unk08, &var_r31->unk34, &var_r31->unk34); var_r31->unk08.x *= 0.95f; var_r31->unk08.y *= 0.95f; var_r31->unk14.y += 20.0f; diff --git a/src/REL/m412Dll/main.c b/src/REL/m412Dll/main.c index 059cae2c..3c6cf951 100644 --- a/src/REL/m412Dll/main.c +++ b/src/REL/m412Dll/main.c @@ -156,7 +156,7 @@ void fn_1_7BC(void) for (var_r31 = 0; var_r31 < 0x168; var_r31++) { HuAudFXEmiterUpDate(temp_r30, &sp14); - PSVECAdd(&sp8, &sp14, &sp14); + VECAdd(&sp8, &sp14, &sp14); HuPrcVSleep(); } HuPrcKill(HuPrcCurrentGet()); @@ -2019,7 +2019,7 @@ void fn_1_A01C(ModelData *model, ParticleData *particle, f32 (*matrix)[4]) var_r31 = particle->unk_48; for (var_r28 = 0; var_r28 < particle->unk_30; var_r28++, var_r31++) { if (var_r31->unk14.x != 0.0f) { - PSVECAdd(&var_r31->unk08, &var_r31->unk34, &var_r31->unk34); + VECAdd(&var_r31->unk08, &var_r31->unk34, &var_r31->unk34); var_r31->unk08.x *= 0.95f; var_r31->unk08.z *= 0.95f; var_r31->unk08.y -= 0.2f; @@ -2100,7 +2100,7 @@ void fn_1_A618(ModelData *model, ParticleData *particle, f32 (*matrix)[4]) var_r31 = particle->unk_48; for (var_r29 = 0; var_r29 < particle->unk_30; var_r29++, var_r31++) { if (0.0f != var_r31->unk14.x) { - PSVECAdd(&var_r31->unk08, &var_r31->unk34, &var_r31->unk34); + VECAdd(&var_r31->unk08, &var_r31->unk34, &var_r31->unk34); var_r31->unk08.x *= 0.95f; var_r31->unk08.z *= 0.95f; var_r31->unk08.y -= 0.2f; diff --git a/src/REL/m414Dll/main.c b/src/REL/m414Dll/main.c index a906f552..b3484695 100644 --- a/src/REL/m414Dll/main.c +++ b/src/REL/m414Dll/main.c @@ -374,7 +374,7 @@ void fn_1_D54(ModelData *arg0, ParticleData *arg1, Mtx arg2, s32 arg3) var_r31 = arg1->unk_48; for (var_r28 = 0; var_r28 < arg1->unk_30; var_r28++, var_r31++) { if (0.0f != var_r31->unk14.x) { - PSVECAdd(&var_r31->unk08, &var_r31->unk34, &var_r31->unk34); + VECAdd(&var_r31->unk08, &var_r31->unk34, &var_r31->unk34); if (var_r31->unk14.x > 10.0f) { var_r31->unk14.x = var_r31->unk14.x - 1.0f; } diff --git a/src/REL/m417Dll/player.c b/src/REL/m417Dll/player.c index 797b12a3..848dd784 100644 --- a/src/REL/m417Dll/player.c +++ b/src/REL/m417Dll/player.c @@ -434,7 +434,7 @@ void fn_1_8B0C(omObjData *object) case 0: sp8 = var_r31->unk_EC; sp8.y = 0.0f; - var_f31 = PSVECMag(&sp8); + var_f31 = VECMag(&sp8); if (var_f31 > 30.000002f) { var_r31->unk_20 = atan2d(-sp8.x, -sp8.z); var_r31->unk_24 = 0.01f * var_f31; @@ -525,15 +525,15 @@ void fn_1_8E44(omObjData *object) case 0: sp8 = var_r31->unk_14C; sp8.y = 0.0f; - if (PSVECMag(&sp8) > 0.0f) { - PSVECNormalize(&sp8, &sp8); + if (VECMag(&sp8) > 0.0f) { + VECNormalize(&sp8, &sp8); } else { sp8.x = 1.0f; sp8.z = 0.0f; } var_r31->unk_68 = atan2d(-sp8.x, -sp8.z); - PSVECScale(&sp8, &var_r31->unk_E0, 1.6666667f); + VECScale(&sp8, &var_r31->unk_E0, 1.6666667f); fn_1_B8A0(object, 5); Hu3DModelLayerSet(object->model[0], 0); Hu3DModelShadowReset(object->model[0]); @@ -547,17 +547,17 @@ void fn_1_8E44(omObjData *object) if (var_r31->unk_D4.y < -300.0f) { sp8 = var_r31->unk_D4; sp8.y = 0.0f; - if (PSVECMag(&sp8) > 0.0f) { - PSVECNormalize(&sp8, &sp8); + if (VECMag(&sp8) > 0.0f) { + VECNormalize(&sp8, &sp8); } else { sp8.x = 0.0f; sp8.z = 1.0f; } - PSVECScale(&sp8, &sp14, 250.0f); + VECScale(&sp8, &sp14, 250.0f); sp14.y = -100.0f; - PSVECSubtract(&sp14, &var_r31->unk_D4, &sp8); - PSVECScale(&sp8, &var_r31->unk_E0, 1.0f / 60.0f); + VECSubtract(&sp14, &var_r31->unk_D4, &sp8); + VECScale(&sp8, &var_r31->unk_E0, 1.0f / 60.0f); fn_1_B8A0(object, 6); var_r31->unk_50++; } @@ -576,7 +576,7 @@ void fn_1_8E44(omObjData *object) break; } - PSVECAdd(&var_r31->unk_D4, &var_r31->unk_E0, &var_r31->unk_D4); + VECAdd(&var_r31->unk_D4, &var_r31->unk_E0, &var_r31->unk_D4); fn_1_9FF0(object); fn_1_91E0(object); fn_1_AD24(object); @@ -623,7 +623,7 @@ void fn_1_9298(omObjData *object) sp14.x = sind(var_r31->unk_20); sp14.y = 0.0f; sp14.z = cosd(var_r31->unk_20); - var_f31 = PSVECDotProduct(&sp20, &sp14); + var_f31 = VECDotProduct(&sp20, &sp14); var_f31 *= (1.0f / 60.0f) * (30.0f * var_r31->unk_24); } var_r31->unk_B4.y += (0.1f * (var_f31 - var_r31->unk_B4.y)); @@ -832,15 +832,15 @@ void fn_1_9C14(omObjData *object) fn_1_B8A0(object, 0); } } - PSVECSubtract(&var_r31->unk_D4, &var_r31->unk_104, &sp1C); + VECSubtract(&var_r31->unk_D4, &var_r31->unk_104, &sp1C); if (fn_1_26F8() == 2) { sp1C.y += -5.8333335f * var_r31->unk_148; } PSMTXMultVec(var_r31->unk_224, &sp1C, &sp1C); - PSVECAdd(&sp1C, &var_r31->unk_E0, &sp1C); + VECAdd(&sp1C, &var_r31->unk_E0, &sp1C); sp10 = sp1C; sp10.y = 0.0f; - var_f31 = sp8 = PSVECMag(&sp10); + var_f31 = sp8 = VECMag(&sp10); if (var_f31 > 150.0f) { var_f31 = 150.0f / var_f31; sp1C.x = sp1C.x * var_f31; @@ -850,7 +850,7 @@ void fn_1_9C14(omObjData *object) var_r31->unk_EC = sp1C; spC = atan2d(sp1C.x, sp1C.z); PSMTXMultVec(var_r31->unk_1C4, &sp1C, &sp1C); - PSVECAdd(&sp1C, &var_r31->unk_F8, &var_r31->unk_D4); + VECAdd(&sp1C, &var_r31->unk_F8, &var_r31->unk_D4); if (var_r31->unk_13C >= 0.95f) { var_r31->unk_3C = 1; return; @@ -936,7 +936,7 @@ void fn_1_9FF0(omObjData *object) if (!var_r31->unk_40) { sp20 = var_r31->unk_EC; sp20.y = 0.0f; - var_f31 = (2.0f / 300.0f) * PSVECMag(&sp20); + var_f31 = (2.0f / 300.0f) * VECMag(&sp20); if (var_f31 <= 0.0f) { var_f31 = 0.0f; sp8.x = 1.0f; @@ -1002,7 +1002,7 @@ void fn_1_9FF0(omObjData *object) sp8.x = sind(var_f31); sp8.y = 0.0f; sp8.z = cosd(var_f31); - var_f29 = PSVECMag(&sp20); + var_f29 = VECMag(&sp20); if (var_f29 > 0.5f) { var_f29 = 0.5f; } @@ -1011,23 +1011,23 @@ void fn_1_9FF0(omObjData *object) if (fn_1_26F8() == 2) { sp20 = var_r31->unk_EC; sp20.y = 0.0f; - var_f31 = PSVECMag(&sp20); + var_f31 = VECMag(&sp20); var_f29 = 0.006666667f * var_f31; if (var_f31 > 0.0f) { - PSVECNormalize(&sp20, &sp20); + VECNormalize(&sp20, &sp20); } - PSVECSubtract(&sp20, &var_r31->unk_14C, &sp14); - if (PSVECMag(&sp14)) { - PSVECNormalize(&sp14, &sp14); + VECSubtract(&sp20, &var_r31->unk_14C, &sp14); + if (VECMag(&sp14)) { + VECNormalize(&sp14, &sp14); } - PSVECScale(&sp14, &sp14, (0.0033333336f * var_f29) + var_r31->unk_144); - PSVECAdd(&var_r31->unk_14C, &sp14, &var_r31->unk_14C); + VECScale(&sp14, &sp14, (0.0033333336f * var_f29) + var_r31->unk_144); + VECAdd(&var_r31->unk_14C, &sp14, &var_r31->unk_14C); } else { - PSVECScale(&var_r31->unk_14C, &var_r31->unk_14C, 0.98f); + VECScale(&var_r31->unk_14C, &var_r31->unk_14C, 0.98f); } var_r31->unk_14C.y = 0.0f; - var_f31 = PSVECMag(&var_r31->unk_14C); + var_f31 = VECMag(&var_r31->unk_14C); if (var_f31 > 1.0f) { var_f31 = 1.0f / var_f31; var_r31->unk_14C.x *= var_f31; @@ -1095,8 +1095,8 @@ void fn_1_ADC4(omObjData *object) sp28 = var_r31->unk_14C; sp28.y = 0.0f; var_f31 = 0.75f + (2.5f * (var_r31->unk_74 * var_r31->unk_74)); - PSVECScale(&sp28, &sp28, 150.0f * -var_f31); - var_f31 = PSVECMag(&sp28); + VECScale(&sp28, &sp28, 150.0f * -var_f31); + var_f31 = VECMag(&sp28); if (var_f31 > 150.0f) { var_f31 = 150.0f / var_f31; sp28.x *= var_f31; @@ -1106,8 +1106,8 @@ void fn_1_ADC4(omObjData *object) sp28.z += (100.0 * ((0.9f - (0.3f * var_r31->unk_74)) * ((0.002 * (float)frandmod(1000)) - 1.0))); sp1C = var_r31->unk_110; sp1C.y = 0.0f; - PSVECSubtract(&sp28, &sp1C, &sp10); - var_f31 = PSVECMag(&sp10); + VECSubtract(&sp28, &sp1C, &sp10); + var_f31 = VECMag(&sp10); if (var_f31 > (100.0f * (1.2f - (0.3f * var_r31->unk_74)))) { var_r31->unk_110 = sp28; } @@ -1120,8 +1120,8 @@ void fn_1_ADC4(omObjData *object) sp28.y = 0.0f; sp1C = var_r31->unk_EC; sp1C.y = 0.0f; - PSVECSubtract(&sp28, &sp1C, &sp10); - var_f31 = PSVECMag(&sp10); + VECSubtract(&sp28, &sp1C, &sp10); + var_f31 = VECMag(&sp10); if (var_r31->unk_48) { var_r30 = 1; } diff --git a/src/REL/m417Dll/sequence.c b/src/REL/m417Dll/sequence.c index 672218a7..ac2b93ca 100644 --- a/src/REL/m417Dll/sequence.c +++ b/src/REL/m417Dll/sequence.c @@ -60,15 +60,15 @@ void fn_1_BD9C(omObjData *object) } else { var_f31 = 0.0055555557f * (var_r31->unk_10 - var_r29); } - PSVECSubtract(&sp2C[1], &sp2C[0], &sp8); - PSVECScale(&sp8, &sp8, var_f31); - PSVECAdd(&sp2C[0], &sp8, &sp8); + VECSubtract(&sp2C[1], &sp2C[0], &sp8); + VECScale(&sp8, &sp8, var_f31); + VECAdd(&sp2C[0], &sp8, &sp8); Center.x = sp8.x; Center.y = sp8.y; Center.z = sp8.z; - PSVECSubtract(&sp14[1], &sp14[0], &sp8); - PSVECScale(&sp8, &sp8, var_f31); - PSVECAdd(&sp14[0], &sp8, &sp8); + VECSubtract(&sp14[1], &sp14[0], &sp8); + VECScale(&sp8, &sp8, var_f31); + VECAdd(&sp14[0], &sp8, &sp8); CRot.x = sp8.x; CRot.y = sp8.y; CRot.z = 0.0f; diff --git a/src/REL/m417Dll/water.c b/src/REL/m417Dll/water.c index 49e3af90..2bfef4b4 100644 --- a/src/REL/m417Dll/water.c +++ b/src/REL/m417Dll/water.c @@ -198,8 +198,8 @@ void fn_1_37A0(omObjData *object, UnkM417Struct3 *arg1) var_r29 = 1; } else { - PSVECSubtract(&arg1->unk_14, &arg1->unk_08, &sp8); - var_f31 = PSVECMag(&sp8); + VECSubtract(&arg1->unk_14, &arg1->unk_08, &sp8); + var_f31 = VECMag(&sp8); if (var_f31 < 50.0f) { var_r29 = 1; } @@ -214,7 +214,7 @@ void fn_1_37A0(omObjData *object, UnkM417Struct3 *arg1) arg1->unk_34 = 200.0f + frandmod(600); arg1->unk_24 = 0.0f; } - PSVECSubtract(&arg1->unk_14, &arg1->unk_08, &sp8); + VECSubtract(&arg1->unk_14, &arg1->unk_08, &sp8); arg1->unk_2C = atan2d(sp8.x, sp8.z); arg1->unk_28 = fn_1_2F08(arg1->unk_28, arg1->unk_2C, 0.05f); arg1->unk_24 += (0.05f * (300.0f - arg1->unk_24)); @@ -332,14 +332,14 @@ void fn_1_3D58(omObjData *object) var_r30 = 0; var_r29 = 1080; for (var_r31 = 0; var_r31 < 1080; var_r31++, var_r28++) { - var_f31 = PSVECMag(var_r28); + var_f31 = VECMag(var_r28); if (var_f31 > 850.0f) { var_r29--; lbl_1_bss_178.unk_28[var_r31] = 0; lbl_1_bss_178.unk_1C[var_r31] = var_r29; lbl_1_bss_178.unk_24[var_r29] = 0.0f; var_f31 = 850.0f / var_f31; - PSVECScale(var_r28, var_r28, var_f31); + VECScale(var_r28, var_r28, var_f31); } else { lbl_1_bss_178.unk_28[var_r31] = 1; @@ -391,8 +391,8 @@ void fn_1_3D58(omObjData *object) var_f28 = 500000.0f; var_r28 = lbl_1_bss_178.unk_2C; for (var_r30 = 0; var_r30 < lbl_1_bss_178.unk_18; var_r30++) { - PSVECSubtract(var_r28++, &lbl_1_bss_178.unk_3C[var_r31].unk_00, &spC); - var_f31 = PSVECMag(&spC); + VECSubtract(var_r28++, &lbl_1_bss_178.unk_3C[var_r31].unk_00, &spC); + var_f31 = VECMag(&spC); if (var_f31 < var_f28) { var_r29 = var_r30; var_f28 = var_f31; @@ -402,8 +402,8 @@ void fn_1_3D58(omObjData *object) var_r28 = lbl_1_bss_178.unk_2C; var_r26 = 0; for (var_r30 = 0; var_r30 < lbl_1_bss_178.unk_18; var_r30++) { - PSVECSubtract(var_r28++, &lbl_1_bss_178.unk_3C[var_r31].unk_00, &spC); - var_f31 = lbl_1_bss_178.unk_3C[var_r31].unk_10 * PSVECMag(&spC); + VECSubtract(var_r28++, &lbl_1_bss_178.unk_3C[var_r31].unk_00, &spC); + var_f31 = lbl_1_bss_178.unk_3C[var_r31].unk_10 * VECMag(&spC); lbl_1_bss_178.unk_3C[var_r31].unk_20[var_r26] = var_f31; for (var_r29 = 0; var_r29 <= var_r26; var_r29++) { var_f29 = lbl_1_bss_178.unk_3C[var_r31].unk_20[var_r29] - var_f31; @@ -519,21 +519,21 @@ void fn_1_4E64(omObjData *object) sp14.x = var_r31->unk_14 * sind(var_r31->unk_10); sp14.y = 0.0f; sp14.z = var_r31->unk_14 * cosd(var_r31->unk_10); - PSVECAdd(&var_r31->unk_04, &sp14, &var_r31->unk_04); + VECAdd(&var_r31->unk_04, &sp14, &var_r31->unk_04); if (var_r31->unk_2C >= 0) { HuAudFXEmiterUpDate(var_r31->unk_2C, &var_r31->unk_04); } - if (PSVECMag(&var_r31->unk_04) > 800.0f && var_r31->unk_00 >= 2 && (var_r31->unk_1C -= 0.033333335f, var_r31->unk_1C < 0.0f)) { + if (VECMag(&var_r31->unk_04) > 800.0f && var_r31->unk_00 >= 2 && (var_r31->unk_1C -= 0.033333335f, var_r31->unk_1C < 0.0f)) { var_r31->unk_00 = 0; } else { if (var_r31->unk_00 < 2) { - PSVECSubtract(&sp8, &var_r31->unk_04, &sp20); - if (PSVECDotProduct(&sp14, &sp20) <= 0.0f) { + VECSubtract(&sp8, &var_r31->unk_04, &sp20); + if (VECDotProduct(&sp14, &sp20) <= 0.0f) { var_r31->unk_00 = 2; } else { - var_f31 = 1.2f * (PSVECMag(&sp20) / (var_r31->unk_18 * var_r31->unk_28)); + var_f31 = 1.2f * (VECMag(&sp20) / (var_r31->unk_18 * var_r31->unk_28)); if (var_f31 < 1.2f) { if (var_f31 > 1.0f) { var_f31 = 5.0f * (1.2f - var_f31); @@ -545,13 +545,13 @@ void fn_1_4E64(omObjData *object) } } } - else if (var_r31->unk_00 == 2 && PSVECMag(&var_r31->unk_04) > ((800.0f - (100.0f * (2.0f * var_r31->unk_20))) - 30.000002f)) { + else if (var_r31->unk_00 == 2 && VECMag(&var_r31->unk_04) > ((800.0f - (100.0f * (2.0f * var_r31->unk_20))) - 30.000002f)) { var_r31->unk_00 = 3; fn_1_6D64(lbl_1_bss_58, 0, var_r31->unk_10, 20.0f + (40.0f * var_r31->unk_20), var_r31->unk_20); sp2C.x = sind(var_r31->unk_10); sp2C.y = 0.0f; sp2C.z = cosd(var_r31->unk_10); - PSVECScale(&sp2C, &sp2C, 800.0f); + VECScale(&sp2C, &sp2C, 800.0f); HuAudFXEmiterPlay(1481, &sp2C); if (var_r31->unk_2C >= 0) { var_r31->unk_2C = -1; @@ -584,7 +584,7 @@ void fn_1_4E64(omObjData *object) var_r27 = lbl_1_bss_178.unk_30; var_r28 = lbl_1_bss_178.unk_6CC[lbl_1_bss_178.unk_6B4]; for (var_r30 = 0; var_r30 < lbl_1_bss_178.unk_18; var_r30++, var_r26++, var_r27++) { - var_f31 = PSVECMag(var_r26); + var_f31 = VECMag(var_r26); if (!(var_f31 >= 1.0f)) { var_f30 = (1.0f - var_f31) * var_r31->unk_1C; var_f28 = var_r31->unk_24 * ((1.0f - var_f31) * (1.0f - var_f31)); @@ -655,7 +655,7 @@ void fn_1_57B0(omObjData *object) var_r24 = lbl_1_bss_178.unk_30; var_r25 = lbl_1_bss_178.unk_6BC[lbl_1_bss_178.unk_6B4]; for (var_r30 = 0; var_r30 < lbl_1_bss_178.unk_18; var_r23++, var_r24++, var_r25++, var_r30++) { - PSVECAdd(var_r23, var_r24, var_r25); + VECAdd(var_r23, var_r24, var_r25); } memset(lbl_1_bss_178.unk_30, 0, 30 * 36 * sizeof(Vec)); var_r28 = lbl_1_bss_178.unk_6C4[lbl_1_bss_178.unk_6B4]; @@ -663,22 +663,22 @@ void fn_1_57B0(omObjData *object) var_r27 = lbl_1_bss_178.unk_6BC[lbl_1_bss_178.unk_6B4]; var_r31 = lbl_1_bss_178.unk_38; for (var_r30 = 0; var_r30 < 1015; var_r31++, var_r30++) { - PSVECSubtract(&var_r27[(*var_r31)[1]], &var_r27[(*var_r31)[0]], &sp30); - PSVECSubtract(&var_r27[(*var_r31)[3]], &var_r27[(*var_r31)[0]], &sp24); - PSVECSubtract(&var_r27[(*var_r31)[2]], &var_r27[(*var_r31)[0]], &sp18); - PSVECCrossProduct(&sp30, &sp24, &spC); - PSVECNormalize(&spC, &spC); - PSVECAdd(&spC, &var_r28[(*var_r31)[0]], &var_r28[(*var_r31)[0]]); - PSVECAdd(&spC, &var_r28[(*var_r31)[1]], &var_r28[(*var_r31)[1]]); - PSVECAdd(&spC, &var_r28[(*var_r31)[3]], &var_r28[(*var_r31)[3]]); - PSVECCrossProduct(&sp24, &sp18, &spC); - PSVECNormalize(&spC, &spC); - PSVECAdd(&spC, &var_r28[(*var_r31)[0]], &var_r28[(*var_r31)[0]]); - PSVECAdd(&spC, &var_r28[(*var_r31)[3]], &var_r28[(*var_r31)[3]]); - PSVECAdd(&spC, &var_r28[(*var_r31)[2]], &var_r28[(*var_r31)[2]]); + VECSubtract(&var_r27[(*var_r31)[1]], &var_r27[(*var_r31)[0]], &sp30); + VECSubtract(&var_r27[(*var_r31)[3]], &var_r27[(*var_r31)[0]], &sp24); + VECSubtract(&var_r27[(*var_r31)[2]], &var_r27[(*var_r31)[0]], &sp18); + VECCrossProduct(&sp30, &sp24, &spC); + VECNormalize(&spC, &spC); + VECAdd(&spC, &var_r28[(*var_r31)[0]], &var_r28[(*var_r31)[0]]); + VECAdd(&spC, &var_r28[(*var_r31)[1]], &var_r28[(*var_r31)[1]]); + VECAdd(&spC, &var_r28[(*var_r31)[3]], &var_r28[(*var_r31)[3]]); + VECCrossProduct(&sp24, &sp18, &spC); + VECNormalize(&spC, &spC); + VECAdd(&spC, &var_r28[(*var_r31)[0]], &var_r28[(*var_r31)[0]]); + VECAdd(&spC, &var_r28[(*var_r31)[3]], &var_r28[(*var_r31)[3]]); + VECAdd(&spC, &var_r28[(*var_r31)[2]], &var_r28[(*var_r31)[2]]); } for (var_r30 = 0; var_r30 < 1080; var_r30++, var_r28++) { - PSVECNormalize(var_r28, var_r28); + VECNormalize(var_r28, var_r28); } var_r25 = lbl_1_bss_178.unk_6BC[lbl_1_bss_178.unk_6B4]; for (var_r30 = 0; var_r30 < lbl_1_bss_178.unk_18; var_r25++, var_r30++) { diff --git a/src/REL/m426Dll/main.c b/src/REL/m426Dll/main.c index 34badc03..40b4e7f6 100644 --- a/src/REL/m426Dll/main.c +++ b/src/REL/m426Dll/main.c @@ -3085,27 +3085,27 @@ void fn_1_80DC(ModelData *arg0, Mtx arg1) if (!var_r29->unk_2C) { var_r28 = sp98; var_r27 = sp38; - PSVECScale(var_r27++, var_r28, var_r29->unk_28); - PSVECAdd(var_r28++, &var_r29->unk_30, var_r30++); - PSVECScale(var_r27++, var_r28, var_r29->unk_28); - PSVECAdd(var_r28++, &var_r29->unk_30, var_r30++); - PSVECScale(var_r27++, var_r28, var_r29->unk_28); - PSVECAdd(var_r28++, &var_r29->unk_30, var_r30++); - PSVECScale(var_r27++, var_r28, var_r29->unk_28); - PSVECAdd(var_r28++, &var_r29->unk_30, var_r30++); + VECScale(var_r27++, var_r28, var_r29->unk_28); + VECAdd(var_r28++, &var_r29->unk_30, var_r30++); + VECScale(var_r27++, var_r28, var_r29->unk_28); + VECAdd(var_r28++, &var_r29->unk_30, var_r30++); + VECScale(var_r27++, var_r28, var_r29->unk_28); + VECAdd(var_r28++, &var_r29->unk_30, var_r30++); + VECScale(var_r27++, var_r28, var_r29->unk_28); + VECAdd(var_r28++, &var_r29->unk_30, var_r30++); } else { - PSVECScale(&lbl_1_data_22C[0], &sp98[0], var_r29->unk_28); - PSVECScale(&lbl_1_data_22C[1], &sp98[1], var_r29->unk_28); - PSVECScale(&lbl_1_data_22C[2], &sp98[2], var_r29->unk_28); - PSVECScale(&lbl_1_data_22C[3], &sp98[3], var_r29->unk_28); + VECScale(&lbl_1_data_22C[0], &sp98[0], var_r29->unk_28); + VECScale(&lbl_1_data_22C[1], &sp98[1], var_r29->unk_28); + VECScale(&lbl_1_data_22C[2], &sp98[2], var_r29->unk_28); + VECScale(&lbl_1_data_22C[3], &sp98[3], var_r29->unk_28); PSMTXRotRad(spC8, 90, var_r29->unk_2C); PSMTXConcat(sp128, spC8, &spF8[0]); PSMTXMultVecArray(spF8, &sp98[0], &sp68[0], 4); - PSVECAdd(&sp68[0], &var_r29->unk_30, var_r30++); - PSVECAdd(&sp68[1], &var_r29->unk_30, var_r30++); - PSVECAdd(&sp68[2], &var_r29->unk_30, var_r30++); - PSVECAdd(&sp68[3], &var_r29->unk_30, var_r30++); + VECAdd(&sp68[0], &var_r29->unk_30, var_r30++); + VECAdd(&sp68[1], &var_r29->unk_30, var_r30++); + VECAdd(&sp68[2], &var_r29->unk_30, var_r30++); + VECAdd(&sp68[3], &var_r29->unk_30, var_r30++); } var_r20 = var_r29->unk_40 & 3; var_r19 = (var_r29->unk_40 >> 2) & 3; diff --git a/src/REL/m429Dll/main.c b/src/REL/m429Dll/main.c index bbb553b2..8d48fad7 100644 --- a/src/REL/m429Dll/main.c +++ b/src/REL/m429Dll/main.c @@ -476,7 +476,7 @@ void fn_1_1FC4(Vec *arg0, float *arg1, s32 arg2, s32 arg3) var_r30 = 1; } } - PSVECAdd((Vec *)&arg0, &sp18, (Vec *)&arg0); + VECAdd((Vec *)&arg0, &sp18, (Vec *)&arg0); } typedef struct data_1340_sub_struct { diff --git a/src/REL/m438Dll/main.c b/src/REL/m438Dll/main.c index 23239a7c..84193a27 100644 --- a/src/REL/m438Dll/main.c +++ b/src/REL/m438Dll/main.c @@ -668,9 +668,9 @@ void fn_1_1204(omObjData *object) var_r31->unk_01 = var_r28 + 1; var_r31->unk_18 = lbl_1_data_68[var_r30][var_r29]; - PSVECSubtract(&lbl_1_data_68[var_r30][var_r29 + 1], &lbl_1_data_68[var_r30][var_r29], &var_r31->unk_24); - var_r31->unk_14 = PSVECMag(&var_r31->unk_24); - PSVECNormalize(&var_r31->unk_24, &var_r31->unk_24); + VECSubtract(&lbl_1_data_68[var_r30][var_r29 + 1], &lbl_1_data_68[var_r30][var_r29], &var_r31->unk_24); + var_r31->unk_14 = VECMag(&var_r31->unk_24); + VECNormalize(&var_r31->unk_24, &var_r31->unk_24); var_r31->unk_08 = var_r31->unk_0A = 0; var_r31->unk_06 = 0; var_r31->unk_0C = 0.0f; @@ -871,7 +871,7 @@ u8 fn_1_1D60(omObjData *object) s32 var_r29; var_r30 = object->data; - sp8 = PSVECMag(&var_r30->unk_84); + sp8 = VECMag(&var_r30->unk_84); for (var_r31 = lbl_1_bss_298, var_r29 = 0; var_r29 < 0x30; var_r29++, var_r31++) { if (var_r31->unk_00 > 2 && var_r31->unk_00 < 5) { spC.x = var_r31->unk_24.x * var_r31->unk_14; @@ -1223,7 +1223,7 @@ void fn_1_2E4C(omObjData *object) if (var_r31->unk_20 != 7) { sp30 = var_r31->unk_6C; sp30.y = 0.0f; - var_f30 = PSVECMag(&sp30); + var_f30 = VECMag(&sp30); if (var_f30 > 700.0f) { var_f29 = -100.0f; } @@ -1259,7 +1259,7 @@ void fn_1_2E4C(omObjData *object) if (sp30.z < 0.0f) { sp30.z *= 0.25f; } - var_f30 = PSVECMag(&sp30); + var_f30 = VECMag(&sp30); Hu3D3Dto2D(&var_r31->unk_6C, 1, &sp24); sp24.x = sp24.x - 288.0f; sp24.y -= 240.0f; @@ -1344,7 +1344,7 @@ void fn_1_35C0(omObjData *object) if (lbl_1_bss_DBA == 7) { var_r31->unk_38++; if (var_r31->unk_38 > var_r31->unk_34) { - PSVECSubtract(&var_r23->unk_34, &var_r31->unk_6C, &sp10); + VECSubtract(&var_r23->unk_34, &var_r31->unk_6C, &sp10); var_f29 = atan2d(sp10.x, sp10.z); if (fabs(fn_1_E5A4(var_r31->unk_7C, var_f29)) > 10.0) { var_r28 = 1; @@ -1511,10 +1511,10 @@ void fn_1_4374(omObjData *object) var_r31->unk_44 -= 0xB4; } if (var_r31->unk_64) { - PSVECSubtract(&var_r31->unk_58, &var_r31->unk_4C, &sp1C); - PSVECSubtract(&sp1C, &var_r31->unk_6C, &sp10); + VECSubtract(&var_r31->unk_58, &var_r31->unk_4C, &sp1C); + VECSubtract(&sp1C, &var_r31->unk_6C, &sp10); sp10.y = 0.0f; - var_f30 = PSVECMag(&sp10); + var_f30 = VECMag(&sp10); if (var_f30 > 10.0f) { if (var_f30 > 20.0f) { var_f30 = 20.0f; @@ -1729,7 +1729,7 @@ void fn_1_4724(omObjData *object) // if (var_r28 < 4) { // var_r29 = lbl_1_bss_DC4[var_r28]->data; // if ((var_r29->unk_07 != 0) && ((var_r29->unk_07 & 2) == 0)) { -// PSVECSubtract(var_r29 + 0x6C, var_r31 + 0x10, &sp18); +// VECSubtract(var_r29 + 0x6C, var_r31 + 0x10, &sp18); // temp_r3_2 = var_r26; // var_r26++; // (&sp8[0])[temp_r3_2] = atan2d(sp18, sp18.z); @@ -1815,7 +1815,7 @@ void fn_1_4724(omObjData *object) // sp18.y = var_r31->unk_14; // sp18.z = var_r31->unk_18; // sp18.y = 0.0f; -// var_f30 = PSVECMag(&sp18); +// var_f30 = VECMag(&sp18); // if (!(var_f30 <= 700.0f)) { // var_r31->unk_02 = 1; // if (fn_1_DA64(atan2d(sp18, sp18.z)) != 0) { @@ -1899,8 +1899,8 @@ void fn_1_4724(omObjData *object) // loop_72: // if (var_r28 < 4) { // var_r29 = lbl_1_bss_DC4[var_r28]->data; -// PSVECSubtract(var_r29 + 0x6C, var_r31 + 0x10, &sp18); -// var_f30 = PSVECMag(&sp18); +// VECSubtract(var_r29 + 0x6C, var_r31 + 0x10, &sp18); +// var_f30 = VECMag(&sp18); // if (!(var_f30 >= 200.0f) && (var_r29->unk_20 != 7)) { // omVibrate(var_r29->unk_00, 0xC, 4, 2); // var_r29->unk_07 = var_r29->unk_07 | 2; @@ -2441,8 +2441,8 @@ void fn_1_7858(omObjData *object) if (var_r31->unk_07 == 0 || (var_r31->unk_07 & 2) != 0) { return; } - PSVECSubtract(&var_r31->unk_6C, &var_r31->unk_90, &sp2C); - var_f29 = PSVECMag(&sp2C); + VECSubtract(&var_r31->unk_6C, &var_r31->unk_90, &sp2C); + var_f29 = VECMag(&sp2C); if (var_f29 == 0.0f) { return; } @@ -2463,15 +2463,15 @@ void fn_1_7858(omObjData *object) sp8.y = var_r30->unk_6C.y; sp8.z = var_r30->unk_6C.z; sp8.y = 0.0f; - PSVECSubtract(&sp14, &sp8, &sp2C); - var_f31 = PSVECMag(&sp2C); + VECSubtract(&sp14, &sp8, &sp2C); + var_f31 = VECMag(&sp2C); if (var_f31 >= 119.40001f) { continue; } - PSVECSubtract(&var_r30->unk_6C, &var_r30->unk_90, &sp2C); - var_f28 = PSVECMag(&sp2C); - PSVECSubtract(&sp14, &sp8, &sp20); - PSVECNormalize(&sp20, &sp20); + VECSubtract(&var_r30->unk_6C, &var_r30->unk_90, &sp2C); + var_f28 = VECMag(&sp2C); + VECSubtract(&sp14, &sp8, &sp20); + VECNormalize(&sp20, &sp20); var_f31 = 120.00001f - var_f31; var_f30 = ((0.6f * var_f28) + (0.4f * var_f29)) / (var_f29 + var_f28); var_r31->unk_6C.x = var_r31->unk_6C.x + (var_f30 * (var_f31 * sp20.x)); @@ -2928,8 +2928,8 @@ void fn_1_9040(float *arg0, Vec *arg1, float arg2[3][3], s32 arg3) arg0[0] = 0.0f; for (var_r30 = 1; var_r30 < arg3; var_r30++) { - PSVECSubtract(&arg1[var_r30], &arg1[var_r30 - 1], &sp8); - arg0[var_r30] = arg0[var_r30 - 1] + PSVECMag(&sp8); + VECSubtract(&arg1[var_r30], &arg1[var_r30 - 1], &sp8); + arg0[var_r30] = arg0[var_r30 - 1] + VECMag(&sp8); } for (var_r27 = 0; var_r27 < 3; var_r27++) { for (var_r30 = 0; var_r30 < arg3; var_r30++) { @@ -3371,9 +3371,9 @@ void fn_1_A688(omObjData *object) { } // if ((var_r30->unk_00 > 1) && (var_r30->unk_00 < 5)) { // var_f31 = 0.0f; // for (var_f31 = 0.0f; var_f31 < (35.416668f + var_r30->unk_14); var_f31 += 35.416668f) { -// PSVECScale(var_r30 + 0x24, &sp8, var_f31); -// PSVECAdd(var_r30 + 0x18, &sp8, &sp14); -// PSVECSubtract(&sp14, &lbl_1_data_514, &sp14); +// VECScale(var_r30 + 0x24, &sp8, var_f31); +// VECAdd(var_r30 + 0x18, &sp8, &sp14); +// VECSubtract(&sp14, &lbl_1_data_514, &sp14); // var_r24 = (0.028235294f * sp14.z) * 0x30; // var_r25 = (0.028235294f * sp14) + var_r24; // var_r25 += lbl_1_bss_DBC->data; @@ -3392,7 +3392,7 @@ void fn_1_A688(omObjData *object) { } // var_r31 = var_r27->data; // if ((var_r31 != NULL) && (var_r31->unk_68 != 0)) { // var_r31->unk_68 = 0; -// PSVECAdd(var_r31 + 0x6C, var_r31 + 0x4C, &sp14); +// VECAdd(var_r31 + 0x6C, var_r31 + 0x4C, &sp14); // var_r31->unk_64 = fn_1_AE18(var_r27->work[0], &sp14, var_r31 + 0x58); // } // } @@ -3429,11 +3429,11 @@ void fn_1_A688(omObjData *object) { } // var_r30 = 0; // var_r28 = 0; // var_f28 = 100.0f * (4.5f - (2.0f * var_f25)); -// var_f31 = PSVECMag(var_r29); +// var_f31 = VECMag(var_r29); // if (var_f31 > 280.0f) { // if (var_f31 > 560.0f) { // var_r28 = 1; -// PSVECNormalize(var_r29, &sp14); +// VECNormalize(var_r29, &sp14); // } // var_f31 -= 280.0f; // var_f31 *= 0.12987013f; @@ -3456,17 +3456,17 @@ void fn_1_A688(omObjData *object) { } // sp8 = sind(var_r31->unk_08); // spC = 0.0f; // sp10 = cosd(var_r31->unk_08); -// PSVECScale(&sp8, &sp20, 600.0f + (100.0f * (8.0f * var_f25))); +// VECScale(&sp8, &sp20, 600.0f + (100.0f * (8.0f * var_f25))); // var_f30 = fn_1_B440(var_r29, &sp2C, &sp20); // if ((var_f30 > -0.2f) && (var_f30 < 1.0f)) { -// PSVECScale(&sp20, &sp20, var_f30); -// PSVECAdd(&sp2C, &sp20, &sp2C); -// PSVECSubtract(&sp2C, var_r29, &sp20); -// var_f31 = PSVECMag(&sp20); +// VECScale(&sp20, &sp20, var_f30); +// VECAdd(&sp2C, &sp20, &sp2C); +// VECSubtract(&sp2C, var_r29, &sp20); +// var_f31 = VECMag(&sp20); // if (var_f31 < var_f28) { // var_f29 = 0.0f; // if (var_r28 != 0) { -// var_f29 = PSVECDotProduct(&sp14, &sp8); +// var_f29 = VECDotProduct(&sp14, &sp8); // var_f27 = fabs(var_f29); // var_f29 = 1.0 - var_f27; // var_f29 = var_f29; @@ -3488,8 +3488,8 @@ void fn_1_A688(omObjData *object) { } // } // else { // block_18: -// PSVECSubtract(var_r29, &sp2C, &sp20); -// var_f31 = PSVECMag(&sp20); +// VECSubtract(var_r29, &sp2C, &sp20); +// var_f31 = VECMag(&sp20); // if (var_f31 < 600.0f) { // var_f31 = 800.0f - var_f31; // var_f31 = 20.0f + (0.1f * var_f31); @@ -3571,7 +3571,7 @@ void fn_1_A688(omObjData *object) { } // var_r19 = 0x2710; // var_r18 = 0; // for (var_r30 = 0; var_r30 < 9; var_r30++) { -// PSVECAdd(&sp40, &lbl_1_data_60C[var_r30], &sp34); +// VECAdd(&sp40, &lbl_1_data_60C[var_r30], &sp34); // sp18 = var_r17 + lbl_1_data_5E8[var_r30]; // var_r21 = &lbl_1_bss_C[lbl_1_data_708[var_r30]] + 0x156; // var_f31 = 0.0f; @@ -3583,7 +3583,7 @@ void fn_1_A688(omObjData *object) { } // for (var_r23 = 0; var_r23 < 3; var_r23++) { // for (var_r28 = 0; var_r28 < 9; var_r28++) { // var_r24 = var_r22 + lbl_1_data_5E8[var_r28]; -// PSVECAdd(&sp28, &lbl_1_data_60C[var_r28], &sp4C); +// VECAdd(&sp28, &lbl_1_data_60C[var_r28], &sp4C); // if ((lbl_1_bss_DBC->data <= var_r24) && ((lbl_1_bss_DBC->data + 0x900) > var_r24)) { // var_f27 = sp4C; // var_f25 = fabs(var_f27); @@ -3606,9 +3606,9 @@ void fn_1_A688(omObjData *object) { } // for (var_r26 = 0; var_r26 < 4; var_r26++) { // if (var_r26 != sp8) { // var_r25 = lbl_1_bss_DC4[var_r26]->data; -// PSVECSubtract(&sp4C, var_r25 + 0x6C, &sp1C); +// VECSubtract(&sp4C, var_r25 + 0x6C, &sp1C); // sp1C.y = 0.0f; -// var_f30 = PSVECMag(&sp1C); +// var_f30 = VECMag(&sp1C); // if (var_f30 < var_f29) { // var_f30 = var_f29 - var_f30; // var_f30 *= 40.0f / var_f29; @@ -3631,7 +3631,7 @@ void fn_1_A688(omObjData *object) { } // } // } // } -// PSVECAdd(&sp28, &lbl_1_data_69C[var_r30], &sp28); +// VECAdd(&sp28, &lbl_1_data_69C[var_r30], &sp28); // var_r22 += lbl_1_data_678[var_r30]; // var_r21 = &var_r21[lbl_1_data_72C[var_r30]]; // var_f31 *= 2.0f; @@ -3667,9 +3667,9 @@ void fn_1_A688(omObjData *object) { } // sp8 = arg0; // spC = arg1; // var_r31 = arg2; -// PSVECSubtract(spC, sp8, &sp10); -// var_f31 = PSVECDotProduct(&sp10, var_r31); -// var_f30 = -PSVECSquareMag(var_r31); +// VECSubtract(spC, sp8, &sp10); +// var_f31 = VECDotProduct(&sp10, var_r31); +// var_f30 = -VECSquareMag(var_r31); // if (var_f30 != 0.0f) { // var_f31 /= var_f30; // } diff --git a/src/REL/m440Dll/main.c b/src/REL/m440Dll/main.c index 0ac4613e..85f9bd0b 100644 --- a/src/REL/m440Dll/main.c +++ b/src/REL/m440Dll/main.c @@ -1688,7 +1688,7 @@ void fn_1_71FC(unkStruct6 *arg0, Vec *arg1, s16 arg2, Vec arg3) sp1C.x = temp_r30->unk68[0]; sp1C.y = temp_r30->unk68[1]; sp1C.z = temp_r30->unk68[2]; - PSVECNormalize(&sp1C, &sp1C); + VECNormalize(&sp1C, &sp1C); var_f31 = var_f30 = var_f29 = 0.0f; for (var_r31 = 0; var_r31 < 3; var_r31++) { @@ -2051,7 +2051,7 @@ void fn_1_8AC4(Mtx arg0) if ((var_r29->unk_00 & 0x8000) != 0) { PSMTXMultVecSR(Hu3DCameraMtx, &sp34, &sp34); } - var_f30 = PSVECDotProduct(&sp34, &sp10); + var_f30 = VECDotProduct(&sp34, &sp10); var_f30 *= 10000.0f; OSf32tos16(&var_f30, &temp_r31); if (temp_r31 == -0x2710) { @@ -2067,8 +2067,8 @@ void fn_1_8AC4(Mtx arg0) PSMTXIdentity(sp40); } else { - PSVECCrossProduct(&sp28, &sp10, &sp1C); - var_f29 = acosf(PSVECDotProduct(&sp10, &sp28)); + VECCrossProduct(&sp28, &sp10, &sp1C); + var_f29 = acosf(VECDotProduct(&sp10, &sp28)); PSMTXRotAxisRad(sp40, &sp1C, var_f29); } PSMTXConcat(sp40, sp70, spA0); @@ -2483,20 +2483,20 @@ void fn_1_9C04(ModelData *arg0, Mtx arg1) else { if (0.0f == var_r29->unk44) { fn_1_A328((Vec *)&sp68[0], &sp38, &var_r29->unk48, 4); - PSVECAdd(&sp38, &var_r29->unk54, var_r31++); - PSVECAdd(&sp44, &var_r29->unk54, var_r31++); - PSVECAdd(&sp50, &var_r29->unk54, var_r31++); - PSVECAdd(&sp5C, &var_r29->unk54, var_r31++); + VECAdd(&sp38, &var_r29->unk54, var_r31++); + VECAdd(&sp44, &var_r29->unk54, var_r31++); + VECAdd(&sp50, &var_r29->unk54, var_r31++); + VECAdd(&sp5C, &var_r29->unk54, var_r31++); } else { fn_1_A328(&temp_r30->unk2C, &sp38, &var_r29->unk48, 4); PSMTXRotRad(spC8, 0x5A, 0.017453292f * var_r29->unk44); PSMTXConcat(sp128, spC8, sp98); PSMTXMultVecArray(sp98, &sp38, &sp8, 4); - PSVECAdd(&sp8, &var_r29->unk54, var_r31++); - PSVECAdd(&sp14, &var_r29->unk54, var_r31++); - PSVECAdd(&sp20, &var_r29->unk54, var_r31++); - PSVECAdd(&sp2C, &var_r29->unk54, var_r31++); + VECAdd(&sp8, &var_r29->unk54, var_r31++); + VECAdd(&sp14, &var_r29->unk54, var_r31++); + VECAdd(&sp20, &var_r29->unk54, var_r31++); + VECAdd(&sp2C, &var_r29->unk54, var_r31++); } if (var_r29->unk60 != -1) { fn_1_A284(var_r27, temp_r30->unk5C, var_r29->unk60, temp_r30->unk60, temp_r30->unk64); diff --git a/src/REL/m441Dll/main.c b/src/REL/m441Dll/main.c index 6d3414e5..3bee3e76 100644 --- a/src/REL/m441Dll/main.c +++ b/src/REL/m441Dll/main.c @@ -476,7 +476,7 @@ void fn_1_1FC4(Vec *arg0, float *arg1, s32 arg2, s32 arg3) var_r30 = 1; } } - PSVECAdd((Vec *)&arg0, &sp18, (Vec *)&arg0); + VECAdd((Vec *)&arg0, &sp18, (Vec *)&arg0); } omObjData *lbl_1_bss_4C; diff --git a/src/REL/m442Dll/main.c b/src/REL/m442Dll/main.c index 4f3de7a0..267d7377 100644 --- a/src/REL/m442Dll/main.c +++ b/src/REL/m442Dll/main.c @@ -237,7 +237,7 @@ void ObjectSetup(void) lbl_1_bss_14.x = lbl_1_data_60.x - lbl_1_data_54.x; lbl_1_bss_14.y = lbl_1_data_60.y - lbl_1_data_54.y; lbl_1_bss_14.z = lbl_1_data_60.z - lbl_1_data_54.z; - PSVECNormalize(&lbl_1_bss_14, &lbl_1_bss_14); + VECNormalize(&lbl_1_bss_14, &lbl_1_bss_14); var_r29 = Hu3DGLightCreateV(&lbl_1_data_54, &lbl_1_bss_14, &lbl_1_data_6C); Hu3DGLightInfinitytSet(var_r29); Hu3DGLightStaticSet(var_r29, 1); @@ -597,8 +597,8 @@ void fn_1_1230(omObjData *object) var_r30 = object->data; var_f28 = 1.0f; - PSVECSubtract(&var_r30->unk_70, &object->trans, &sp18); - var_f30 = PSVECMag(&sp18); + VECSubtract(&var_r30->unk_70, &object->trans, &sp18); + var_f30 = VECMag(&sp18); if (var_f30 < 300.0f) { if (var_f30 < 140.0f) { if ((frand() & 1) == 0) { @@ -610,7 +610,7 @@ void fn_1_1230(omObjData *object) } else { var_f29 = 32.0f; - PSVECNormalize(&sp18, &sp18); + VECNormalize(&sp18, &sp18); var_r30->unk_06 = sp18.x * var_f29; var_r30->unk_07 = -sp18.z * var_f29; } @@ -627,8 +627,8 @@ void fn_1_1230(omObjData *object) var_r27 = omGetGroupMemberListEx(HuPrcCurrentGet(), 0); for (var_r28 = 0; var_r28 < 1; var_r28++) { if (var_r27[var_r28] != object) { - PSVECSubtract(&lbl_1_bss_C084[var_r31 + 1][var_r29 + 1].unk_00, &var_r27[var_r28]->trans, &sp18); - var_f30 = PSVECMag(&sp18); + VECSubtract(&lbl_1_bss_C084[var_r31 + 1][var_r29 + 1].unk_00, &var_r27[var_r28]->trans, &sp18); + var_f30 = VECMag(&sp18); if (var_f30 < 800.0f) { var_f31 = cosd(((90.0f * var_f30) / 800.0f)); var_f31 *= var_f31; @@ -642,8 +642,8 @@ void fn_1_1230(omObjData *object) for (var_r28 = 0; var_r28 < 15; var_r28++) { var_r19 = var_r27[var_r28]->data; if (var_r19->unk_00_field0) { - PSVECSubtract(&lbl_1_bss_C084[var_r31 + 1][var_r29 + 1].unk_00, &var_r27[var_r28]->trans, &sp18); - var_f30 = PSVECMag(&sp18); + VECSubtract(&lbl_1_bss_C084[var_r31 + 1][var_r29 + 1].unk_00, &var_r27[var_r28]->trans, &sp18); + var_f30 = VECMag(&sp18); if (var_f30 < 800.0f) { var_f31 = cosd(((90.0f * var_f30) / 800.0f)); var_f31 *= var_f31; @@ -735,8 +735,8 @@ void fn_1_1230(omObjData *object) } } } while (var_r22 != 0); - PSVECSubtract(&lbl_1_bss_C084[sp24[3] + 1][sp24[2] + 1].unk_00, &object->trans, &sp18); - var_f30 = PSVECMag(&sp18); + VECSubtract(&lbl_1_bss_C084[sp24[3] + 1][sp24[2] + 1].unk_00, &object->trans, &sp18); + var_f30 = VECMag(&sp18); var_f29 = 64.0f + (0.2f * (32.0f * var_r30->unk_12)); var_r30->unk_18 = fn_1_85E8(var_r30->unk_18, atan2d(sp18.x, sp18.z), 0.1f); var_r30->unk_06 = var_f29 * sind(var_r30->unk_18); @@ -1061,11 +1061,11 @@ s16 fn_1_31FC(omObjData *object) sp20.z = object->trans.z + (140.0f * sp8.z); if (sp20.x >= -800.0f && sp20.x < 800.0f && sp20.z >= -800.0f && sp20.z < 800.0f) { for (var_r27 = lbl_1_bss_C9F8, var_r28 = 0; var_r28 < lbl_1_bss_119F8; var_r28++, var_r27++) { - PSVECSubtract(&var_r27->unk_00, &sp20, &sp14); - var_f31 = PSVECMag(&sp14); - PSVECSubtract(&var_r27->unk_00, &object->trans, &sp14); - PSVECNormalize(&sp14, &sp14); - var_f29 = PSVECDotProduct(&sp14, &sp8); + VECSubtract(&var_r27->unk_00, &sp20, &sp14); + var_f31 = VECMag(&sp14); + VECSubtract(&var_r27->unk_00, &object->trans, &sp14); + VECNormalize(&sp14, &sp14); + var_f29 = VECDotProduct(&sp14, &sp8); if (var_f31 < var_f30 && var_f29 >= 0.0f) { var_f30 = var_f31; var_r29 = var_r28; @@ -1076,8 +1076,8 @@ s16 fn_1_31FC(omObjData *object) var_r26 = 1; } if (var_r29 >= 0 && lbl_1_bss_C9F8[var_r29].unk_0C < 3) { - PSVECSubtract(&object->trans, &lbl_1_bss_C9F8[var_r29].unk_00, &sp14); - PSVECNormalize(&sp14, &sp14); + VECSubtract(&object->trans, &lbl_1_bss_C9F8[var_r29].unk_00, &sp14); + VECNormalize(&sp14, &sp14); var_r31->unk_4C = (140.0f * sp14.x) + lbl_1_bss_C9F8[var_r29].unk_00.x; var_r31->unk_50 = 0.0f; var_r31->unk_54 = (140.0f * sp14.z) + lbl_1_bss_C9F8[var_r29].unk_00.z; @@ -1132,12 +1132,12 @@ void fn_1_3658(omObjData *object) for (var_r30 = 0; var_r30 < 15; var_r30++) { var_r28 = var_r29[var_r30]->data; if (var_r28->unk_00_field0) { - PSVECSubtract(&object->trans, &var_r29[var_r30]->trans, &spC); - var_f31 = PSVECMag(&spC); + VECSubtract(&object->trans, &var_r29[var_r30]->trans, &spC); + var_f31 = VECMag(&spC); if (var_f31 < 70.0f) { var_f30 = 70.0f - var_f31; if (var_f31 != 0.0f) { - PSVECNormalize(&spC, &spC); + VECNormalize(&spC, &spC); } else { spC.x = 0.0f; @@ -1169,12 +1169,12 @@ void fn_1_37B8(omObjData *object) var_r29 = var_r28[var_r30]; if (object != var_r29) { sp8 = var_r29->data; - PSVECSubtract(&object->trans, &var_r29->trans, &sp10); - var_f31 = PSVECMag(&sp10); + VECSubtract(&object->trans, &var_r29->trans, &sp10); + var_f31 = VECMag(&sp10); if (var_f31 < 100.0f) { var_f30 = 100.0f - var_f31; if (var_f31 != 0.0f) { - PSVECNormalize(&sp10, &sp10); + VECNormalize(&sp10, &sp10); } else { sp10.x = 0.0f; @@ -1210,12 +1210,12 @@ void fn_1_3908(omObjData *object) var_r31 = var_r28[var_r29]; if (object != var_r31) { var_r26 = var_r31->data; - PSVECSubtract(&object->trans, &var_r31->trans, &sp8); - var_f27 = PSVECMag(&sp8); + VECSubtract(&object->trans, &var_r31->trans, &sp8); + var_f27 = VECMag(&sp8); if (var_f27 < 100.0f) { var_f31 = 100.0f - var_f27; - var_f29 = PSVECMag(&var_r27->unk_24); - var_f26 = PSVECMag(&var_r26->unk_24); + var_f29 = VECMag(&var_r27->unk_24); + var_f26 = VECMag(&var_r26->unk_24); if (var_f29 + var_f26 == 0.0f) { var_f30 = var_f28 = 0.5f; } @@ -1223,7 +1223,7 @@ void fn_1_3908(omObjData *object) var_f30 = var_f29 / (var_f29 + var_f26); var_f28 = 1.0f - var_f30; } - PSVECNormalize(&sp8, &sp8); + VECNormalize(&sp8, &sp8); object->trans.x += var_f28 * (sp8.x * var_f31); object->trans.z += var_f28 * (sp8.z * var_f31); var_r31->trans.x += var_f30 * (-sp8.x * var_f31); @@ -1247,17 +1247,17 @@ s32 fn_1_3AE4(omObjData *object, Vec *arg1) s32 var_r28; sp8 = object->data; - PSVECSubtract(arg1, &object->trans, &spC); - PSVECNormalize(&spC, &spC); + VECSubtract(arg1, &object->trans, &spC); + VECNormalize(&spC, &spC); var_r30 = omGetGroupMemberListEx(HuPrcCurrentGet(), 0); var_r28 = 1; for (var_r31 = 0; var_r31 < 1; var_r31++) { if (object != var_r30[var_r31]) { - PSVECSubtract(&var_r30[var_r31]->trans, arg1, &sp18); - var_f30 = PSVECMag(&sp18); - PSVECSubtract(&var_r30[var_r31]->trans, &object->trans, &sp18); - PSVECNormalize(&sp18, &sp18); - var_f31 = PSVECDotProduct(&sp18, &spC); + VECSubtract(&var_r30[var_r31]->trans, arg1, &sp18); + var_f30 = VECMag(&sp18); + VECSubtract(&var_r30[var_r31]->trans, &object->trans, &sp18); + VECNormalize(&sp18, &sp18); + var_f31 = VECDotProduct(&sp18, &spC); if (var_f31 >= 0.0f && var_f30 < 80.0f) { var_r28 = 0; } @@ -1639,8 +1639,8 @@ s32 fn_1_59C0(Vec *arg0) s32 var_r31; for (var_r31 = 0; var_r31 < lbl_1_bss_119F8; var_r31++) { - PSVECSubtract(&lbl_1_bss_C9F8[var_r31].unk_00, arg0, &spC); - if (PSVECMag(&spC) < 50.0f) { + VECSubtract(&lbl_1_bss_C9F8[var_r31].unk_00, arg0, &spC); + if (VECMag(&spC) < 50.0f) { return var_r31; } } @@ -1804,7 +1804,7 @@ void fn_1_64B4(ModelData *model, ParticleData *particle, Mtx matrix) var_r31->unk08.x = 20.0f; var_r31->unk08.y = 100.0f; var_r31->unk08.z = 0.0f; - PSVECNormalize(&var_r31->unk08, &var_r31->unk08); + VECNormalize(&var_r31->unk08, &var_r31->unk08); var_r31->unk40.r = var_r31->unk40.g = var_r31->unk40.b = var_r31->unk40.a = 0xFF; } var_r31 = var_r29->unk_48; @@ -1840,7 +1840,7 @@ void fn_1_64B4(ModelData *model, ParticleData *particle, Mtx matrix) sp20.x = sp38.x + (2500.0f * sp8.x); sp20.y = sp38.y + (2500.0f * sp8.y); sp20.z = sp38.z + (2500.0f * sp8.z); - var_f31 = -PSVECDotProduct(&var_r31->unk08, &sp14); + var_f31 = -VECDotProduct(&var_r31->unk08, &sp14); if (var_f31 >= 0.0f) { espTPLvlSet(particle->unk_02, 0.5f * var_f31 * var_f31); } @@ -2016,8 +2016,8 @@ s32 fn_1_75DC(Vec *arg0) for (var_r30 = 0; var_r30 < 15; var_r30++) { var_r28 = var_r29[var_r30]->data; if (var_r28->unk_00_field0 == 0) { - PSVECSubtract(&var_r29[var_r30]->trans, arg0, &spC); - var_f31 = PSVECMag(&spC); + VECSubtract(&var_r29[var_r30]->trans, arg0, &spC); + var_f31 = VECMag(&spC); if (var_f31 < 100.0f) { return var_r30; } diff --git a/src/REL/m444dll/main.c b/src/REL/m444dll/main.c index 126a778e..2560908d 100644 --- a/src/REL/m444dll/main.c +++ b/src/REL/m444dll/main.c @@ -1439,15 +1439,15 @@ void fn_1_7290(omObjData *object) + (dir.x * (offset.x * offset.z * (1.0 - cosd(z_rot)) - offset.y * sind(z_rot)) + dir.y * (offset.y * offset.z * (1.0 - cosd(z_rot)) + offset.x * sind(z_rot))); - PSVECCrossProduct(&dir, &offset, &offset); - PSVECNormalize(&offset, &offset); + VECCrossProduct(&dir, &offset, &offset); + VECNormalize(&offset, &offset); stick_pos = (HuPadSubStkX[0] & 0xF8); if (stick_pos != 0) { lbl_1_bss_290[0].x += 0.05f * (offset.x * stick_pos); lbl_1_bss_290[0].y += 0.05f * (offset.y * stick_pos); lbl_1_bss_290[0].z += 0.05f * (offset.z * stick_pos); } - PSVECNormalize(&y_offset, &offset); + VECNormalize(&y_offset, &offset); stick_pos = -(HuPadSubStkY[0] & 0xF8); if (stick_pos != 0) { lbl_1_bss_290[0].x += 0.05f * (offset.x * stick_pos); diff --git a/src/REL/m447dll/player.c b/src/REL/m447dll/player.c index 6a311bff..20398245 100755 --- a/src/REL/m447dll/player.c +++ b/src/REL/m447dll/player.c @@ -528,7 +528,7 @@ void fn_1_5080(UnkM447Struct_04* arg0) { fn_1_7A6C(arg0); var_r30 = fn_1_7984(arg0); fn_1_1ED4(var_r30, &sp14); - PSVECSubtract(&sp14, &arg0->unk28, &sp8); + VECSubtract(&sp14, &arg0->unk28, &sp8); arg0->unk38 = fn_1_4F7C(arg0->unk38, atan2d(sp8.x, sp8.z), 1.0f); fn_1_71FC(arg0, 3, 0.0f, 8.0f, 0); arg0->unk20 = 1; @@ -695,7 +695,7 @@ void fn_1_5760(UnkM447Struct_04* arg0) { case 1: var_r30 = fn_1_7984(arg0); sp14 = lbl_1_bss_A4[var_r30]->unk10; - PSVECSubtract(&sp14, &arg0->unk28, &sp8); + VECSubtract(&sp14, &arg0->unk28, &sp8); arg0->unk38 = fn_1_4F7C(arg0->unk38, atan2d(sp8.x, sp8.z), 0.1f); if (arg0->unk60++ < 30) { break; diff --git a/src/REL/messDll/main.c b/src/REL/messDll/main.c index fe6119d4..9f861bf1 100755 --- a/src/REL/messDll/main.c +++ b/src/REL/messDll/main.c @@ -87,15 +87,15 @@ static void fn_1_300(omObjData *arg0) { sp8.z = sp14.x * (sp20.x * sp20.z * (1.0 - cosd(temp_f31)) - sp20.y * sind(temp_f31)) + sp14.y * (sp20.y * sp20.z * (1.0 - cosd(temp_f31)) + sp20.x * sind(temp_f31)) + sp14.z * (sp20.z * sp20.z + (1.0f - sp20.z * sp20.z) * cosd(temp_f31)); - PSVECCrossProduct(&sp14, &sp20, &sp20); - PSVECNormalize(&sp20, &sp20); + VECCrossProduct(&sp14, &sp20, &sp20); + VECNormalize(&sp20, &sp20); temp_r31 = HuPadSubStkX[0] & 0xF8; if (temp_r31 != 0) { Center.x += sp20.x * temp_r31 * 0.05f; Center.y += sp20.y * temp_r31 * 0.05f; Center.z += sp20.z * temp_r31 * 0.05f; } - PSVECNormalize(&sp8, &sp20); + VECNormalize(&sp8, &sp20); temp_r31 = -(HuPadSubStkY[0] & 0xF8); if (temp_r31 != 0) { Center.x += sp20.x * temp_r31 * 0.05f; diff --git a/src/REL/mgmodedll/mgmode.c b/src/REL/mgmodedll/mgmode.c index b4565103..110cbe9b 100644 --- a/src/REL/mgmodedll/mgmode.c +++ b/src/REL/mgmodedll/mgmode.c @@ -1232,15 +1232,15 @@ void fn_1_5974(omObjData *object) + (dir.x * (offset.x * offset.z * (1.0 - cosd(z_rot)) - offset.y * sind(z_rot)) + dir.y * (offset.y * offset.z * (1.0 - cosd(z_rot)) + offset.x * sind(z_rot))); - PSVECCrossProduct(&dir, &offset, &offset); - PSVECNormalize(&offset, &offset); + VECCrossProduct(&dir, &offset, &offset); + VECNormalize(&offset, &offset); stick_pos = (HuPadSubStkX[0] & 0xF8); if (stick_pos != 0) { lbl_1_bss_274[0].x += 0.05f * (offset.x * stick_pos); lbl_1_bss_274[0].y += 0.05f * (offset.y * stick_pos); lbl_1_bss_274[0].z += 0.05f * (offset.z * stick_pos); } - PSVECNormalize(&y_offset, &offset); + VECNormalize(&y_offset, &offset); stick_pos = -(HuPadSubStkY[0] & 0xF8); if (stick_pos != 0) { lbl_1_bss_274[0].x += 0.05f * (offset.x * stick_pos); diff --git a/src/REL/modeltestDll/main.c b/src/REL/modeltestDll/main.c index 85e6f2ad..6a31b39b 100644 --- a/src/REL/modeltestDll/main.c +++ b/src/REL/modeltestDll/main.c @@ -351,7 +351,7 @@ static inline void HuControlCamCenter(Point3d *sp18, Point3d *sp30) Center.y += 0.05f * (sp30->y * temp_r28); Center.z += 0.05f * (sp30->z * temp_r28); } - PSVECNormalize(sp18, sp30); + VECNormalize(sp18, sp30); temp_r28 = -(HuPadSubStkY[0] & 0xF8); if (temp_r28 != 0) { Center.x += 0.05f * (sp30->x * temp_r28); @@ -489,8 +489,8 @@ void fn_1_F9C(struct om_obj_data *omData) + (sp24.x * (sp30.x * sp30.z * (1.0 - cos((M_PI * temp_f31) / 180.0)) - sp30.y * sin((M_PI * temp_f31) / 180.0)) + sp24.y * (sp30.y * sp30.z * (1.0 - cos((M_PI * temp_f31) / 180.0)) + sp30.x * sin((M_PI * temp_f31) / 180.0))); - PSVECCrossProduct(&sp24, &sp30, &sp30); - PSVECNormalize(&sp30, &sp30); + VECCrossProduct(&sp24, &sp30, &sp30); + VECNormalize(&sp30, &sp30); if (lbl_1_bss_C == 0) { HuControlCamCenter(&sp18, &sp30); diff --git a/src/REL/modeltestDll/modeltest00.c b/src/REL/modeltestDll/modeltest00.c index ac8d4e0a..2f5eb8e1 100644 --- a/src/REL/modeltestDll/modeltest00.c +++ b/src/REL/modeltestDll/modeltest00.c @@ -60,7 +60,7 @@ static inline void HuControlCamCenter(Point3d *sp18, Point3d *sp30) { Center.y += 0.05f * (sp30->y * temp_r28); Center.z += 0.05f * (sp30->z * temp_r28); } - PSVECNormalize(sp18, sp30); + VECNormalize(sp18, sp30); temp_r28 = -(HuPadSubStkY[0] & 0xF8); if (temp_r28 != 0) { Center.x += 0.05f * (sp30->x * temp_r28); @@ -126,8 +126,8 @@ void fn_1_37DC(omObjData *) + (sp24.x * (sp30.x * sp30.z * (1.0 - cos((M_PI * temp_f31) / 180.0)) - sp30.y * sin((M_PI * temp_f31) / 180.0)) + sp24.y * (sp30.y * sp30.z * (1.0 - cos((M_PI * temp_f31) / 180.0)) + sp30.x * sin((M_PI * temp_f31) / 180.0))); - PSVECCrossProduct(&sp24, &sp30, &sp30); - PSVECNormalize(&sp30, &sp30); + VECCrossProduct(&sp24, &sp30, &sp30); + VECNormalize(&sp30, &sp30); HuControlCamCenter(&sp18, &sp30); } diff --git a/src/REL/modeltestDll/modeltest01.c b/src/REL/modeltestDll/modeltest01.c index 69dba59e..c76316a2 100644 --- a/src/REL/modeltestDll/modeltest01.c +++ b/src/REL/modeltestDll/modeltest01.c @@ -139,7 +139,7 @@ void fn_1_4DF8(omObjData *object) Center.y += 0.05f * (offset.y * temp_r31); Center.z += 0.05f * (offset.z * temp_r31); } - PSVECNormalize(&y_offset, &offset); + VECNormalize(&y_offset, &offset); temp_r31 = -(HuPadSubStkY[0] & 0xF8); if (temp_r31 != 0) { Center.x += 0.05f * (offset.x * temp_r31); diff --git a/src/REL/modeseldll/main.c b/src/REL/modeseldll/main.c index 84d5c977..7a9b949c 100644 --- a/src/REL/modeseldll/main.c +++ b/src/REL/modeseldll/main.c @@ -294,15 +294,15 @@ void fn_1_F40(omObjData *object) + (dir.x * (offset.x * offset.z * (1.0 - cos((M_PI * z_rot) / 180.0)) - offset.y * sin((M_PI * z_rot) / 180.0)) + dir.y * (offset.y * offset.z * (1.0 - cos((M_PI * z_rot) / 180.0)) + offset.x * sin((M_PI * z_rot) / 180.0))); - PSVECCrossProduct(&dir, &offset, &offset); - PSVECNormalize(&offset, &offset); + VECCrossProduct(&dir, &offset, &offset); + VECNormalize(&offset, &offset); stick_pos = (HuPadSubStkX[0] & 0xF8); if (stick_pos != 0) { lbl_1_bss_C[0].x += 0.05f * (offset.x * stick_pos); lbl_1_bss_C[0].y += 0.05f * (offset.y * stick_pos); lbl_1_bss_C[0].z += 0.05f * (offset.z * stick_pos); } - PSVECNormalize(&y_offset, &offset); + VECNormalize(&y_offset, &offset); stick_pos = -(HuPadSubStkY[0] & 0xF8); if (stick_pos != 0) { lbl_1_bss_C[0].x += 0.05f * (offset.x * stick_pos); diff --git a/src/REL/resultDll/main.c b/src/REL/resultDll/main.c index 52dcbd6a..7c27ee4c 100644 --- a/src/REL/resultDll/main.c +++ b/src/REL/resultDll/main.c @@ -1287,15 +1287,15 @@ void fn_1_5880(omObjData *object) + (dir.x * (offset.x * offset.z * (1.0 - cos((M_PI * z_rot) / 180.0)) - offset.y * sin((M_PI * z_rot) / 180.0)) + dir.y * (offset.y * offset.z * (1.0 - cos((M_PI * z_rot) / 180.0)) + offset.x * sin((M_PI * z_rot) / 180.0))); - PSVECCrossProduct(&dir, &offset, &offset); - PSVECNormalize(&offset, &offset); + VECCrossProduct(&dir, &offset, &offset); + VECNormalize(&offset, &offset); stick_pos = (HuPadSubStkX[0] & 0xF8); if (stick_pos != 0) { Center.x += 0.05f * (offset.x * stick_pos); Center.y += 0.05f * (offset.y * stick_pos); Center.z += 0.05f * (offset.z * stick_pos); } - PSVECNormalize(&y_offset, &offset); + VECNormalize(&y_offset, &offset); stick_pos = -(HuPadSubStkY[0] & 0xF8); if (stick_pos != 0) { Center.x += 0.05f * (offset.x * stick_pos); diff --git a/src/REL/w01Dll/main.c b/src/REL/w01Dll/main.c index 70dce0bd..b96e4e36 100755 --- a/src/REL/w01Dll/main.c +++ b/src/REL/w01Dll/main.c @@ -727,8 +727,8 @@ static void fn_1_1990(void) { temp_r3 = temp_r31; break; } - PSVECSubtract(&temp_r3->pos, &temp_r31->pos, &sp10); - var_f31 += PSVECMag(&sp10); + VECSubtract(&temp_r3->pos, &temp_r31->pos, &sp10); + var_f31 += VECMag(&sp10); if (var_f31 >= lbl_1_bss_640) { break; } @@ -755,11 +755,11 @@ static void fn_1_1B3C(void) { Vec spC; Mtx sp48; - PSVECSubtract(&lbl_1_bss_654, &lbl_1_bss_648, &sp30); + VECSubtract(&lbl_1_bss_654, &lbl_1_bss_648, &sp30); if (lbl_1_bss_6B3 != 0) { BoardModelPosGet(lbl_1_bss_6C4[1], &sp3C); - PSVECSubtract(&sp3C, &lbl_1_bss_654, &sp18); - PSVECNormalize(&sp18, &sp18); + VECSubtract(&sp3C, &lbl_1_bss_654, &sp18); + VECNormalize(&sp18, &sp18); sp24 = lbl_1_bss_648; spC = lbl_1_bss_654; BoardMTXCalcLookAt(sp48, &spC, &sp18, &sp24); @@ -811,10 +811,10 @@ static void fn_1_1FA4(void) { spC.x = lbl_1_bss_648.x; spC.y = lbl_1_bss_648.y + 200.0f; spC.z = lbl_1_bss_648.z; - PSVECSubtract(&spC, &lbl_1_bss_618, &spC); - PSVECScale(&spC, &spC, 0.08f); - PSVECAdd(&spC, &lbl_1_bss_618, &lbl_1_bss_618); - PSVECSubtract(&lbl_1_bss_654, &lbl_1_bss_648, &spC); + VECSubtract(&spC, &lbl_1_bss_618, &spC); + VECScale(&spC, &spC, 0.08f); + VECAdd(&spC, &lbl_1_bss_618, &lbl_1_bss_618); + VECSubtract(&lbl_1_bss_654, &lbl_1_bss_648, &spC); if (spC.x != 0.0f || spC.z != 0.0f) { temp_f29 = atan2f(spC.y, VECMagXZ(&spC)); temp_f28 = atan2f(-spC.x, -spC.z); @@ -836,9 +836,9 @@ static void fn_1_1FA4(void) { sp18.x = sp18.x + var_f27 * sin(1.4137166738510132); // TODO: should be sind(81) sp18.y = sp18.y + -150.0f; sp18.z = sp18.z + var_f27 * cos(1.4137166738510132); // TODO: should be cosd(81) - PSVECSubtract(&sp18, &lbl_1_bss_630, &spC); - PSVECScale(&spC, &spC, lbl_1_bss_66C); - PSVECAdd(&spC, &lbl_1_bss_630, &lbl_1_bss_630); + VECSubtract(&sp18, &lbl_1_bss_630, &spC); + VECScale(&spC, &spC, lbl_1_bss_66C); + VECAdd(&spC, &lbl_1_bss_630, &lbl_1_bss_630); } else { if (lbl_1_bss_66C < 0.08f) { lbl_1_bss_66C += 0.00066666666f; @@ -846,10 +846,10 @@ static void fn_1_1FA4(void) { spC.x = 400.0 * (sin(temp_f28) * cos(temp_f29)); spC.y = 400.0 * -sin(temp_f29); spC.z = 400.0 * (cos(temp_f28) * cos(temp_f29)); - PSVECAdd(&lbl_1_bss_618, &spC, &spC); - PSVECSubtract(&spC, &lbl_1_bss_630, &spC); - PSVECScale(&spC, &spC, lbl_1_bss_66C); - PSVECAdd(&spC, &lbl_1_bss_630, &lbl_1_bss_630); + VECAdd(&lbl_1_bss_618, &spC, &spC); + VECSubtract(&spC, &lbl_1_bss_630, &spC); + VECScale(&spC, &spC, lbl_1_bss_66C); + VECAdd(&spC, &lbl_1_bss_630, &lbl_1_bss_630); } } @@ -870,8 +870,8 @@ static float fn_1_2524(void) { for (i = 0; i < 24; i++) { if (lbl_1_bss_600[i] == 0) { BoardModelPosGet(lbl_1_bss_5D0[i], &sp18); - PSVECSubtract(&sp18, &sp24, &spC); - if (!(PSVECMag(&spC) > 400.0f)) { + VECSubtract(&sp18, &sp24, &spC); + if (!(VECMag(&spC) > 400.0f)) { break; } } @@ -879,7 +879,7 @@ static float fn_1_2524(void) { if (i == 24) { return 0.0f; } - PSVECSubtract(&sp18, &sp24, &spC); + VECSubtract(&sp18, &sp24, &spC); var_f30 = atan2d(spC.x, spC.z); if (var_f30 > 0.0f) { var_f30 = 45.0f; @@ -944,7 +944,7 @@ static void fn_1_2F18(void) { var_f29 -= 360.0f; } BoardModelPosGet(lbl_1_bss_6C4[0], &spC); - PSVECSubtract(&lbl_1_bss_654, &lbl_1_bss_648, &sp18); + VECSubtract(&lbl_1_bss_654, &lbl_1_bss_648, &sp18); if (sp18.z != 0.0f || sp18.x != 0.0f) { sp24.y = atan2d(sp18.x, sp18.z); sp24.x = -atan2d(sp18.y, VECMagXZ(&sp18)); @@ -961,7 +961,7 @@ static void fn_1_2F18(void) { sp30.x = spD8[0][3]; sp30.y = spD8[1][3]; sp30.z = spD8[2][3]; - PSVECAdd(&sp30, &spC, &sp30); + VECAdd(&sp30, &spC, &sp30); if (var_f29 < 27.000002f && var_f29 > -27.000002f) { return; } @@ -1004,8 +1004,8 @@ static void fn_1_3350(void) { lbl_1_bss_654.x = temp_r31->data.curr.pos.x; lbl_1_bss_654.y = temp_r31->data.curr.pos.y; lbl_1_bss_654.z = temp_r31->data.curr.pos.z; - PSVECSubtract(&lbl_1_bss_648, &lbl_1_bss_654, &sp8); - lbl_1_bss_640 += PSVECMag(&sp8); + VECSubtract(&lbl_1_bss_648, &lbl_1_bss_654, &sp8); + lbl_1_bss_640 += VECMag(&sp8); } static s32 lbl_1_data_594[8][2] = { @@ -1271,8 +1271,8 @@ static s32 fn_1_48B4(void) { temp_r28 = BoardSpaceLinkFlagSearch(0, temp_r30, 0x02000000); BoardSpacePosGet(0, temp_r30, &sp20); BoardSpacePosGet(0, temp_r28, &sp14); - PSVECSubtract(&sp14, &sp20, &sp8); - PSVECNormalize(&sp8, &sp8); + VECSubtract(&sp14, &sp20, &sp8); + VECNormalize(&sp8, &sp8); var_f31 = atan2d(-sp8.x, -sp8.z); BoardPlayerRotSet(lbl_1_bss_6B4, 0.0f, var_f31, 0.0f); BoardPlayerMoveBetween(lbl_1_bss_6B4, temp_r30, temp_r28); @@ -1329,8 +1329,8 @@ static s32 fn_1_48B4(void) { BoardWinKill(); } BoardCameraTargetPlayerSet(lbl_1_bss_6B4); - PSVECSubtract(&sp20, &sp14, &sp8); - PSVECNormalize(&sp8, &sp8); + VECSubtract(&sp20, &sp14, &sp8); + VECNormalize(&sp8, &sp8); var_f31 = atan2d(-sp8.x, -sp8.z); BoardPlayerRotSet(lbl_1_bss_6B4, 0.0f, var_f31, 0.0f); BoardPlayerMoveBetween(lbl_1_bss_6B4, temp_r28, temp_r30); @@ -1408,8 +1408,8 @@ static void fn_1_50D4(void) { var_r27 = var_r26; var_r29 = 0; } - PSVECSubtract(&sp14, &temp_r31->pos, &sp8); - PSVECNormalize(&sp8, &sp8); + VECSubtract(&sp14, &temp_r31->pos, &sp8); + VECNormalize(&sp8, &sp8); var_f31 = atan2d(sp8.z, sp8.x); if (var_r27 != 0) { var_f31 += 180.0f; @@ -1681,7 +1681,7 @@ static void fn_1_6194(Bss18Work *arg0, omObjData *arg1) { var_f30 = 1000000.0f; for (i = 0; i < 3; i++) { Hu3DModelObjPosGet(BoardModelIDGet(arg0->unk04), lbl_1_data_604[i], &sp8); - temp_f31 = PSVECSquareDistance(&sp8, &sp20); + temp_f31 = VECSquareDistance(&sp8, &sp20); if (temp_f31 < var_f30) { var_f30 = temp_f31; lbl_1_bss_28 = i; @@ -1691,7 +1691,7 @@ static void fn_1_6194(Bss18Work *arg0, omObjData *arg1) { Hu3DModelObjMtxGet(BoardModelIDGet(arg0->unk04), lbl_1_data_604[lbl_1_bss_28], sp38); Hu3DMtxRotGet(&sp38, &sp14); sp14.y = 180.0f; - PSVECSubtract(&sp2C, &sp20, &sp8); + VECSubtract(&sp2C, &sp20, &sp8); arg1->trans.x = sp8.x / 25.0f; arg1->trans.z = sp8.z / 25.0f; var_r28 = BoardPlayerRotYGet(GWSystem.player_curr); @@ -1772,7 +1772,7 @@ static void fn_1_6A14(Bss18Work *arg0, omObjData *arg1) { Hu3DModelObjPosGet(BoardModelIDGet(arg0->unk04), lbl_1_data_604[lbl_1_bss_28], &sp14); BoardPlayerPosSetV(GWSystem.player_curr, &sp14); BoardSpacePosGet(0, lbl_1_bss_24, &sp20); - PSVECSubtract(&sp20, &sp14, &sp8); + VECSubtract(&sp20, &sp14, &sp8); arg1->trans.x = sp8.x / 25.0f; arg1->trans.z = sp8.z / 25.0f; arg1->scale.x = sp20.x; @@ -1901,8 +1901,8 @@ static void fn_1_7528(s32 arg0, s32 arg1) { BoardSpacePosGet(0, arg1, &sp30); BoardModelPosGet(lbl_1_bss_6C4[23], &sp24); BoardModelPosGet(lbl_1_bss_6C4[28], &sp18); - temp_f31 = PSVECDistance(&sp24, &sp30); - temp_f30 = PSVECDistance(&sp18, &sp30); + temp_f31 = VECDistance(&sp24, &sp30); + temp_f30 = VECDistance(&sp18, &sp30); if (temp_f31 < temp_f30) { lbl_1_bss_29 = 0; } else { @@ -2156,7 +2156,7 @@ static void fn_1_8988(BssCData *arg0, omObjData *arg1) { } BoardModelPosGet(*lbl_1_bss_6C4, &sp20); BoardPlayerPosGet(arg0->unk01, &sp14); - PSVECSubtract(&sp20, &sp14, &sp8); + VECSubtract(&sp20, &sp14, &sp8); BoardPlayerRotYSet(arg0->unk01, atan2d(sp8.x, sp8.z)); arg0->unk00 = 1; } @@ -2198,7 +2198,7 @@ static void fn_1_8B6C(BssCData *arg0, omObjData *arg1) { BoardPlayerPosGet(arg0->unk01, &arg0->unk14); BoardModelPosGet(lbl_1_bss_6C4[0], &sp20); - PSVECSubtract(&sp20, &arg0->unk14, &sp14); + VECSubtract(&sp20, &arg0->unk14, &sp14); BoardPlayerRotYSet(arg0->unk01, -atan2d(sp14.x, sp14.z)); BoardPlayerMotionStart(arg0->unk01, 3, 0x40000001); BoardPlayerMotionSpeedSet(arg0->unk01, 2.0f); @@ -2217,7 +2217,7 @@ static void fn_1_8B6C(BssCData *arg0, omObjData *arg1) { sp14.x = sp8.x - var_r30->data.curr.pos.x; sp14.y = sp8.y - var_r30->data.curr.pos.y; sp14.z = sp8.z - var_r30->data.curr.pos.z; - var_f31 += PSVECMag(&sp14); + var_f31 += VECMag(&sp14); if (var_f31 >= arg0->unk10) { break; } @@ -2254,11 +2254,11 @@ static void fn_1_8DDC(BssCData *arg0, omObjData *arg1) { sp30.x = var_r30->data.curr.pos.x; sp30.y = var_r30->data.curr.pos.y; sp30.z = var_r30->data.curr.pos.z; - PSVECSubtract(&sp30, &arg0->unk14, &sp24); + VECSubtract(&sp30, &arg0->unk14, &sp24); if (fn_1_94A8(arg0) != 0) { BoardModelPosGet(lbl_1_bss_6C4[1], &sp18); - PSVECSubtract(&sp18, &sp30, &sp48); - PSVECNormalize(&sp48, &sp48); + VECSubtract(&sp18, &sp30, &sp48); + VECNormalize(&sp48, &sp48); var_r27 = &arg0->unk14; var_r26 = &sp30; BoardMTXCalcLookAt(sp54, var_r26, &sp48, var_r27); @@ -2295,7 +2295,7 @@ static void fn_1_918C(BssCData *arg0, omObjData *arg1) { BoardSpacePosGet(0, var_r30, &sp20); BoardPlayerPosGet(arg0->unk01, &sp14); BoardPlayerMtxSet(arg0->unk01, &arg0->unk20); - PSVECSubtract(&sp20, &sp14, &sp8); + VECSubtract(&sp20, &sp14, &sp8); BoardPlayerRotYSet(arg0->unk01, atan2d(-sp8.z, -sp8.x)); BoardPlayerPosLerpStart(arg0->unk01, &sp14, &sp20, 20); arg0->unk00 = 5; @@ -2344,7 +2344,7 @@ static void fn_1_932C(BssCData *arg0) { BoardSpaceFlagPosGet(0, 0x2000, &sp14); } for (i = 0; i < 2; i++) { - spC[i] = PSVECSquareDistance(&sp14, &sp20[i]); + spC[i] = VECSquareDistance(&sp14, &sp20[i]); } if (spC[0] < spC[1]) { arg0->unk06 = sp8[0]; @@ -2437,8 +2437,8 @@ static void fn_1_95F4(BssCData *arg0) { sp2C.x = var_r30->data.curr.pos.x; sp2C.y = var_r30->data.curr.pos.y; sp2C.z = var_r30->data.curr.pos.z; - PSVECSubtract(&sp2C, &sp20, &sp8); - var_f31 += PSVECMag(&sp8); + VECSubtract(&sp2C, &sp20, &sp8); + var_f31 += VECMag(&sp8); if (BoardVecMinDistCheck(&sp14, &sp2C, 150.0f)) { break; } @@ -2518,7 +2518,7 @@ static void fn_1_9A24(Bss20Work *arg0) { if (temp_r31->unk00 == -1) { temp_r31->unk00 = 10; Hu3DMtxTransGet(sp8, &temp_r31->unk08); - PSVECAdd(&lbl_1_bss_654, &temp_r31->unk08, &temp_r31->unk08); + VECAdd(&lbl_1_bss_654, &temp_r31->unk08, &temp_r31->unk08); temp_r31->unk14.x = 0.0f; temp_r31->unk14.y = 0.0f; temp_r31->unk14.z = 0.001f; @@ -2549,7 +2549,7 @@ static void fn_1_9BBC(Bss20Work *arg0) { if (temp_r31->unk00 <= 3) { temp_r31->unk04 = sind(30.0f * temp_r31->unk00); } - PSVECAdd(&temp_r31->unk08, &temp_r31->unk14, &temp_r31->unk08); + VECAdd(&temp_r31->unk08, &temp_r31->unk14, &temp_r31->unk08); BoardModelMtxSet(temp_r31->unk02, &lbl_1_bss_678); BoardModelPosSetV(temp_r31->unk02, &temp_r31->unk08); BoardModelScaleSet(temp_r31->unk02, temp_r31->unk04, temp_r31->unk04, temp_r31->unk04); diff --git a/src/REL/w01Dll/mg_coin.c b/src/REL/w01Dll/mg_coin.c index 9520710c..7d6eac1a 100755 --- a/src/REL/w01Dll/mg_coin.c +++ b/src/REL/w01Dll/mg_coin.c @@ -434,7 +434,7 @@ static void fn_1_A6E0(omObjData *arg0) { if (temp_r31->unk1C > 1.0f) { temp_r31->unk1C = 1.0f; } - PSVECAdd(&temp_r31->unk20, &temp_r31->unk2C, &temp_r31->unk20); + VECAdd(&temp_r31->unk20, &temp_r31->unk2C, &temp_r31->unk20); if (temp_r31->unk20.y >= 4.0f) { temp_r31->unk20.y = 4.0f; temp_r31->unk2C.y = -0.1f; @@ -870,8 +870,8 @@ static void fn_1_C894(omObjData *arg0) { } static void fn_1_C94C(Vec *arg0, Vec *arg1, Vec *arg2) { - PSVECSubtract(arg1, arg0, arg2); - PSVECNormalize(arg2, arg2); + VECSubtract(arg1, arg0, arg2); + VECNormalize(arg2, arg2); } static float fn_1_C998(Vec *arg0) { @@ -915,8 +915,8 @@ static u32 fn_1_CB44(Vec *arg0, float arg1) { float var_f31; BoardPlayerPosGet(lbl_1_bss_798, &sp18); - PSVECSubtract(arg0, &sp18, &sp24); - PSVECNormalize(&sp24, &sp24); + VECSubtract(arg0, &sp18, &sp24); + VECNormalize(&sp24, &sp24); var_f28 = fn_1_C998(&sp24); BoardPlayerRotGet(lbl_1_bss_798, &spC); var_f31 = spC.y; diff --git a/src/REL/w01Dll/mg_item.c b/src/REL/w01Dll/mg_item.c index a2c6333e..0a107490 100755 --- a/src/REL/w01Dll/mg_item.c +++ b/src/REL/w01Dll/mg_item.c @@ -292,19 +292,19 @@ static void fn_1_E44C(omObjData *arg0) { BoardAudSeqPause(0, 1, 1000); BoardPlayerPosGet(lbl_1_bss_7E4, &sp18); Hu3DModelObjPosGet(BoardModelIDGet(lbl_1_bss_6C4[17]), lbl_1_data_F9C[0], &spC); - var_f26 = PSVECSquareDistance(&sp18, &spC); + var_f26 = VECSquareDistance(&sp18, &spC); arg0->work[2] = 0; for (i = 1; i < 4; i++) { Hu3DModelObjPosGet(BoardModelIDGet(lbl_1_bss_6C4[17]), lbl_1_data_F9C[i], &spC); - temp_f27 = PSVECSquareDistance(&sp18, &spC); + temp_f27 = VECSquareDistance(&sp18, &spC); if (temp_f27 < var_f26) { var_f26 = temp_f27; arg0->work[2] = i; } } Hu3DModelObjPosGet(BoardModelIDGet(lbl_1_bss_6C4[17]), lbl_1_data_F9C[arg0->work[2]], &lbl_1_bss_7D8); - PSVECSubtract(&lbl_1_bss_7D8, &sp18, &spC); - PSVECNormalize(&spC, &spC); + VECSubtract(&lbl_1_bss_7D8, &sp18, &spC); + VECNormalize(&spC, &spC); arg0->trans.x = spC.x; arg0->trans.y = spC.y; arg0->trans.z = spC.z; @@ -455,8 +455,8 @@ static void fn_1_F3F8(omObjData *arg0) { return; } BoardPlayerPosGet(lbl_1_bss_7E4, &sp18); - PSVECSubtract(&lbl_1_bss_7C4, &sp18, &spC); - PSVECNormalize(&spC, &spC); + VECSubtract(&lbl_1_bss_7C4, &sp18, &spC); + VECNormalize(&spC, &spC); arg0->trans.x = spC.x; arg0->trans.y = spC.y; arg0->trans.z = spC.z; @@ -466,8 +466,8 @@ static void fn_1_F3F8(omObjData *arg0) { arg0->rot.z = sp18.y; arg0->scale.x = 0.0f; BoardPlayerMotionShiftSet(lbl_1_bss_7E4, 4, 0.0f, 5.0f, 0); - PSVECSubtract(&lbl_1_bss_7C4, &sp18, &spC); - PSVECNormalize(&spC, &spC); + VECSubtract(&lbl_1_bss_7C4, &sp18, &spC); + VECNormalize(&spC, &spC); BoardPlayerRotSet(lbl_1_bss_7E4, 0.0f, fn_1_10EB8(&spC), 0.0f); arg0->func = fn_1_F6E8; } @@ -737,8 +737,8 @@ static void fn_1_10820(omObjData *arg0) { sp18.y = 0.0f; sp18.z = arg0->trans.z; sp24.y = 0.0f; - PSVECSubtract(&sp24, &sp18, &spC); - PSVECNormalize(&spC, &spC); + VECSubtract(&sp24, &sp18, &spC); + VECNormalize(&spC, &spC); var_f28 = VECDistanceXZ(&sp24, &sp18); if (var_f28 < 8.0f) { arg0->trans.x = sp24.x; diff --git a/src/REL/w02Dll/roulette.c b/src/REL/w02Dll/roulette.c index 0ff58995..332b54ea 100644 --- a/src/REL/w02Dll/roulette.c +++ b/src/REL/w02Dll/roulette.c @@ -291,15 +291,15 @@ s32 fn_1_C108(s32 arg0) { sp1C.y = var_f27 - (0.55833334f * (0.25f * (var_f31 * var_f31))); var_f31 += 1.0f; BoardModelPosGet(lbl_1_bss_30[6], &sp28); - PSVECAdd(&sp28, &sp1C, &sp28); + VECAdd(&sp28, &sp1C, &sp28); var_f25 = VECDistanceXZ(&sp28, &sp10); if (var_f25 >= 430.0f) { if (sp28.y <= (55.0f + sp10.y)) { - PSVECSubtract(&sp28, &sp10, (Vec* ) &sp1C); - PSVECNormalize((Vec* ) &sp1C, (Vec* ) &sp1C); + VECSubtract(&sp28, &sp10, (Vec* ) &sp1C); + VECNormalize((Vec* ) &sp1C, (Vec* ) &sp1C); sp1C.y = 0.0f; - PSVECScale((Vec* ) &sp1C, (Vec* ) &sp1C, 429.0f); - PSVECAdd((Vec* ) &sp1C, &sp10, (Vec* ) &sp1C); + VECScale((Vec* ) &sp1C, (Vec* ) &sp1C, 429.0f); + VECAdd((Vec* ) &sp1C, &sp10, (Vec* ) &sp1C); sp28.x = sp1C.x; sp28.z = sp1C.z; sp1C.x = -5.0f; @@ -328,8 +328,8 @@ s32 fn_1_C108(s32 arg0) { } HuAudFXPlay(0x41E); - PSVECSubtract(&sp28, &sp10, (Vec* ) &sp1C); - PSVECNormalize((Vec* ) &sp1C, (Vec* ) &sp1C); + VECSubtract(&sp28, &sp10, (Vec* ) &sp1C); + VECNormalize((Vec* ) &sp1C, (Vec* ) &sp1C); var_f31 = atan2d(-sp1C.z, sp1C.x); BoardModelRotGet(lbl_1_bss_30[4], &sp34); var_f31 = var_f31 - sp34.y; @@ -351,8 +351,8 @@ s32 fn_1_C108(s32 arg0) { var_f31 = (22.5f * var_r30) + sp34.y; // TODO: Update rodata for asm change sp1C.x = cosd(var_f31); sp1C.z = -sind(var_f31); - PSVECScale(&sp1C, &sp1C, 429.0f); - PSVECAdd(&sp1C, &sp10, &sp1C); + VECScale(&sp1C, &sp1C, 429.0f); + VECAdd(&sp1C, &sp10, &sp1C); sp28.x = sp1C.x; sp28.z = sp1C.z; BoardModelPosSetV(lbl_1_bss_30[6], &sp28); @@ -370,8 +370,8 @@ s32 fn_1_C108(s32 arg0) { var_f31 = (22.5f * (f32) var_r30) + sp34.y; sp1C.x = cosd(var_f31); sp1C.z = -sind(var_f31); - PSVECScale(&sp1C, &sp1C, 429.0f); - PSVECAdd((Vec* ) &sp1C, &sp10, (Vec* ) &sp1C); + VECScale(&sp1C, &sp1C, 429.0f); + VECAdd((Vec* ) &sp1C, &sp10, (Vec* ) &sp1C); sp28.x = sp1C.x; sp28.z = sp1C.z; BoardModelPosSetV(lbl_1_bss_30[6], (Vec* ) &sp28); diff --git a/src/REL/w03Dll/condor.c b/src/REL/w03Dll/condor.c index e71f2139..bf19b8b3 100644 --- a/src/REL/w03Dll/condor.c +++ b/src/REL/w03Dll/condor.c @@ -210,7 +210,7 @@ s32 fn_1_3478(s32 arg0) BoardPlayerPosGet(arg0, &sp2C); temp = BoardSpaceLinkFlagSearch(0, temp_r28, 0x02000000); BoardSpacePosGet(0, temp, &sp38); - PSVECSubtract(&sp38, &sp2C, &sp20); + VECSubtract(&sp38, &sp2C, &sp20); float_temp = atan2(sp20.x, sp20.z) / M_PI * 180.0f; BoardPlayerMotBlendSet(arg0, (float_temp), 0xF); @@ -339,9 +339,9 @@ void fn_1_3968(s32 arg0) Hu3DModelObjPosGet(BoardModelIDGet(lbl_1_data_310), "itemhook_oya", &sp3C); BoardPlayerPosGet(arg0, &sp30); temp_f30 = BoardVecDistXZCalc(&sp3C, &sp30); - PSVECSubtract(&sp3C, &sp30, &sp24); - PSVECNormalize(&sp24, &sp24); - PSVECScale(&sp24, &sp24, temp_f30 / 45.0f); + VECSubtract(&sp3C, &sp30, &sp24); + VECNormalize(&sp24, &sp24); + VECScale(&sp24, &sp24, temp_f30 / 45.0f); BoardPlayerMotionShiftSet(arg0, 4, 0.0f, 5.0f, 0); HuPrcSleep(5); @@ -354,7 +354,7 @@ void fn_1_3968(s32 arg0) while (1) { temp_f31 = __OSs16tof32(&sp8); sp24.y = temp_f28 + (-0.08166667f * (0.75f * (temp_f31 * temp_f31))); - PSVECAdd(&sp30, &sp24, &sp30); + VECAdd(&sp30, &sp24, &sp30); temp_f30 = BoardVecDistXZCalc(&sp3C, &sp30); if (temp_f30 < 5.0f) { @@ -583,10 +583,10 @@ void fn_1_4424(w03StructUnk2 *arg0) BoardSpaceFlagPosGet(0, 0x8000U, &sp60); if (lbl_1_bss_0->unk1 != 0) { - PSVECSubtract(&sp6C, &sp60, &sp3C); + VECSubtract(&sp6C, &sp60, &sp3C); } else { - PSVECSubtract(&sp60, &sp6C, &sp3C); + VECSubtract(&sp60, &sp6C, &sp3C); } sp10_2 = 180.0f * (atan2(-sp3C.x, -sp3C.z) / M_PI); @@ -717,7 +717,7 @@ void fn_1_4ABC(w03StructUnk2 *arg0) if (temp_r31->unk_00 == 1) { temp_r31->unk_04 += 1.0f; temp_f31 = 0.8f * (temp_r31->unk_04 * temp_r31->unk_04); - PSVECAdd(&temp_r31->unk_14, &temp_r31->unk_08, &temp_r31->unk_08); + VECAdd(&temp_r31->unk_14, &temp_r31->unk_08, &temp_r31->unk_08); temp_r31->unk_08.y += -0.0375f * temp_f31; if (temp_r31->unk_08.y < -300.0f) { temp_r31->unk_00 = -1; @@ -914,8 +914,8 @@ void fn_1_50D4(omObjData *arg0) if (i != GWSystem.player_curr) { BoardPlayerPosGet(i, &sp50); BoardModelPosGet(lbl_1_data_310, &sp44); - PSVECSubtract(&sp50, &sp44, &sp38); - if (PSVECMag(&sp38) >= 2000.0f) { + VECSubtract(&sp50, &sp44, &sp38); + if (VECMag(&sp38) >= 2000.0f) { BoardModelVisibilitySet(BoardPlayerModelGet(i), 0); } else { @@ -1058,7 +1058,7 @@ void fn_1_5C5C(omObjData *arg0, w03UnkStruct5 *arg1) Hu3DModelObjPosGet(BoardModelIDGet(lbl_1_data_314), temp_r27, &sp44); if (0.0f != temp_r30->unk_64) { - PSVECSubtract(&sp38, &sp44, &sp2C); + VECSubtract(&sp38, &sp44, &sp2C); } else { sp2C.x = sp2C.y = sp2C.z = 0.0f; diff --git a/src/REL/w03Dll/mg_coin.c b/src/REL/w03Dll/mg_coin.c index 54c33285..2f039385 100644 --- a/src/REL/w03Dll/mg_coin.c +++ b/src/REL/w03Dll/mg_coin.c @@ -173,8 +173,8 @@ s32 fn_1_7D18(s32 arg0) temp_r28 = BoardSpaceLinkFlagSearch(0, space, 0x02000000); BoardPlayerPosGet(arg0, &sp2C); BoardSpacePosGet(0, temp_r28, &sp38); - PSVECSubtract(&sp38, &sp2C, &sp20); - PSVECNormalize(&sp20, &sp20); + VECSubtract(&sp38, &sp2C, &sp20); + VECNormalize(&sp20, &sp20); BoardPlayerRotYSet(arg0, 180.0 * (atan2(-sp20.x, -sp20.z) / M_PI)); HuPrcSleep(0x1E); model = BoardModelIDGet(lbl_1_bss_C[7]); @@ -196,7 +196,7 @@ s32 fn_1_7D18(s32 arg0) while (GWPlayer[arg0].moving != 0) { BoardModelPosGet(lbl_1_bss_C[10], &sp2C); BoardPlayerPosGet(arg0, &sp38); - PSVECSubtract(&sp38, &sp2C, &sp20); + VECSubtract(&sp38, &sp2C, &sp20); arctan = atan2(sp20.x, sp20.z) / M_PI * 180.0; BoardModelRotYSet(lbl_1_bss_C[10], arctan); HuPrcVSleep(); @@ -625,7 +625,7 @@ void fn_1_9230(s32 arg0) while (GWPlayer[arg0].moving != 0) { BoardModelPosGet(lbl_1_bss_C[10], &sp20); BoardPlayerPosGet(arg0, &sp14); - PSVECSubtract(&sp14, &sp20, &sp8); + VECSubtract(&sp14, &sp20, &sp8); rotY = atan2(sp8.x, sp8.z) / M_PI * 180.0; BoardModelRotYSet(lbl_1_bss_C[10], rotY); HuPrcVSleep(); diff --git a/src/REL/w03Dll/mg_item.c b/src/REL/w03Dll/mg_item.c index 0e0c6249..53e6d165 100644 --- a/src/REL/w03Dll/mg_item.c +++ b/src/REL/w03Dll/mg_item.c @@ -247,8 +247,8 @@ s32 fn_1_9CF4(s32 arg0) temp_r29 = BoardSpaceLinkFlagSearch(0, spaceCur, 0x02000000); BoardPlayerPosGet(arg0, &sp2C); BoardSpacePosGet(0, temp_r29, &sp38); - PSVECSubtract(&sp38, &sp2C, &sp20); - PSVECNormalize(&sp20, &sp20); + VECSubtract(&sp38, &sp2C, &sp20); + VECNormalize(&sp20, &sp20); BoardPlayerRotYSet(arg0, (f32)(180.0 * (atan2(-sp20.x, -sp20.z) / M_PI))); BoardPlayerPosLerpStart(arg0, &sp2C, &sp38, 0x14); @@ -285,7 +285,7 @@ void fn_1_9FE4(void) sp18.x = (-3179.800048828125 + (200.0 * sin(0.0))); sp18.z = (-907.7000122070313 + 200.0 * cos(0.0)); sp18.y = sp24.y; - PSVECSubtract(&sp18, &sp24, &spC); + VECSubtract(&sp18, &sp24, &spC); temp_f30 = (atan2(spC.z, spC.x) / M_PI * 180.0); sp8 = BoardModelRotYGet(lbl_1_bss_C[11]); BoardModelMotionShiftSet(lbl_1_bss_C[11], lbl_1_data_4DA, 0.0f, 10.0, 0x40000001); @@ -305,7 +305,7 @@ void fn_1_9FE4(void) var_f31 = 0.0f; while (var_f31 < 20.0f) { - PSVECAdd(&sp30, &spC, &sp30); + VECAdd(&sp30, &spC, &sp30); BoardModelPosSetV(lbl_1_bss_C[11], &sp30); HuPrcVSleep(); var_f31 += 1.0f; @@ -317,7 +317,7 @@ void fn_1_9FE4(void) BoardCameraQuakeSet(3, 100.0f); fn_1_B8E8(1); BoardModelMotionShiftSet(lbl_1_bss_C[11], lbl_1_data_4DC, 0.0f, 10.0, 0x40000005); - PSVECSubtract(&sp24, &sp30, &spC); + VECSubtract(&sp24, &sp30, &spC); spC.x /= 60.0f; spC.z /= 60.0f; @@ -325,7 +325,7 @@ void fn_1_9FE4(void) var_f31 = 0.0f; while (var_f31 < 60.0f) { - PSVECAdd(&sp30, &spC, &sp30); + VECAdd(&sp30, &spC, &sp30); BoardModelPosSetV(lbl_1_bss_C[11], &sp30); HuPrcVSleep(); var_f31 += 1.0f; diff --git a/src/REL/w03Dll/river.c b/src/REL/w03Dll/river.c index 115c33dd..ed9ca65c 100644 --- a/src/REL/w03Dll/river.c +++ b/src/REL/w03Dll/river.c @@ -166,7 +166,7 @@ s32 fn_1_6898(s32 arg0) { Hu3DModelObjPosGet(BoardModelIDGet(lbl_1_data_388), "hei01", &sp20); BoardPlayerPosGet(arg0, &sp14); - PSVECSubtract(&sp20, &sp14, &sp8); + VECSubtract(&sp20, &sp14, &sp8); temp_f31 = 180.0 * (atan2(sp8.x, sp8.z) / M_PI); BoardCameraTargetModelSet(lbl_1_data_388); BoardPlayerMotBlendSet(arg0, temp_f31, 15); @@ -272,7 +272,7 @@ void fn_1_6B98(s32 arg0) { sp18.x = sp30.x + (400.0 * sin(M_PI / 2)); sp18.z = sp30.z + (400.0 * cos(M_PI / 2)); sp18.y = sp24.y; - PSVECSubtract(&sp18, &sp24, &spC); + VECSubtract(&sp18, &sp24, &spC); spC.x = spC.x / 120.0f; spC.y /= 120.0f; spC.z = spC.z / 120.0f; @@ -282,7 +282,7 @@ void fn_1_6B98(s32 arg0) { var_r31 = 0; for (i = 0; i < 0x78U; i++) { - PSVECAdd(&spC, &sp24, &sp24); + VECAdd(&spC, &sp24, &sp24); temp_f1 = BoardModelMotionTimeGet(lbl_1_data_38A); if ((temp_f1 >= 5.0f) && (temp_f1 < 15.0f) && ((s16) var_r31 == 0)) { @@ -332,7 +332,7 @@ void fn_1_6F9C(s32 arg0) { BoardPlayerPosGet(arg0, &sp14); Hu3DModelObjPosGet(BoardModelIDGet(lbl_1_data_388), "chara01", &sp20); - PSVECSubtract(&sp20, &sp14, &sp8); + VECSubtract(&sp20, &sp14, &sp8); sp8.x /= 60.0f; sp8.z /= 60.0f; @@ -352,7 +352,7 @@ void fn_1_6F9C(s32 arg0) { BoardPlayerMotionShiftSet(arg0, 4, 0.0f, 10.0f, 0); for (var_r30 = 0, var_f31 = 0.0f; var_f31 < 60.0f; var_f31 += 1.0f) { - PSVECAdd(&sp14, &sp8, &sp14); + VECAdd(&sp14, &sp8, &sp14); sp14.y += 10.0f + var_f30 + (var_f29 * (-0.08166667f * var_f31 * var_f31)); if (sp14.y <= sp20.y) { sp14.y = sp20.y; @@ -394,7 +394,7 @@ void fn_1_735C(s32 arg0) { Hu3DModelObjPosGet(BoardModelIDGet(lbl_1_data_388), "chara01", &sp14); BoardPlayerPosSetV(arg0, &sp14); BoardModelHookObjReset(lbl_1_data_388, "chara01"); - PSVECSubtract(&sp20, &sp14, &sp8); + VECSubtract(&sp20, &sp14, &sp8); sp8.x = sp8.x / 60.0f; sp8.z = sp8.z / 60.0f; @@ -409,7 +409,7 @@ void fn_1_735C(s32 arg0) { } for (var_r30 = 0, var_f31 = 0.0f; var_f31 < 60.0f; var_f31 += 1.0f) { - PSVECAdd(&sp14, &sp8, &sp14); + VECAdd(&sp14, &sp8, &sp14); sp14.y += 20.0f + (var_f30 * (-0.08166667f * var_f31 * var_f31)); if (sp14.y <= sp20.y && var_f31 > 48.0f) { sp14.y = sp20.y; diff --git a/src/REL/w03Dll/statue.c b/src/REL/w03Dll/statue.c index 82c73f4c..d9519b4f 100644 --- a/src/REL/w03Dll/statue.c +++ b/src/REL/w03Dll/statue.c @@ -154,7 +154,7 @@ s32 fn_1_1650(s32 arg0) { temp2 = BoardSpaceLinkFlagSearch(0, GWPlayer[arg0].space_curr, 0x02000000); BoardSpacePosGet(0, temp2, &sp38); BoardPlayerPosGet(arg0, &sp2C); - PSVECSubtract(&sp38, &sp2C, &sp20); + VECSubtract(&sp38, &sp2C, &sp20); temp = (atan2(-sp20.x, -sp20.z) / M_PI) * 180.0f; BoardPlayerRotYSet(arg0, temp); sp14.x = 0.0f; @@ -537,8 +537,8 @@ void fn_1_26E0(s32 arg0) { BoardSpacePosGet(0, GWPlayer[arg0].space_curr, &sp20); BoardPlayerPosGet(arg0, &sp14); - PSVECSubtract(&sp20, &sp14, &sp8); - PSVECNormalize(&sp8, &sp8); + VECSubtract(&sp20, &sp14, &sp8); + VECNormalize(&sp8, &sp8); temp = (180.0f * (atan2(-sp8.x, -sp8.z) / M_PI)); BoardPlayerRotYSet(arg0, temp); BoardCameraViewSet(1); diff --git a/src/REL/w04Dll/boo_event.c b/src/REL/w04Dll/boo_event.c index 3dadfc9d..8d3bde5c 100755 --- a/src/REL/w04Dll/boo_event.c +++ b/src/REL/w04Dll/boo_event.c @@ -211,10 +211,10 @@ static void fn_1_20EC(void) { while (fn_1_1130(lbl_1_bss_FA, atan2d(sp14.x - sp20.x, sp14.z - sp20.z), 2.0f) == 0) { HuPrcVSleep(); } - PSVECSubtract(&sp14, &sp20, &sp8); - PSVECScale(&sp8, &sp8, 0.022222223f); + VECSubtract(&sp14, &sp20, &sp8); + VECScale(&sp8, &sp8, 0.022222223f); for (i = 0; i < 45; i++) { - PSVECAdd(&sp20, &sp8, &sp20); + VECAdd(&sp20, &sp8, &sp20); BoardModelPosSetV(lbl_1_bss_FA, &sp20); HuPrcVSleep(); } @@ -293,12 +293,12 @@ static void fn_1_28BC(void) { BoardModelPosGet(lbl_1_bss_FA, &sp14); temp_f30 = atan2d(sp20.x - sp14.x, sp20.z - sp14.z); BoardModelRotYSet(lbl_1_bss_FA, temp_f30); - PSVECSubtract(&sp20, &sp14, &sp8); - PSVECScale(&sp8, &sp8, 0.022222223f); + VECSubtract(&sp20, &sp14, &sp8); + VECScale(&sp8, &sp8, 0.022222223f); *var_r26 = temp_f30 - 180.0f; fn_1_2EE8(3); for (i = 0; i < 45; i++) { - PSVECAdd(&sp8, &sp14, &sp14); + VECAdd(&sp8, &sp14, &sp14); BoardModelPosSetV(lbl_1_bss_FA, &sp14); fn_1_5018(); if (var_r29 != 0) { @@ -473,10 +473,10 @@ static void fn_1_30A4(void) { while (fn_1_1130(temp_r31->unk04, temp_f31, 5.0f) == 0) { HuPrcVSleep(); } - PSVECSubtract(&temp_r31->unk20, &sp20, &sp14); - PSVECScale(&sp14, &sp14, 0.016666668f); + VECSubtract(&temp_r31->unk20, &sp20, &sp14); + VECScale(&sp14, &sp14, 0.016666668f); for (i = 0; i < 60; i++) { - PSVECAdd(&sp14, &sp20, &sp20); + VECAdd(&sp14, &sp20, &sp20); BoardModelPosSetV(temp_r31->unk04, &sp20); HuPrcVSleep(); } @@ -533,8 +533,8 @@ static void fn_1_30A4(void) { if (temp_r31->unk08 != -1) { BoardPlayerRotYSet(temp_r31->unk08, temp_f31); } - PSVECSubtract(&temp_r31->unk20, &sp20, &sp14); - PSVECScale(&sp14, &sp14, 0.022222223f); + VECSubtract(&temp_r31->unk20, &sp20, &sp14); + VECScale(&sp14, &sp14, 0.022222223f); if (temp_r31->unk0C > 0) { var_r28 = BoardSpaceGet(0, temp_r31->unk0C); if (var_r28->flag & 1) { @@ -547,7 +547,7 @@ static void fn_1_30A4(void) { } } for (i = 0; i < 45; i++) { - PSVECAdd(&sp20, &sp14, &sp20); + VECAdd(&sp20, &sp14, &sp20); BoardModelPosSetV(temp_r31->unk04, &sp20); if (temp_r31->unk08 != -1) { BoardPlayerPosSetV(temp_r31->unk08, &sp20); @@ -610,14 +610,14 @@ static void fn_1_38D8(void) { BoardPlayerPosGet(temp_r31, &sp24); var_f28 = atan2d(sp18.x - sp24.x, sp18.z - sp24.z); BoardPlayerRotYSet(temp_r31, var_f28); - PSVECSubtract(&sp18, &sp24, &spC); - PSVECScale(&spC, &spC, 0.025f); + VECSubtract(&sp18, &sp24, &spC); + VECScale(&spC, &spC, 0.025f); temp_f26 = 12.0f; var_f29 = 0.0f; while (TRUE) { spC.y = temp_f26 - var_f29 * var_f29 * 0.25f * 0.075f; var_f29 += 1.0f; - PSVECAdd(&spC, &sp24, &sp24); + VECAdd(&spC, &sp24, &sp24); if (sp24.y <= sp18.y) { sp24.y = sp18.y; break; @@ -696,16 +696,16 @@ static s32 fn_1_3C9C(void) { for (i = 0; i < var_r29; i++) { BoardSpacePosGet(0, sp20[i], &sp44); sp50.y = sp44.y; - PSVECSubtract(&sp44, &sp50, &sp38); + VECSubtract(&sp44, &sp50, &sp38); var_f31 = atan2d(sp38.x, sp38.z); if (var_f31 < 0.0f) { var_f31 += 360.0f; } sp28[i] = var_f31; - PSVECNormalize(&sp38, &sp44); - PSVECScale(&sp44, &sp44, 110.0f); + VECNormalize(&sp38, &sp44); + VECScale(&sp44, &sp44, 110.0f); sp44.y += 200.0f; - PSVECAdd(&sp50, &sp44, &sp44); + VECAdd(&sp50, &sp44, &sp44); BoardModelPosSetV(lbl_1_bss_F4[i], &sp44); BoardModelRotYSet(lbl_1_bss_F4[i], var_f31); BoardModelVisibilitySet(lbl_1_bss_F4[i], 1); diff --git a/src/REL/w04Dll/bridge.c b/src/REL/w04Dll/bridge.c index 8198e5e7..97f7569a 100755 --- a/src/REL/w04Dll/bridge.c +++ b/src/REL/w04Dll/bridge.c @@ -262,8 +262,8 @@ static void fn_1_1E60(void) { while (TRUE) { BoardSpacePosGet(0, var_r29, &sp14); BoardSpacePosGet(0, var_r28, &sp8); - PSVECSubtract(&sp8, &sp14, &sp20); - PSVECScale(&sp20, &sp20, 0.008333334f); + VECSubtract(&sp8, &sp14, &sp20); + VECScale(&sp20, &sp20, 0.008333334f); temp_f31 = atan2d(sp8.x - sp14.x, sp8.z - sp14.z); BoardModelPosGet(temp_r31[1], &sp14); while (fn_1_1130(temp_r31[1], temp_f31, 2.5f) == 0) { @@ -280,7 +280,7 @@ static void fn_1_1E60(void) { } else { BoardModelAlphaSet(temp_r31[1], 0); } - PSVECAdd(&sp14, &sp20, &sp14); + VECAdd(&sp14, &sp20, &sp14); BoardModelPosSetV(temp_r31[1], &sp14); HuPrcVSleep(); } diff --git a/src/REL/w04Dll/mg_coin.c b/src/REL/w04Dll/mg_coin.c index 4be845b4..29557d44 100755 --- a/src/REL/w04Dll/mg_coin.c +++ b/src/REL/w04Dll/mg_coin.c @@ -137,11 +137,11 @@ void fn_1_C7D4(void) { BoardModelPosGet(lbl_1_bss_14[9], &sp8); sp14 = sp8; sp14.x = sp2C.x; - PSVECSubtract(&sp14, &sp8, &sp38); - PSVECScale(&sp38, &sp38, 0.022727273f); + VECSubtract(&sp14, &sp8, &sp38); + VECScale(&sp38, &sp38, 0.022727273f); for (i = 0; i < 44; i++) { BoardModelPosGet(lbl_1_bss_14[9], &sp8); - PSVECAdd(&sp8, &sp38, &sp8); + VECAdd(&sp8, &sp38, &sp8); BoardModelPosSetV(lbl_1_bss_14[9], &sp8); HuPrcVSleep(); } @@ -159,17 +159,17 @@ void fn_1_C7D4(void) { BoardPlayerMotionShiftSet(lbl_1_bss_324, 4, 0.0f, 5.0f, 0); var_f31 = 0.0f; temp_f30 = 8.0f; - PSVECSubtract(&sp2C, &sp20, &sp38); - PSVECScale(&sp38, &sp38, 0.05f); + VECSubtract(&sp2C, &sp20, &sp38); + VECScale(&sp38, &sp38, 0.05f); while (TRUE) { BoardPlayerPosGet(lbl_1_bss_324, &sp20); sp38.y = temp_f30 - var_f31 * var_f31 * 0.25f * 0.075f; var_f31 += 1.0f; - PSVECAdd(&sp38, &sp20, &sp20); + VECAdd(&sp38, &sp20, &sp20); sp14 = sp2C; sp14.y = sp20.y; - PSVECSubtract(&sp14, &sp20, &sp14); - var_f29 = PSVECMag(&sp14); + VECSubtract(&sp14, &sp20, &sp14); + var_f29 = VECMag(&sp14); if (var_f29 <= 1.0f) { sp38.x = sp38.z = 0.0f; sp20.x = sp2C.x; @@ -429,17 +429,17 @@ static void fn_1_D770(void) { temp_f29 = 8.0f; lbl_1_bss_308.z = sp18.z + 100.0f; lbl_1_bss_308.x = sp18.x + 50.0f; - PSVECSubtract(&lbl_1_bss_308, &sp18, &spC); - PSVECScale(&spC, &spC, 0.04f); + VECSubtract(&lbl_1_bss_308, &sp18, &spC); + VECScale(&spC, &spC, 0.04f); while (TRUE) { BoardPlayerPosGet(lbl_1_bss_324, &sp18); spC.y = temp_f29 - var_f30 * var_f30 * 0.25f * 0.075f; var_f30 += 1.0f; - PSVECAdd(&spC, &sp18, &sp18); + VECAdd(&spC, &sp18, &sp18); sp114[0] = lbl_1_bss_308; sp114[0].y = sp18.y; - PSVECSubtract(&sp114[0], &sp18, &sp114[0]); - var_f31 = PSVECMag(&sp114[0]); + VECSubtract(&sp114[0], &sp18, &sp114[0]); + var_f31 = VECMag(&sp114[0]); if (var_f31 <= 1.0f) { spC.x = spC.z = 0.0f; sp18.x = lbl_1_bss_308.x; @@ -472,11 +472,11 @@ static void fn_1_E004(void) { HuPrcVSleep(); } BoardModelPosGet(lbl_1_bss_14[9], &sp14); - PSVECSubtract(&lbl_1_bss_2FC, &sp14, &sp8); - PSVECScale(&sp8, &sp8, 0.1f); + VECSubtract(&lbl_1_bss_2FC, &sp14, &sp8); + VECScale(&sp8, &sp8, 0.1f); for (i = 0; i < 10; i++) { BoardModelPosGet(lbl_1_bss_14[9], &sp14); - PSVECAdd(&sp14, &sp8, &sp14); + VECAdd(&sp14, &sp8, &sp14); BoardModelPosSetV(lbl_1_bss_14[9], &sp14); HuPrcVSleep(); } @@ -540,8 +540,8 @@ static void fn_1_E374(omObjData *arg0) { if (temp_r3 >= 30 && temp_r3 <= 39) { Hu3DModelObjPosGet(BoardModelIDGet(lbl_1_bss_14[7]), lbl_1_data_5BC[arg0->work[1]], &sp14); BoardPlayerPosGet(lbl_1_bss_324, &sp20); - PSVECSubtract(&sp14, &sp20, &sp8); - PSVECScale(&sp8, &sp8, 0.04f); + VECSubtract(&sp14, &sp20, &sp8); + VECScale(&sp8, &sp8, 0.04f); arg0->trans.x = sp8.x; arg0->trans.z = sp8.z; arg0->trans.y = 5.0f; @@ -569,11 +569,11 @@ static void fn_1_E4C0(omObjData *arg0) { sp20.z = arg0->trans.z; sp20.y = arg0->trans.y - arg0->rot.x * arg0->rot.x * 0.25f * 0.075f; arg0->rot.x += 1.0f; - PSVECAdd(&sp2C, &sp20, &sp2C); + VECAdd(&sp2C, &sp20, &sp2C); sp8 = sp2C; sp8.y = sp14.y; - PSVECSubtract(&sp14, &sp8, &sp8); - var_f31 = PSVECMag(&sp8); + VECSubtract(&sp14, &sp8, &sp8); + var_f31 = VECMag(&sp8); if (var_f31 <= 1.0f) { arg0->trans.x = arg0->trans.z = 0.0f; sp2C.x = sp14.x; diff --git a/src/REL/w04Dll/mg_item.c b/src/REL/w04Dll/mg_item.c index 342d8f5c..9c747954 100755 --- a/src/REL/w04Dll/mg_item.c +++ b/src/REL/w04Dll/mg_item.c @@ -304,13 +304,13 @@ static void fn_1_A7E8(void) { var_f29 = 12.0f; sp3C = sp54[var_r30]; BoardPlayerPosGet(lbl_1_bss_2AC, &sp30); - PSVECSubtract(&sp3C, &sp30, &sp3C); - PSVECScale(&sp3C, &sp3C, 0.05f); + VECSubtract(&sp3C, &sp30, &sp3C); + VECScale(&sp3C, &sp3C, 0.05f); while (TRUE) { BoardPlayerPosGet(lbl_1_bss_2AC, &sp30); sp3C.y = var_f29 - var_f30 * var_f30 * 0.25f * 0.075f; var_f30 += 1.0f; - PSVECAdd(&sp3C, &sp30, &sp30); + VECAdd(&sp3C, &sp30, &sp30); if (sp30.y <= sp54[var_r30].y - 40.0f && sp3C.y < 0.0f) { sp30.y = sp54[var_r30].y - 40.0f; break; @@ -318,8 +318,8 @@ static void fn_1_A7E8(void) { BoardPlayerPosSetV(lbl_1_bss_2AC, &sp30); sp48 = sp54[var_r30]; sp48.y = sp30.y = 0.0f; - PSVECSubtract(&sp48, &sp30, &sp30); - var_f31 = PSVECMag(&sp30); + VECSubtract(&sp48, &sp30, &sp30); + var_f31 = VECMag(&sp30); if (var_f31 <= 1.0f) { sp3C.x = sp3C.z = 0.0f; } @@ -379,13 +379,13 @@ static void fn_1_A7E8(void) { var_f30 = 0.0f; var_f29 = 12.0f; BoardPlayerPosGet(lbl_1_bss_2AC, &sp30); - PSVECSubtract(&sp18, &sp30, &sp3C); - PSVECScale(&sp3C, &sp3C, 0.05f); + VECSubtract(&sp18, &sp30, &sp3C); + VECScale(&sp3C, &sp3C, 0.05f); while (TRUE) { BoardPlayerPosGet(lbl_1_bss_2AC, &sp30); sp3C.y = var_f29 - var_f30 * var_f30 * 0.25f * 0.075f; var_f30 += 1.0f; - PSVECAdd(&sp3C, &sp30, &sp30); + VECAdd(&sp3C, &sp30, &sp30); if (sp30.y < sp18.y) { sp30.y = sp18.y; break; @@ -393,8 +393,8 @@ static void fn_1_A7E8(void) { BoardPlayerPosSetV(lbl_1_bss_2AC, &sp30); sp48 = sp18; sp48.y = sp30.y = 0.0f; - PSVECSubtract(&sp48, &sp30, &sp30); - var_f31 = PSVECMag(&sp30); + VECSubtract(&sp48, &sp30, &sp30); + var_f31 = VECMag(&sp30); if (var_f31 <= 1.0f) { sp3C.x = sp3C.z = 0.0f; } @@ -406,11 +406,11 @@ static void fn_1_A7E8(void) { BoardModelPosGet(lbl_1_bss_298[temp_r29], &sp24); sp3C = sp24; sp3C.z += 100.0f; - PSVECSubtract(&sp3C, &sp24, &sp3C); - PSVECScale(&sp3C, &sp3C, 0.033333335f); + VECSubtract(&sp3C, &sp24, &sp3C); + VECScale(&sp3C, &sp3C, 0.033333335f); for (i = 0; i < 30; i++) { BoardModelPosGet(lbl_1_bss_298[temp_r29], &sp24); - PSVECAdd(&sp24, &sp3C, &sp24); + VECAdd(&sp24, &sp3C, &sp24); BoardModelPosSetV(lbl_1_bss_298[temp_r29], &sp24); HuPrcVSleep(); } @@ -538,8 +538,8 @@ void fn_1_BB00(s16 *arg0) { BoardModelPosGet(lbl_1_bss_14[10], &sp24); BoardModelPosSetV(lbl_1_bss_298[i], &sp24); BoardModelScaleSetV(lbl_1_bss_298[i], &sp18); - PSVECSubtract(&sp54[i], &sp24, &sp30[i]); - PSVECNormalize(&sp30[i], &sp30[i]); + VECSubtract(&sp54[i], &sp24, &sp30[i]); + VECNormalize(&sp30[i], &sp30[i]); spC[i] = 0.0f; } sp30[0].y = 16.0f; diff --git a/src/REL/w05Dll/dolphin.c b/src/REL/w05Dll/dolphin.c index 14f7d66b..c156f1ef 100644 --- a/src/REL/w05Dll/dolphin.c +++ b/src/REL/w05Dll/dolphin.c @@ -137,7 +137,7 @@ void fn_1_4034(s32 arg0) HuPrcSleep(8); lbl_1_bss_64 = BoardModelCreate(DATA_MAKE_NUM(DATADIR_W05, 0x26), lbl_1_data_244, 0); Hu3DModelObjPosGet(BoardModelIDGet(lbl_1_data_118), lbl_1_data_22C[arg0], &sp40); - PSVECAdd(&sp40, &lbl_1_data_2A4[arg0], &sp40); + VECAdd(&sp40, &lbl_1_data_2A4[arg0], &sp40); BoardModelMotionStart(lbl_1_bss_64, 4, 0); sp40.y = -50.0f; BoardModelPosSetV(lbl_1_bss_64, &sp40); @@ -188,9 +188,9 @@ void fn_1_4034(s32 arg0) BoardPlayerPosGet(lbl_1_bss_68, &sp28); var_f27 = sqrtf(((sp40.x - sp28.x) * (sp40.x - sp28.x)) + ((sp40.z - sp28.z) * (sp40.z - sp28.z))); - PSVECSubtract(&sp40, &sp28, &sp1C); - PSVECNormalize(&sp1C, &sp1C); - PSVECScale(&sp1C, &sp1C, var_f27 / 50.0f); + VECSubtract(&sp40, &sp28, &sp1C); + VECNormalize(&sp1C, &sp1C); + VECScale(&sp1C, &sp1C, var_f27 / 50.0f); BoardPlayerMotionStart(lbl_1_bss_68, 4, 0); var_f26 = 0.0f; temp_f22 = 15.0f; @@ -198,7 +198,7 @@ void fn_1_4034(s32 arg0) loop_37: sp1C.y = temp_f22 - (0.075f * (0.25f * (var_f26 * var_f26))); var_f26++; - PSVECAdd(&sp28, &sp1C, &sp28); + VECAdd(&sp28, &sp1C, &sp28); var_f27 = sqrtf(((sp40.x - sp28.x) * (sp40.x - sp28.x)) + ((sp40.z - sp28.z) * (sp40.z - sp28.z))); if (var_f27 < 5.0f) { sp1C.x = sp1C.z = 0.0f; @@ -319,9 +319,9 @@ void fn_1_4EB4(s32 arg1, s32 arg2, Vec *arg3) temp_f23 = 10.0f; BoardModelPosGet(lbl_1_bss_64, &sp3C); arg3->y = sp3C.y; - PSVECSubtract(arg3, &sp3C, &sp24); - PSVECNormalize(&sp24, &sp24); - PSVECScale(&sp24, &sp24, temp_f23); + VECSubtract(arg3, &sp3C, &sp24); + VECNormalize(&sp24, &sp24); + VECScale(&sp24, &sp24, temp_f23); temp_r28 = HuAudFXPlay(0x47F); BoardModelPosGet(lbl_1_bss_64, &sp18); temp_r30 = fn_1_66C0(4, &sp18); @@ -338,7 +338,7 @@ void fn_1_4EB4(s32 arg1, s32 arg2, Vec *arg3) break; } else { - PSVECAdd(&sp3C, &sp24, &sp3C); + VECAdd(&sp3C, &sp24, &sp3C); BoardModelPosSetV(lbl_1_bss_64, &sp3C); sp30 = sp3C; sp30.y += 20.0f; @@ -361,9 +361,9 @@ void fn_1_4EB4(s32 arg1, s32 arg2, Vec *arg3) BoardPlayerPosGet(lbl_1_bss_68, &sp30); var_f28 = sqrtf(((sp3C.x - sp30.x) * (sp3C.x - sp30.x)) + ((sp3C.z - sp30.z) * (sp3C.z - sp30.z))); - PSVECSubtract(&sp3C, &sp30, &sp24); - PSVECNormalize(&sp24, &sp24); - PSVECScale(&sp24, &sp24, var_f28 / 45.0f); + VECSubtract(&sp3C, &sp30, &sp24); + VECNormalize(&sp24, &sp24); + VECScale(&sp24, &sp24, var_f28 / 45.0f); BoardPlayerMotionStart(lbl_1_bss_68, 4, 0); var_f24 = 0.0f; @@ -372,7 +372,7 @@ void fn_1_4EB4(s32 arg1, s32 arg2, Vec *arg3) while (1) { sp24.y = temp_f19 - (0.075f * (0.25f * (var_f24 * var_f24))); var_f24++; - PSVECAdd(&sp30, &sp24, &sp30); + VECAdd(&sp30, &sp24, &sp30); var_f28 = sqrtf(((sp3C.x - sp30.x) * (sp3C.x - sp30.x)) + ((sp3C.z - sp30.z) * (sp3C.z - sp30.z))); if (var_f28 < 5.0f) { sp24.x = sp24.z = 0.0f; @@ -449,9 +449,9 @@ void fn_1_5794(s32 arg0, s32 arg1, Vec *arg2) fn_1_62AC(arg0, arg2); temp_f22 = 10.0f; arg2->y = sp58.y; - PSVECSubtract(arg2, &sp58, &sp40); - PSVECNormalize(&sp40, &sp40); - PSVECScale(&sp40, &sp40, temp_f22); + VECSubtract(arg2, &sp58, &sp40); + VECNormalize(&sp40, &sp40); + VECScale(&sp40, &sp40, temp_f22); if (arg0 == 5) { var_r29 = 0x96; } @@ -483,7 +483,7 @@ void fn_1_5794(s32 arg0, s32 arg1, Vec *arg2) break; } else { - PSVECAdd(&sp58, &sp40, &sp58); + VECAdd(&sp58, &sp40, &sp58); sp64 = sp58; if (var_r29 == 0) { sp58.y += 250.0 * sin((M_PI * var_f28) / 180.0); @@ -548,16 +548,16 @@ void fn_1_5794(s32 arg0, s32 arg1, Vec *arg2) } BoardPlayerPosGet(lbl_1_bss_68, &sp4C); var_f27 = sqrtf(((sp58.x - sp4C.x) * (sp58.x - sp4C.x)) + ((sp58.z - sp4C.z) * (sp58.z - sp4C.z))); - PSVECSubtract(&sp58, &sp4C, &sp40); - PSVECNormalize(&sp40, &sp40); - PSVECScale(&sp40, &sp40, var_f27 / 45.0f); + VECSubtract(&sp58, &sp4C, &sp40); + VECNormalize(&sp40, &sp40); + VECScale(&sp40, &sp40, var_f27 / 45.0f); BoardPlayerMotionStart(lbl_1_bss_68, 4, 0); var_f23 = 0.0f; temp_f18 = 15.0f; while (1) { sp40.y = temp_f18 - (0.075f * (0.25f * (var_f23 * var_f23))); var_f23++; - PSVECAdd(&sp4C, &sp40, &sp4C); + VECAdd(&sp4C, &sp40, &sp4C); var_f27 = sqrtf(((sp58.x - sp4C.x) * (sp58.x - sp4C.x)) + ((sp58.z - sp4C.z) * (sp58.z - sp4C.z))); if (var_f27 < 5.0f) { sp40.x = sp40.z = 0.0f; @@ -591,19 +591,19 @@ void fn_1_62AC(s32 arg0, Vec *arg1) BoardModelPosGet(lbl_1_bss_64, &sp34); arg0 -= 4; arg1->y = sp34.y; - PSVECSubtract(arg1, &sp34, &sp28); - PSVECNormalize(&sp28, &sp28); + VECSubtract(arg1, &sp34, &sp28); + VECNormalize(&sp28, &sp28); var_f31 = 45.0f; var_r31 = 0; while (var_r31 < 3) { sp1C = sp28; sp10 = sp28; - PSVECScale(&sp1C, &sp1C, sp8[arg0]); + VECScale(&sp1C, &sp1C, sp8[arg0]); sp1C.y += (250.0 * sin((M_PI * var_f31) / 180.0)); var_f30 = (250.0 * -cos((M_PI * var_f31) / 180.0)); - PSVECScale(&sp10, &sp10, var_f30); - PSVECAdd(&sp10, &sp1C, &sp1C); - PSVECAdd(&sp1C, &sp34, &sp1C); + VECScale(&sp10, &sp10, var_f30); + VECAdd(&sp10, &sp1C, &sp1C); + VECAdd(&sp1C, &sp34, &sp1C); BoardModelPosSetV(lbl_1_bss_6C[var_r31], &sp1C); BoardModelVisibilitySet(lbl_1_bss_6C[var_r31], 1); var_f31 += 45.0f; @@ -623,8 +623,8 @@ void fn_1_64BC(void) for (var_r31 = 0; var_r31 < 3; var_r31++) { if (BoardModelVisibilityGet(lbl_1_bss_6C[var_r31]) != 0) { BoardModelPosGet(lbl_1_bss_6C[var_r31], &sp14); - PSVECSubtract(&sp14, &sp20, &sp8); - var_f31 = PSVECMag(&sp8); + VECSubtract(&sp14, &sp20, &sp8); + var_f31 = VECMag(&sp8); if (var_f31 < 60.0f) { CharModelCoinEffectCreate(1, &sp14); BoardModelVisibilitySet(lbl_1_bss_6C[var_r31], 0); diff --git a/src/REL/w05Dll/hotel.c b/src/REL/w05Dll/hotel.c index f3a00e24..8838a724 100644 --- a/src/REL/w05Dll/hotel.c +++ b/src/REL/w05Dll/hotel.c @@ -94,11 +94,11 @@ void fn_1_155C(void) { BoardModelRotYSet(lbl_1_bss_14[4], -90.0f); } BoardModelMotionStart(lbl_1_bss_14[4], temp_r28, 0x40000001); - PSVECSubtract(&sp28, &sp40, &sp34); - PSVECScale(&sp34, &sp34, 0.018518519f); + VECSubtract(&sp28, &sp40, &sp34); + VECScale(&sp34, &sp34, 0.018518519f); for (var_r31 = 0; var_r31 < 0x36; var_r31++) { - PSVECAdd(&sp40, &sp34, &sp40); + VECAdd(&sp40, &sp34, &sp40); BoardModelPosSetV(lbl_1_bss_14[4], &sp40); HuPrcVSleep(); } @@ -175,11 +175,11 @@ void fn_1_155C(void) { BoardModelRotYSet(lbl_1_bss_14[4], 90.0f); } BoardModelMotionStart(lbl_1_bss_14[4], temp_r28, 0x40000001); - PSVECSubtract(&sp28, &sp40, &sp34); - PSVECScale(&sp34, &sp34, 0.033333335f); + VECSubtract(&sp28, &sp40, &sp34); + VECScale(&sp34, &sp34, 0.033333335f); for (var_r31 = 0; var_r31 < 0x1E; var_r31++) { - PSVECAdd(&sp40, &sp34, &sp40); + VECAdd(&sp40, &sp34, &sp40); BoardModelPosSetV(lbl_1_bss_14[4], &sp40); HuPrcVSleep(); } @@ -257,11 +257,11 @@ void fn_1_1E44(void) { BoardModelRotYSet(lbl_1_bss_14[4], -90.0f); } BoardModelMotionStart(lbl_1_bss_14[4], sp8[0], 0x40000001); - PSVECSubtract(&sp2C, &sp5C, &sp44); - PSVECScale(&sp44, &sp44, 0.018518519f); + VECSubtract(&sp2C, &sp5C, &sp44); + VECScale(&sp44, &sp44, 0.018518519f); for (var_r31 = 0; var_r31 < 0x36U; var_r31++) { - PSVECAdd(&sp5C, &sp44, &sp5C); + VECAdd(&sp5C, &sp44, &sp5C); BoardModelPosSetV(lbl_1_bss_14[4], &sp5C); HuPrcVSleep(); } @@ -400,11 +400,11 @@ void fn_1_1E44(void) { BoardModelRotYSet(lbl_1_bss_14[4], 90.0f); } BoardModelMotionStart(lbl_1_bss_14[4], sp8[0], 0x40000001U); - PSVECSubtract(&sp38, &sp5C, &sp44); - PSVECScale(&sp44, &sp44, 0.055555556); + VECSubtract(&sp38, &sp5C, &sp44); + VECScale(&sp44, &sp44, 0.055555556); for (var_r31 = 0; var_r31 < 0x12U; var_r31++) { - PSVECAdd(&sp5C, &sp44, &sp5C); + VECAdd(&sp5C, &sp44, &sp5C); BoardModelPosSetV(lbl_1_bss_14[4], &sp5C); HuPrcVSleep(); } diff --git a/src/REL/w05Dll/mg_coin.c b/src/REL/w05Dll/mg_coin.c index 7818996c..7421e2e1 100644 --- a/src/REL/w05Dll/mg_coin.c +++ b/src/REL/w05Dll/mg_coin.c @@ -321,11 +321,11 @@ void fn_1_A5B0(omObjData *arg0) Hu3DModelObjPosGet(BoardModelIDGet(lbl_1_bss_14[1]), "fish", &sp14); BoardModelPosGet(lbl_1_bss_FE, &sp8); sp14.y = sp8.y; - PSVECSubtract(&sp14, &sp8, temp_r31); - var_f31 = PSVECMag(temp_r31); - PSVECNormalize(temp_r31, temp_r31); + VECSubtract(&sp14, &sp8, temp_r31); + var_f31 = VECMag(temp_r31); + VECNormalize(temp_r31, temp_r31); var_f31 /= 38.0f; - PSVECScale(temp_r31, temp_r31, var_f31); + VECScale(temp_r31, temp_r31, var_f31); temp_r31->y = 25.0f; temp_r29->trans.x = var_f31; BoardPlayerMotionStart(lbl_1_bss_C0, lbl_1_bss_102[2], 0); @@ -536,10 +536,10 @@ void fn_1_B3C4(omObjData *arg0) sp8.y = 180.0f; sp8.z = 0.0f; BoardModelRotSetV(lbl_1_bss_FE, &sp8); - PSVECAdd(&sp20, &sp2C, &sp20); + VECAdd(&sp20, &sp2C, &sp20); sp14.y = sp20.y; - PSVECSubtract(&sp14, &sp20, &sp14); - temp_f29 = PSVECMag(&sp14); + VECSubtract(&sp14, &sp20, &sp14); + temp_f29 = VECMag(&sp14); Hu3DModelObjPosGet(BoardModelIDGet(lbl_1_bss_14[1]), "fish", &sp14); if (temp_f29 <= arg0->trans.x) { sp20.x = sp14.x; diff --git a/src/REL/w05Dll/mg_item.c b/src/REL/w05Dll/mg_item.c index f0cfd6a2..91159cae 100644 --- a/src/REL/w05Dll/mg_item.c +++ b/src/REL/w05Dll/mg_item.c @@ -85,7 +85,7 @@ void fn_1_6B7C(void) BoardModelHookSet(BoardPlayerModelGet(lbl_1_bss_B6), "a-itemhook-r", lbl_1_bss_A2); Hu3DModelObjPosGet(BoardModelIDGet(*lbl_1_bss_14), "chara1", &sp10); Hu3DModelObjPosGet(BoardModelIDGet(BoardPlayerModelGet(lbl_1_bss_B6)), "a-itemhook-r", &sp1C); - PSVECAdd(&sp1C, &sp10, &sp1C); + VECAdd(&sp1C, &sp10, &sp1C); sp1C.y += 25.0f; CharModelLayerSetAll(7); CharModelEffectCreate(-1, &sp1C); @@ -292,13 +292,13 @@ void fn_1_799C(void) temp_r31 = temp_r30->work[0]; BoardModelPosGet(lbl_1_bss_A4[temp_r31], &sp20); sp2C.y = sp20.y = 0.0f; - PSVECSubtract(&sp2C, &sp20, &sp14); - temp_f30 = PSVECMag(&sp14); - PSVECScale(&sp14, &sp14, 0.016666668); + VECSubtract(&sp2C, &sp20, &sp14); + temp_f30 = VECMag(&sp14); + VECScale(&sp14, &sp14, 0.016666668); for (var_r29 = 0; var_r29 < 0x3C; var_r29++) { BoardModelPosGet(lbl_1_bss_A4[temp_r31], &sp20); - PSVECAdd(&sp20, &sp14, &sp20); + VECAdd(&sp20, &sp14, &sp20); BoardModelPosSetV(lbl_1_bss_A4[temp_r31], &sp20); HuPrcVSleep(); } @@ -505,7 +505,7 @@ void fn_1_850C(omObjData *arg0) BoardPlayerMotionStart(lbl_1_bss_B6, lbl_1_bss_9E[0], 0x40000001); Hu3DModelObjPosGet(BoardModelIDGet(lbl_1_bss_14[0]), "chara1", &sp8); Hu3DModelObjPosGet(BoardModelIDGet(BoardPlayerModelGet(lbl_1_bss_B6)), "a-itemhook-r", &sp14); - PSVECAdd(&sp14, &sp8, &sp14); + VECAdd(&sp14, &sp8, &sp14); sp14.y += 25.0f; CharModelLayerSetAll(7); CharModelEffectCreate(-1, &sp14); diff --git a/src/REL/w05Dll/monkey.c b/src/REL/w05Dll/monkey.c index 52c6f9db..860bec35 100644 --- a/src/REL/w05Dll/monkey.c +++ b/src/REL/w05Dll/monkey.c @@ -110,25 +110,25 @@ void fn_1_3044(void) { HuPrcSleep(0x88); Hu3DModelObjPosGet(BoardModelIDGet(lbl_1_bss_4A), lbl_1_data_1C4[lbl_1_bss_48], &sp20); Hu3DModelObjPosGet(BoardModelIDGet(lbl_1_bss_4E[lbl_1_bss_48]), "bakawa1", &sp14); - PSVECAdd(&sp20, &sp14, &sp14); + VECAdd(&sp20, &sp14, &sp14); BoardModelPosSetV(lbl_1_bss_44[0], &sp14); BoardModelVisibilitySet(lbl_1_bss_44[0], 1); BoardModelMotionTimeSet(lbl_1_bss_44[0], 0.0f); HuAudFXPlay(0x48C); - PSVECSubtract(&lbl_1_bss_38, &sp14, &sp8); + VECSubtract(&lbl_1_bss_38, &sp14, &sp8); sp8.y = 0.0f; - PSVECNormalize(&sp8, &sp8); - PSVECScale(&sp8, &sp8, 8.0f); + VECNormalize(&sp8, &sp8); + VECScale(&sp8, &sp8, 8.0f); temp_f30 = 11.0f; var_f31 = 0.0f; while (1) { sp8.y = (temp_f30 - (0.075 * (0.25f * (var_f31 * var_f31)))); var_f31 += 1.0f; - PSVECAdd(&sp14, &sp8, &sp14); - PSVECSubtract(&lbl_1_bss_38, &sp14, &sp20); + VECAdd(&sp14, &sp8, &sp14); + VECSubtract(&lbl_1_bss_38, &sp14, &sp20); sp20.y = 0.0f; - var_f29 = PSVECMag(&sp20); + var_f29 = VECMag(&sp20); if (var_f29 <= 8.0f) { sp14.x = lbl_1_bss_38.x; sp14.z = lbl_1_bss_38.z; @@ -179,19 +179,19 @@ void fn_1_3514(void) { BoardPlayerPosGet(lbl_1_bss_4C, &sp2C); BoardPlayerMotionShiftSet(lbl_1_bss_4C, 4, 0.0f, 5.0f, 0); - PSVECSubtract(&lbl_1_bss_38, &sp2C, &sp20); + VECSubtract(&lbl_1_bss_38, &sp2C, &sp20); sp20.y = 0.0f; - PSVECNormalize(&sp20, &sp20); - PSVECScale(&sp20, &sp20, 7.2f); + VECNormalize(&sp20, &sp20); + VECScale(&sp20, &sp20, 7.2f); var_f30 = 10.0f; var_f31 = 0.0f; while (1) { sp20.y = (var_f30 - (0.075f * (0.25f * (var_f31 * var_f31)))); var_f31 += 1.0f; - PSVECAdd(&sp2C, &sp20, &sp2C); - PSVECSubtract(&lbl_1_bss_38, &sp2C, &sp14); + VECAdd(&sp2C, &sp20, &sp2C); + VECSubtract(&lbl_1_bss_38, &sp2C, &sp14); sp14.y = 0.0f; - var_f29 = PSVECMag(&sp14); + var_f29 = VECMag(&sp14); if (var_f29 <= 7.2f) { sp2C.x = lbl_1_bss_38.x; sp2C.z = lbl_1_bss_38.z; @@ -218,19 +218,19 @@ void fn_1_3514(void) { var_r31 = BoardSpaceLinkFlagSearch(0, var_r31, 0x400); } BoardSpacePosGet(0, var_r31, &sp8); - PSVECSubtract(&sp8, &sp2C, &sp20); + VECSubtract(&sp8, &sp2C, &sp20); sp20.y = 0.0f; - PSVECNormalize(&sp20, &sp20); - PSVECScale(&sp20, &sp20, 10.0f); + VECNormalize(&sp20, &sp20); + VECScale(&sp20, &sp20, 10.0f); var_f30 = 9.0f; var_f31 = 0.0f; while (1) { sp20.y = var_f30 - (0.075f * (0.25f * (var_f31 * var_f31))); var_f31 += 1.0f; - PSVECAdd(&sp2C, &sp20, &sp2C); - PSVECSubtract(&sp8, &sp2C, &sp14); + VECAdd(&sp2C, &sp20, &sp2C); + VECSubtract(&sp8, &sp2C, &sp14); sp14.y = 0.0f; - var_f29 = PSVECMag(&sp14); + var_f29 = VECMag(&sp14); if (var_f29 <= 10.0f) { sp2C.x = sp8.x; sp2C.z = sp8.z; @@ -327,7 +327,7 @@ void fn_1_3E8C(void) { sp8.x = 25.0f; } for (i = 0; i < 60; i++) { - PSVECAdd(&sp14, &sp8, &sp14); + VECAdd(&sp14, &sp8, &sp14); sp8.y -= 0.625f; BoardModelPosSetV(lbl_1_bss_44[1], &sp14); HuPrcVSleep(); diff --git a/src/REL/w06Dll/bowser.c b/src/REL/w06Dll/bowser.c index c9215a5d..266b5ae3 100755 --- a/src/REL/w06Dll/bowser.c +++ b/src/REL/w06Dll/bowser.c @@ -250,8 +250,8 @@ static void fn_1_95AC(s32 arg0) { lbl_1_data_49C = BoardPlayerMotionCreate(arg0, lbl_1_data_510[GWPlayer[arg0].character]); BoardPlayerPosGet(arg0, &sp38); BoardModelPosGet(lbl_1_data_49A, &sp2C); - PSVECSubtract(&sp2C, &sp38, &sp20); - PSVECNormalize(&sp20, &sp20); + VECSubtract(&sp2C, &sp38, &sp20); + VECNormalize(&sp20, &sp20); BoardModelMotionShiftSet(lbl_1_data_498, 4, 0.0f, 8.0f, 0); HuPrcSleep(8); HuAudFXPlay(0x3C); @@ -300,8 +300,8 @@ static void fn_1_95AC(s32 arg0) { omVibrate(arg0, 12, 4, 2); BoardPlayerMotionStart(arg0, lbl_1_data_49C, 0x40000001); temp_r30 = BoardSpaceFlagPosGet(0, 0x8000, &sp2C); - PSVECSubtract(&sp2C, &sp38, &sp20); - PSVECNormalize(&sp20, &sp20); + VECSubtract(&sp2C, &sp38, &sp20); + VECNormalize(&sp20, &sp20); sp20.x = 500.0f * sp20.x / 90.0f; sp20.z = 500.0f * sp20.z / 90.0f; sp38.y += 150.0f; @@ -384,8 +384,8 @@ static void fn_1_9E5C(s32 arg0) { BoardPlayerPosGet(arg0, &sp38); BoardModelPosGet(lbl_1_data_49A, &sp2C); - PSVECSubtract(&sp2C, &sp38, &sp20); - PSVECNormalize(&sp20, &sp20); + VECSubtract(&sp2C, &sp38, &sp20); + VECNormalize(&sp20, &sp20); BoardModelMotionShiftSet(lbl_1_data_498, 4, 0.0f, 8.0f, 0); HuPrcSleep(8); HuAudFXPlay(0x3C); @@ -500,8 +500,8 @@ static void fn_1_A408(s32 arg0) { BoardPlayerPosGet(arg0, &sp38); BoardModelPosGet(lbl_1_data_49A, &sp2C); - PSVECSubtract(&sp2C, &sp38, &sp20); - PSVECNormalize(&sp20, &sp20); + VECSubtract(&sp2C, &sp38, &sp20); + VECNormalize(&sp20, &sp20); BoardModelMotionShiftSet(lbl_1_data_498, 4, 0.0f, 8.0f, 0); HuPrcSleep(8); HuAudFXPlay(0x3C); @@ -656,8 +656,8 @@ static void fn_1_AB4C(s32 arg0, s32 arg1) { BoardSpacePosGet(0, arg1, &sp3C); BoardPlayerPosSetV(arg0, &sp3C); BoardModelPosGet(lbl_1_data_49A, &sp30); - PSVECSubtract(&sp30, &sp3C, &sp24); - PSVECNormalize(&sp24, &sp24); + VECSubtract(&sp30, &sp3C, &sp24); + VECNormalize(&sp24, &sp24); BoardPlayerRotYSet(arg0, atan2d(sp24.x, sp24.z)); BoardPlayerSizeSet(arg0, 2); sp18.x = 0.0f; @@ -774,8 +774,8 @@ static void fn_1_B27C(s32 arg0) { BoardPlayerPosGet(arg0, &sp38); BoardModelPosGet(lbl_1_data_49A, &sp2C); - PSVECSubtract(&sp2C, &sp38, &sp20); - PSVECNormalize(&sp20, &sp20); + VECSubtract(&sp2C, &sp38, &sp20); + VECNormalize(&sp20, &sp20); BoardModelMotionShiftSet(lbl_1_data_498, 4, 0.0f, 8.0f, 0); HuPrcSleep(8); HuAudFXPlay(0x3C); @@ -960,7 +960,7 @@ static void fn_1_BD8C(s32 arg0) { OSs8tof32(&lbl_1_data_4A4[lbl_1_bss_0->unk04 - 1], &var_f25); BoardPlayerPosGet(arg0, &sp18); BoardModelPosGet(lbl_1_data_49A, &sp24); - PSVECSubtract(&sp18, &sp24, &spC); + VECSubtract(&sp18, &sp24, &spC); var_f26 = atan2d(spC.x, spC.z); BoardPlayerMotBlendSet(arg0, var_f26 + 180.0f, 0x14); fn_1_B6A0(var_f25, 20); @@ -1205,9 +1205,9 @@ void fn_1_CD0C(void) { BoardModelVisibilitySet(lbl_1_data_49A, 1); BoardModelPosGet(lbl_1_data_498, &sp20); BoardViewFocusGetPos(&sp2C); - PSVECSubtract(&sp2C, &sp20, &sp14); + VECSubtract(&sp2C, &sp20, &sp14); sp14.y = 0.0f; - temp_f30 = PSVECMag(&sp14); + temp_f30 = VECMag(&sp14); if (temp_f30 > 3000.0f) { var_r30 = 180; } else if (temp_f30 > 1500.0f) { diff --git a/src/REL/w06Dll/bridge.c b/src/REL/w06Dll/bridge.c index 9045bc1e..98e74c7d 100755 --- a/src/REL/w06Dll/bridge.c +++ b/src/REL/w06Dll/bridge.c @@ -226,7 +226,7 @@ static s32 fn_1_8490(s32 arg0, s8 arg1) { BoardPlayerPosGet(arg0, &sp18); BoardSpacePosGet(0, lbl_1_bss_E2, &sp24); - PSVECSubtract(&sp24, &sp18, &spC); + VECSubtract(&sp24, &sp18, &spC); temp_f30 = atan2d(spC.x, spC.z); BoardPlayerMotBlendSet(arg0, temp_f30, 0xF); while (!BoardPlayerMotBlendCheck(arg0)) { diff --git a/src/REL/w06Dll/fire.c b/src/REL/w06Dll/fire.c index be247094..794377cc 100755 --- a/src/REL/w06Dll/fire.c +++ b/src/REL/w06Dll/fire.c @@ -154,7 +154,7 @@ static void fn_1_72CC(s32 arg0) { } BoardPlayerPosGet(arg0, &sp18); BoardModelPosGet(lbl_1_bss_C0, &sp24); - PSVECSubtract(&sp24, &sp18, &spC); + VECSubtract(&sp24, &sp18, &spC); for (i = 0; i < 4; i++) { if (var_r30 & BoardSpaceFlagGet(0, GWPlayer[i].space_curr)) { lbl_1_bss_C2[i] = 1; @@ -265,11 +265,11 @@ static void fn_1_7760(s32 arg0) { } BoardModelPosGet(lbl_1_bss_C0, &sp20); BoardSpacePosGet(0, var_r29, &sp2C); - PSVECSubtract(&sp2C, &sp20, &sp8); + VECSubtract(&sp2C, &sp20, &sp8); sp8.x *= 0.4f; sp8.y *= 0.4f; sp8.z *= 0.4f; - PSVECAdd(&sp20, &sp8, &sp2C); + VECAdd(&sp20, &sp8, &sp2C); lbl_1_data_22A = BoardModelCreate(DATA_MAKE_NUM(DATADIR_BOARD, 10), NULL, 0); BoardModelVisibilitySet(lbl_1_data_22A, 0); BoardModelPosSetV(lbl_1_data_22A, &sp2C); diff --git a/src/REL/w06Dll/mg_coin.c b/src/REL/w06Dll/mg_coin.c index 112ba588..daa0ac8b 100755 --- a/src/REL/w06Dll/mg_coin.c +++ b/src/REL/w06Dll/mg_coin.c @@ -203,8 +203,8 @@ static s32 fn_1_4BF8(s32 arg0) { BoardModelPosGet(lbl_1_bss_C[0], &sp38); sp38.x += 115.0 * sin(M_PI); sp38.z += 115.0 * cos(M_PI); - PSVECSubtract(&sp38, &sp2C, &sp20); - PSVECNormalize(&sp20, &sp20); + VECSubtract(&sp38, &sp2C, &sp20); + VECNormalize(&sp20, &sp20); BoardPlayerRotYSet(arg0, atan2d(-sp20.x, -sp20.z)); BoardPlayerPosLerpStart(arg0, &sp2C, &sp38, 40); BoardModelPosGet(lbl_1_bss_C[5], &sp2C); @@ -212,7 +212,7 @@ static s32 fn_1_4BF8(s32 arg0) { BoardModelMotionSpeedSet(lbl_1_bss_C[5], 2.0f); while (GWPlayer[arg0].moving) { BoardPlayerPosGet(arg0, &sp38); - PSVECSubtract(&sp38, &sp2C, &sp20); + VECSubtract(&sp38, &sp2C, &sp20); BoardModelRotYSet(lbl_1_bss_C[5], atan2d(sp20.x, sp20.z)); HuPrcVSleep(); } @@ -285,7 +285,7 @@ static void fn_1_519C(s32 arg0) { BoardModelMotionSpeedSet(lbl_1_bss_C[5], 2.0f); while (GWPlayer[arg0].moving) { BoardPlayerPosGet(arg0, &sp14); - PSVECSubtract(&sp14, &sp20, &sp8); + VECSubtract(&sp14, &sp20, &sp8); BoardModelRotYSet(lbl_1_bss_C[5], atan2d(sp8.x, sp8.z)); HuPrcVSleep(); } @@ -336,8 +336,8 @@ static void fn_1_5490(s32 arg0) { sp3C.x += 50.0f; BoardPlayerPosGet(arg0, &sp30); sp30.x -= 10.0f; - PSVECSubtract(&sp30, &sp3C, &sp24); - PSVECNormalize(&sp24, &sp18); + VECSubtract(&sp30, &sp3C, &sp24); + VECNormalize(&sp24, &sp18); temp_r3->trans.x = sp24.x / 60.0f; temp_r3->trans.y = sp24.y / 60.0f; temp_r3->trans.z = sp24.z / 60.0f; diff --git a/src/REL/w06Dll/mg_item.c b/src/REL/w06Dll/mg_item.c index 60400ef0..fa37e956 100755 --- a/src/REL/w06Dll/mg_item.c +++ b/src/REL/w06Dll/mg_item.c @@ -273,8 +273,8 @@ static s32 fn_1_12A0(s32 arg0) { lbl_1_bss_34 = BoardSpaceLinkFlagSearch(0, var_r30, 0x02000000); BoardPlayerPosGet(arg0, &sp2C); BoardSpacePosGet(0, lbl_1_bss_34, &sp38); - PSVECSubtract(&sp38, &sp2C, &sp20); - PSVECNormalize(&sp20, &sp20); + VECSubtract(&sp38, &sp2C, &sp20); + VECNormalize(&sp20, &sp20); BoardPlayerRotYSet(arg0, atan2d(-sp20.x, -sp20.z)); BoardPlayerPosLerpStart(arg0, &sp2C, &sp38, 20); while (GWPlayer[arg0].moving) { @@ -979,7 +979,7 @@ static void fn_1_3698(s8 arg0) { } else { var_f30 = 20.0f; } - PSVECSubtract(&sp18, &sp24, &spC); + VECSubtract(&sp18, &sp24, &spC); lbl_1_bss_28->trans.y = temp_f31 / var_f30; BoardModelRotYSet(lbl_1_bss_C[4], atan2d(spC.x, spC.z)); BoardModelMotionShiftSet(lbl_1_bss_C[4], temp_r31->unk08, 0.0f, 8.0f, 0x40000001); diff --git a/src/REL/ztardll/main.c b/src/REL/ztardll/main.c index a142e25f..12c726e7 100644 --- a/src/REL/ztardll/main.c +++ b/src/REL/ztardll/main.c @@ -156,7 +156,7 @@ block_7: sp2C.y = 400.0f; sp2C.z = 100.0f; Hu3D2Dto3D(&sp2C, 1, &sp20); - PSVECSubtract(&sp8, &sp20, &sp14); + VECSubtract(&sp8, &sp20, &sp14); for (var_r31 = 0; var_r31 <= 0x1E; var_r31++) { if (var_r31 <= 0x14) { var_f31 = var_r31 / 20.0; @@ -166,8 +166,8 @@ block_7: HuSprGrpPosSet(lbl_1_bss_4C[1], 438.0 + (300.0 * (1.0 - sind((90.0f * var_f31)))), 240.0f); } var_f31 = var_r31 / 30.0; - PSVECScale(&sp14, &sp2C, var_f31); - PSVECAdd(&sp2C, &sp20, &sp2C); + VECScale(&sp14, &sp2C, var_f31); + VECAdd(&sp2C, &sp20, &sp2C); Hu3DModelRotSet(lbl_1_bss_42, 0.0f, -10.0f, -15.0f); Hu3DModelPosSetV(lbl_1_bss_42, &sp2C); HuPrcVSleep(); @@ -1450,15 +1450,15 @@ void fn_1_6804(void) sp8.z = sp14.z * ((sp20.z * sp20.z) + ((1.0f - (sp20.z * sp20.z)) * cosd(var_f31))) + (sp14.x * (((sp20.x * sp20.z) * (1.0 - cosd(var_f31))) - sp20.y * sind(var_f31)) + sp14.y * (((sp20.y * sp20.z) * (1.0 - cosd(var_f31))) + sp20.x * sind(var_f31))); - PSVECCrossProduct(&sp14, &sp20, &sp20); - PSVECNormalize(&sp20, &sp20); + VECCrossProduct(&sp14, &sp20, &sp20); + VECNormalize(&sp20, &sp20); var_r31 = HuPadSubStkX[0] & 0xF8; if (var_r31 != 0) { Center.x += 0.05f * (sp20.x * var_r31); Center.y += 0.05f * (sp20.y * var_r31); Center.z += 0.05f * (sp20.z * var_r31); } - PSVECNormalize(&sp8, &sp20); + VECNormalize(&sp8, &sp20); var_r31 = -(HuPadSubStkY[0] & 0xF8); if (var_r31 != 0) { Center.x += 0.05f * (sp20.x * var_r31); diff --git a/src/game/EnvelopeExec.c b/src/game/EnvelopeExec.c index cf417b01..53a9d990 100644 --- a/src/game/EnvelopeExec.c +++ b/src/game/EnvelopeExec.c @@ -367,11 +367,11 @@ static void SetEnvelop(HsfCenv *arg0) { sp44.x = var_r25->value * (sp44.x - temp_r31->x); sp44.y = var_r25->value * (sp44.y - temp_r31->y); sp44.z = var_r25->value * (sp44.z - temp_r31->z); - PSVECAdd(&sp38, &sp44, &sp38); + VECAdd(&sp38, &sp44, &sp38); sp2C.x = var_r25->value * (sp2C.x - temp_r26->x); sp2C.y = var_r25->value * (sp2C.y - temp_r26->y); sp2C.z = var_r25->value * (sp2C.z - temp_r26->z); - PSVECAdd(&sp20, &sp2C, &sp20); + VECAdd(&sp20, &sp2C, &sp20); } temp_r28->x = temp_r31->x + sp38.x; temp_r28->y = temp_r31->y + sp38.y; diff --git a/src/game/board/boo.c b/src/game/board/boo.c index f8323694..b8f57490 100755 --- a/src/game/board/boo.c +++ b/src/game/board/boo.c @@ -1292,7 +1292,7 @@ static void TakeBallCoin(void) { var_r31->unk1C.x = 3.0f * (BoardRandFloat() - 0.5f); var_r31->unk1C.y = 3.0 * sin(BoardRandFloat()); var_r31->unk1C.z = 3.0f * (BoardRandFloat() - 0.5f); - PSVECScale(&var_r31->unk1C, &var_r31->unk1C, 4.0f); + VECScale(&var_r31->unk1C, &var_r31->unk1C, 4.0f); BoardModelPosSetV(var_r31->unk00, &var_r31->unk04); var_r31->unk10 = var_r31->unk1C; } @@ -1329,8 +1329,8 @@ static void TakeBallCoinPosSet(BallTakeCoinData *arg0, Vec *arg1) { arg0->unk00 = -1; return; } - PSVECAdd(&arg0->unk04, &arg0->unk10, &arg0->unk04); - PSVECAdd(&arg0->unk04, &arg0->unk1C, &arg0->unk04); + VECAdd(&arg0->unk04, &arg0->unk10, &arg0->unk04); + VECAdd(&arg0->unk04, &arg0->unk1C, &arg0->unk04); arg0->unk10.y += -0.98f; BoardModelPosSetV(arg0->unk00, &arg0->unk04); } diff --git a/src/game/board/boo_house.c b/src/game/board/boo_house.c index 544eabd6..447c3512 100644 --- a/src/game/board/boo_house.c +++ b/src/game/board/boo_house.c @@ -237,8 +237,8 @@ static void ExecBooHouse(void) temp_r29 = BoardSpaceLinkFlagSearch(0, var_r30, 0x02000000); BoardSpacePosGet(0, var_r30, &sp38); BoardSpacePosGet(0, temp_r29, &sp2C); - PSVECSubtract(&sp2C, &sp38, &sp20); - PSVECNormalize(&sp20, &sp20); + VECSubtract(&sp2C, &sp38, &sp20); + VECNormalize(&sp20, &sp20); temp_f31 = atan2d(-sp20.x, -sp20.z); sp14.x = -15.0f; sp14.y = temp_f31; @@ -837,8 +837,8 @@ void BoardBooHouseTutorialExec(void) temp_r28 = BoardSpaceLinkFlagSearch(0, temp_r29, 0x02000000); BoardSpacePosGet(0, temp_r29, &sp38); BoardSpacePosGet(0, temp_r28, &sp2C); - PSVECSubtract(&sp2C, &sp38, &sp20); - PSVECNormalize(&sp20, &sp20); + VECSubtract(&sp2C, &sp38, &sp20); + VECNormalize(&sp20, &sp20); temp_f31 = atan2d(-sp20.x, -sp20.z); sp14.x = -15.0f; sp14.y = temp_f31; diff --git a/src/game/board/com.c b/src/game/board/com.c index 00a66a66..ed7f1e3c 100755 --- a/src/game/board/com.c +++ b/src/game/board/com.c @@ -746,7 +746,7 @@ s32 BoardComJunctionInputGet(s32 item, Vec *input, s32 num_dirs, float *dirs) { } else { BoardSpacePosGet(0, space, &pos_junction); BoardSpacePosGet(0, space_next, &pos_next); - PSVECSubtract(&pos_next, &pos_junction, &dir); + VECSubtract(&pos_next, &pos_junction, &dir); angle = BoardDAngleCalc(90.0 - atan2d(dir.z, dir.x)); if (angle < 0.0f) { angle += 360.0f; diff --git a/src/game/board/item.c b/src/game/board/item.c index 76563ee2..682448db 100755 --- a/src/game/board/item.c +++ b/src/game/board/item.c @@ -326,7 +326,7 @@ static void ItemRotProc(void) { if (temp_r31->unk0C >= 360.0f) { temp_r31->unk0C -= 360.0f; } - PSVECAdd(&sp8, &temp_r31->unk10, &sp8); + VECAdd(&sp8, &temp_r31->unk10, &sp8); if (sp8.x < 0.0f) { sp8.x += 360.0f; } @@ -384,7 +384,7 @@ static inline void BoardUiInlineFunc01(Vec *arg0) { } sp3C.y -= var_f31; BoardModelPosSetV(suitMdl, &sp3C); - PSVECAdd(&sp48, arg0, &sp48); + VECAdd(&sp48, arg0, &sp48); for (i = 0; i < 3; i++) { if (((float*) &sp48)[i] < 0.0f) { ((float*) &sp48)[i] += 360.0f; @@ -896,8 +896,8 @@ static void ExecItemPipe(void) { temp_f28 = 19.0f; var_f29 = 0.0f; for (var_r31 = 0; var_r31 < 2; var_r31++) { - PSVECSubtract(&spE4[var_r31], &spCC[var_r31], &spB4[var_r31]); - PSVECScale(&spB4[var_r31], &spB4[var_r31], 0.03f); + VECSubtract(&spE4[var_r31], &spCC[var_r31], &spB4[var_r31]); + VECScale(&spB4[var_r31], &spB4[var_r31], 0.03f); BoardModelVisibilitySet(BoardPlayerModelGet(sp2C[var_r31]), 1); } HuAudPlayerVoicePlay(currItemRestore, 0x122); @@ -1035,7 +1035,7 @@ static void ExecItemSwap(void) { } BoardModelRotGet(suitMdl, &spA8); while (1) { - PSVECAdd(&spA8, &sp9C, &spA8); + VECAdd(&spA8, &sp9C, &spA8); for (var_r26 = 0; var_r26 < 3; var_r26++) { if (((float*) &spA8)[var_r26] < 0.0f) { ((float*) &spA8)[var_r26] += 360.0f; @@ -1092,8 +1092,8 @@ static void ExecItemSwap(void) { BoardItemGetDestPos(currItemRestore, &sp15C[0]); BoardItemGetDestPos(temp_r24, &sp138[0]); BoardModelPosGet(suitMdl, &sp90); - PSVECSubtract(&sp90, &Hu3DCamera->pos, &sp90); - temp_f29 = PSVECMag(&sp90); + VECSubtract(&sp90, &Hu3DCamera->pos, &sp90); + temp_f29 = VECMag(&sp90); for (var_r31 = 0; var_r31 < 3; var_r31++) { sp15C[var_r31].z = temp_f29; sp138[var_r31].z = temp_f29; @@ -1105,15 +1105,15 @@ static void ExecItemSwap(void) { sp1A4[var_r31] = sp180[var_r31] = spB4; Hu3D2Dto3D(&sp15C[var_r31], 1, &sp84); Hu3D2Dto3D(&sp138[var_r31], 1, &sp78); - PSVECSubtract(&sp84, &sp1A4[var_r31], &sp6C); - PSVECScale(&sp6C, &sp6C, 0.033333335f); - PSVECSubtract(&sp78, &sp180[var_r31], &sp60); - PSVECScale(&sp60, &sp60, 0.033333335f); + VECSubtract(&sp84, &sp1A4[var_r31], &sp6C); + VECScale(&sp6C, &sp6C, 0.033333335f); + VECSubtract(&sp78, &sp180[var_r31], &sp60); + VECScale(&sp60, &sp60, 0.033333335f); for (var_r30 = 0; var_r30 < 30; var_r30++) { BoardModelPosSetV(sp54[var_r31], &sp1A4[var_r31]); BoardModelPosSetV(sp54[var_r31 + 3], &sp180[var_r31]); - PSVECAdd(&sp1A4[var_r31], &sp6C, &sp1A4[var_r31]); - PSVECAdd(&sp180[var_r31], &sp60, &sp180[var_r31]); + VECAdd(&sp1A4[var_r31], &sp6C, &sp1A4[var_r31]); + VECAdd(&sp180[var_r31], &sp60, &sp180[var_r31]); HuPrcVSleep(); } sp1A4[var_r31] = sp84; @@ -1154,15 +1154,15 @@ static void ExecItemSwap(void) { } for (var_r31 = (var_r28 / 2) - 1; var_r31 >= 0; var_r31--) { HuAudFXPlay(0x32C); - PSVECSubtract(&spB4, &sp1A4[var_r31], &sp6C); - PSVECScale(&sp6C, &sp6C, 0.033333335f); - PSVECSubtract(&spB4, &sp180[var_r31], &sp60); - PSVECScale(&sp60, &sp60, 0.033333335f); + VECSubtract(&spB4, &sp1A4[var_r31], &sp6C); + VECScale(&sp6C, &sp6C, 0.033333335f); + VECSubtract(&spB4, &sp180[var_r31], &sp60); + VECScale(&sp60, &sp60, 0.033333335f); for (var_r30 = 0; var_r30 < 30; var_r30++) { BoardModelPosSetV(sp54[var_r31], &sp1A4[var_r31]); BoardModelPosSetV(sp54[var_r31 + 3], &sp180[var_r31]); - PSVECAdd(&sp1A4[var_r31], &sp6C, &sp1A4[var_r31]); - PSVECAdd(&sp180[var_r31], &sp60, &sp180[var_r31]); + VECAdd(&sp1A4[var_r31], &sp6C, &sp1A4[var_r31]); + VECAdd(&sp180[var_r31], &sp60, &sp180[var_r31]); HuPrcVSleep(); } BoardModelVisibilitySet(sp54[var_r31], 0); @@ -1174,7 +1174,7 @@ static void ExecItemSwap(void) { while (1) { BoardModelRotSetV(suitMdl, &spA8); BoardModelAlphaSet(suitMdl, var_f30); - PSVECAdd(&spA8, &sp9C, &spA8); + VECAdd(&spA8, &sp9C, &spA8); sp9C.y *= 1.02f; if (sp9C.y >= 35.0f) { if (var_r21 == 0) { @@ -1397,8 +1397,8 @@ static void ExecItemWhistle(void) { BoardPlayerPosGet(currItemRestore, &sp84); sp84.y += 200.0f; sp84.z += 100.0f; - PSVECSubtract(&sp84, &sp90, &sp78); - PSVECScale(&sp78, &sp78, 0.03448276f); + VECSubtract(&sp84, &sp90, &sp78); + VECScale(&sp78, &sp78, 0.03448276f); BoardPlayerMotionStart(currItemRestore, temp_r23, 0); BoardPlayerMotionTimeSet(currItemRestore, 1.0f); for (var_r31 = 0; var_r31 < 29; var_r31++) { @@ -1978,8 +1978,8 @@ static void LampParticleUpdate(ModelData *model, ParticleData *particle, Mtx mat for (i = 0; i < particle->unk_30; i++, var_r31++) { if (var_r31->unk2C != 0.0f) { if (var_r31->unk00_s16 == 0) { - PSVECAdd(&var_r31->unk34, &var_r31->unk08, &var_r31->unk34); - PSVECScale(&var_r31->unk08, &var_r31->unk08, 0.95f); + VECAdd(&var_r31->unk34, &var_r31->unk08, &var_r31->unk34); + VECScale(&var_r31->unk08, &var_r31->unk08, 0.95f); var_r31->unk2C += 8.0f; var_r31->unk14.y -= 2.8333333f; if (var_r31->unk14.y <= 120.0f) { @@ -1992,7 +1992,7 @@ static void LampParticleUpdate(ModelData *model, ParticleData *particle, Mtx mat } var_r31->unk40.a = var_r31->unk14.y; } else { - PSVECAdd(&var_r31->unk34, &var_r31->unk08, &var_r31->unk34); + VECAdd(&var_r31->unk34, &var_r31->unk08, &var_r31->unk34); var_r31->unk2C += 0.2f; var_r31->unk14.y -= 1.8214285f; if (var_r31->unk14.y <= 55.0f) { @@ -2034,8 +2034,8 @@ static void GenieParticleUpdate(ModelData *model, ParticleData *particle, Mtx ma for (i = 0; i < particle->unk_30; i++, var_r31++) { if (var_r31->unk2C != 0.0f) { var_r28++; - PSVECAdd(&var_r31->unk34, &var_r31->unk08, &var_r31->unk34); - PSVECScale(&var_r31->unk08, &var_r31->unk08, 0.995f); + VECAdd(&var_r31->unk34, &var_r31->unk08, &var_r31->unk34); + VECScale(&var_r31->unk08, &var_r31->unk08, 0.995f); var_r31->unk2C -= 0.2f; var_r31->unk14.y -= 1.59375f; if (var_r31->unk14.y <= 20.0f) { @@ -2216,8 +2216,8 @@ static void GenieSceneExec(void) { BoardPlayerCameraSet(currItemRestore, 2); BoardPlayerPosSetV(currItemRestore, &sp38); BoardModelVisibilitySet(BoardPlayerModelGet(currItemRestore), 1); - PSVECSubtract(&shadowUp, &shadowPos, &sp2C); - PSVECNormalize(&sp2C, &sp2C); + VECSubtract(&shadowUp, &shadowPos, &sp2C); + VECNormalize(&sp2C, &sp2C); temp_r20 = Hu3DGLightCreateV(&shadowPos, &sp2C, &sp1C); Hu3DShadowCreate(60.0f, 10.0f, 20000.0f); Hu3DModelShadowSet(BoardModelIDGet(BoardPlayerModelGet(currItemRestore))); diff --git a/src/game/board/lottery.c b/src/game/board/lottery.c index 9e307af2..c1fb5f7f 100755 --- a/src/game/board/lottery.c +++ b/src/game/board/lottery.c @@ -503,10 +503,10 @@ static void ExecLottery(void) { lotterySpace = BoardSpaceLinkFlagSearch(0, temp_r28, 0x02000000); BoardSpacePosGet(0, temp_r28, &sp38); BoardSpacePosGet(0, lotterySpace, &sp2C); - PSVECSubtract(&sp2C, &sp38, &sp20); + VECSubtract(&sp2C, &sp38, &sp20); if (GWBoardGet() == BOARD_ID_MAIN3 || GWBoardGet() == BOARD_ID_MAIN4) { - PSVECScale(&sp20, &sp20, 0.95f); - PSVECAdd(&sp20, &sp38, &sp2C); + VECScale(&sp20, &sp20, 0.95f); + VECAdd(&sp20, &sp38, &sp2C); } temp_r26 = atan2d(-sp20.x, -sp20.z); if (BoardPlayerSizeGet(temp_r31) == 1) { @@ -546,8 +546,8 @@ static void ExecLottery(void) { for (i = 0; i < 4; i++) { if (i != temp_r31) { BoardPlayerPosGet(i, &sp38); - PSVECSubtract(&sp2C, &sp38, &sp20); - PSVECNormalize(&sp20, &sp20); + VECSubtract(&sp2C, &sp38, &sp20); + VECNormalize(&sp20, &sp20); BoardPlayerMotBlendSet(i, atan2d(sp20.x, sp20.z), 7); } } @@ -620,7 +620,7 @@ static void DoMiniJumpUp(s32 arg0) { temp_f29 = BoardPlayerMotionMaxTimeGet(arg0); BoardPlayerPosGet(arg0, &sp1C); sp28.y += 52.5308f; - PSVECSubtract(&sp28, &sp1C, &sp10); + VECSubtract(&sp28, &sp1C, &sp10); sp10.x /= temp_f29; sp10.z /= temp_f29; sp10.y /= temp_f29; @@ -653,7 +653,7 @@ static void DoMiniJumpDown(s32 arg0) { BoardPlayerPosGet(arg0, &sp18); BoardSpacePosGet(0, lotterySpace, &sp24); - PSVECSubtract(&sp24, &sp18, &spC); + VECSubtract(&sp24, &sp18, &spC); BoardPlayerMotionStart(arg0, 4, 0); spC.x /= 30.0f; spC.z /= 30.0f; @@ -1049,7 +1049,7 @@ static void ExecBallPrize(void) { PSMTXTrans(sp3C, temp_r3->data.curr.pos.x, temp_r3->data.curr.pos.y + 210.0f, temp_r3->data.curr.pos.z + -40.0f); PSMTXConcat(sp6C, sp3C, sp3C); Hu3DMtxTransGet(sp3C, &spC); - PSVECAdd(&spC, &sp30, &sp30); + VECAdd(&spC, &sp30, &sp30); BoardModelVisibilitySet(temp_r29, 1); sp24.x = 10.5f; sp24.y = -3.0f; @@ -1065,7 +1065,7 @@ static void ExecBallPrize(void) { sp24.y -= temp_f26; sp24.x *= 0.92f; sp24.z *= 0.92f; - PSVECAdd(&sp24, &sp30, &sp30); + VECAdd(&sp24, &sp30, &sp30); var_f29 += sp24.z; if (sp30.y - 25.0f < temp_f28) { if (var_r28 == 0) { @@ -1294,13 +1294,13 @@ static void ExecScratchSpr(omObjData *arg0) { sp14.y = arg0->trans.y; sp20.x = arg0->rot.x; sp20.y = arg0->rot.y; - PSVECSubtract(&sp14, &sp20, &sp8); + VECSubtract(&sp14, &sp20, &sp8); if (ABS(sp8.x) < 1.0f && ABS(sp8.y) < 1.0f) { sp8 = sp14; temp_r30->unk00_field1 = 1; } else { - PSVECScale(&sp8, &sp8, 0.2f); - PSVECAdd(&sp20, &sp8, &sp8); + VECScale(&sp8, &sp8, 0.2f); + VECAdd(&sp20, &sp8, &sp8); temp_r30->unk00_field1 = 0; } HuSprPosSet(ticketSprGrp, temp_r30->unk00_field2, sp8.x, sp8.y); @@ -1589,16 +1589,16 @@ static s32 TicketUpdate(AnimBmpData *arg0, Vec *arg1, s32 arg2) { if (handUpdateF == 0) { handUpdateF = 1; } - PSVECNormalize(&sp48, &sp48); + VECNormalize(&sp48, &sp48); temp_f20 = atan2f(sp48.x, -sp48.y); sp48.x = sin(temp_f20); sp48.y = cos(temp_f20); - temp_f25 = 127.0f * PSVECMag(&sp48); + temp_f25 = 127.0f * VECMag(&sp48); OSf32tos8(&temp_f25, &spD); HuAudFXVolSet(arg2, spD); sp48.x *= 8.0f; sp48.y *= 8.0f; - PSVECAdd(&sp48, arg1, &sp3C); + VECAdd(&sp48, arg1, &sp3C); var_r18 = 0; if (sp3C.x < 192.0f) { sp3C.x = 192.0f; @@ -2027,8 +2027,8 @@ void BoardLotteryTutorialExec(void) { temp_r29 = BoardSpaceLinkFlagSearch(0, temp_r31, 0x02000000); BoardSpacePosGet(0, temp_r31, &sp38); BoardSpacePosGet(0, temp_r29, &sp2C); - PSVECSubtract(&sp2C, &sp38, &sp20); - PSVECNormalize(&sp20, &sp20); + VECSubtract(&sp2C, &sp38, &sp20); + VECNormalize(&sp20, &sp20); temp_r28 = atan2d(-sp20.x, -sp20.z); sp14.x = -3.0f; sp14.y = temp_r28; diff --git a/src/game/board/mg_setup.c b/src/game/board/mg_setup.c index 23e10108..1bca487c 100644 --- a/src/game/board/mg_setup.c +++ b/src/game/board/mg_setup.c @@ -837,8 +837,8 @@ static void FallMGType(bitcopy* arg0, omObjData* arg1) { temp_r31->unk_1C[1][temp_r30].y = -128.0f; arg0->unk_02 = 1; } - PSVECSubtract(&temp_r31->unk_1C[1][temp_r30], &temp_r31->unk_1C[0][temp_r30], &sp10); - if (PSVECMag(&sp10) <= 1.0f) { + VECSubtract(&temp_r31->unk_1C[1][temp_r30], &temp_r31->unk_1C[0][temp_r30], &sp10); + if (VECMag(&sp10) <= 1.0f) { temp_r31->unk_1C[0][temp_r30] = temp_r31->unk_1C[1][temp_r30]; temp_r29 = (bitcopy*) mgSetupObj->work; temp_r29->field00_bit1 = 7; @@ -846,8 +846,8 @@ static void FallMGType(bitcopy* arg0, omObjData* arg1) { temp_r29->unk_03 = 0; temp_r29->unk_04 = 0; } else { - PSVECScale(&sp10, &sp10, 0.1f); - PSVECAdd(&sp10, &temp_r31->unk_1C[0][temp_r30], &temp_r31->unk_1C[0][temp_r30]); + VECScale(&sp10, &sp10, 0.1f); + VECAdd(&sp10, &temp_r31->unk_1C[0][temp_r30], &temp_r31->unk_1C[0][temp_r30]); } HuSprPosSet(temp_r31->unk_00[0], temp_r30, temp_r31->unk_1C[0][temp_r30].x, temp_r31->unk_1C[0][temp_r30].y); } diff --git a/src/game/board/mushroom.c b/src/game/board/mushroom.c index 57aa85d6..74f73e0d 100644 --- a/src/game/board/mushroom.c +++ b/src/game/board/mushroom.c @@ -325,9 +325,9 @@ static void CenterBox(ItemGiveWork2* arg0, omObjData* arg1) { sp14.y = arg1->trans.y; sp14.z = arg1->trans.z; BoardPlayerPosGet(arg0->unk00_field5, &sp20); - PSVECSubtract(&sp20, &sp14, &sp8); - PSVECScale(&sp8, &sp8, 0.2f); - PSVECAdd(&sp8, &sp14, &sp14); + VECSubtract(&sp20, &sp14, &sp8); + VECScale(&sp8, &sp8, 0.2f); + VECAdd(&sp8, &sp14, &sp14); if (BoardVecMaxDistXZCheck(&sp20, &sp14, 3.0f) != 0) { arg1->trans.x = sp20.x; diff --git a/src/game/board/pause.c b/src/game/board/pause.c index 7c426ae9..4b5d5401 100755 --- a/src/game/board/pause.c +++ b/src/game/board/pause.c @@ -811,7 +811,7 @@ static void CreatePadConfig(omObjData *arg0, ConfigWork *arg1) { sp14.x = 96.0f; sp14.y = 176.0f; sp14.z = padBoxPos.z; - PSVECSubtract(&sp14, &padBoxPos, &sp8); + VECSubtract(&sp14, &padBoxPos, &sp8); arg0->scale.x = sp8.x / 20.0f; arg0->scale.y = sp8.y / 20.0f; arg1->unk01 = 1; @@ -996,7 +996,7 @@ static void ScrollOutPadConfig(omObjData *arg0, ConfigWork *arg1) { sp14.x = boxPosTbl[0][0]; sp14.y = boxPosTbl[0][1]; sp14.z = 700.0f; - PSVECSubtract(&sp14, &padBoxPos, &sp8); + VECSubtract(&sp14, &padBoxPos, &sp8); arg0->scale.x = sp8.x / 20.0f; arg0->scale.y = sp8.y / 20.0f; arg1->unk01 = 1; diff --git a/src/game/board/player.c b/src/game/board/player.c index e1388143..e309e8f0 100644 --- a/src/game/board/player.c +++ b/src/game/board/player.c @@ -1134,8 +1134,8 @@ static void InitJunction(s32 arg0, s32 arg1, f32 arg8) && ((temp_r25->flag & 0x04000000) == 0)) { if ((temp_r25->flag & BoardJunctionMaskGet()) == 0) { BoardSpacePosGet(0, temp_r26->link[var_r22], &sp50); - PSVECSubtract(&sp50, &sp68, &sp44); - PSVECNormalize(&sp44, &sp44); + VECSubtract(&sp50, &sp68, &sp44); + VECNormalize(&sp44, &sp44); angle = (180.0 * (atan2(sp44.x, sp44.z) / M_PI)); if (angle < 0.0f) { @@ -1339,7 +1339,7 @@ static s32 DoDebugMove(s32 arg0, s16 *arg1) spAC[var_r29] = 0; } else { - PSVECSubtract(&sp5C->pos, &sp88, &sp94); + VECSubtract(&sp5C->pos, &sp88, &sp94); var_f30 = 90.0 - (180.0 * (atan2(sp94.z, sp94.x) / M_PI)); OSf32tos16(&var_f30, &var_r26); if (var_r26 < 0) { @@ -1388,7 +1388,7 @@ static s32 DoDebugMove(s32 arg0, s16 *arg1) } RestoreJunction(var_f30, 1); sp50 = &boardCamera; - PSVECSubtract(&sp50->target, &sp50->pos, &sp7C); + VECSubtract(&sp50->target, &sp50->pos, &sp7C); var_f30 = (var_f30 + (90.0 - (180.0 * (atan2(-sp7C.z, -sp7C.x) / M_PI)))); if (var_f30 < 0.0f) { var_f30 += 360.0f; @@ -1519,7 +1519,7 @@ static s32 ExecJunction(s32 arg0, s16 *arg1) spD0[var_r28] = 0; } else { - PSVECSubtract(&sp88->pos, &spAC, &spB8); + VECSubtract(&sp88->pos, &spAC, &spB8); var_f29 = (90.0 - (180.0 * (atan2(spB8.z, spB8.x) / M_PI))); if (var_f29 < 0.0f) { var_f29 += 360.0f; @@ -1712,8 +1712,8 @@ void BoardPlayerPosLerpStart(s32 arg0, Vec *arg1, Vec *arg2, s16 arg3) BoardBowserSuitMotionSetWalk(); BoardModelMotionSpeedSet(suitMdl, 1.5f); } - PSVECSubtract(arg2, arg1, &sp18); - PSVECNormalize(&sp18, &sp18); + VECSubtract(arg2, arg1, &sp18); + VECNormalize(&sp18, &sp18); var_f26 = 90.0 - (180.0 * (atan2(sp18.z, sp18.x) / M_PI)); var_f30 = var_f26; if (var_f30 < 0.0f) { diff --git a/src/game/board/roll.c b/src/game/board/roll.c index c58d40e1..b233ffab 100755 --- a/src/game/board/roll.c +++ b/src/game/board/roll.c @@ -783,8 +783,8 @@ static void DiceDigitMove(DiceDigitWork *arg0, s32 arg1) { for (i = 0; i < 2; i++) { BoardModelPosGet(arg0->unk04[i], &sp30); Hu3D2Dto3D(&sp54[i], 1, &sp54[i]); - PSVECSubtract(&sp54[i], &sp30, &sp24); - if (PSVECMag(&sp24) < 0.01f) { + VECSubtract(&sp54[i], &sp30, &sp24); + if (VECMag(&sp24) < 0.01f) { arg0->unk00_field2 = 0; if (arg1 != 0 && arg0->unk00_field3 != 0) { BoardModelVisibilitySet(arg0->unk04[i], 0); @@ -792,8 +792,8 @@ static void DiceDigitMove(DiceDigitWork *arg0, s32 arg1) { } else { arg0->unk00_field2 = 1; } - PSVECScale(&sp24, &sp24, arg0->unk08); - PSVECAdd(&sp30, &sp24, &sp30); + VECScale(&sp24, &sp24, arg0->unk08); + VECAdd(&sp30, &sp24, &sp30); BoardModelPosSetV(arg0->unk04[i], &sp30); } } diff --git a/src/game/board/shop.c b/src/game/board/shop.c index 33a41420..f5636adc 100755 --- a/src/game/board/shop.c +++ b/src/game/board/shop.c @@ -260,8 +260,8 @@ static void ExecShop(void) { temp_r25 = BoardSpaceLinkFlagSearch(0, temp_r28, 0x02000000); BoardSpacePosGet(0, temp_r28, &sp38); BoardSpacePosGet(0, temp_r25, &sp2C); - PSVECSubtract(&sp2C, &sp38, &sp20); - PSVECNormalize(&sp20, &sp20); + VECSubtract(&sp2C, &sp38, &sp20); + VECNormalize(&sp20, &sp20); temp_f31 = atan2d(-sp20.x, -sp20.z); sp14.x = -10.0f; sp14.y = temp_f31; @@ -1135,8 +1135,8 @@ void BoardShopTutorialExec(s32 arg0) { temp_r27 = BoardSpaceLinkFlagSearch(0, arg0, 0x02000000); BoardSpacePosGet(0, arg0, &sp48); BoardSpacePosGet(0, temp_r27, &sp3C); - PSVECSubtract(&sp3C, &sp48, &sp30); - PSVECNormalize(&sp30, &sp30); + VECSubtract(&sp3C, &sp48, &sp30); + VECNormalize(&sp30, &sp30); temp_f31 = atan2d(-sp30.x, -sp30.z); sp24.x = -10.0f; sp24.y = temp_f31; diff --git a/src/game/board/star.c b/src/game/board/star.c index cbccef34..c9f7e6ea 100755 --- a/src/game/board/star.c +++ b/src/game/board/star.c @@ -206,7 +206,7 @@ static void ExecStar(void) { starDoneF = 0; var_r22 = BoardSpaceLinkFlagSearch(0, temp_r24, 0x04000000); BoardSpacePosGet(0, var_r22, &sp18); - PSVECSubtract(&sp18, &sp24, &spC); + VECSubtract(&sp18, &sp24, &spC); temp_f30 = 90.0 - atan2d(spC.z, spC.x); temp_f30 = 90.0f * ((temp_f30 + 3.0f) / 90.0f); temp_f29 = BoardPlayerRotYGet(temp_r31); @@ -696,9 +696,9 @@ void BoardStarShowNext(s32 arg0) { showNextObj->scale.z = sp50.z; BoardPlayerPosGet(arg0, &sp38); sp50.y = sp38.y; - PSVECSubtract(&sp50, &sp38, &sp20); + VECSubtract(&sp50, &sp38, &sp20); sp20.y = 0.0f; - temp_f31 = PSVECMag(&sp20); + temp_f31 = VECMag(&sp20); if (temp_f31 > 3000.0f) { var_r27 = 0xF0; } else if (temp_f31 > 1500.0f) { diff --git a/src/game/board/start.c b/src/game/board/start.c index 2d8072a6..ae88ff57 100755 --- a/src/game/board/start.c +++ b/src/game/board/start.c @@ -279,13 +279,13 @@ static void FocusStart(void) { sp20.x = spacePos.x + 150.0f; sp20.y = spacePos.y + 100.0f; sp20.z = spacePos.z + 150.0f; - PSVECSubtract(&sp20, &sp2C, &sp14); + VECSubtract(&sp20, &sp2C, &sp14); sp14.x /= 120.0f; sp14.y /= 120.0f; sp14.z /= 120.0f; HuAudSStreamFadeOut(streamStatus, 0x1388); for (var_r31 = 0; var_r31 < 120; var_r31++) { - PSVECAdd(&sp14, &sp2C, &sp2C); + VECAdd(&sp14, &sp2C, &sp2C); BoardModelPosSetV(camFocus, &sp2C); HuPrcVSleep(); } diff --git a/src/game/board/ui.c b/src/game/board/ui.c index 3e472858..0dd58fbf 100755 --- a/src/game/board/ui.c +++ b/src/game/board/ui.c @@ -650,15 +650,15 @@ static void MoveBoardStatus(s32 arg0) { float var_f30; Vec spC; - PSVECSubtract(&temp_r30->unk10, &temp_r30->unk04, &spC); + VECSubtract(&temp_r30->unk10, &temp_r30->unk04, &spC); if (ABS(spC.x) < 1.0f && ABS(spC.y) < 1.0f) { spC = temp_r30->unk10; temp_r30->unk00_bit2 = 0; } else { OSs8tof32(&temp_r30->unk01, &var_f30); var_f30 /= 32; - PSVECScale(&spC, &spC, var_f30); - PSVECAdd(&temp_r30->unk04, &spC, &spC); + VECScale(&spC, &spC, var_f30); + VECAdd(&temp_r30->unk04, &spC, &spC); temp_r30->unk00_bit2 = 1; } temp_r30->unk04.x = spC.x; @@ -833,15 +833,15 @@ static void MovePicker(UnkUiWork01 *arg0, omObjData *arg1) { sp14.x = arg1->trans.x; sp14.y = arg1->trans.y; sp14.z = arg1->trans.z; - PSVECSubtract(&sp8, &sp14, &sp8); - if (PSVECMag(&sp8) < 1.0f) { + VECSubtract(&sp8, &sp14, &sp8); + if (VECMag(&sp8) < 1.0f) { arg1->trans.x = arg1->rot.x; arg1->trans.y = arg1->rot.y; arg1->trans.z = arg1->rot.z; arg0->unk00_bit6 = 0; } else { - PSVECScale(&sp8, &sp8, temp_f31); - PSVECAdd(&sp14, &sp8, &sp8); + VECScale(&sp8, &sp8, temp_f31); + VECAdd(&sp14, &sp8, &sp8); arg1->trans.x = sp8.x; arg1->trans.y = sp8.y; arg1->trans.z = sp8.z; @@ -1444,7 +1444,7 @@ static void MakeItemPickSpace(UnkUiWork03 *arg0) { } for (i = 0; i < 4; i++) { for (j = 0; j < 6; j++) { - PSVECSubtract(&(temp_r28 + 4)[i][j], &temp_r28[i][j], &sp8); + VECSubtract(&(temp_r28 + 4)[i][j], &temp_r28[i][j], &sp8); if (ABS(sp8.x) < 1.0f && ABS(sp8.y) < 1.0f) { sp8 = (temp_r28 + 4)[i][j]; if (arg0->unk00_bit1 && arg0->unk03 == 0) { @@ -1452,8 +1452,8 @@ static void MakeItemPickSpace(UnkUiWork03 *arg0) { } } else { var_f29 = 0.3f; - PSVECScale(&sp8, &sp8, var_f29); - PSVECAdd(&temp_r28[i][j], &sp8, &sp8); + VECScale(&sp8, &sp8, var_f29); + VECAdd(&temp_r28[i][j], &sp8, &sp8); } temp_r28[i][j].x = sp8.x; temp_r28[i][j].y = sp8.y; @@ -1513,7 +1513,7 @@ void BoardItemGetDestPos(s32 arg0, Vec *arg1) { spC.y = statusPosTbl[arg0][1]; spC.z = 0.0f; for (i = 0; i < 3; i++) { - PSVECAdd((Vec*) &statusItemPosTbl[i + 2], &spC, &arg1[i]); + VECAdd((Vec*) &statusItemPosTbl[i + 2], &spC, &arg1[i]); } } @@ -1536,7 +1536,7 @@ static void ItemGetPos(s32 arg0, Vec *arg1) { } spC.z = 0.0f; for (i = 0; i < 3; i++) { - PSVECAdd((Vec*) statusItemPosTbl[i + 2], &spC, &arg1[i]); + VECAdd((Vec*) statusItemPosTbl[i + 2], &spC, &arg1[i]); } } @@ -1565,7 +1565,7 @@ void BoardItemStatusKill(s32 arg0) { } sp8.z = 0.0f; for (i = 0; i < 3; i++) { - PSVECAdd((Vec*) statusItemPosTbl[i + 2], &sp8, &sp68[i]); + VECAdd((Vec*) statusItemPosTbl[i + 2], &sp8, &sp68[i]); if (itemMdlId[arg0][i] != -1) { BoardModelRotGet(itemMdlId[arg0][i], &sp44[i]); BoardModelScaleGet(itemMdlId[arg0][i], &sp20[i]); @@ -1731,13 +1731,13 @@ static void UpdateItemPickup(omObjData *arg0) { Hu3D3Dto2D(&sp2C, 1, &sp2C); sp20.x = arg0->trans.x; sp20.y = arg0->trans.y; - PSVECSubtract(&sp2C, &sp20, &sp14); + VECSubtract(&sp2C, &sp20, &sp14); if (ABS(sp14.x) < 1.0f && ABS(sp14.y) < 1.0f) { HuSprAttrSet(temp_r31->unk04, 0, 4); temp_r31->unk00_bit3 = 6; } else { - PSVECScale(&sp14, &sp14, 0.1f); - PSVECAdd(&sp20, &sp14, &sp50); + VECScale(&sp14, &sp14, 0.1f); + VECAdd(&sp20, &sp14, &sp50); sp50.z = 3200.0f; arg0->trans.x = sp50.x; arg0->trans.y = sp50.y; @@ -1917,12 +1917,12 @@ static void UpdateItemWindow(omObjData *arg0) { var_r27 = 0; for (i = 0; i < temp_r29->unk02; i++) { if ((temp_r31->unk06[i] != -1) && (temp_r31->unk12[i] != -1)) { - PSVECSubtract(&temp_r31->unk74[i], &temp_r31->unk2C[i], &sp20); - if (PSVECMag(&sp20) <= 1.0f) { + VECSubtract(&temp_r31->unk74[i], &temp_r31->unk2C[i], &sp20); + if (VECMag(&sp20) <= 1.0f) { temp_r31->unk2C[i] = temp_r31->unk74[i]; } else { - PSVECScale(&sp20, &sp20, 0.3f); - PSVECAdd(&sp20, &temp_r31->unk2C[i], &temp_r31->unk2C[i]); + VECScale(&sp20, &sp20, 0.3f); + VECAdd(&sp20, &temp_r31->unk2C[i], &temp_r31->unk2C[i]); var_r27 = 1; } HuWinPosSet(temp_r31->unk12[i], temp_r31->unk2C[i].x, temp_r31->unk2C[i].y); diff --git a/src/game/board/view.c b/src/game/board/view.c index 6a0859c6..4e4de23a 100755 --- a/src/game/board/view.c +++ b/src/game/board/view.c @@ -249,7 +249,7 @@ static void ExecMapView(void) { spC.x = var_f29 * sin(temp_f28 * M_PI / 180.0); spC.z = var_f29 * cos(temp_f28 * M_PI / 180.0); } - PSVECAdd(&spC, &focusPos, &focusPos); + VECAdd(&spC, &focusPos, &focusPos); if (focusPos.x < temp_f26) { focusPos.x = temp_f26; } @@ -277,7 +277,7 @@ static void ExecStarView(void) { SetTargetView(); do { OSu16tof32(&focusTimer, &temp_f30); - PSVECSubtract(&focusPosTarget, &focusPos, &sp8); + VECSubtract(&focusPosTarget, &focusPos, &sp8); sp8.x /= temp_f30; sp8.y /= temp_f30; sp8.z /= temp_f30; @@ -287,7 +287,7 @@ static void ExecStarView(void) { } focusDestroyF = 0; while (focusTimer != 0) { - PSVECAdd(&sp8, &focusPos, &focusPos); + VECAdd(&sp8, &focusPos, &focusPos); BoardModelPosSetV(focusMdl, &focusPos); HuPrcVSleep(); focusTimer--; @@ -547,10 +547,10 @@ static void UpdateOverheadView(omObjData *arg0) { Hu3D3Dto2D(&sp14, 1, &sp14); sp14.x -= 288.0f; sp14.y -= 240.0f; - PSVECSubtract(&sp20, &sp14, &sp8); + VECSubtract(&sp20, &sp14, &sp8); sp8.z = 0.0f; temp_f30 = BoardDAngleCalc(180.0 * (atan2(sp8.y, sp8.x) / M_PI) - 90.0); - temp_f31 = PSVECMag(&sp8) / 32; + temp_f31 = VECMag(&sp8) / 32; if (i != 4) { var_r28 = i + 4; } else { diff --git a/src/game/chrman.c b/src/game/chrman.c index 9e953bea..e0599240 100755 --- a/src/game/chrman.c +++ b/src/game/chrman.c @@ -440,7 +440,7 @@ static void UpdateCharAnim(s16 character, s16 arg1, s16 arg2, u8 arg3, s16 arg4, sp1C.y = sp28[1][3]; sp1C.z = sp28[2][3]; if (arg4 != 0) { - PSVECSubtract(&sp1C, arg5, &sp10); + VECSubtract(&sp1C, arg5, &sp10); var_r20 = 0.2 * sqrtf(sp10.x * sp10.x + sp10.y * sp10.y + sp10.z * sp10.z); if (var_r20 > 5) { var_r20 = 5; @@ -878,7 +878,7 @@ static void UpdateEffect(ModelData *model, ParticleData *particle, Mtx matrix) var_r31->unk08.x *= temp_r30[i].unk18; var_r31->unk08.y *= temp_r30[i].unk1C; var_r31->unk08.z *= temp_r30[i].unk20; - PSVECAdd(&var_r31->unk08, &var_r31->unk34, &var_r31->unk34); + VECAdd(&var_r31->unk08, &var_r31->unk34, &var_r31->unk34); var_r31->unk08.y += temp_r30[i].unk24; var_r28 = var_r31->unk40.r + temp_r30[i].unk34 * (temp_r30[i].unk08 - temp_r30[i].unk04); if (var_r28 < 0) { @@ -1580,8 +1580,8 @@ void fn_8004EC74(s16 character) spC.x = sp24[0][2]; spC.y = sp24[1][2]; spC.z = sp24[2][2]; - PSVECScale(&spC, &spC, 20.0f); - PSVECAdd(&sp18, &spC, &sp18); + VECScale(&spC, &spC, 20.0f); + VECAdd(&sp18, &spC, &sp18); fn_8004EDA4(temp_r31->camera, &sp18, &temp_r31->rot); } } @@ -1605,15 +1605,15 @@ void fn_8004EDA4(s16 arg0, Vec *arg1, Vec *arg2) sp14.x = sp20.x * sp20.y * (1.0 - cosd(temp_f31)) - sp20.z * sind(temp_f31); sp14.y = sp20.y * sp20.y + (1.0f - sp20.y * sp20.y) * cosd(temp_f31); sp14.z = sp20.y * sp20.z * (1.0 - cosd(temp_f31)) + sp20.x * sind(temp_f31); - PSVECNormalize(&sp14, &sp14); - PSVECScale(&sp14, &lbl_80131030.unk0C, 10.0f); + VECNormalize(&sp14, &sp14); + VECScale(&sp14, &lbl_80131030.unk0C, 10.0f); var_r28 = CreateEffect(effectMdl[4], arg0, arg1->x, arg1->y, arg1->z, 20.0f, &lbl_80131030); if (var_r28 == -1) { break; } - PSVECScale(&sp20, &sp8, -2.0 - 0.1 * frandmod(20)); - PSVECScale(&sp14, &sp14, 2.0f); - PSVECAdd(&sp14, &sp8, &lbl_80131068.unk0C); + VECScale(&sp20, &sp8, -2.0 - 0.1 * frandmod(20)); + VECScale(&sp14, &sp14, 2.0f); + VECAdd(&sp14, &sp8, &lbl_80131068.unk0C); var_r28 = CreateEffect(effectMdl[6], arg0, arg1->x, arg1->y, arg1->z, 20.0f, &lbl_80131068); if (var_r28 == -1) { break; @@ -1645,8 +1645,8 @@ void fn_8004F058(s16 character) spC.x = sp24[0][2]; spC.y = sp24[1][2]; spC.z = sp24[2][2]; - PSVECScale(&spC, &spC, 30.0f); - PSVECAdd(&sp18, &spC, &sp18); + VECScale(&spC, &spC, 30.0f); + VECAdd(&sp18, &spC, &sp18); fn_8004F13C(temp_r31->camera, &sp18, &temp_r31->rot); } @@ -1669,15 +1669,15 @@ void fn_8004F13C(s16 arg0, Vec *arg1, Vec *arg2) sp14.x = sp20.x * sp20.y * (1.0 - cosd(temp_f31)) - sp20.z * sind(temp_f31); sp14.y = sp20.y * sp20.y + (1.0f - sp20.y * sp20.y) * cosd(temp_f31); sp14.z = sp20.y * sp20.z * (1.0 - cosd(temp_f31)) + sp20.x * sind(temp_f31); - PSVECNormalize(&sp14, &sp14); - PSVECScale(&sp14, &lbl_801310BC.unk0C, 10.0f); + VECNormalize(&sp14, &sp14); + VECScale(&sp14, &lbl_801310BC.unk0C, 10.0f); var_r28 = CreateEffect(effectMdl[4], arg0, arg1->x, arg1->y, arg1->z, 20.0f, &lbl_801310BC); if (var_r28 == -1) { break; } - PSVECScale(&sp20, &sp8, -2.0 - 0.1 * frandmod(20)); - PSVECScale(&sp14, &sp14, 2.0f); - PSVECAdd(&sp14, &sp8, &lbl_801310F4.unk0C); + VECScale(&sp20, &sp8, -2.0 - 0.1 * frandmod(20)); + VECScale(&sp14, &sp14, 2.0f); + VECAdd(&sp14, &sp8, &lbl_801310F4.unk0C); var_r28 = CreateEffect(effectMdl[6], arg0, arg1->x, arg1->y, arg1->z, 20.0f, &lbl_801310F4); if (var_r28 == -1) { break; diff --git a/src/game/hsfanim.c b/src/game/hsfanim.c index 2293f23e..e8ffafbd 100755 --- a/src/game/hsfanim.c +++ b/src/game/hsfanim.c @@ -319,7 +319,7 @@ void Hu3DAnimExec(void) { mtxTransCat(var_r31->unk3C, var_r31->unk04.x, var_r31->unk04.y, var_r31->unk04.z); } else { if (var_r31->unk00 & 1) { - PSVECAdd(&var_r31->unk04, &var_r31->unk1C, &var_r31->unk04); + VECAdd(&var_r31->unk04, &var_r31->unk1C, &var_r31->unk04); if (var_r31->unk04.x > 1.0f) { var_r31->unk04.x -= 1.0f; } @@ -717,17 +717,17 @@ static void _Hu3DParticleAttrReset(ModelData *arg0, Mtx arg1) { var_r30->z = sp38[3].z * temp_f31 + var_r29->unk34.z; var_r30++; } else { - PSVECScale(&basePos[0], &sp98[0], var_r29->unk2C); - PSVECScale(&basePos[1], &sp98[1], var_r29->unk2C); - PSVECScale(&basePos[2], &sp98[2], var_r29->unk2C); - PSVECScale(&basePos[3], &sp98[3], var_r29->unk2C); + VECScale(&basePos[0], &sp98[0], var_r29->unk2C); + VECScale(&basePos[1], &sp98[1], var_r29->unk2C); + VECScale(&basePos[2], &sp98[2], var_r29->unk2C); + VECScale(&basePos[3], &sp98[3], var_r29->unk2C); PSMTXRotRad(spC8, 'Z', var_r29->unk30); PSMTXConcat(sp128, spC8, spF8); PSMTXMultVecArray(spF8, sp98, sp68, 4); - PSVECAdd(&sp68[0], &var_r29->unk34, var_r30++); - PSVECAdd(&sp68[1], &var_r29->unk34, var_r30++); - PSVECAdd(&sp68[2], &var_r29->unk34, var_r30++); - PSVECAdd(&sp68[3], &var_r29->unk34, var_r30++); + VECAdd(&sp68[0], &var_r29->unk34, var_r30++); + VECAdd(&sp68[1], &var_r29->unk34, var_r30++); + VECAdd(&sp68[2], &var_r29->unk34, var_r30++); + VECAdd(&sp68[3], &var_r29->unk34, var_r30++); } var_r19 = 1; } else { @@ -1117,10 +1117,10 @@ static void ParManFunc(void) { sp20.x = (s32) frandmod((u32) (temp_r30->unk08 * 2.0f)) - temp_r30->unk08; sp20.y = (s32) frandmod((u32) (temp_r30->unk08 * 2.0f)) - temp_r30->unk08; sp20.z = (s32) frandmod((u32) (temp_r30->unk08 * 2.0f)) - temp_r30->unk08; - PSVECNormalize(&sp20, &sp20); - PSVECScale(&sp20, &sp20, temp_r30->unk08); - PSVECAdd(&sp20, &var_r29->unk34, &var_r29->unk34); - PSVECNormalize(&temp_r31->unk18, &sp2C); + VECNormalize(&sp20, &sp20); + VECScale(&sp20, &sp20, temp_r30->unk08); + VECAdd(&sp20, &var_r29->unk34, &var_r29->unk34); + VECNormalize(&temp_r31->unk18, &sp2C); if (temp_r31->unk02 & 0x100) { var_f28 = var_f26 + (360.0f / temp_r30->unk04) * var_r26; var_f29 = temp_r30->unk0C; @@ -1145,9 +1145,9 @@ static void ParManFunc(void) { sp14.y = 1.0f; sp14.z = sp2C.z; } - PSVECCrossProduct(&sp14, &sp2C, &sp8); + VECCrossProduct(&sp14, &sp2C, &sp8); } - PSVECNormalize(&sp8, &sp8); + VECNormalize(&sp8, &sp8); temp_f31 = sind(var_f28); temp_f30 = cosd(var_f28); sp14.x = sp8.x * (sp2C.x * sp2C.x + temp_f30 * (1.0f - sp2C.x * sp2C.x)) @@ -1159,7 +1159,7 @@ static void ParManFunc(void) { sp14.z = sp8.x * (sp2C.x * sp2C.z * (1.0f - temp_f30) - sp2C.y * temp_f31) + sp8.y * (sp2C.y * sp2C.z * (1.0f - temp_f30) + sp2C.x * temp_f31) + sp8.z * (sp2C.z * sp2C.z + temp_f30 * (1.0f - sp2C.z * sp2C.z)); - PSVECCrossProduct(&sp14, &sp2C, &sp8); + VECCrossProduct(&sp14, &sp2C, &sp8); temp_f31 = sind(var_f29); temp_f30 = cosd(var_f29); sp14.x = sp2C.x * (sp8.x * sp8.x + temp_f30 * (1.0f - sp8.x * sp8.x)) @@ -1171,7 +1171,7 @@ static void ParManFunc(void) { sp14.z = sp2C.x * (sp8.x * sp8.z * (1.0f - temp_f30) - sp8.y * temp_f31) + sp2C.y * (sp8.y * sp8.z * (1.0f - temp_f30) + sp8.x * temp_f31) + sp2C.z * (sp8.z * sp8.z + temp_f30 * (1.0f - sp8.z * sp8.z)); - PSVECNormalize(&sp14, &sp14); + VECNormalize(&sp14, &sp14); temp_f31 = temp_r30->unk1C; if (temp_r31->unk02 & 2) { temp_f31 = temp_f31 * 0.9 + (s32) frandmod((u32) (temp_f31 * 0.1 * 1000.0)) / 1000.0f; @@ -1180,7 +1180,7 @@ static void ParManFunc(void) { } else if (temp_r31->unk02 & 8) { temp_f31 = (s32) frandmod((u32) (temp_f31 * 1000.0f)) / 1000.0f; } - PSVECScale(&sp14, &var_r29->unk08, temp_f31); + VECScale(&sp14, &var_r29->unk08, temp_f31); var_r29->unk14 = temp_r30->unk10; var_r29->unk20 = temp_r30->unk20; if (temp_r31->unk02 & 0x1000) { @@ -1245,17 +1245,17 @@ static void ParManHook(ModelData *model, ParticleData *particle, Mtx matrix) { var_r29->unk34.x += var_r29->unk08.x + var_r29->unk14.x; var_r29->unk34.y += var_r29->unk08.y + var_r29->unk14.y; var_r29->unk34.z += var_r29->unk08.z + var_r29->unk14.z; - PSVECScale(&var_r29->unk08, &var_r29->unk08, var_r29->unk20); - PSVECAdd(&temp_r26->unk10, &var_r29->unk14, &var_r29->unk14); + VECScale(&var_r29->unk08, &var_r29->unk08, var_r29->unk20); + VECAdd(&temp_r26->unk10, &var_r29->unk14, &var_r29->unk14); if (temp_r28->unk02 & 0x200) { - PSVECSubtract(&temp_r28->unk24, &var_r29->unk34, &sp1C); - PSVECNormalize(&sp1C, &sp1C); - PSVECScale(&sp1C, &sp1C, temp_r28->unk30); - PSVECAdd(&sp1C, &var_r29->unk14, &var_r29->unk14); - PSVECAdd(&var_r29->unk08, &var_r29->unk14, &sp1C); - PSVECSubtract(&temp_r28->unk24, &var_r29->unk34, &sp10); - temp_f29 = PSVECSquareMag(&sp1C); - if (PSVECSquareMag(&sp10) <= temp_f29) { + VECSubtract(&temp_r28->unk24, &var_r29->unk34, &sp1C); + VECNormalize(&sp1C, &sp1C); + VECScale(&sp1C, &sp1C, temp_r28->unk30); + VECAdd(&sp1C, &var_r29->unk14, &var_r29->unk14); + VECAdd(&var_r29->unk08, &var_r29->unk14, &sp1C); + VECSubtract(&temp_r28->unk24, &var_r29->unk34, &sp10); + temp_f29 = VECSquareMag(&sp1C); + if (VECSquareMag(&sp10) <= temp_f29) { var_r29->unk2C = 0.0f; continue; } diff --git a/src/game/hsfdraw.c b/src/game/hsfdraw.c index ab341258..ba1a9404 100755 --- a/src/game/hsfdraw.c +++ b/src/game/hsfdraw.c @@ -135,7 +135,7 @@ void Hu3DDraw(ModelData *arg0, Mtx arg1, Vec *arg2) { sp8.x = temp_r31->matrix[0][3]; sp8.y = temp_r31->matrix[1][3]; sp8.z = temp_r31->matrix[2][3]; - temp_f31 = PSVECMag(&sp8); + temp_f31 = VECMag(&sp8); temp_r31->z = temp_f31; temp_r31->model = arg0; DrawObjIdx++; @@ -308,7 +308,7 @@ static void objMesh(ModelData *arg0, HsfObject *arg1) { sp10.x = temp_r29->matrix[0][3]; sp10.y = temp_r29->matrix[1][3]; sp10.z = temp_r29->matrix[2][3]; - temp_f31 = PSVECMag(&sp10); + temp_f31 = VECMag(&sp10); if (temp_r25->flags & 0x10000) { temp_r29->z = -(900000.0f - temp_f31); } else { @@ -2152,7 +2152,7 @@ void Hu3DDrawPost(void) { if (temp_r22->unk_00 & 0x8000) { PSMTXMultVecSR(Hu3DCameraMtx, &sp30, &sp30); } - temp_f30 = PSVECDotProduct(&sp30, &sp54); + temp_f30 = VECDotProduct(&sp30, &sp54); temp_f30 *= 10000.0f; OSf32tos16(&temp_f30, &sp8); if (sp8 == -10000) { @@ -2169,8 +2169,8 @@ void Hu3DDrawPost(void) { if (sp8 == 10000) { PSMTXIdentity(spC0); } else { - PSVECCrossProduct(&sp3C, &sp54, &sp48); - temp_f28 = acosf(PSVECDotProduct(&sp54, &sp3C)); + VECCrossProduct(&sp3C, &sp54, &sp48); + temp_f28 = acosf(VECDotProduct(&sp54, &sp3C)); PSMTXRotAxisRad(spC0, &sp48, temp_f28); } PSMTXConcat(spC0, sp90, sp60); @@ -2291,7 +2291,7 @@ static void ObjDraw(HsfDrawObject *arg0) { if (temp_r24->unk_00 & 0x8000) { PSMTXMultVecSR(Hu3DCameraMtx, &sp20, &sp20); } - temp_f30 = PSVECDotProduct(&sp20, &sp44); + temp_f30 = VECDotProduct(&sp20, &sp44); temp_f30 *= 10000.0f; OSf32tos16(&temp_f30, &var_r21); if (var_r21 == -10000) { @@ -2308,8 +2308,8 @@ static void ObjDraw(HsfDrawObject *arg0) { if (var_r21 == 10000) { PSMTXIdentity(spB0); } else { - PSVECCrossProduct(&sp2C, &sp44, &sp38); - temp_f29 = acosf(PSVECDotProduct(&sp44, &sp2C)); + VECCrossProduct(&sp2C, &sp44, &sp38); + temp_f29 = acosf(VECDotProduct(&sp44, &sp2C)); PSMTXRotAxisRad(spB0, &sp38, temp_f29); } PSMTXConcat(spB0, sp80, sp50); @@ -2756,13 +2756,13 @@ static s32 MakeCalcNBT(HsfObject *arg0, HsfFace *arg1, s16 arg2, s16 arg3) { sp10.x = temp_r28[temp_r27][0]; sp10.y = temp_r28[temp_r27][1]; sp10.z = temp_r28[temp_r27][2]; - PSVECNormalize(&sp10, &sp10); + VECNormalize(&sp10, &sp10); } NBTB.x = temp_r31[temp_r25].x - temp_r31[temp_r24].x; NBTB.y = temp_r31[temp_r25].y - temp_r31[temp_r24].y; NBTB.z = temp_r31[temp_r25].z - temp_r31[temp_r24].z; - PSVECNormalize(&NBTB, &NBTB); - PSVECCrossProduct(&NBTB, &sp10, &NBTT); + VECNormalize(&NBTB, &NBTB); + VECCrossProduct(&NBTB, &sp10, &NBTT); GXPosition3s16(sp10.x * 256.0f, sp10.y * 256.0f, sp10.z * 256.0f); GXPosition3s16(NBTB.x * 256.0f, NBTB.y * 256.0f, NBTB.z * 256.0f); GXPosition3s16(NBTT.x * 256.0f, NBTT.y * 256.0f, NBTT.z * 256.0f); @@ -2787,7 +2787,7 @@ static s32 MakeNBT(HsfObject *arg0, HsfFace *arg1, s16 arg2, s16 arg3) { sp10.x = temp_r29[temp_r28][0]; sp10.y = temp_r29[temp_r28][1]; sp10.z = temp_r29[temp_r28][2]; - PSVECNormalize(&sp10, &sp10); + VECNormalize(&sp10, &sp10); } GXPosition3s16(sp10.x * 256.0f, sp10.y * 256.0f, sp10.z * 256.0f); GXPosition3s16(NBTB.x * 256.0f, NBTB.y * 256.0f, NBTB.z * 256.0f); diff --git a/src/game/hsfex.c b/src/game/hsfex.c index 7f72507c..a09129ec 100644 --- a/src/game/hsfex.c +++ b/src/game/hsfex.c @@ -105,8 +105,8 @@ void CamMotionEx(s16 arg0, s16 arg1, Vec *arg2, Vec *arg3, Vec *arg4, float arg5 var_r31->unk04 = 0.0f; var_f26 = 0.0f; for (var_f31 = var_f26; var_f31 < var_r29 - 1; var_f31 += 1.0f, var_r31++) { - PSVECSubtract(&var_r31[1].unk08, &var_r31[0].unk08, &sp3C); - var_r31[1].unk04 = PSVECMag(&sp3C); + VECSubtract(&var_r31[1].unk08, &var_r31[0].unk08, &sp3C); + var_r31[1].unk04 = VECMag(&sp3C); var_f26 += var_r31[1].unk04; } var_r31 = temp_r21; @@ -340,12 +340,12 @@ static void SetObjCamMotion(s16 arg0, HsfTrack *arg1, float arg2, HsfexStruct02 arg3->unk20.z = temp_r31->scale.z * (arg2 + temp_r31->pos.z); break; case 14: - PSVECSubtract(&arg3->unk08, &arg3->unk20, &spC); - PSVECNormalize(&spC, &spC); + VECSubtract(&arg3->unk08, &arg3->unk20, &spC); + VECNormalize(&spC, &spC); sp18.x = spC.x * spC.y * (1.0 - cos(M_PI * arg2 / 180.0)) - spC.z * sin(M_PI * arg2 / 180.0); sp18.y = spC.y * spC.y + (1.0f - spC.y * spC.y) * cos(M_PI * arg2 / 180.0); sp18.z = spC.y * spC.z * (1.0 - cos(M_PI * arg2 / 180.0)) + spC.x * sin(M_PI * arg2 / 180.0); - PSVECNormalize(&sp18, &arg3->unk14); + VECNormalize(&sp18, &arg3->unk14); break; } } @@ -541,30 +541,30 @@ void Hu3DMtxScaleGet(Mtx arg0, Vec *arg1) { sp2C.x = arg0[0][0]; sp2C.y = arg0[1][0]; sp2C.z = arg0[2][0]; - arg1->x = PSVECMag(&sp2C); - PSVECNormalize(&sp2C, &sp2C); + arg1->x = VECMag(&sp2C); + VECNormalize(&sp2C, &sp2C); sp20.x = arg0[0][1]; sp20.y = arg0[1][1]; sp20.z = arg0[2][1]; - sp38.x = PSVECDotProduct(&sp2C, &sp20); - PSVECScale(&sp2C, &sp8, sp38.x); - PSVECSubtract(&sp20, &sp8, &sp20); - arg1->y = PSVECMag(&sp20); - PSVECNormalize(&sp20, &sp20); + sp38.x = VECDotProduct(&sp2C, &sp20); + VECScale(&sp2C, &sp8, sp38.x); + VECSubtract(&sp20, &sp8, &sp20); + arg1->y = VECMag(&sp20); + VECNormalize(&sp20, &sp20); sp38.x /= arg1->y; sp14.x = arg0[0][2]; sp14.y = arg0[1][2]; sp14.z = arg0[2][2]; - sp38.z = PSVECDotProduct(&sp20, &sp14); - PSVECScale(&sp20, &sp8, sp38.z); - PSVECSubtract(&sp14, &sp8, &sp14); - sp38.y = PSVECDotProduct(&sp2C, &sp14); - PSVECScale(&sp2C, &sp8, sp38.y); - PSVECSubtract(&sp14, &sp8, &sp14); - arg1->z = PSVECMag(&sp14); - PSVECNormalize(&sp14, &sp14); - PSVECCrossProduct(&sp20, &sp14, &sp8); - if (PSVECDotProduct(&sp2C, &sp8) < 0.0) { + sp38.z = VECDotProduct(&sp20, &sp14); + VECScale(&sp20, &sp8, sp38.z); + VECSubtract(&sp14, &sp8, &sp14); + sp38.y = VECDotProduct(&sp2C, &sp14); + VECScale(&sp2C, &sp8, sp38.y); + VECSubtract(&sp14, &sp8, &sp14); + arg1->z = VECMag(&sp14); + VECNormalize(&sp14, &sp14); + VECCrossProduct(&sp20, &sp14, &sp8); + if (VECDotProduct(&sp2C, &sp8) < 0.0) { arg1->x *= -1.0; arg1->y *= -1.0; arg1->z *= -1.0; diff --git a/src/game/hsfman.c b/src/game/hsfman.c index f695dedf..1cbbe341 100644 --- a/src/game/hsfman.c +++ b/src/game/hsfman.c @@ -1276,12 +1276,12 @@ BOOL Hu3DModelCameraInfoSet(s16 arg0, u16 arg1) { temp_f31 = obj_copy->data.base.rot.x; cam->aspect_dupe = temp_f31; - PSVECSubtract((Point3d* ) &obj_copy->camera.target, (Point3d* ) &obj_copy->camera.pos, &sp8); + VECSubtract((Point3d* ) &obj_copy->camera.target, (Point3d* ) &obj_copy->camera.pos, &sp8); sp14.x = ((sp8.x * sp8.y * (1.0 - cosd(temp_f31))) - (sp8.z * sind(temp_f31))); sp14.y = ((sp8.y * sp8.y) + (1.0f - (sp8.y * sp8.y)) * cosd(temp_f31)); sp14.z = (((sp8.y * sp8.z) * (1.0 - cosd(temp_f31))) + (sp8.x * sind(temp_f31))); - PSVECNormalize(&sp14, &sp8); + VECNormalize(&sp14, &sp8); Hu3DCameraPosSet(arg1, obj_copy->camera.target.x, obj_copy->camera.target.y, obj_copy->camera.target.z, sp8.x, sp8.y, sp8.z, @@ -1386,7 +1386,7 @@ inline s16 Hu3DLightCreateV(LightData *light, Vec *arg0, Vec *arg1, GXColor *arg light->unk_34.x = light->unk_34.y = light->unk_34.z = 0.0f; light->unk_04 = 30.0f; light->unk_02 = 2; - PSVECNormalize(&light->unk_28, &light->unk_28); + VECNormalize(&light->unk_28, &light->unk_28); light->color = *arg2; } @@ -1584,7 +1584,7 @@ void Hu3DLLightColorSet(s16 dataIndex, s16 lightIndex, u8 r, u8 g, u8 b, u8 a) { inline void Hu3DLightPosSetV(LightData *light, Vec* pos, Vec* aim) { light->unk_1C = *pos; - PSVECNormalize(aim, &light->unk_28); + VECNormalize(aim, &light->unk_28); } void Hu3DGLightPosSetV(s16 index, Vec* pos, Vec* aim) { @@ -1609,7 +1609,7 @@ inline void Hu3DLightPosSet(LightData *light, f32 arg8, f32 arg9, f32 argA, f32 light->unk_28.x = argB; light->unk_28.y = argC; light->unk_28.z = argD; - PSVECNormalize(&light->unk_28, &light->unk_28); + VECNormalize(&light->unk_28, &light->unk_28); } void Hu3DGLightPosSet(s16 arg0, f32 arg8, f32 arg9, f32 argA, f32 argB, f32 argC, f32 argD) { @@ -1630,8 +1630,8 @@ void Hu3DLLightPosSet(s16 arg0, s16 arg1, f32 arg8, f32 arg9, f32 argA, f32 argB inline void Hu3DLightPosAimSetV(LightData *light, Vec* pos, Vec* aim) { light->unk_1C = *pos; - PSVECSubtract(aim, pos, &light->unk_28); - PSVECNormalize(&light->unk_28, &light->unk_28); + VECSubtract(aim, pos, &light->unk_28); + VECNormalize(&light->unk_28, &light->unk_28); } void Hu3DGLightPosAimSetV(s16 index, Vec* pos, Vec* aim) { @@ -1816,7 +1816,7 @@ void lightSet(LightData* arg0, s16 arg1, Mtx *arg2, Mtx *arg3, f32 arg8) { GXInitLightAttn(&sp30, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f); GXInitLightSpot(&sp30, 20.0f, GX_SP_COS); GXInitLightAttnK(&sp30, 1.0f, 0.0f, 0.0f); - PSVECScale(&arg0->unk_28, &arg0->unk_1C, -1000000.0f); + VECScale(&arg0->unk_28, &arg0->unk_1C, -1000000.0f); break; case 2: GXInitLightAttn(&sp30, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f); @@ -1885,7 +1885,7 @@ void Hu3DShadowCreate(f32 arg8, f32 arg9, f32 argA) { Hu3DShadowData.unk_2C.y = 1.0f; Hu3DShadowData.unk_2C.z = 0.0f; C_MTXLightPerspective(Hu3DShadowData.unk_68, arg8, 1.2f, 0.5f, -0.5f, 0.5f, 0.5f); - PSVECNormalize(&Hu3DShadowData.unk_2C, &Hu3DShadowData.unk_2C); + VECNormalize(&Hu3DShadowData.unk_2C, &Hu3DShadowData.unk_2C); Hu3DShadowData.unk_00 = 0x80; Hu3DShadowF = 1; } @@ -2053,7 +2053,7 @@ s16 Hu3DProjectionCreate(void *arg0, f32 arg8, f32 arg9, f32 argA) { var_r31->unk_2C.y = 1.0f; var_r31->unk_2C.z = 0.0f; C_MTXLightPerspective(var_r31->unk_68, arg8, 1.2f, 0.5f, -0.5f, 0.5f, 0.5f); - PSVECNormalize(&var_r31->unk_2C, &var_r31->unk_2C); + VECNormalize(&var_r31->unk_2C, &var_r31->unk_2C); var_r31->unk_00 = 0x80; Hu3DProjectionNum++; return var_r30; diff --git a/src/game/hsfmotion.c b/src/game/hsfmotion.c index 69ba3236..258e7103 100644 --- a/src/game/hsfmotion.c +++ b/src/game/hsfmotion.c @@ -1096,12 +1096,12 @@ void SetObjCameraMotion(s16 arg0, HsfTrack *arg1, float arg2) { case 14: for (i = 0, var_r30 = 1; i < 16; i++, var_r30 <<= 1) { if (var_r30 & temp_r28) { - PSVECSubtract(&Hu3DCamera[i].pos, &Hu3DCamera[i].target, &spC); - PSVECNormalize(&spC, &spC); + VECSubtract(&Hu3DCamera[i].pos, &Hu3DCamera[i].target, &spC); + VECNormalize(&spC, &spC); sp18.x = spC.x * spC.y * (1.0 - cosd(arg2)) - spC.z * sind(arg2); sp18.y = spC.y * spC.y + (1.0f - spC.y * spC.y) * cosd(arg2); sp18.z = spC.y * spC.z * (1.0 - cosd(arg2)) + spC.x * sind(arg2); - PSVECNormalize(&sp18, &Hu3DCamera[i].up); + VECNormalize(&sp18, &Hu3DCamera[i].up); Hu3DCamera[i].aspect_dupe = arg2; } } diff --git a/src/game/mapspace.c b/src/game/mapspace.c index 47c9293b..f04e7c16 100755 --- a/src/game/mapspace.c +++ b/src/game/mapspace.c @@ -762,39 +762,39 @@ static s32 PrecalcPntToTriangle(Vec *arg0, Vec *arg1, Vec *arg2, Vec* arg3, Vec temp_f30 = temp_f28 * (arg2->z * (arg3->y * sp14.x - arg3->x * sp14.y) + arg2->y * (arg3->x * sp14.z - arg3->z * sp14.x) + arg2->x * (arg3->z * sp14.y - arg3->y * sp14.z)); temp_f29 = temp_f28 * (arg1->z * (arg3->x * sp14.y - arg3->y * sp14.x) + arg1->y * (arg3->z * sp14.x - arg3->x * sp14.z) + arg1->x * (arg3->y * sp14.z - arg3->z * sp14.y)); if (temp_f30 > 0.0f && temp_f29 > 0.0f && temp_f30 + temp_f29 > 1.0f) { - PSVECSubtract(arg2, arg1, &sp14); - PSVECSubtract(arg4, arg1, &sp8); - temp_f31 = PSVECDotProduct(&sp14, &sp8) / PSVECDotProduct(&sp14, &sp14); + VECSubtract(arg2, arg1, &sp14); + VECSubtract(arg4, arg1, &sp8); + temp_f31 = VECDotProduct(&sp14, &sp8) / VECDotProduct(&sp14, &sp14); if (temp_f31 <= 0.0f) { arg5 = arg1; } else { if (temp_f31 >= 1.0f) { arg5 = arg2; } else { - PSVECScale(&sp14, &sp8, temp_f31); - PSVECAdd(arg1, &sp8, arg5); + VECScale(&sp14, &sp8, temp_f31); + VECAdd(arg1, &sp8, arg5); } } } else if (temp_f29 < 0.0f) { - temp_f31 = PSVECDotProduct(arg1, arg4) / PSVECDotProduct(arg1, arg1); + temp_f31 = VECDotProduct(arg1, arg4) / VECDotProduct(arg1, arg1); if (temp_f31 <= 0.0f) { HuSetVecF(arg5, 0.0, 0.0, 0.0); } else { if (temp_f31 >= 1.0f) { arg5 = arg1; } else { - PSVECScale(arg1, arg5, temp_f31); + VECScale(arg1, arg5, temp_f31); } } } else if (temp_f30 < 0.0f) { - temp_f31 = PSVECDotProduct(arg2, arg4) / PSVECDotProduct(arg2, arg2); + temp_f31 = VECDotProduct(arg2, arg4) / VECDotProduct(arg2, arg2); if (temp_f31 <= 0.0f) { HuSetVecF(arg5, 0.0, 0.0, 0.0); } else { if (temp_f31 >= 1.0f) { arg5 = arg2; } else { - PSVECScale(arg2, arg5, temp_f31); + VECScale(arg2, arg5, temp_f31); } } } else { @@ -815,13 +815,13 @@ BOOL Hitcheck_Triangle_with_Sphere(Vec *arg0, Vec *arg1, float arg2, Vec *arg3) sp48.x = arg0[0].x; sp48.y = arg0[0].y; sp48.z = arg0[0].z; - PSVECSubtract(&arg0[1], &arg0[0], &sp3C); - PSVECSubtract(&arg0[2], &arg0[0], &sp30); - PSVECCrossProduct(&sp3C, &sp30, &sp24); - PSVECSubtract(arg1, &arg0[0], &sp18); + VECSubtract(&arg0[1], &arg0[0], &sp3C); + VECSubtract(&arg0[2], &arg0[0], &sp30); + VECCrossProduct(&sp3C, &sp30, &sp24); + VECSubtract(arg1, &arg0[0], &sp18); PrecalcPntToTriangle(&sp48, &sp3C, &sp30, &sp24, &sp18, &spC); - PSVECAdd(&spC, &sp48, arg3); - var_f31 = PSVECDistance(arg3, arg1); + VECAdd(&spC, &sp48, arg3); + var_f31 = VECDistance(arg3, arg1); if (var_f31 > arg2) { return FALSE; } else { @@ -845,17 +845,17 @@ BOOL Hitcheck_Quadrangle_with_Sphere(Vec *arg0, Vec *arg1, float arg2, Vec *arg3 sp6C.x = arg0->x; sp6C.y = arg0->y; sp6C.z = arg0->z; - PSVECSubtract(&arg0[2], &arg0[0], &sp60); - PSVECSubtract(&arg0[3], &arg0[0], &sp54); - PSVECSubtract(&arg0[1], &arg0[0], &sp48); - PSVECCrossProduct(&sp60, &sp54, &sp3C); - PSVECSubtract(arg1, &arg0[0], &sp30); + VECSubtract(&arg0[2], &arg0[0], &sp60); + VECSubtract(&arg0[3], &arg0[0], &sp54); + VECSubtract(&arg0[1], &arg0[0], &sp48); + VECCrossProduct(&sp60, &sp54, &sp3C); + VECSubtract(arg1, &arg0[0], &sp30); PrecalcPntToTriangle(&sp6C, &sp60, &sp54, &sp3C, &sp30, &sp24); - PSVECAdd(&sp24, &sp6C, &sp18); + VECAdd(&sp24, &sp6C, &sp18); PrecalcPntToTriangle(&sp6C, &sp54, &sp48, &sp3C, &sp30, &sp24); - PSVECAdd(&sp24, &sp6C, &spC); - var_f31 = PSVECDistance(&sp18, arg1); - temp_f30 = PSVECDistance(&spC, arg1); + VECAdd(&sp24, &sp6C, &spC); + var_f31 = VECDistance(&sp18, arg1); + temp_f30 = VECDistance(&spC, arg1); if (temp_f30 > var_f31) { arg3->x = sp18.x; arg3->y = sp18.y;