z_olib.c OK and Documented (#202)

* z_olib.c OK

* Clean-Up Clamp

* Take out extra space

src/code/z_actor.c

@@ -520,7 +520,7 @@ s32 Actor_IsActorFacedByActor(Actor* actor, Actor* other, s16 tolerance) {
     s16 angle;
     s16 dist;
 
-    angle = Actor_YawBetweenActors(actor, other) + 0x8000;
+    angle = BINANG_ROT180(Actor_YawBetweenActors(actor, other));
     dist = angle - other->shape.rot.y;
     if (ABS_ALT(dist) < tolerance) {
         return 1;

src/code/z_olib.c

@@ -0,0 +1,293 @@
+#include "global.h"
+
+/**
+ * Calculates the distances between `a` and `b`
+ */
+f32 OLib_Vec3fDist(Vec3f* a, Vec3f* b) {
+    f32 dx = a->x - b->x;
+    f32 dy = a->y - b->y;
+    f32 dz = a->z - b->z;
+
+    return sqrtf(SQ(dx) + SQ(dy) + SQ(dz));
+}
+
+/**
+ * Calculates the distances between `a` and `b`, and outputs the vector
+ * created by the difference into `dest`
+ */
+f32 OLib_Vec3fDistOutDiff(Vec3f* a, Vec3f* b, Vec3f* dest) {
+    dest->x = a->x - b->x;
+    dest->y = a->y - b->y;
+    dest->z = a->z - b->z;
+
+    return sqrtf(SQ(dest->x) + SQ(dest->y) + SQ(dest->z));
+}
+
+/**
+ * Calculates the distances on the xz plane between `a` and `b`
+ */
+f32 OLib_Vec3fDistXZ(Vec3f* a, Vec3f* b) {
+    return sqrtf(SQ(a->x - b->x) + SQ(a->z - b->z));
+}
+
+/**
+ * Clamps `val` to a maximum of -`min` as `val` approaches zero, and a minimum of
+ * `min` as `val` approaches zero
+ */
+f32 OLib_ClampMinDist(f32 val, f32 min) {
+    if (val < 0.0f) {
+        return CLAMP_MAX(val, -min);
+    } else {
+        return CLAMP_MIN(val, min);
+    }
+}
+
+/**
+ * Clamps `val` to a minimum of -`max` as `val` approaches -`max`, and a maximum of `max`
+ * as `val` approaches `max`
+ */
+f32 OLib_ClampMaxDist(f32 val, f32 max) {
+    if (val < 0.0f) {
+        return CLAMP_MIN(val, -max);
+    } else {
+        return CLAMP_MAX(val, max);
+    }
+}
+
+/**
+ * Takes the difference of points b and a, and creates a normal vector
+ */
+Vec3f* OLib_Vec3fDistNormalize(Vec3f* dest, Vec3f* a, Vec3f* b) {
+    Vec3f v1;
+    Vec3f v2;
+    f32 dist;
+
+    v1.x = b->x - a->x;
+    v1.y = b->y - a->y;
+    v1.z = b->z - a->z;
+
+    dist = OLib_ClampMinDist(sqrtf(SQ(v1.x) + SQ(v1.y) + SQ(v1.z)), 0.01f);
+
+    v2.x = v1.x / dist;
+    v2.y = v1.y / dist;
+    v2.z = v1.z / dist;
+
+    *dest = v2;
+
+    return dest;
+}
+
+/**
+ * Takes the spherical coordinate `sph`, and converts it into a x,y,z position
+ */
+Vec3f* OLib_VecSphToVec3f(Vec3f* dest, VecSph* sph) {
+    Vec3f v;
+    f32 sinPitch;
+    f32 cosPitch = Math_CosS(sph->pitch);
+    f32 sinYaw;
+    f32 cosYaw = Math_CosS(sph->yaw);
+
+    sinPitch = Math_SinS(sph->pitch);
+    sinYaw = Math_SinS(sph->yaw);
+
+    v.x = sph->r * sinPitch * sinYaw;
+    v.y = sph->r * cosPitch;
+    v.z = sph->r * sinPitch * cosYaw;
+
+    *dest = v;
+
+    return dest;
+}
+
+/**
+ * Takes the geographic point `sph` and converts it into a x,y,z position
+ */
+Vec3f* OLib_VecSphGeoToVec3f(Vec3f* dest, VecSph* sph) {
+    VecSph geo;
+
+    geo.r = sph->r;
+    geo.pitch = 0x4000 - sph->pitch;
+    geo.yaw = sph->yaw;
+
+    return OLib_VecSphToVec3f(dest, &geo);
+}
+
+/**
+ * Takes the point `vec`, and converts it into a spherical coordinate
+ */
+VecSph* OLib_Vec3fToVecSph(VecSph* dest, Vec3f* vec) {
+    VecSph sph;
+    f32 distSquared = SQ(vec->x) + SQ(vec->z);
+    f32 dist = sqrtf(distSquared);
+
+    if ((dist == 0.0f) && (vec->y == 0.0f)) {
+        sph.pitch = 0;
+    } else {
+        sph.pitch = DEGF_TO_BINANG(RADF_TO_DEGF(func_80086B30(dist, vec->y)));
+    }
+
+    sph.r = sqrtf(SQ(vec->y) + distSquared);
+    if ((vec->x == 0.0f) && (vec->z == 0.0f)) {
+        sph.yaw = 0;
+    } else {
+        sph.yaw = DEGF_TO_BINANG(RADF_TO_DEGF(func_80086B30(vec->x, vec->z)));
+    }
+
+    *dest = sph;
+
+    return dest;
+}
+
+/**
+ * Takes the point `vec`, and converts it to a geographic coordinate
+ */
+VecSph* OLib_Vec3fToVecSphGeo(VecSph* dest, Vec3f* vec) {
+    VecSph sph;
+
+    OLib_Vec3fToVecSph(&sph, vec);
+    sph.pitch = 0x4000 - sph.pitch;
+
+    *dest = sph;
+
+    return dest;
+}
+
+/**
+ * Takes the differences of positions `a` and `b`, and converts them to spherical coordinates
+ */
+VecSph* OLib_Vec3fDiffToVecSph(VecSph* dest, Vec3f* a, Vec3f* b) {
+    Vec3f sph;
+
+    sph.x = b->x - a->x;
+    sph.y = b->y - a->y;
+    sph.z = b->z - a->z;
+
+    return OLib_Vec3fToVecSph(dest, &sph);
+}
+
+/**
+ * Takes the difference of positions `a` and `b`, and converts them to geographic coordinates
+ */
+VecSph* OLib_Vec3fDiffToVecSphGeo(VecSph* dest, Vec3f* a, Vec3f* b) {
+    Vec3f sph;
+
+    sph.x = b->x - a->x;
+    sph.y = b->y - a->y;
+    sph.z = b->z - a->z;
+
+    return OLib_Vec3fToVecSphGeo(dest, &sph);
+}
+
+/**
+ * Takes the sum of positions `a` (x,y,z coordinates) and `sph` (geographic coordinates), result is in x,y,z position
+ */
+Vec3f* OLib_VecSphToVec3fSum(Vec3f* dest, Vec3f* a, VecSph* sph) {
+    Vec3f vec;
+    Vec3f b;
+
+    OLib_VecSphGeoToVec3f(&b, sph);
+    vec.x = a->x + b.x;
+    vec.y = a->y + b.y;
+    vec.z = a->z + b.z;
+
+    *dest = vec;
+
+    return dest;
+}
+
+/**
+ * Gets the pitch/yaw of the vector formed from `b`-`a`, result is in radians
+ */
+Vec3f* OLib_Vec3fDiffRad(Vec3f* dest, Vec3f* a, Vec3f* b) {
+    Vec3f anglesRad;
+
+    anglesRad.x = func_80086B30(b->z - a->z, b->y - a->y);
+    anglesRad.y = func_80086B30(b->x - a->x, b->z - a->z);
+    anglesRad.z = 0;
+
+    *dest = anglesRad;
+
+    return dest;
+}
+
+/**
+ * Gets the pitch/yaw of the vector formed from `b`-`a`, result is in degrees
+ */
+Vec3f* OLib_Vec3fDiffDegF(Vec3f* dest, Vec3f* a, Vec3f* b) {
+    Vec3f anglesRad;
+    Vec3f anglesDegrees;
+
+    OLib_Vec3fDiffRad(&anglesRad, a, b);
+
+    anglesDegrees.x = RADF_TO_DEGF(anglesRad.x);
+    anglesDegrees.y = RADF_TO_DEGF(anglesRad.y);
+    anglesDegrees.z = 0.0f;
+
+    *dest = anglesDegrees;
+
+    return dest;
+}
+
+/**
+ * Gets the pitch/yaw of the vector formed from `b`-`a`, result is in binary degrees
+ */
+Vec3s* OLib_Vec3fDiffBinAng(Vec3s* dest, Vec3f* a, Vec3f* b) {
+    Vec3f anglesRad;
+    Vec3s anglesBinAng;
+
+    OLib_Vec3fDiffRad(&anglesRad, a, b);
+
+    anglesBinAng.x = DEGF_TO_BINANG(RADF_TO_DEGF(anglesRad.x));
+    anglesBinAng.y = DEGF_TO_BINANG(RADF_TO_DEGF(anglesRad.y));
+    anglesBinAng.z = 0.0f;
+
+    *dest = anglesBinAng;
+
+    return dest;
+}
+
+/**
+ * Gets a x,y,z position diff depending on the dbCamera mode
+ */
+void OLib_DbCameraVec3fDiff(PosRot* a, Vec3f* b, Vec3f* dest, s16 mode) {
+    VecSph sph;
+
+    switch (mode) {
+        case 1:
+            OLib_Vec3fDiffToVecSphGeo(&sph, &a->pos, b);
+            sph.yaw -= a->rot.y;
+            OLib_VecSphGeoToVec3f(dest, &sph);
+            break;
+        case 2:
+            dest->x = b->x - a->pos.x;
+            dest->y = b->y - a->pos.y;
+            dest->z = b->z - a->pos.z;
+            break;
+        default:
+            *dest = *b;
+            break;
+    }
+}
+
+/**
+ * Gets a x,y,z position sum depending on the dbCamera mode
+ */
+void OLib_DbCameraVec3fSum(PosRot* a, Vec3f* b, Vec3f* dest, s16 mode) {
+    VecSph sph;
+
+    switch (mode) {
+        case 1:
+            OLib_Vec3fToVecSphGeo(&sph, b);
+            sph.yaw += a->rot.y;
+            OLib_VecSphToVec3fSum(dest, &a->pos, &sph);
+            break;
+        case 2:
+            dest->x = a->pos.x + b->x;
+            dest->y = a->pos.y + b->y;
+            dest->z = a->pos.z + b->z;
+            break;
+        default:
+            *dest = *b;
+            break;
+    }
+}

src/code/z_snap.c

@@ -122,7 +122,7 @@ s32 func_8013A530(GlobalContext* globalCtx, Actor* actor, s32 flag, Vec3f* pos,
 
     camera = ACTIVE_CAM;
 
-    distance = CamMath_Distance(pos, &camera->eye);
+    distance = OLib_Vec3fDist(pos, &camera->eye);
     if ((distance < distanceMin) || (distanceMax < distance)) {
         func_8013A41C(0x3f);
         ret = 0x3f;

src/overlays/actors/ovl_Door_Ana/z_door_ana.c

@@ -197,7 +197,7 @@ void DoorAna_Update(Actor* thisx, GlobalContext* globalCtx) {
     DoorAna* this = THIS;
 
     this->actionFunc(this, globalCtx);
-    this->actor.shape.rot.y = func_800DFCDC(globalCtx->cameraPtrs[globalCtx->activeCamera]) + 0x8000;
+    this->actor.shape.rot.y = BINANG_ROT180(func_800DFCDC(globalCtx->cameraPtrs[globalCtx->activeCamera]));
 }
 
 void DoorAna_Draw(Actor* thisx, GlobalContext* globalCtx) {

src/overlays/actors/ovl_En_Nutsball/z_en_nutsball.c

@@ -106,7 +106,7 @@ void EnNutsball_Update(Actor* thisx, GlobalContext* globalCtx) {
                 (this->collider.base.atFlags & AT_TYPE_ENEMY) && (this->collider.base.atFlags & AT_BOUNCED)) {
                 EnNutsball_InitColliderParams(this);
                 func_8018219C(&player->shieldMf, &worldRot, 0);
-                this->actor.world.rot.y = worldRot.y + 0x8000;
+                this->actor.world.rot.y = BINANG_ROT180(worldRot.y);
                 this->timer = 20;
             } else {
                 spawnBurstPos.x = this->actor.world.pos.x;

src/overlays/actors/ovl_En_Pametfrog/z_en_pametfrog.c

@@ -310,7 +310,7 @@ void EnPametfrog_ShakeCamera(EnPametfrog* this, GlobalContext* globalCtx, f32 ma
     s16 y;
     Vec3f eye;
 
-    y = func_800DFCDC(camera) + 0x8000;
+    y = BINANG_ROT180(func_800DFCDC(camera));
     eye.x = (Math_SinS(y) * magShakeXZ) + camera->focalPoint.x;
     eye.y = camera->focalPoint.y + magShakeY;
     eye.z = (Math_CosS(y) * magShakeXZ) + camera->focalPoint.z;
@@ -340,7 +340,7 @@ void EnPametfrog_PlaceSnapper(EnPametfrog* this, GlobalContext* globalCtx) {
     poly = NULL;
     this->actor.child->world.pos.x = (Math_SinS(this->actor.shape.rot.y) * 300.0f) + this->actor.world.pos.x;
     this->actor.child->world.pos.z = (Math_CosS(this->actor.shape.rot.y) * 300.0f) + this->actor.world.pos.z;
-    this->actor.child->shape.rot.y = this->actor.shape.rot.y + 0x8000;
+    this->actor.child->shape.rot.y = BINANG_ROT180(this->actor.shape.rot.y);
     vec2.x = this->actor.child->world.pos.x;
     vec2.y = this->actor.child->world.pos.y + 50.0f;
     vec2.z = this->actor.child->world.pos.z;
@@ -482,7 +482,7 @@ void EnPametfrog_SetupFallOffSnapper(EnPametfrog* this, GlobalContext* globalCtx
     this->actor.params = ENPAMETFROG_FALL_OFF_SNAPPER;
     this->actor.speedXZ = 7.0f;
     this->actor.velocity.y = 15.0f;
-    this->actor.world.rot.y = this->actor.child->world.rot.y + 0x8000;
+    this->actor.world.rot.y = BINANG_ROT180(this->actor.child->world.rot.y);
     this->actor.shape.rot.y = this->actor.world.rot.y;
     this->actor.flags |= 1;
     this->timer = 30;
@@ -506,7 +506,7 @@ void EnPametfrog_FallOffSnapper(EnPametfrog* this, GlobalContext* globalCtx) {
         this->timer--;
     }
 
-    sin = sin_rad(this->timer * (M_PI / 3.0f)) * ((0.02f * (this->timer * (1.0f / 6.0f))) + 0.005f) + 1.0f;
+    sin = sin_rad(this->timer * (M_PI / 3)) * ((0.02f * (this->timer * (1.0f / 6.0f))) + 0.005f) + 1.0f;
     EnPametfrog_ShakeCamera(this, globalCtx, 300.0f * sin, 100.0f * sin);
     if (this->actor.bgCheckFlags & 1) {
         EnPametfrog_StopCutscene(this, globalCtx);
@@ -644,7 +644,7 @@ void EnPametfrog_SetupWallPause(EnPametfrog* this) {
     this->actor.speedXZ = 0.0f;
     this->skelAnime.animPlaybackSpeed = 1.5f;
     if (this->timer != 0) {
-        this->wallRotation = this->unk_2E8.y > 0.0f ? (M_PI / 30.0f) : (-M_PI / 30.0f);
+        this->wallRotation = this->unk_2E8.y > 0.0f ? (M_PI / 30) : (-M_PI / 30);
     } else {
         randFloat = Rand_ZeroFloat(0x2000);
         this->wallRotation = (Rand_ZeroOne() < 0.5f ? -1 : 1) * (0x1000 + randFloat) * (M_PI / (15 * 0x8000));
@@ -931,7 +931,7 @@ void EnPametfrog_SetupSpawnFrog(EnPametfrog* this, GlobalContext* globalCtx) {
     static Vec3f sAccel = { 0.0f, -0.5f, 0.0f };
     static Color_RGBA8 primColor = { 250, 250, 250, 255 };
     static Color_RGBA8 envColor = { 180, 180, 180, 255 };
-    s16 yaw = func_800DFCDC(ACTIVE_CAM) + 0x8000;
+    s16 yaw = BINANG_ROT180(func_800DFCDC(ACTIVE_CAM));
     Vec3f vec1;
     Vec3f vel;
     s32 i;
@@ -961,7 +961,7 @@ void EnPametfrog_SpawnFrog(EnPametfrog* this, GlobalContext* globalCtx) {
     f32 magShake;
 
     this->timer--;
-    magShake = (sin_rad(this->timer * (M_PI / 5.0f)) * ((0.04f * (this->timer * 0.1f)) + 0.02f)) + 1.0f;
+    magShake = (sin_rad(this->timer * (M_PI / 5)) * ((0.04f * (this->timer * 0.1f)) + 0.02f)) + 1.0f;
     EnPametfrog_ShakeCamera(this, globalCtx, 75.0f * magShake, 10.0f * magShake);
     if (this->timer == 0) {
         EnPametfrog_StopCutscene(this, globalCtx);
@@ -1099,7 +1099,7 @@ void func_8086CB4C(EnPametfrog* this) {
     Audio_PlayActorSound2(&this->actor, NA_SE_EN_FROG_DAMAGE);
     func_800BCB70(&this->actor, 0x4000, 0xFF, 0, 20);
     func_800BE5CC(&this->actor, &this->collider, 0);
-    this->actor.shape.rot.y = this->actor.world.rot.y + 0x8000;
+    this->actor.shape.rot.y = BINANG_ROT180(this->actor.world.rot.y);
     this->actionFunc = func_8086CC04;
 }
 

src/overlays/actors/ovl_En_Sb/z_en_sb.c

@@ -218,7 +218,7 @@ void EnSb_WaitOpen(EnSb* this, GlobalContext* globalCtx) {
 }
 
 void EnSb_TurnAround(EnSb* this, GlobalContext* globalCtx) {
-    s16 invertedYaw = this->yawAngle + 0x8000;
+    s16 invertedYaw = BINANG_ROT180(this->yawAngle);
 
     Math_SmoothStepToS(&this->actor.shape.rot.y, invertedYaw, 1, 0x1F40, 0xA);
     if (this->actor.shape.rot.y == invertedYaw) {