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

Merge pull request #393 from abnormalhare/main

Browse source 
match m415Dll/main.c (except 1)
This commit is contained in:
Liam Coleman 2024-08-09 23:30:29 -05:00 • committed by GitHub
commit 11001637bb
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
84 changed files with 3033 additions and 968 deletions
Download patch file Download diff file Expand all files Collapse all files

200
include/REL/m415Dll.h Normal file
View file

@ -0,0 +1,200 @@
#include "dolphin.h"
#include "game/hsfformat.h"
#include "game/object.h"
#define FABS(x) ((x < 0.0f) ? -(x) : (x))
// types
typedef struct _unkStruct {
s16 unk0[3];
s16 unk6;
s16 unk8;
} unkStruct; // sizeof 0xC
typedef struct _unkStruct2 {
char unk[0xE];
s8 unkE;
} unkStruct2;
typedef struct _unkStruct3 {
u8 unk0;
u8 unk1;
u8 unk2;
u8 unk3;
u8 unk4;
u8 unk5;
u8 unk6;
u8 unk7;
char unk8[0x2];
u8 unkA;
u8 unkB;
u8 unkC;
u8 unkD;
u8 unkE;
u8 unkF;
s16 unk10;
s16 unk12;
s16 unk14;
s16 unk16;
s16 unk18;
s16 unk1A;
f32 unk1C;
f32 unk20;
f32 unk24;
f32 unk28;
Vec unk2C;
Vec unk38;
Vec unk44;
Vec unk50;
u8 unk5C;
u8 unk5D;
union {
s32* unk60;
struct {
s16 unk60s;
s16 unk62s;
};
};
s16 unk64;
s16 unk66;
s16 unk68;
Vec unk6C;
} unkStruct3;
typedef struct _unkStruct4 {
u8 unk0;
Vec unk4;
Vec unk10;
Vec unk1C;
Vec unk28;
Vec unk34;
Vec unk40;
Vec unk4C;
Vec unk58;
Vec unk64[3];
Vec unk88[3];
Vec unkAC[3];
Vec unkD0[3];
f32 unkF4[3];
f32 unk100[3];
f32 unk10C[3];
f32 unk118[3];
f32 unk124[3];
f32 unk130;
f32 unk134;
f32 unk138;
f32 unk13C;
f32 unk140;
f32 unk144;
f32 unk148;
} unkStruct4;
// taken from m438
typedef struct _unkSubStruct {
Vec unk0;
char unkC[0xC];
Vec unk18;
char unk24[0x2C];
GXColor unk50;
char unk54[0x8];
s8 unk5C;
char unk5D[0xB];
Vec unk68;
char unk74[0x20];
} unkSubStruct; /* size = 0x94 */
typedef struct _unkSubStruct2 {
s16 unk0;
s16 unk2;
char unk4[0x2C];
void *unk30; // TODO type
char unk34[8];
unkSubStruct *unk3C;
char unk40[0x20];
u8 unk60;
char unk61[0x1A];
s16 unk7C;
s16 unk7E;
float unk80;
float unk84;
float unk88;
float unk8C;
float unk90;
char unk94[0x28];
} unkSubStruct2; /* size = 0xBC */
typedef struct _unkStruct5 {
/* 0x00 */ char unk00[0x36];
s16 unk36;
s16 unk38;
s16 unk3A;
char unk3C[4];
unkSubStruct2 *unk40;
} unkStruct5; /* size = */
// prototypes
void ObjectSetup(void);
void fn_1_43C(omObjData* object);
void fn_1_4B0(omObjData* object);
void fn_1_7D8(omObjData* object);
void fn_1_14C0(omObjData* object);
void fn_1_1524(s16, char*, f32, Mtx);
void fn_1_15D0(omObjData* object);
void fn_1_1960(omObjData* object);
void fn_1_1A60(unkStruct3*);
void fn_1_2B18(omObjData* object);
void fn_1_2C14(omObjData* object);
void fn_1_2E88(f32, Vec*, Vec*, f32);
void fn_1_2F28(f32, Vec*, Vec*, f32, Vec*, Vec*, f32);
void fn_1_31E0(f32);
void fn_1_3208(omObjData* object);
void fn_1_3640(omObjData* object);
void fn_1_3764(omObjData* object);
void fn_1_3B44(omObjData* object);
void fn_1_4660(omObjData* object);
void fn_1_5B20(unkSubStruct2*);
void fn_1_5FB0(omObjData* object);
void fn_1_6304(omObjData* object);
void fn_1_6368(void);
void* fn_1_63A8(s32);
void fn_1_6448(void*);
void fn_1_64DC(void);
void fn_1_6584(s16, char*, u8, u8, u8);
AnimBmpData* fn_1_668C(s16);
s16 fn_1_66AC(void);
s32 fn_1_679C(void);
f32 fn_1_67F0(f32, f32, f32);
void fn_1_6958(Mtx, f32, f32, f32);
void fn_1_6A78(Mtx, Vec*);
f32 fn_1_6D84(f32, f32, f32, f32);
void fn_1_6DFC(f32*, f32*, f32*, f32*, f32);
f32 fn_1_6F18(f32, f32, f32, f32);
void fn_1_6F90(f32*, f32*, f32*, f32*, f32);
void fn_1_7268(f32*, f32*, f32*, s32);
f32 fn_1_7520(f32, f32*, f32*, f32*, s32);
void fn_1_7674(f32*, Vec*, Vec*, s32);
// ...
void fn_1_7A54(f32, Vec*, f32*, Vec*, Vec*, s32);
void fn_1_8780(s32, s32);
AnimData** fn_1_9734(s16); // *
s16 fn_1_A2D0(s32, s32);
void fn_1_A800(s16);
s16 fn_1_A94C(s32, s16, s16);
void fn_1_ACF4(s16, s16, s16, s16, s16, s16);
void fn_1_AFC8(s16, s32, s32, s32, s32);
void fn_1_B038(s16, s32, s32);
void fn_1_B0B8(s16, s32, s16);
void fn_1_B634(void);
void fn_1_B864(s16, f32, f32, f32);
void fn_1_B8D0(s16, s16, f32, f32, f32);
void fn_1_BB4C(s16, f32, f32, f32);
void fn_1_BC9C(s16, f32, f32, f32);
void fn_1_BD08(s16, s16, f32, f32, f32);
void fn_1_BE30(s16, s16, s32);
void fn_1_C110(s16, s16, u8, u8, u8, u8);
void fn_1_C264(s16, s32);
void fn_1_C2D0(s16, s32, s32);
void fn_1_C410(s16, s16, u8, u8);
void fn_1_C58C(s16, s16, u8 , f32);
void fn_1_C81C(s16, s32);

