Merge pull request #17 from glankk/code_800FCE80

code_800FCE80 OK

src/code/code_8007BF90.c

@@ -121,8 +121,8 @@ Vec3f* func_8007C4E0(Vec3f* dest, Vec3f* a, Vec3f* b)
 {
     Vec3f var;
 
-    var.x = func_800FD250(b->z - a->z, b->y - a->y);
-    var.y = func_800FD250(b->x - a->x, b->z - a->z);
+    var.x = Math_atan2f(b->z - a->z, b->y - a->y);
+    var.y = Math_atan2f(b->x - a->x, b->z - a->z);
     var.z = 0;
 
     *dest = var;

src/code/code_800FCE80.c

@@ -0,0 +1,229 @@
+#include <ultra64.h>
+#include <global.h>
+#include <fp.h>
+
+s32 use_cfrac;
+
+f32 Math_tanf(f32 x)
+{
+    f32 sin = sinf(x);
+    f32 cos = cosf(x);
+    return sin / cos;
+}
+
+f32 Math_floorf(f32 x)
+{
+    return floorf(x);
+}
+
+f32 Math_ceilf(f32 x)
+{
+    return ceilf(x);
+}
+
+f32 Math_roundf(f32 x)
+{
+    return roundf(x);
+}
+
+f32 Math_truncf(f32 x)
+{
+    return truncf(x);
+}
+
+f32 Math_nearbyintf(f32 x)
+{
+    return nearbyintf(x);
+}
+
+/* Arctangent approximation using a Taylor series (one quadrant) */
+f32 Math_atanf_taylor_q(f32 x)
+{
+    static const f32 coeffs[] =
+    {
+        -1.f / 3,
+        +1.f / 5,
+        -1.f / 7,
+        +1.f / 9,
+        -1.f / 11,
+        +1.f / 13,
+        -1.f / 15,
+        +1.f / 17,
+        0.f,
+    };
+
+    f32 poly = x;
+    f32 sq = SQ(x);
+    f32 exp = x * sq;
+    const f32 *c = coeffs;
+    f32 term;
+
+    while (1)
+    {
+        term = *c++ * exp;
+        if (poly + term == poly)
+        {
+            break;
+        }
+        poly = poly + term;
+        exp = exp * sq;
+    }
+
+    return poly;
+}
+
+/* Ditto for two quadrants */
+f32 Math_atanf_taylor(f32 x)
+{
+    f32 t;
+    f32 q;
+
+    if (x > 0.f)
+    {
+        t = x;
+    }
+    else if (x < 0.f)
+    {
+        t = -x;
+    }
+    else if (x == 0.f)
+    {
+        return 0.f;
+    }
+    else
+    {
+        return qNaN0x10000;
+    }
+
+    if (t <= M_SQRT2 - 1.f)
+    {
+        return Math_atanf_taylor_q(x);
+    }
+
+    if (t >= M_SQRT2 + 1.f)
+    {
+        q = M_PI / 2 - Math_atanf_taylor_q(1.f / t);
+    }
+    else
+    {
+        q = M_PI / 4 - Math_atanf_taylor_q((1.f - t) / (1.f + t));
+    }
+
+    if (x > 0.f)
+    {
+        return q;
+    }
+    else
+    {
+        return -q;
+    }
+}
+
+/* Arctangent approximation using a continued fraction */
+f32 Math_atanf_cfrac(f32 x)
+{
+    s32 sector;
+    f32 z;
+    f32 conv;
+    f32 sq;
+    s32 i;
+
+    if (x >= -1.f && x <= 1.f)
+    {
+        sector = 0;
+    }
+    else if (x > 1.f)
+    {
+        sector = 1;
+        x = 1.f / x;
+    }
+    else if (x < -1.f)
+    {
+        sector = -1;
+        x = 1.f / x;
+    }
+    else
+    {
+        return qNaN0x10000;
+    }
+
+    sq = SQ(x);
+    conv = 0.f;
+    z = 8.f;
+    for (i = 8; i != 0; i--)
+    {
+        conv = SQ(z) * sq / (2.f * z + 1.f + conv);
+        z -= 1.f;
+    }
+    conv = x / (1.f + conv);
+
+    if (sector == 0)
+    {
+        return conv;
+    }
+    else if (sector > 0)
+    {
+        return M_PI / 2 - conv;
+    }
+    else
+    {
+        return -M_PI / 2 - conv;
+    }
+}
+
+f32 Math_atanf(f32 x)
+{
+    if (use_cfrac == 0)
+    {
+        return Math_atanf_taylor(x);
+    }
+    else
+    {
+        return Math_atanf_cfrac(x);
+    }
+}
+
+f32 Math_atan2f(f32 y, f32 x)
+{
+    if (x == 0.f)
+    {
+        if (y == 0.f)
+        {
+            return 0.f;
+        }
+        else if (y > 0.f)
+        {
+            return M_PI / 2;
+        }
+        else if (y < 0.f)
+        {
+            return -M_PI / 2;
+        }
+        else
+        {
+            return qNaN0x10000;
+        }
+    }
+    else if (x >= 0.f)
+    {
+        return Math_atanf(y / x);
+    }
+    else if (y < 0.f)
+    {
+        return Math_atanf(y / x) - M_PI;
+    }
+    else
+    {
+        return M_PI - Math_atanf(-(y / x));
+    }
+}
+
+f32 Math_asinf(f32 x)
+{
+    return Math_atan2f(x, sqrtf(1.f - SQ(x)));
+}
+
+f32 Math_acosf(f32 x)
+{
+    return M_PI / 2 - Math_asinf(x);
+}

src/code/sys_matrix.c

@@ -792,22 +792,22 @@ void func_800D1FD4(MtxF* mf)
 // same differences as func_800D2264
 void func_800D20CC(MtxF* mf, Vec3s* vec, s32 flag)
 {
-    vec->x = func_800FD250(-mf->zy, sqrtf(SQ(mf->zx) + SQ(mf->zz))) * (32768 / M_PI);
+    vec->x = Math_atan2f(-mf->zy, sqrtf(SQ(mf->zx) + SQ(mf->zz))) * (32768 / M_PI);
 
     if ((vec->x == 0x4000) || (vec->x == -0x4000))
     {
         vec->z = 0;
-        vec->y = func_800FD250(-mf->xz, mf->xx) * (32768 / M_PI);
+        vec->y = Math_atan2f(-mf->xz, mf->xx) * (32768 / M_PI);
         return;
     }
 
-    vec->y = func_800FD250(mf->zx, mf->zz) * (32768 / M_PI);
+    vec->y = Math_atan2f(mf->zx, mf->zz) * (32768 / M_PI);
 
     if (!flag)
-        vec->z = func_800FD250(mf->xy, mf->yy) * (32768 / M_PI);
+        vec->z = Math_atan2f(mf->xy, mf->yy) * (32768 / M_PI);
     else
-        vec->z = func_800FD250(mf->xy / sqrtf(SQ(mf->xx) + SQ(mf->xz) + SQ(mf->xy)), 
-                               mf->yy / sqrtf(SQ(mf->yx) + SQ(mf->yz) + SQ(mf->yy))) * (32768 / M_PI);
+        vec->z = Math_atan2f(mf->xy / sqrtf(SQ(mf->xx) + SQ(mf->xz) + SQ(mf->xy)), 
+                             mf->yy / sqrtf(SQ(mf->yx) + SQ(mf->yz) + SQ(mf->yy))) * (32768 / M_PI);
 }
 #else
 #pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/func_800D20CC.s")
@@ -817,22 +817,22 @@ void func_800D20CC(MtxF* mf, Vec3s* vec, s32 flag)
 // same differences as func_800D20CC
 void func_800D2264(MtxF* mf, Vec3s* vec, s32 flag)
 {
-    vec->y = func_800FD250(-mf->xz, sqrtf(SQ(mf->xx) + SQ(mf->xy))) * (32768 / M_PI);
+    vec->y = Math_atan2f(-mf->xz, sqrtf(SQ(mf->xx) + SQ(mf->xy))) * (32768 / M_PI);
 
     if ((vec->y == 0x4000) || (vec->y == -0x4000))
     {
         vec->x = 0;
-        vec->z = func_800FD250(-mf->yx, mf->yy) * (32768 / M_PI);
+        vec->z = Math_atan2f(-mf->yx, mf->yy) * (32768 / M_PI);
         return;
     }
 
-    vec->z = func_800FD250(mf->xy, mf->xx) * (32768 / M_PI);
+    vec->z = Math_atan2f(mf->xy, mf->xx) * (32768 / M_PI);
 
     if (!flag)
-        vec->x = func_800FD250(mf->yz, mf->zz) * (32768 / M_PI);
+        vec->x = Math_atan2f(mf->yz, mf->zz) * (32768 / M_PI);
     else
-        vec->x = func_800FD250(mf->yz / sqrtf(SQ(mf->yx) + SQ(mf->yy) + SQ(mf->yz)), 
-                               mf->zz / sqrtf(SQ(mf->zx) + SQ(mf->zy) + SQ(mf->zz))) * (32768 / M_PI);
+        vec->x = Math_atan2f(mf->yz / sqrtf(SQ(mf->yx) + SQ(mf->yy) + SQ(mf->yz)), 
+                             mf->zz / sqrtf(SQ(mf->zx) + SQ(mf->zy) + SQ(mf->zz))) * (32768 / M_PI);
 }
 #else
 #pragma GLOBAL_ASM("asm/non_matchings/code/sys_matrix/func_800D2264.s")

src/code/z_actor.c

@@ -88,7 +88,7 @@ void func_8002B66C(GlobalContext* globalCtx, Light* light, MtxF* arg2, s32 arg3,
     gDPSetPrimColor(gfxCtx->polyOpa.p++, 0, 0, 0, 0, 0,
                     (u32)(((arg3 * 0.00005f) > 1.0f ? 1.0f : (arg3 * 0.00005f)) * arg4) & 0xFF);
 
-    sp58 = func_800FD250(light->l.dir[0], light->l.dir[2]);
+    sp58 = Math_atan2f(light->l.dir[0], light->l.dir[2]);
     arg6 *= (4.5f - (light->l.dir[1] * 0.035f));
     arg6 = (arg6 < 1.0f) ? 1.0f : arg6;
     Matrix_Put(arg2);
@@ -4688,12 +4688,12 @@ void func_800359B8(Actor* actor, s16 arg1, Vec3s* arg2)
         sp38 = Math_Sins(arg1);
         sp34 = Math_Coss(arg1);
         sp28 = (-(sp44 * sp38) - (sp3C * sp34));
-        arg2->x = -(s16)(func_800FD250(sp28 * sp40, 1.0f) * (32768 / M_PI));
+        arg2->x = -(s16)(Math_atan2f(sp28 * sp40, 1.0f) * (32768 / M_PI));
 
         sp2C = Math_Sins(arg1 - 16375);
         sp30 = Math_Coss(arg1 - 16375);
         sp24 = (-(sp44 * sp2C) - (sp3C * sp30));
-        arg2->z = -(s16)(func_800FD250(sp24 * sp40, 1.0f) * (32768 / M_PI));
+        arg2->z = -(s16)(Math_atan2f(sp24 * sp40, 1.0f) * (32768 / M_PI));
     }
 }
 

