kobayashi90/marioparty4
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

rename PSVEC to VEC

Browse source 
This is the correct name for the Vec functions for Dolphin. This also applies to PSMTX...
This commit is contained in:
CreateSource 2024-08-09 23:53:58 -04:00
parent 64413586b9
commit afa9c0a4b5
82 changed files with 968 additions and 968 deletions
Download patch file Download diff file Expand all files Collapse all files

4
src/game/EnvelopeExec.c
View file

@ -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;

6
src/game/board/boo.c
View file

@ -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);
}

8
src/game/board/boo_house.c
View file

@ -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;

2
src/game/board/com.c
View file

@ -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;

58
src/game/board/item.c
View file

@ -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)));

34
src/game/board/lottery.c
View file

@ -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;

8
src/game/board/mg_setup.c
View file

@ -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);
}

6
src/game/board/mushroom.c
View file

@ -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;

4
src/game/board/pause.c
View file

@ -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;

14
src/game/board/player.c
View file

@ -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) {

8
src/game/board/roll.c
View file

@ -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);
}
}

8
src/game/board/shop.c
View file

@ -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;

6
src/game/board/star.c
View file

@ -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) {

4
src/game/board/start.c
View file

@ -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();
}

40
src/game/board/ui.c
View file

@ -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);

10
src/game/board/view.c
View file

@ -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 {

32
src/game/chrman.c
View file

@ -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;

56
src/game/hsfanim.c
View file

@ -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;
}

24
src/game/hsfdraw.c
View file

@ -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);

44
src/game/hsfex.c
View file

@ -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;

20
src/game/hsfman.c
View file

@ -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;

6
src/game/hsfmotion.c
View file

@ -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;
}
}

48
src/game/mapspace.c
View file

@ -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;