6
src/REL/bootDll/main.c
View file

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

6
src/REL/instDll/main.c
View file

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

6
src/REL/m402Dll/main.c
View file

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

26
src/REL/m403Dll/main.c
View file

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

40
src/REL/m403Dll/scene.c
View file

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

2
src/REL/m404Dll/main.c
View file

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

36
src/REL/m405Dll/main.c
View file

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

16
src/REL/m406Dll/main.c
View file

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

80
src/REL/m406Dll/map.c
View file

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

160
src/REL/m406Dll/player.c
View file

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

16
src/REL/m409Dll/main.c
View file

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

104
src/REL/m410Dll/game.c
View file

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

12
src/REL/m410Dll/main.c
View file

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

6
src/REL/m410Dll/player.c
View file

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

2
src/REL/m411Dll/main.c
View file

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

6
src/REL/m412Dll/main.c
View file

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

2
src/REL/m414Dll/main.c
View file

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

1865
src/REL/m415Dll/main.c Normal file
View file

File diff suppressed because it is too large Load diff

64
src/REL/m417Dll/player.c
View file

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

12
src/REL/m417Dll/sequence.c
View file

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

64
src/REL/m417Dll/water.c
View file

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

32
src/REL/m426Dll/main.c
View file

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

2
src/REL/m429Dll/main.c
View file

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

92
src/REL/m438Dll/main.c
View file

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

24
src/REL/m440Dll/main.c
View file

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

2
src/REL/m441Dll/main.c
View file

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

82
src/REL/m442Dll/main.c
View file

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

6
src/REL/m444dll/main.c
View file

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

4
src/REL/m447dll/player.c
View file

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

6
src/REL/messDll/main.c
View file

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

6
src/REL/mgmodedll/mgmode.c
View file

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

6
src/REL/modeltestDll/main.c
View file

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

6
src/REL/modeltestDll/modeltest00.c
View file

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

2
src/REL/modeltestDll/modeltest01.c
View file

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

6
src/REL/modeseldll/main.c
View file

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

6
src/REL/resultDll/main.c
View file

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

92
src/REL/w01Dll/main.c
View file

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

10
src/REL/w01Dll/mg_coin.c
View file

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

20
src/REL/w01Dll/mg_item.c
View file

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

22
src/REL/w02Dll/roulette.c
View file

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

22
src/REL/w03Dll/condor.c
View file

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

8
src/REL/w03Dll/mg_coin.c
View file

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

12
src/REL/w03Dll/mg_item.c
View file

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

14
src/REL/w03Dll/river.c
View file

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

6
src/REL/w03Dll/statue.c
View file

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

38
src/REL/w04Dll/boo_event.c
View file

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

6
src/REL/w04Dll/bridge.c
View file

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

42
src/REL/w04Dll/mg_coin.c
View file

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

30
src/REL/w04Dll/mg_item.c
View file

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

58
src/REL/w05Dll/dolphin.c
View file

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

24
src/REL/w05Dll/hotel.c
View file

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

14
src/REL/w05Dll/mg_coin.c
View file

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

12
src/REL/w05Dll/mg_item.c
View file

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

40
src/REL/w05Dll/monkey.c
View file

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

30
src/REL/w06Dll/bowser.c
View file

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

2
src/REL/w06Dll/bridge.c
View file

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

6
src/REL/w06Dll/fire.c
View file

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

12
src/REL/w06Dll/mg_coin.c
View file

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

6
src/REL/w06Dll/mg_item.c
View file

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

12
src/REL/ztardll/main.c
View file

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

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;