src/code/z_camera.c

@@ -383,7 +383,7 @@ f32 func_800449AC(Camera *camera, Vec3f *b, s32 *arg2)
 
 s16 func_80044A74(Vec3f *a, Vec3f *b)
 {
-    return func_800FD250(b->x - a->x, b->z - a->z) * (180 / M_PI) * (32767.5f / 180) + 0.5f;
+    return Math_atan2f(b->x - a->x, b->z - a->z) * (180 / M_PI) * (32767.5f / 180) + 0.5f;
 }
 
 // 234 lines
@@ -505,7 +505,7 @@ s32 func_800458D4(Camera *camera, struct_80045714 *b, f32 c, f32 *d, s16 e)
         sp60.y -= func_80045714(&camera->unk_108, temp_s1->rot.y, b->unk_06, OREG(9));
     
     sp48 = temp_s1->pos.y - *d;
-    temp_ret = func_800FD250(sp48, func_8007C028(&camera->unk_50, &camera->unk_5C)); // f2 and f14 are swapped
+    temp_ret = Math_atan2f(sp48, func_8007C028(&camera->unk_50, &camera->unk_5C)); // f2 and f14 are swapped
     
     if (OREG(32) * (M_PI / 180) < temp_ret)
         phi_f2 = 1.0f - sinf(temp_ret - OREG(32) * (M_PI / 180));
@@ -600,8 +600,8 @@ s32 func_80045C74(Camera *camera, struct_80045714 *b, f32 c, f32 *d, s16 arg4)
         if (PREG(75) == 0)
         {
             sp54 = func_8007C028(&camera->unk_50, &camera->unk_5C);
-            func_800FD250(temp, sp54);
-            temp_f2 = func_800FCE80(camera->unk_FC * 0.4f * (M_PI / 180)) * sp54;
+            Math_atan2f(temp, sp54);
+            temp_f2 = Math_tanf(camera->unk_FC * 0.4f * (M_PI / 180)) * sp54;
             
             if (temp > temp_f2)
             {
@@ -621,7 +621,7 @@ s32 func_80045C74(Camera *camera, struct_80045714 *b, f32 c, f32 *d, s16 arg4)
         }
         else
         {
-            temp_ret_3 = func_800FD250(temp, func_8007C028(&camera->unk_50, &camera->unk_5C));
+            temp_ret_3 = Math_atan2f(temp, func_8007C028(&camera->unk_50, &camera->unk_5C));
             
             if (OREG(32) * (M_PI / 180) < temp_ret_3)
                 phi_f16 = 1.0f - sinf(temp_ret_3 - OREG(32) * (M_PI / 180));