mirror of
https://github.com/zeldaret/mm.git
synced 2026-06-22 00:06:28 -04:00
Cleanup files in code. Decompile code_800CAAD0.c
This commit is contained in:
rozlette
+231
-231
@@ -5,10 +5,10 @@
|
||||
extern float fabsf(float);
|
||||
#pragma intrinsic (fabsf)
|
||||
|
||||
void* Lib_bcopy(void* dst, void* src, size_t n) {
|
||||
_bcopy(src, dst, n);
|
||||
void* Lib_bcopy(void* dest, void* src, size_t n) {
|
||||
_bcopy(src, dest, n);
|
||||
|
||||
return dst;
|
||||
return dest;
|
||||
}
|
||||
|
||||
#ifdef NONMATCHING
|
||||
@@ -36,99 +36,99 @@ GLOBAL_ASM("./asm/nonmatching/z_lib/Lib_memset.asm")
|
||||
|
||||
#endif
|
||||
|
||||
f32 Lib_cos(s16 a0) {
|
||||
return coss(a0) * D_801DDA80;
|
||||
f32 Lib_cos(s16 angle) {
|
||||
return coss(angle) * D_801DDA80;
|
||||
}
|
||||
|
||||
f32 Lib_sin(s16 a0) {
|
||||
return sins(a0) * D_801DDA84;
|
||||
f32 Lib_sin(s16 angle) {
|
||||
return sins(angle) * D_801DDA84;
|
||||
}
|
||||
|
||||
s32 Lib_StepTowardsGet_i(s32 a0, s32 a1, s32 a2) {
|
||||
s32 Lib_StepTowardsGet_i(s32 start, s32 value, s32 step) {
|
||||
s32 v1;
|
||||
|
||||
if (a1 >= a0) {
|
||||
v1 = a0 + a2;
|
||||
if (a1 >= v1) {
|
||||
if (value >= start) {
|
||||
v1 = start + step;
|
||||
if (value >= v1) {
|
||||
return v1;
|
||||
}
|
||||
} else {
|
||||
v1 = a0 - a2;
|
||||
if (v1 >= a1) {
|
||||
v1 = start - step;
|
||||
if (v1 >= value) {
|
||||
return v1;
|
||||
}
|
||||
}
|
||||
return a1;
|
||||
return value;
|
||||
}
|
||||
|
||||
void Lib_StepTowards_i(s32* a0, s32 a1, s32 a2) {
|
||||
*a0 = Lib_StepTowardsGet_i(*a0, a1, a2);
|
||||
void Lib_StepTowards_i(s32* start, s32 value, s32 step) {
|
||||
*start = Lib_StepTowardsGet_i(*start, value, step);
|
||||
}
|
||||
|
||||
UNK_TYPE Lib_StepTowardsCheck_i(s32* a0, s32 a1, s32 a2) {
|
||||
Lib_StepTowards_i(a0, a1, a2);
|
||||
s32 Lib_StepTowardsCheck_i(s32* start, s32 value, s32 step) {
|
||||
Lib_StepTowards_i(start, value, step);
|
||||
|
||||
return a1 == *a0;
|
||||
return value == *start;
|
||||
}
|
||||
|
||||
UNK_TYPE Lib_StepTowardsCheckFramerateScaled_s(s16* a0, s16 a1, s16 a2) {
|
||||
s32 Lib_StepTowardsCheckFramerateScaled_s(s16* start, s16 target, s16 step) {
|
||||
f32 f0;
|
||||
|
||||
if (a2 != 0) {
|
||||
if (step != 0) {
|
||||
f0 = D_801D1508;
|
||||
|
||||
if ((s16)(*a0 - a1) > 0) {
|
||||
a2 = -a2;
|
||||
if ((s16)(*start - target) > 0) {
|
||||
step = -step;
|
||||
}
|
||||
|
||||
*a0 += (s16)(a2 * f0);
|
||||
*start += (s16)(step * f0);
|
||||
|
||||
if (((s16)(*a0 - a1) * a2) >= 0) {
|
||||
*a0 = a1;
|
||||
if (((s16)(*start - target) * step) >= 0) {
|
||||
*start = target;
|
||||
|
||||
return 1;
|
||||
}
|
||||
} else if (a1 == *a0) {
|
||||
} else if (target == *start) {
|
||||
return 1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
UNK_TYPE Lib_StepTowardsCheck_s(s16* a0, s16 a1, s16 a2) {
|
||||
if (a2 != 0) {
|
||||
if (a1 < *a0) {
|
||||
a2 = -a2;
|
||||
s32 Lib_StepTowardsCheck_s(s16* start, s16 target, s16 step) {
|
||||
if (step != 0) {
|
||||
if (target < *start) {
|
||||
step = -step;
|
||||
}
|
||||
|
||||
*a0 += a2;
|
||||
*start += step;
|
||||
|
||||
if (((*a0 - a1) * a2) >= 0) {
|
||||
*a0 = a1;
|
||||
if (((*start - target) * step) >= 0) {
|
||||
*start = target;
|
||||
|
||||
return 1;
|
||||
}
|
||||
} else if (a1 == *a0) {
|
||||
} else if (target == *start) {
|
||||
return 1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
UNK_TYPE Lib_StepTowardsCheck_c(s8* a0, s8 a1, s8 a2) {
|
||||
if (a2 != 0) {
|
||||
if (a1 < *a0) {
|
||||
a2 = -a2;
|
||||
s32 Lib_StepTowardsCheck_c(s8* start, s8 target, s8 step) {
|
||||
if (step != 0) {
|
||||
if (target < *start) {
|
||||
step = -step;
|
||||
}
|
||||
|
||||
*a0 += a2;
|
||||
*start += step;
|
||||
|
||||
if (((*a0 - a1) * a2) >= 0) {
|
||||
*a0 = a1;
|
||||
if (((*start - target) * step) >= 0) {
|
||||
*start = target;
|
||||
|
||||
return 1;
|
||||
}
|
||||
} else if (a1 == *a0) {
|
||||
} else if (target == *start) {
|
||||
return 1;
|
||||
}
|
||||
|
||||
@@ -137,21 +137,21 @@ UNK_TYPE Lib_StepTowardsCheck_c(s8* a0, s8 a1, s8 a2) {
|
||||
|
||||
#ifdef NONMATCHING
|
||||
|
||||
UNK_TYPE Lib_StepTowardsCheck_f(f32* a0, f32 a1, f32 a2) {
|
||||
if (a2 != 0) {
|
||||
s32 Lib_StepTowardsCheck_f(f32* start, f32 target, f32 step) {
|
||||
if (step != 0) {
|
||||
// XXX: regalloc is messed up
|
||||
if (a1 < *a0) {
|
||||
a2 = -a2;
|
||||
if (target < *start) {
|
||||
step = -step;
|
||||
}
|
||||
|
||||
*a0 += a2;
|
||||
*start += step;
|
||||
|
||||
if (((*a0 - a1) * a2) >= 0) {
|
||||
*a0 = a1;
|
||||
if (((*start - target) * step) >= 0) {
|
||||
*start = target;
|
||||
|
||||
return 1;
|
||||
}
|
||||
} else if (a1 != *a0) {
|
||||
} else if (target != *start) {
|
||||
return 1;
|
||||
}
|
||||
|
||||
@@ -166,7 +166,7 @@ GLOBAL_ASM("./asm/nonmatching/z_lib/Lib_StepTowardsCheck_f.asm")
|
||||
|
||||
#ifdef NONMATCHING
|
||||
|
||||
UNK_TYPE func_800FF0D0(s16* a0, s16 a1, s16 a2) {
|
||||
s32 func_800FF0D0(s16* a0, s16 a1, s16 a2) {
|
||||
s32 v0 = *a0;
|
||||
|
||||
// XXX: regalloc is messed up
|
||||
@@ -189,7 +189,7 @@ GLOBAL_ASM("./asm/nonmatching/z_lib/func_800FF0D0.asm")
|
||||
|
||||
#ifdef NONMATCHING
|
||||
|
||||
UNK_RET func_800FF138() {
|
||||
void func_800FF138() {
|
||||
|
||||
}
|
||||
|
||||
@@ -201,7 +201,7 @@ GLOBAL_ASM("./asm/nonmatching/z_lib/func_800FF138.asm")
|
||||
|
||||
#ifdef NONMATCHING
|
||||
|
||||
UNK_RET func_800FF1FC() {
|
||||
void func_800FF1FC(void) {
|
||||
|
||||
}
|
||||
|
||||
@@ -213,7 +213,7 @@ GLOBAL_ASM("./asm/nonmatching/z_lib/func_800FF1FC.asm")
|
||||
|
||||
#ifdef NONMATCHING
|
||||
|
||||
UNK_RET func_800FF2A8() {
|
||||
void func_800FF2A8(void) {
|
||||
|
||||
}
|
||||
|
||||
@@ -225,7 +225,7 @@ GLOBAL_ASM("./asm/nonmatching/z_lib/func_800FF2A8.asm")
|
||||
|
||||
#ifdef NONMATCHING
|
||||
|
||||
UNK_RET func_800FF2F8() {
|
||||
void func_800FF2F8(void) {
|
||||
|
||||
}
|
||||
|
||||
@@ -237,7 +237,7 @@ GLOBAL_ASM("./asm/nonmatching/z_lib/func_800FF2F8.asm")
|
||||
|
||||
#ifdef NONMATCHING
|
||||
|
||||
UNK_RET func_800FF3A0() {
|
||||
void func_800FF3A0(void) {
|
||||
|
||||
}
|
||||
|
||||
@@ -247,156 +247,156 @@ GLOBAL_ASM("./asm/nonmatching/z_lib/func_800FF3A0.asm")
|
||||
|
||||
#endif
|
||||
|
||||
s16 Lib_rand_s(s16 a0, s16 a1) {
|
||||
return (s16)(randZeroOne() * a1) + a0;
|
||||
s16 Lib_rand_s(s16 base, s16 range) {
|
||||
return (s16)(randZeroOne() * range) + base;
|
||||
}
|
||||
|
||||
s16 Lib_randStride_s(s16 a0, s16 a1, s16 a2) {
|
||||
return (s16)(randZeroOne() * a2) * a1 + a0;
|
||||
s16 Lib_randestride_s(s16 base, s16 stride, s16 range) {
|
||||
return (s16)(randZeroOne() * range) * stride + base;
|
||||
}
|
||||
|
||||
UNK_RET Lib_CopyVec3f(Vector3f* dst, Vector3f* src) {
|
||||
void Lib_CopyVec3f(Vector3f* dest, Vector3f* src) {
|
||||
f32 x = src->x;
|
||||
f32 y = src->y;
|
||||
f32 z = src->z;
|
||||
|
||||
dst->x = x;
|
||||
dst->y = y;
|
||||
dst->z = z;
|
||||
dest->x = x;
|
||||
dest->y = y;
|
||||
dest->z = z;
|
||||
}
|
||||
|
||||
UNK_RET Lib_CopyVec3s(Vector3s* dst, Vector3s* src) {
|
||||
void Lib_CopyVec3s(Vector3s* dest, Vector3s* src) {
|
||||
s16 x = src->x;
|
||||
s16 y = src->y;
|
||||
s16 z = src->z;
|
||||
|
||||
dst->x = x;
|
||||
dst->y = y;
|
||||
dst->z = z;
|
||||
dest->x = x;
|
||||
dest->y = y;
|
||||
dest->z = z;
|
||||
}
|
||||
|
||||
UNK_RET Lib_ToVec3f(Vector3f* dst, Vector3s* src) {
|
||||
void Lib_ToVec3f(Vector3f* dest, Vector3s* src) {
|
||||
f32 x = src->x;
|
||||
f32 y = src->y;
|
||||
f32 z = src->z;
|
||||
|
||||
dst->x = x;
|
||||
dst->y = y;
|
||||
dst->z = z;
|
||||
dest->x = x;
|
||||
dest->y = y;
|
||||
dest->z = z;
|
||||
}
|
||||
|
||||
UNK_RET Lib_ToVec3s(Vector3s* dst, Vector3f* src) {
|
||||
void Lib_ToVec3s(Vector3s* dest, Vector3f* src) {
|
||||
f32 x = src->x;
|
||||
f32 y = src->y;
|
||||
f32 z = src->z;
|
||||
|
||||
dst->x = x;
|
||||
dst->y = y;
|
||||
dst->z = z;
|
||||
dest->x = x;
|
||||
dest->y = y;
|
||||
dest->z = z;
|
||||
}
|
||||
|
||||
UNK_RET Lib_AddVec3f(Vector3f* a0, Vector3f* a1, Vector3f* a2) {
|
||||
a2->x = a0->x + a1->x;
|
||||
a2->y = a0->y + a1->y;
|
||||
a2->z = a0->z + a1->z;
|
||||
void Lib_AddVec3f(Vector3f* l, Vector3f* r, Vector3f* dest) {
|
||||
dest->x = l->x + r->x;
|
||||
dest->y = l->y + r->y;
|
||||
dest->z = l->z + r->z;
|
||||
}
|
||||
|
||||
UNK_RET Lib_SubVec3f(Vector3f* a0, Vector3f* a1, Vector3f* a2) {
|
||||
a2->x = a0->x - a1->x;
|
||||
a2->y = a0->y - a1->y;
|
||||
a2->z = a0->z - a1->z;
|
||||
void Lib_SubVec3f(Vector3f* l, Vector3f* r, Vector3f* dest) {
|
||||
dest->x = l->x - r->x;
|
||||
dest->y = l->y - r->y;
|
||||
dest->z = l->z - r->z;
|
||||
}
|
||||
|
||||
UNK_RET Lib_SubVec3sToVec3f(Vector3f* a0, Vector3s* a1, Vector3s* a2) {
|
||||
a0->x = a1->x - a2->x;
|
||||
a0->y = a1->y - a2->y;
|
||||
a0->z = a1->z - a2->z;
|
||||
void Lib_SubVec3sToVec3f(Vector3f* dest, Vector3s* l, Vector3s* r) {
|
||||
dest->x = l->x - r->x;
|
||||
dest->y = l->y - r->y;
|
||||
dest->z = l->z - r->z;
|
||||
}
|
||||
|
||||
UNK_RET Lib_ScaleInPlaceVec3f(Vector3f* a0, f32 a1) {
|
||||
a0->x *= a1;
|
||||
a0->y *= a1;
|
||||
a0->z *= a1;
|
||||
void Lib_ScaleInPlaceVec3f(Vector3f* vec, f32 scale) {
|
||||
vec->x *= scale;
|
||||
vec->y *= scale;
|
||||
vec->z *= scale;
|
||||
}
|
||||
|
||||
UNK_RET Lib_ScaleVec3f(Vector3f* a0, f32 a1, Vector3f* a2) {
|
||||
a2->x = a0->x * a1;
|
||||
a2->y = a0->y * a1;
|
||||
a2->z = a0->z * a1;
|
||||
void Lib_ScaleVec3f(Vector3f* vec, f32 scale, Vector3f* dest) {
|
||||
dest->x = vec->x * scale;
|
||||
dest->y = vec->y * scale;
|
||||
dest->z = vec->z * scale;
|
||||
}
|
||||
|
||||
UNK_RET Lib_LerpVec3f(Vector3f* a0, Vector3f* a1, f32 a2, Vector3f* a3) {
|
||||
a3->x = (a1->x - a0->x) * a2 + a0->x;
|
||||
a3->y = (a1->y - a0->y) * a2 + a0->y;
|
||||
a3->z = (a1->z - a0->z) * a2 + a0->z;
|
||||
void Lib_LerpVec3f(Vector3f* a, Vector3f* b, f32 t, Vector3f* dest) {
|
||||
dest->x = (b->x - a->x) * t + a->x;
|
||||
dest->y = (b->y - a->y) * t + a->y;
|
||||
dest->z = (b->z - a->z) * t + a->z;
|
||||
}
|
||||
|
||||
UNK_RET Lib_AddScaledVec3f(Vector3f* a0, Vector3f* a1, f32 a2, Vector3f* a3) {
|
||||
a3->x = a1->x * a2 + a0->x;
|
||||
a3->y = a1->y * a2 + a0->y;
|
||||
a3->z = a1->z * a2 + a0->z;
|
||||
void Lib_AddScaledVec3f(Vector3f* a, Vector3f* b, f32 scale, Vector3f* dest) {
|
||||
dest->x = b->x * scale + a->x;
|
||||
dest->y = b->y * scale + a->y;
|
||||
dest->z = b->z * scale + a->z;
|
||||
}
|
||||
|
||||
UNK_RET Lib_ModifyRandScaled(Vector3f* a0, f32 a1, Vector3f* a2) {
|
||||
a2->x = randPlusMinusPoint5Scaled(a1) + a0->x;
|
||||
a2->y = randPlusMinusPoint5Scaled(a1) + a0->y;
|
||||
a2->z = randPlusMinusPoint5Scaled(a1) + a0->z;
|
||||
void Lib_ModifyRandScaled(Vector3f* orig, f32 scale, Vector3f* dest) {
|
||||
dest->x = randPlusMinusPoint5Scaled(scale) + orig->x;
|
||||
dest->y = randPlusMinusPoint5Scaled(scale) + orig->y;
|
||||
dest->z = randPlusMinusPoint5Scaled(scale) + orig->z;
|
||||
}
|
||||
|
||||
void Lib_ScaledNormalizedDifferenceVec3f(Vector3f* a0, Vector3f* a1, f32 a2, Vector3f* a3) {
|
||||
f32 f0 = Lib_DistanceAndDifferenceVec3f(a0, a1, a3);
|
||||
void Lib_ScaledNormalizedDifferenceVec3f(Vector3f* a, Vector3f* b, f32 scale, Vector3f* dest) {
|
||||
f32 f0 = Lib_DistanceAndDifferenceVec3f(a, b, dest);
|
||||
f32 f2;
|
||||
|
||||
if (f0 == 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
f2 = a2 / f0;
|
||||
f2 = scale / f0;
|
||||
|
||||
a3->x *= f2;
|
||||
a3->y *= f2;
|
||||
a3->z *= f2;
|
||||
dest->x *= f2;
|
||||
dest->y *= f2;
|
||||
dest->z *= f2;
|
||||
}
|
||||
|
||||
f32 Lib_DistanceVec3f(Vector3f* a0, Vector3f* a1) {
|
||||
f32 Lib_DistanceVec3f(Vector3f* a, Vector3f* b) {
|
||||
Vector3f sp1C;
|
||||
Lib_SubVec3f(a1, a0, &sp1C);
|
||||
Lib_SubVec3f(b, a, &sp1C);
|
||||
return sqrtf((sp1C.x * sp1C.x) + (sp1C.y * sp1C.y) + (sp1C.z * sp1C.z));
|
||||
}
|
||||
|
||||
f32 Lib_DistanceAndDifferenceVec3f(Vector3f* a0, Vector3f* a1, Vector3f* a2) {
|
||||
Lib_SubVec3f(a1, a0, a2);
|
||||
return sqrtf((a2->x * a2->x) + (a2->y * a2->y) + (a2->z * a2->z));
|
||||
f32 Lib_DistanceAndDifferenceVec3f(Vector3f* a, Vector3f* b, Vector3f* difference) {
|
||||
Lib_SubVec3f(b, a, difference);
|
||||
return sqrtf((difference->x * difference->x) + (difference->y * difference->y) + (difference->z * difference->z));
|
||||
}
|
||||
|
||||
f32 Lib_DistanceXZVec3f(Vector3f* a0, Vector3f* a1) {
|
||||
f32 dx = a1->x - a0->x;
|
||||
f32 dz = a1->z - a0->z;
|
||||
f32 Lib_DistanceXZVec3f(Vector3f* a, Vector3f* b) {
|
||||
f32 dx = b->x - a->x;
|
||||
f32 dz = b->z - a->z;
|
||||
return sqrtf((dx * dx) + (dz * dz));
|
||||
}
|
||||
|
||||
f32 Lib_DistanceAndDifferenceXZVec3f(Vector3f* a0, Vector3f* a1, f32* a2, f32* a3) {
|
||||
*a2 = a1->x - a0->x;
|
||||
*a3 = a1->z - a0->z;
|
||||
return sqrtf((*a2 * *a2) + (*a3 * *a3));
|
||||
f32 Lib_DistanceAndDifferenceXZVec3f(Vector3f* a, Vector3f* b, f32* xDiff, f32* zDiff) {
|
||||
*xDiff = b->x - a->x;
|
||||
*zDiff = b->z - a->z;
|
||||
return sqrtf((*xDiff * *xDiff) + (*zDiff * *zDiff));
|
||||
}
|
||||
|
||||
#ifdef NONMATCHING
|
||||
|
||||
UNK_RET Lib_PushAwayXZVec3f(Vector3f* a0, Vector3f* a1, f32 a2) {
|
||||
void Lib_PushAwayXZVec3f(Vector3f* start, Vector3f* pusher, f32 distanceToApproach) {
|
||||
f32 sp24;
|
||||
f32 sp20;
|
||||
f32 f0 = Lib_DistanceAndDifferenceXZVec3f(a1, a0, &sp24, &sp20);
|
||||
f32 f2 = f0 - a2;
|
||||
f32 f0 = Lib_DistanceAndDifferenceXZVec3f(pusher, start, &sp24, &sp20);
|
||||
f32 f2 = f0 - distanceToApproach;
|
||||
|
||||
if ((f0 >= a2) && (f2 != 0)) {
|
||||
if ((f0 >= distanceToApproach) && (f2 != 0)) {
|
||||
f2 /= f0;
|
||||
} else {
|
||||
f2 = 0;
|
||||
}
|
||||
|
||||
a0->x = a1->x + sp24 * f2;
|
||||
a0->z = a1->z + sp20 * f2;
|
||||
start->x = pusher->x + sp24 * f2;
|
||||
start->z = pusher->z + sp20 * f2;
|
||||
}
|
||||
|
||||
#else
|
||||
@@ -405,79 +405,79 @@ GLOBAL_ASM("./asm/nonmatching/z_lib/Lib_PushAwayXZVec3f.asm")
|
||||
|
||||
#endif
|
||||
|
||||
f32 Lib_DistanceYVec3f(Vector3f* a0, Vector3f* a1) {
|
||||
return a1->y - a0->y;
|
||||
f32 Lib_DistanceYVec3f(Vector3f* a, Vector3f* b) {
|
||||
return b->y - a->y;
|
||||
}
|
||||
|
||||
UNK_TYPE Lib_YawVec3f(Vector3f* a0, Vector3f* a1) {
|
||||
f32 f14 = a1->x - a0->x;
|
||||
f32 f12 = a1->z - a0->z;
|
||||
s32 Lib_YawVec3f(Vector3f* from, Vector3f* to) {
|
||||
f32 f14 = to->x - from->x;
|
||||
f32 f12 = to->z - from->z;
|
||||
return atans_flip(f12, f14);
|
||||
}
|
||||
|
||||
UNK_TYPE Lib_PitchVec3f(Vector3f* a0, Vector3f* a1) {
|
||||
return atans_flip(Lib_DistanceXZVec3f(a0, a1), a0->y - a1->y);
|
||||
s32 Lib_PitchVec3f(Vector3f* from, Vector3f* to) {
|
||||
return atans_flip(Lib_DistanceXZVec3f(from, to), from->y - to->y);
|
||||
}
|
||||
|
||||
void Lib_ApplyActorInitVars(Actor* a0, ActorInitVar* a1) {
|
||||
void Lib_ApplyActorInitVars(Actor* actor, ActorInitVar* init) {
|
||||
do {
|
||||
actorInitVarFuncs[a1->type]((u8*)a0, a1);
|
||||
} while ((a1++)->cont);
|
||||
actorInitVarFuncs[init->type]((u8*)actor, init);
|
||||
} while ((init++)->cont);
|
||||
}
|
||||
|
||||
UNK_RET Lib_ApplyActorInitVarByte1(u8* a0, ActorInitVar* a1) {
|
||||
*(u8*)(a0 + a1->offset) = (u8)(a1->value);
|
||||
void Lib_ApplyActorInitVarByte1(u8* actor, ActorInitVar* init) {
|
||||
*(u8*)(actor + init->offset) = (u8)(init->value);
|
||||
}
|
||||
|
||||
UNK_RET Lib_ApplyActorInitVarByte2(u8* a0, ActorInitVar* a1) {
|
||||
*(u8*)(a0 + a1->offset) = (u8)(a1->value);
|
||||
void Lib_ApplyActorInitVarByte2(u8* actor, ActorInitVar* init) {
|
||||
*(u8*)(actor + init->offset) = (u8)(init->value);
|
||||
}
|
||||
|
||||
UNK_RET Lib_ApplyActorInitVarShort1(u8* a0, ActorInitVar* a1) {
|
||||
*(u16*)(a0 + a1->offset) = (u16)(a1->value);
|
||||
void Lib_ApplyActorInitVarShort1(u8* actor, ActorInitVar* init) {
|
||||
*(u16*)(actor + init->offset) = (u16)(init->value);
|
||||
}
|
||||
|
||||
UNK_RET Lib_ApplyActorInitVarShort2(u8* a0, ActorInitVar* a1) {
|
||||
*(u16*)(a0 + a1->offset) = (u16)(a1->value);
|
||||
void Lib_ApplyActorInitVarShort2(u8* actor, ActorInitVar* init) {
|
||||
*(u16*)(actor + init->offset) = (u16)(init->value);
|
||||
}
|
||||
|
||||
UNK_RET Lib_ApplyActorInitVarWord1(u8* a0, ActorInitVar* a1) {
|
||||
*(u32*)(a0 + a1->offset) = (u32)(a1->value);
|
||||
void Lib_ApplyActorInitVarWord1(u8* actor, ActorInitVar* init) {
|
||||
*(u32*)(actor + init->offset) = (u32)(init->value);
|
||||
}
|
||||
|
||||
UNK_RET Lib_ApplyActorInitVarWord2(u8* a0, ActorInitVar* a1) {
|
||||
*(u32*)(a0 + a1->offset) = (u32)(a1->value);
|
||||
void Lib_ApplyActorInitVarWord2(u8* actor, ActorInitVar* init) {
|
||||
*(u32*)(actor + init->offset) = (u32)(init->value);
|
||||
}
|
||||
|
||||
UNK_RET Lib_ApplyActorInitVarFloat(u8* a0, ActorInitVar* a1) {
|
||||
*(f32*)(a0 + a1->offset) = (f32)(a1->value);
|
||||
void Lib_ApplyActorInitVarFloat(u8* actor, ActorInitVar* init) {
|
||||
*(f32*)(actor + init->offset) = (f32)(init->value);
|
||||
}
|
||||
|
||||
UNK_RET Lib_ApplyActorInitVarFloat1000th(u8* a0, ActorInitVar* a1) {
|
||||
*(f32*)(a0 + a1->offset) = (f32)(a1->value) / 1000;
|
||||
void Lib_ApplyActorInitVarFloat1000th(u8* actor, ActorInitVar* init) {
|
||||
*(f32*)(actor + init->offset) = (f32)(init->value) / 1000;
|
||||
}
|
||||
|
||||
UNK_RET Lib_ApplyActorInitVarVector3f(u8* a0, ActorInitVar* a1) {
|
||||
Vector3f* v0 = (Vector3f*)(a0 + a1->offset);
|
||||
f32 f0 = (f32)(a1->value);
|
||||
void Lib_ApplyActorInitVarVector3f(u8* actor, ActorInitVar* init) {
|
||||
Vector3f* v0 = (Vector3f*)(actor + init->offset);
|
||||
f32 f0 = (f32)(init->value);
|
||||
|
||||
v0->z = f0;
|
||||
v0->y = f0;
|
||||
v0->x = f0;
|
||||
}
|
||||
|
||||
UNK_RET Lib_ApplyActorInitVarVector3f1000th(u8* a0, ActorInitVar* a1) {
|
||||
Vector3f* v0 = (Vector3f*)(a0 + a1->offset);
|
||||
f32 f0 = (f32)(a1->value) / 1000;
|
||||
void Lib_ApplyActorInitVarVector3f1000th(u8* actor, ActorInitVar* init) {
|
||||
Vector3f* v0 = (Vector3f*)(actor + init->offset);
|
||||
f32 f0 = (f32)(init->value) / 1000;
|
||||
|
||||
v0->z = f0;
|
||||
v0->y = f0;
|
||||
v0->x = f0;
|
||||
}
|
||||
|
||||
UNK_RET Lib_ApplyActorInitVarVector3s(u8* a0, ActorInitVar* a1) {
|
||||
Vector3s* v0 = (Vector3s*)(a0 + a1->offset);
|
||||
s16 v1 = (s16)(a1->value);
|
||||
void Lib_ApplyActorInitVarVector3s(u8* actor, ActorInitVar* init) {
|
||||
Vector3s* v0 = (Vector3s*)(actor + init->offset);
|
||||
s16 v1 = (s16)(init->value);
|
||||
|
||||
v0->z = v1;
|
||||
v0->y = v1;
|
||||
@@ -524,37 +524,37 @@ f32 func_800FFCD8(f32* a0, f32 a1, f32 a2, f32 a3, f32 a4) {
|
||||
return fabsf(a1 - *a0);
|
||||
}
|
||||
|
||||
void Lib_ScaleMax_f(f32* a0, f32 a1, f32 a2, f32 a3) {
|
||||
void Lib_ScaleMax_f(f32* start, f32 target, f32 scale, f32 maxStep) {
|
||||
f32 f2;
|
||||
|
||||
if (*a0 != a1) {
|
||||
f2 = (a1 - *a0) * a2;
|
||||
if (*start != target) {
|
||||
f2 = (target - *start) * scale;
|
||||
|
||||
if (f2 > a3) {
|
||||
f2 = a3;
|
||||
} else if (f2 < -a3) {
|
||||
f2 = -a3;
|
||||
if (f2 > maxStep) {
|
||||
f2 = maxStep;
|
||||
} else if (f2 < -maxStep) {
|
||||
f2 = -maxStep;
|
||||
}
|
||||
|
||||
*a0 += f2;
|
||||
*start += f2;
|
||||
}
|
||||
}
|
||||
|
||||
void Lib_Scale_f(f32* a0, f32 a1, f32 a2) {
|
||||
f32 f0 = *a0 * a1;
|
||||
void Lib_Scale_f(f32* start, f32 scale, f32 maxStep) {
|
||||
f32 f0 = *start * scale;
|
||||
|
||||
if (a2 < f0) {
|
||||
f0 = a2;
|
||||
} else if (f0 < -a2) {
|
||||
f0 = -a2;
|
||||
if (maxStep < f0) {
|
||||
f0 = maxStep;
|
||||
} else if (f0 < -maxStep) {
|
||||
f0 = -maxStep;
|
||||
}
|
||||
|
||||
*a0 = *a0 - f0;
|
||||
*start = *start - f0;
|
||||
}
|
||||
|
||||
#ifdef NONMATCHING
|
||||
|
||||
s16 Lib_ScaleMaxMin_s(s16* a0, s16 a1, s16 a2, s16 a3, s16 a4) {
|
||||
s32 Lib_ScaleMaxMin_s(s16* start, s16 target, s16 scale, s16 maxStep, s16 minStep) {
|
||||
|
||||
}
|
||||
|
||||
@@ -564,60 +564,60 @@ GLOBAL_ASM("./asm/nonmatching/z_lib/Lib_ScaleMaxMin_s.asm")
|
||||
|
||||
#endif
|
||||
|
||||
void Lib_ScaleMax_s(s16* a0, s16 a1, s16 a2, s16 a3) {
|
||||
s16 v0 = a1 - *a0;
|
||||
v0 /= a2;
|
||||
void Lib_ScaleMax_s(s16* start, s16 target, s16 scale, s16 maxStep) {
|
||||
s16 v0 = target - *start;
|
||||
v0 /= scale;
|
||||
|
||||
if (v0 > a3) {
|
||||
*a0 += a3;
|
||||
if (v0 > maxStep) {
|
||||
*start += maxStep;
|
||||
return;
|
||||
}
|
||||
|
||||
if (v0 < -a3) {
|
||||
*a0 -= a3;
|
||||
if (v0 < -maxStep) {
|
||||
*start -= maxStep;
|
||||
return;
|
||||
}
|
||||
|
||||
*a0 += v0;
|
||||
*start += v0;
|
||||
}
|
||||
|
||||
UNK_RET Lib_CopyColor(ColorRGBA8* a0, ColorRGBA8* a1) {
|
||||
a0->red = a1->red;
|
||||
a0->green = a1->green;
|
||||
a0->blue = a1->blue;
|
||||
a0->alpha = a1->alpha;
|
||||
void Lib_CopyColor(ColorRGBA8* dst, ColorRGBA8* src) {
|
||||
dst->red = src->red;
|
||||
dst->green = src->green;
|
||||
dst->blue = src->blue;
|
||||
dst->alpha = src->alpha;
|
||||
}
|
||||
|
||||
UNK_RET func_801000A4(u16 a0) {
|
||||
void func_801000A4(u16 a0) {
|
||||
play_sound(a0);
|
||||
}
|
||||
|
||||
UNK_RET func_801000CC(u16 a0) {
|
||||
void func_801000CC(u16 a0) {
|
||||
func_8019F128(a0);
|
||||
}
|
||||
|
||||
UNK_RET func_801000F4(UNK_TYPE a0, u16 a1) {
|
||||
void func_801000F4(s32 a0, u16 a1) {
|
||||
func_8019F1C0(a0, a1);
|
||||
}
|
||||
|
||||
void Lib_TranslateAndRotateYVec3f(Vector3f* a0, s16 a1, Vector3f* a2, Vector3f* a3) {
|
||||
void Lib_TranslateAndRotateYVec3f(Vector3f* translation, s16 rotation, Vector3f* src, Vector3f* dst) {
|
||||
f32 sp1C;
|
||||
f32 f0;
|
||||
|
||||
sp1C = Lib_cos(a1);
|
||||
f0 = Lib_sin(a1);
|
||||
a3->x = a0->x + (a2->x * sp1C + a2->z * f0);
|
||||
a3->y = a0->y + a2->y;
|
||||
a3->z = a0->z + (a2->z * sp1C - a2->x * f0);
|
||||
sp1C = Lib_cos(rotation);
|
||||
f0 = Lib_sin(rotation);
|
||||
dst->x = translation->x + (src->x * sp1C + src->z * f0);
|
||||
dst->y = translation->y + src->y;
|
||||
dst->z = translation->z + (src->z * sp1C - src->x * f0);
|
||||
}
|
||||
|
||||
#ifdef NONMATCHING
|
||||
|
||||
void Lib_LerpRGB(RGB* a0, RGB* a1, f32 a2, RGB* a3) {
|
||||
void Lib_LerpRGB(RGB* a, RGB* b, f32 t, RGB* dst) {
|
||||
// XXX regalloc is slightly off
|
||||
a3->red = (f32)a0->red + ((f32)a1->red - (f32)a0->red) * a2;
|
||||
a3->green = (f32)a0->green + ((f32)a1->green - (f32)a0->green) * a2;
|
||||
a3->blue = (f32)a0->blue + ((f32)a1->blue - (f32)a0->blue) * a2;
|
||||
dst->red = (f32)a->red + ((f32)b->red - (f32)a->red) * t;
|
||||
dst->green = (f32)a->green + ((f32)b->green - (f32)a->green) * t;
|
||||
dst->blue = (f32)a->blue + ((f32)b->blue - (f32)a->blue) * t;
|
||||
}
|
||||
|
||||
#else
|
||||
@@ -626,21 +626,21 @@ GLOBAL_ASM("./asm/nonmatching/z_lib/Lib_LerpRGB.asm")
|
||||
|
||||
#endif
|
||||
|
||||
f32 Lib_PushAwayVec3f(Vector3f* a0, Vector3f* a1, f32 a2) {
|
||||
f32 Lib_PushAwayVec3f(Vector3f* start, Vector3f* pusher, f32 distanceToApproach) {
|
||||
Vector3f sp24;
|
||||
f32 f2;
|
||||
f32 f0;
|
||||
|
||||
Lib_SubVec3f(a1, a0, &sp24);
|
||||
Lib_SubVec3f(pusher, start, &sp24);
|
||||
f0 = Math3D_Length(&sp24);
|
||||
if (a2 < f0) {
|
||||
f2 = a2 / f0;
|
||||
f0 = f0 - a2;
|
||||
a0->x = a0->x + f2 * sp24.x;
|
||||
a0->y = a0->y + f2 * sp24.y;
|
||||
a0->z = a0->z + f2 * sp24.z;
|
||||
if (distanceToApproach < f0) {
|
||||
f2 = distanceToApproach / f0;
|
||||
f0 = f0 - distanceToApproach;
|
||||
start->x = start->x + f2 * sp24.x;
|
||||
start->y = start->y + f2 * sp24.y;
|
||||
start->z = start->z + f2 * sp24.z;
|
||||
} else {
|
||||
Lib_CopyVec3f(a0, a1);
|
||||
Lib_CopyVec3f(start, pusher);
|
||||
f0 = 0;
|
||||
}
|
||||
|
||||
@@ -649,30 +649,30 @@ f32 Lib_PushAwayVec3f(Vector3f* a0, Vector3f* a1, f32 a2) {
|
||||
|
||||
void Lib_Nop801004FC(void) {}
|
||||
|
||||
u32 Lib_PtrSegToVirt(u32 a0) {
|
||||
return(gRspSegmentPhysAddrs[(a0 << 4) >> 28] + (a0 & 0xFFFFFF)) + 0x80000000;
|
||||
u32 Lib_PtrSegToVirt(u32 ptr) {
|
||||
return(gRspSegmentPhysAddrs[(ptr << 4) >> 28] + (ptr & 0xFFFFFF)) + 0x80000000;
|
||||
}
|
||||
|
||||
u32 Lib_PtrSegToVirtNull(u32 a0) {
|
||||
if ((a0 >> 28) == 0) {
|
||||
return a0;
|
||||
u32 Lib_PtrSegToVirtNull(u32 ptr) {
|
||||
if ((ptr >> 28) == 0) {
|
||||
return ptr;
|
||||
}
|
||||
|
||||
return(gRspSegmentPhysAddrs[(a0 << 4) >> 28] + (a0 & 0xFFFFFF)) + 0x80000000;
|
||||
return(gRspSegmentPhysAddrs[(ptr << 4) >> 28] + (ptr & 0xFFFFFF)) + 0x80000000;
|
||||
}
|
||||
|
||||
u32 Lib_PtrSegToK0(u32 a0) {
|
||||
if (a0 == 0) {
|
||||
u32 Lib_PtrSegToK0(u32 ptr) {
|
||||
if (ptr == 0) {
|
||||
return 0;
|
||||
} else {
|
||||
return a0 + 0x80000000;
|
||||
return ptr + 0x80000000;
|
||||
}
|
||||
}
|
||||
|
||||
u32 Lib_PtrSegToK0Null(u32 a0) {
|
||||
if (a0 == 0) {
|
||||
u32 Lib_PtrSegToK0Null(u32 ptr) {
|
||||
if (ptr == 0) {
|
||||
return 0;
|
||||
} else {
|
||||
return a0 + 0x80000000;
|
||||
return ptr + 0x80000000;
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user