Library/Math: Implement some MathUtil functions (#509)

data/odyssey_functions.csv

@@ -58636,67 +58636,67 @@ Address,Quality,Size,Name
 0x000000710091db88,O,000064,_ZNK2al10InOutParam15calcSquareValueEf
 0x000000710091dbc8,U,000016,_ZN2al15IntervalTriggerC2Ef
 0x000000710091dbd8,U,000120,_ZN2al15IntervalTrigger6updateEf
-0x000000710091dc50,U,000140,_ZN2al15calcAngleRadianERKN4sead7Vector3IfEES4_
-0x000000710091dcdc,U,000156,_ZN2al15calcAngleDegreeERKN4sead7Vector3IfEES4_
-0x000000710091dd78,U,000116,_ZN2al15calcAngleDegreeERKN4sead7Vector2IfEES4_
-0x000000710091ddec,U,000032,_ZN2al10isNearZeroERKN4sead7Vector2IfEEf
-0x000000710091de0c,U,000256,_ZN2al18tryCalcAngleDegreeEPfRKN4sead7Vector3IfEES5_
-0x000000710091df0c,U,000044,_ZN2al10isNearZeroERKN4sead7Vector3IfEEf
-0x000000710091df38,U,000300,_ZN2al22calcAngleOnPlaneRadianERKN4sead7Vector3IfEES4_S4_
-0x000000710091e064,U,000092,_ZN2al14verticalizeVecEPN4sead7Vector3IfEERKS2_S5_
-0x000000710091e0c0,U,000312,_ZN2al22calcAngleOnPlaneDegreeERKN4sead7Vector3IfEES4_S4_
-0x000000710091e1f8,U,000076,_ZN2al28calcAngleOnPlaneDegreeOrZeroERKN4sead7Vector3IfEES4_S4_
+0x000000710091dc50,O,000140,_ZN2al15calcAngleRadianERKN4sead7Vector3IfEES4_
+0x000000710091dcdc,O,000156,_ZN2al15calcAngleDegreeERKN4sead7Vector3IfEES4_
+0x000000710091dd78,O,000116,_ZN2al15calcAngleDegreeERKN4sead7Vector2IfEES4_
+0x000000710091ddec,O,000032,_ZN2al10isNearZeroERKN4sead7Vector2IfEEf
+0x000000710091de0c,O,000256,_ZN2al18tryCalcAngleDegreeEPfRKN4sead7Vector3IfEES5_
+0x000000710091df0c,O,000044,_ZN2al10isNearZeroERKN4sead7Vector3IfEEf
+0x000000710091df38,O,000300,_ZN2al22calcAngleOnPlaneRadianERKN4sead7Vector3IfEES4_S4_
+0x000000710091e064,O,000092,_ZN2al14verticalizeVecEPN4sead7Vector3IfEERKS2_S5_
+0x000000710091e0c0,O,000312,_ZN2al22calcAngleOnPlaneDegreeERKN4sead7Vector3IfEES4_S4_
+0x000000710091e1f8,O,000076,_ZN2al28calcAngleOnPlaneDegreeOrZeroERKN4sead7Vector3IfEES4_S4_
 0x000000710091e244,U,000624,_ZN2al25tryCalcAngleOnPlaneDegreeEPfRKN4sead7Vector3IfEES5_S5_
 0x000000710091e4b4,U,000132,_ZN2al19isParallelDirectionERKN4sead7Vector3IfEES4_f
-0x000000710091e538,U,000188,_ZN2al20calcAngleSignOnPlaneERKN4sead7Vector3IfEES4_S4_
+0x000000710091e538,O,000188,_ZN2al20calcAngleSignOnPlaneERKN4sead7Vector3IfEES4_S4_
 0x000000710091e5f4,U,000284,_ZN2al17isNearAngleRadianERKN4sead7Vector2IfEES4_f
-0x000000710091e710,U,000116,_ZN2al9normalizeEPN4sead7Vector2IfEERKS2_
+0x000000710091e710,O,000116,_ZN2al9normalizeEPN4sead7Vector2IfEERKS2_
 0x000000710091e784,U,000364,_ZN2al17isNearAngleRadianERKN4sead7Vector3IfEES4_f
-0x000000710091e8f0,U,000148,_ZN2al9normalizeEPN4sead7Vector3IfEERKS2_
+0x000000710091e8f0,O,000148,_ZN2al9normalizeEPN4sead7Vector3IfEERKS2_
 0x000000710091e984,U,000292,_ZN2al17isNearAngleDegreeERKN4sead7Vector2IfEES4_f
 0x000000710091eaa8,U,000372,_ZN2al17isNearAngleDegreeERKN4sead7Vector3IfEES4_f
 0x000000710091ec1c,U,000772,_ZN2al19isNearAngleRadianHVERKN4sead7Vector3IfEES4_S4_ff
-0x000000710091ef20,U,000184,_ZN2al18tryNormalizeOrZeroEPN4sead7Vector3IfEERKS2_
-0x000000710091efd8,U,000156,_ZN2al18tryNormalizeOrZeroEPN4sead7Vector3IfEE
-0x000000710091f074,U,000020,_ZN2al19isNearAngleDegreeHVERKN4sead7Vector3IfEES4_S4_ff
+0x000000710091ef20,O,000184,_ZN2al18tryNormalizeOrZeroEPN4sead7Vector3IfEERKS2_
+0x000000710091efd8,O,000156,_ZN2al18tryNormalizeOrZeroEPN4sead7Vector3IfEE
+0x000000710091f074,O,000020,_ZN2al19isNearAngleDegreeHVERKN4sead7Vector3IfEES4_S4_ff
 0x000000710091f088,U,000660,_ZN2al24isInAngleOnPlaneDegreeHVERKN4sead7Vector3IfEES4_S4_ffff
-0x000000710091f31c,U,000040,_ZN2al6isNearEfff
-0x000000710091f344,U,000084,_ZN2al6isNearERKN4sead7Vector2IfEES4_f
-0x000000710091f398,U,000104,_ZN2al6isNearERKN4sead7Vector3IfEES4_f
-0x000000710091f400,U,000156,_ZN2al6isNearERKN4sead7Color4fES3_f
-0x000000710091f49c,U,000024,_ZN2al10isNearZeroEff
-0x000000710091f4b4,U,000144,_ZN2al10isNearZeroERKN4sead8Matrix34IfEEf
-0x000000710091f544,U,000036,_ZN2al19isNearZeroOrGreaterEff
-0x000000710091f568,U,000036,_ZN2al16isNearZeroOrLessEff
-0x000000710091f58c,U,000092,_ZN2al18isExistNearZeroValERKN4sead7Vector3IfEEf
-0x000000710091f5e8,U,000104,_ZN2al11isNormalizeERKN4sead7Vector3IfEEf
+0x000000710091f31c,O,000040,_ZN2al6isNearEfff
+0x000000710091f344,O,000084,_ZN2al6isNearERKN4sead7Vector2IfEES4_f
+0x000000710091f398,O,000104,_ZN2al6isNearERKN4sead7Vector3IfEES4_f
+0x000000710091f400,O,000156,_ZN2al6isNearERKN4sead7Color4fES3_f
+0x000000710091f49c,O,000024,_ZN2al10isNearZeroEff
+0x000000710091f4b4,O,000144,_ZN2al10isNearZeroERKN4sead8Matrix34IfEEf
+0x000000710091f544,O,000036,_ZN2al19isNearZeroOrGreaterEff
+0x000000710091f568,O,000036,_ZN2al16isNearZeroOrLessEff
+0x000000710091f58c,O,000092,_ZN2al18isExistNearZeroValERKN4sead7Vector3IfEEf
+0x000000710091f5e8,O,000104,_ZN2al11isNormalizeERKN4sead7Vector3IfEEf
 0x000000710091f650,U,000312,_ZN2al11isNormalizeERKN4sead8Matrix34IfEE
-0x000000710091f788,U,000044,_ZN2al19isParallelDirectionERKN4sead7Vector2IfEES4_f
+0x000000710091f788,O,000044,_ZN2al19isParallelDirectionERKN4sead7Vector2IfEES4_f
 0x000000710091f7b4,U,000168,_ZN2al18isReverseDirectionERKN4sead7Vector3IfEES4_f
-0x000000710091f85c,U,000072,_ZN2al15isNearDirectionERKN4sead7Vector2IfEES4_f
+0x000000710091f85c,O,000072,_ZN2al15isNearDirectionERKN4sead7Vector2IfEES4_f
 0x000000710091f8a4,U,000168,_ZN2al15isNearDirectionERKN4sead7Vector3IfEES4_f
-0x000000710091f94c,U,000056,_ZN2al9isInRangeEiii
-0x000000710091f984,U,000056,_ZN2al9isInRangeEfff
-0x000000710091f9bc,U,000096,_ZN2al9normalizeEPN4sead7Vector2IfEE
-0x000000710091fa1c,U,000120,_ZN2al9normalizeEPN4sead7Vector3IfEE
+0x000000710091f94c,O,000056,_ZN2al9isInRangeEiii
+0x000000710091f984,O,000056,_ZN2al9isInRangeEfff
+0x000000710091f9bc,O,000096,_ZN2al9normalizeEPN4sead7Vector2IfEE
+0x000000710091fa1c,O,000120,_ZN2al9normalizeEPN4sead7Vector3IfEE
 0x000000710091fa94,U,000392,_ZN2al9normalizeEPN4sead8Matrix33IfEE
 0x000000710091fc1c,U,000400,_ZN2al9normalizeEPN4sead8Matrix34IfEE
-0x000000710091fdac,U,000128,_ZN2al18tryNormalizeOrZeroEPN4sead7Vector2IfEE
-0x000000710091fe2c,U,000148,_ZN2al18tryNormalizeOrZeroEPN4sead7Vector2IfEERKS2_
-0x000000710091fec0,U,000180,_ZN2al18tryNormalizeOrDirZEPN4sead7Vector3IfEE
-0x000000710091ff74,U,000208,_ZN2al18tryNormalizeOrDirZEPN4sead7Vector3IfEERKS2_
+0x000000710091fdac,O,000128,_ZN2al18tryNormalizeOrZeroEPN4sead7Vector2IfEE
+0x000000710091fe2c,O,000148,_ZN2al18tryNormalizeOrZeroEPN4sead7Vector2IfEERKS2_
+0x000000710091fec0,O,000180,_ZN2al18tryNormalizeOrDirZEPN4sead7Vector3IfEE
+0x000000710091ff74,O,000208,_ZN2al18tryNormalizeOrDirZEPN4sead7Vector3IfEERKS2_
 0x0000007100920044,U,001732,_ZN2al19normalizeComplementEPN4sead8Matrix34IfEE
 0x0000007100920708,U,000076,_ZN2al21getMaxAbsElementIndexERKN4sead7Vector3IfEE
-0x0000007100920754,U,000128,_ZN2al9setLengthEPN4sead7Vector3IfEEf
-0x00000071009207d4,U,000076,_ZN2al19setProjectionLengthEPN4sead7Vector3IfEERKS2_f
-0x0000007100920820,U,000136,_ZN2al11limitLengthEPN4sead7Vector2IfEERKS2_f
-0x00000071009208a8,U,000168,_ZN2al11limitLengthEPN4sead7Vector3IfEERKS2_f
-0x0000007100920950,U,000204,_ZN2al12normalizeAbsEfff
+0x0000007100920754,O,000128,_ZN2al9setLengthEPN4sead7Vector3IfEEf
+0x00000071009207d4,O,000076,_ZN2al19setProjectionLengthEPN4sead7Vector3IfEERKS2_f
+0x0000007100920820,O,000136,_ZN2al11limitLengthEPN4sead7Vector2IfEERKS2_f
+0x00000071009208a8,O,000168,_ZN2al11limitLengthEPN4sead7Vector3IfEERKS2_f
+0x0000007100920950,O,000204,_ZN2al12normalizeAbsEfff
 0x0000007100920a1c,O,000092,_ZN2al9normalizeEfff
 0x0000007100920a78,O,000084,_ZN2al9normalizeEiii
 0x0000007100920acc,O,000024,_ZN2al4signEf
 0x0000007100920ae4,O,000016,_ZN2al4signEi
-0x0000007100920af4,U,000132,_ZN2al8cubeRootEf
+0x0000007100920af4,O,000132,_ZN2al8cubeRootEf
 0x0000007100920b78,U,000104,_ZN2al8clampV3fEPN4sead7Vector3IfEERKS2_S5_
 0x0000007100920be0,U,000072,_ZN2al8clampV2fEPN4sead7Vector2IfEERKS2_S5_
 0x0000007100920c28,O,000028,_ZN2al6easeInEf
@@ -58706,12 +58706,12 @@ Address,Quality,Size,Name
 0x0000007100920c84,O,000016,_ZN2al9squareOutEf
 0x0000007100920c94,O,000004,_ZN2al7powerInEff
 0x0000007100920c98,O,000012,_ZN2al8powerOutEff
-0x0000007100920ca4,U,000092,_ZN2al11logarithmInEff
-0x0000007100920d00,U,000096,_ZN2al12logarithmOutEff
-0x0000007100920d60,U,000048,_ZN2al10exponentInEff
-0x0000007100920d90,U,000056,_ZN2al11exponentOutEff
-0x0000007100920dc8,U,000064,_ZN2al11hermiteRateEfff
-0x0000007100920e08,U,000056,_ZN2al19calcFourthOrderRateEff
+0x0000007100920ca4,O,000092,_ZN2al11logarithmInEff
+0x0000007100920d00,O,000096,_ZN2al12logarithmOutEff
+0x0000007100920d60,O,000048,_ZN2al10exponentInEff
+0x0000007100920d90,O,000056,_ZN2al11exponentOutEff
+0x0000007100920dc8,O,000064,_ZN2al11hermiteRateEfff
+0x0000007100920e08,O,000056,_ZN2al19calcFourthOrderRateEff
 0x0000007100920e40,U,000080,_ZN2al18calcTriangleWave01Eff
 0x0000007100920e90,U,000124,_ZN2al16calcTriangleWaveEffff
 0x0000007100920f0c,O,000056,_ZN2al9lerpValueEfff
@@ -58734,8 +58734,8 @@ Address,Quality,Size,Name
 0x0000007100921958,U,000308,_ZN2al21lerpExponentVecEaseInEPN4sead7Vector3IfEERKS2_S5_ff
 0x0000007100921a8c,U,000316,_ZN2al22lerpExponentVecEaseOutEPN4sead7Vector3IfEERKS2_S5_ff
 0x0000007100921bc8,U,000228,_ZN2al15clampLeapMinAbsEffff
-0x0000007100921cac,U,000064,_ZN2al7hermiteEfffff
-0x0000007100921cec,U,000080,_ZN2al7hermiteEffffff
+0x0000007100921cac,O,000064,_ZN2al7hermiteEfffff
+0x0000007100921cec,O,000080,_ZN2al7hermiteEffffff
 0x0000007100921d3c,U,000188,_ZN2al10hermiteVecEPN4sead7Vector3IfEERKS2_S5_S5_S5_f
 0x0000007100921df8,U,000040,_ZN2al8convergeEiii
 0x0000007100921e20,U,000044,_ZN2al8convergeEfff

lib/al/Library/Area/AreaShape.cpp

@@ -22,11 +22,11 @@ void AreaShape::setScale(const sead::Vector3f& scale) {
 }
 
 bool AreaShape::calcLocalPos(sead::Vector3f* localPos, const sead::Vector3f& trans) const {
-    if (isNearZeroOrLess(mScale.x, 0.001))
+    if (isNearZero(mScale.x, 0.001))
         return false;
-    if (isNearZeroOrLess(mScale.y, 0.001))
+    if (isNearZero(mScale.y, 0.001))
         return false;
-    if (isNearZeroOrLess(mScale.z, 0.001))
+    if (isNearZero(mScale.z, 0.001))
         return false;
 
     if (mBaseMtxPtr)

lib/al/Library/Math/MathUtil.cpp

@@ -1,113 +1,430 @@
 #include "Library/Math/MathUtil.h"
 
 #include <math/seadMathCalcCommon.h>
+#include <prim/seadBitUtil.h>
 #include <random/seadGlobalRandom.h>
 
 namespace al {
-f32 normalize(f32 var, f32 min, f32 max) {
+f32 calcAngleRadian(const sead::Vector3f& a, const sead::Vector3f& b) {
+    f32 dot = a.dot(b);
+    sead::Vector3f cross;
+    cross.setCross(a, b);
+    return sead::Mathf::atan2(cross.length(), dot);
+}
+
+f32 calcAngleDegree(const sead::Vector3f& a, const sead::Vector3f& b) {
+    return sead::Mathf::rad2deg(calcAngleRadian(a, b));
+}
+
+f32 calcAngleDegree(const sead::Vector2f& a, const sead::Vector2f& b) {
+    if (isNearZero(a, 0.001) || isNearZero(b, 0.001))
+        return 0.0f;
+
+    return sead::Mathf::rad2deg(sead::Mathf::atan2(a.cross(b), a.dot(b)));
+}
+
+bool isNearZero(const sead::Vector2f& vec, f32 tolerance) {
+    return vec.squaredLength() < tolerance * tolerance;
+}
+
+bool tryCalcAngleDegree(f32* out, const sead::Vector3f& a, const sead::Vector3f& b) {
+    if (isNearZero(a, 0.001) || isNearZero(b, 0.001))
+        return false;
+
+    *out = calcAngleDegree(a, b);
+    return true;
+}
+
+bool isNearZero(const sead::Vector3f& vec, f32 tolerance) {
+    return vec.squaredLength() < tolerance * tolerance;
+}
+
+f32 calcAngleOnPlaneRadian(const sead::Vector3f& a, const sead::Vector3f& b,
+                           const sead::Vector3f& vertical) {
+    sead::Vector3f planeA;
+    verticalizeVec(&planeA, vertical, a);
+    sead::Vector3f planeB;
+    verticalizeVec(&planeB, vertical, b);
+
+    f32 dot = planeA.dot(planeB);
+    sead::Vector3f cross;
+    cross.setCross(planeA, planeB);
+    f32 angle = sead::Mathf::atan2(cross.length(), dot);
+
+    return vertical.dot(cross) < 0.0f ? -angle : angle;
+}
+
+/**
+ * Takes the plane perpendicular to unit vector `vertical`, projects `vec` onto it, and
+ * stores the result in `out`. The effect is that `vec` and `out` will look equal
+ * if looking in the direction of `vertical`.
+ */
+void verticalizeVec(sead::Vector3f* out, const sead::Vector3f& vertical,
+                    const sead::Vector3f& vec) {
+    out->setScaleAdd(-vertical.dot(vec), vertical, vec);
+}
+
+f32 calcAngleOnPlaneDegree(const sead::Vector3f& a, const sead::Vector3f& b,
+                           const sead::Vector3f& vertical) {
+    return sead::Mathf::rad2deg(calcAngleOnPlaneRadian(a, b, vertical));
+}
+
+f32 calcAngleOnPlaneDegreeOrZero(const sead::Vector3f& a, const sead::Vector3f& b,
+                                 const sead::Vector3f& vertical) {
+    f32 angle = 0.0f;
+    if (!tryCalcAngleOnPlaneDegree(&angle, a, b, vertical))
+        return 0.0f;
+
+    return angle;
+}
+
+s32 calcAngleSignOnPlane(const sead::Vector3f& a, const sead::Vector3f& b,
+                         const sead::Vector3f& vertical) {
+    sead::Vector3f planeA;
+    verticalizeVec(&planeA, vertical, a);
+    sead::Vector3f planeB;
+    verticalizeVec(&planeB, vertical, b);
+
+    sead::Vector3f cross;
+    cross.setCross(planeA, planeB);
+    const f32 angle = vertical.dot(cross);
+
+    if (angle > 0.0f)
+        return 1;
+    if (angle < 0.0f)
+        return -1;
+
+    return 0;
+}
+
+void normalize(sead::Vector2f* out, const sead::Vector2f& vec) {
+    *out = vec;
+    normalize(out);
+}
+
+void normalize(sead::Vector3f* out, const sead::Vector3f& vec) {
+    *out = vec;
+    normalize(out);
+}
+
+bool tryNormalizeOrZero(sead::Vector3f* vec) {
+    if (isNearZero(*vec, 0.001f)) {
+        *vec = {0.0f, 0.0f, 0.0f};
+        return false;
+    }
+
+    normalize(vec);
+    return true;
+}
+
+bool tryNormalizeOrZero(sead::Vector3f* out, const sead::Vector3f& vec) {
+    *out = vec;
+    return tryNormalizeOrZero(out);
+}
+
+// TODO: Rename parameters here and in header
+bool isNearAngleDegreeHV(const sead::Vector3f& a, const sead::Vector3f& b, const sead::Vector3f& c,
+                         f32 d, f32 e) {
+    return isNearAngleRadianHV(a, b, c, sead::Mathf::deg2rad(d), sead::Mathf::deg2rad(e));
+}
+
+bool isNear(f32 value, f32 target, f32 tolerance) {
+    return sead::Mathf::abs(value - target) < sead::Mathf::abs(tolerance);
+}
+
+bool isNear(const sead::Vector2f& value, const sead::Vector2f& target, f32 tolerance) {
+    return (value - target).length() <= tolerance;
+}
+
+bool isNear(const sead::Vector3f& value, const sead::Vector3f& target, f32 tolerance) {
+    return (value - target).length() <= tolerance;
+}
+
+bool isNear(const sead::Color4f& value, const sead::Color4f& target, f32 tolerance) {
+    return sead::Mathf::abs(value.r - target.r) < tolerance &&
+           sead::Mathf::abs(value.g - target.g) < tolerance &&
+           sead::Mathf::abs(value.b - target.b) < tolerance &&
+           sead::Mathf::abs(value.a - target.a) < tolerance;
+}
+
+bool isNearZero(f32 value, f32 tolerance) {
+    return sead::Mathf::abs(value) < tolerance;
+}
+
+bool isNearZero(const sead::Matrix34f& value, f32 tolerance) {
+    sead::Vector3f vec;
+
+    value.getBase(vec, 0);
+    if (isNearZero(vec, tolerance))
+        return true;
+    value.getBase(vec, 1);
+    if (isNearZero(vec, tolerance))
+        return true;
+    value.getBase(vec, 2);
+    if (isNearZero(vec, tolerance))
+        return true;
+
+    return false;
+}
+
+bool isNearZeroOrGreater(f32 value, f32 tolerance) {
+    return value >= 0.0f || isNearZero(value, tolerance);
+}
+
+bool isNearZeroOrLess(f32 value, f32 tolerance) {
+    return value <= 0.0f || isNearZero(value, tolerance);
+}
+
+bool isExistNearZeroVal(const sead::Vector3f& vec, f32 tolerance) {
+    return isNearZero(vec.x, tolerance) || isNearZero(vec.y, tolerance) ||
+           isNearZero(vec.z, tolerance);
+}
+
+bool isNormalize(const sead::Vector3f& vec, f32 tolerance) {
+    return sead::Mathf::abs(1.0f - vec.length()) <= tolerance;
+}
+
+bool isParallelDirection(const sead::Vector2f& a, const sead::Vector2f& b, f32 tolerance) {
+    return !(sead::Mathf::abs(a.cross(b)) > tolerance);
+}
+
+bool isNearDirection(const sead::Vector2f& a, const sead::Vector2f& b, f32 tolerance) {
+    if (a.dot(b) < 0.0f)
+        return false;
+
+    return isParallelDirection(a, b, tolerance);
+}
+
+bool isInRange(s32 x, s32 a, s32 b) {
+    return (b < a) ? (a >= x && x >= b) : (b >= x && x >= a);
+}
+
+bool isInRange(f32 x, f32 a, f32 b) {
+    if (b < a) {
+        if (x < b || a < x)
+            return false;
+        return true;
+    } else {
+        if (x < a || b < x)
+            return false;
+        return true;
+    }
+}
+
+void normalize(sead::Vector2f* vec) {
+    vec->normalize();
+}
+
+void normalize(sead::Vector3f* vec) {
+    vec->normalize();
+}
+
+bool tryNormalizeOrZero(sead::Vector2f* vec) {
+    if (isNearZero(*vec, 0.001f)) {
+        *vec = {0.0f, 0.0f};
+        return false;
+    }
+
+    normalize(vec);
+    return true;
+}
+
+bool tryNormalizeOrZero(sead::Vector2f* out, const sead::Vector2f& vec) {
+    *out = vec;
+    return tryNormalizeOrZero(out);
+}
+
+bool tryNormalizeOrDirZ(sead::Vector3f* vec) {
+    if (isNearZero(*vec, 0.001f)) {
+        // mismatches if this isn't set twice
+        vec->set(0.0f, 0.0f, 0.0f);
+        vec->set(sead::Vector3f::ez);
+        return false;
+    }
+
+    normalize(vec);
+    return true;
+}
+
+bool tryNormalizeOrDirZ(sead::Vector3f* out, const sead::Vector3f& vec) {
+    *out = vec;
+    return tryNormalizeOrDirZ(out);
+}
+
+void setLength(sead::Vector3f* vec, f32 length) {
+    f32 curLen = vec->length();
+    if (curLen > 0.0f) {
+        f32 scale = length / curLen;
+        *vec *= scale;
+    }
+}
+
+void setProjectionLength(sead::Vector3f* out, const sead::Vector3f& vec, f32 length) {
+    f32 scale = length / sead::Mathf::abs(vec.dot(*out));
+    *out *= scale;
+}
+
+bool limitLength(sead::Vector2f* out, const sead::Vector2f& vec, f32 limit) {
+    f32 len = vec.length();
+    if (len > limit) {
+        f32 invLen = limit / len;
+        out->setScale(vec, invLen);
+        return true;
+    } else {
+        out->set(vec);
+        return false;
+    }
+}
+
+bool limitLength(sead::Vector3f* out, const sead::Vector3f& vec, f32 limit) {
+    f32 len = vec.length();
+    if (len > limit) {
+        f32 invLen = limit / len;
+        out->setScale(vec, invLen);
+        return true;
+    } else {
+        out->set(vec);
+        return false;
+    }
+}
+
+f32 normalizeAbs(f32 x, f32 min, f32 max) {
+    if (x >= 0)
+        return normalize(x, min, max);
+    else
+        return -normalize(-x, min, max);
+}
+
+f32 normalize(f32 x, f32 min, f32 max) {
     if (sead::Mathf::abs(max - min) < 0.001f) {
-        if (var < min)
+        if (x < min)
             return 0.0f;
         else
             return 1.0f;
     }
 
-    f32 clamped = sead::Mathf::clamp(var, min, max);
+    f32 clamped = sead::Mathf::clamp(x, min, max);
     return (clamped - min) / (max - min);
 }
 
-f32 normalize(s32 var, s32 min, s32 max) {
-    s32 v3;
-    f32 result;
-
-    if (var <= min)
+f32 normalize(s32 x, s32 min, s32 max) {
+    if (x <= min)
         return 0.0f;
-
     if (max - min <= 0) {
-        result = 1.0f;
-
-        if (var < min)
-            result = 0.0f;
-    } else {
-        if (var <= max)
-            v3 = var;
+        if (x < min)
+            return 0.0f;
         else
-            v3 = max;
-
-        if (var < min)
-            v3 = min;
-
-        result = (static_cast<f32>(v3 - min) / static_cast<f32>(max - min));
+            return 1.0f;
     }
 
-    return result;
+    return (static_cast<f32>(clamp(x, min, max) - min) / static_cast<f32>(max - min));
 }
 
-f32 easeIn(f32 var) {
-    return (((var * -0.5f) + 1.5f) * var) * var;
+f32 sign(f32 x) {
+    if (x < 0.0f)
+        return -1.0f;
+    if (x > 0.0f)
+        return 1.0f;
+    return x;
 }
 
-f32 easeOut(f32 var) {
-    return (((var * -0.5f) * var) + 1.5f) * var;
-}
-
-f32 easeInOut(f32 var) {
-    return (((var * -2.0f) + 3.0f) * var) * var;
-}
-
-f32 sign(f32 result) {
-    f32 v1;
-    v1 = result < 0.0f;
-    if (result > 0.0f)
-        result = 1.0f;
-    if (v1)
-        result = -1.0f;
-
-    return result;
-}
-
-s32 sign(s32 var) {
-    if (var < 0)
+s32 sign(s32 x) {
+    if (x < 0)
         return -1;
-    if (var > 0)
+    if (x > 0)
         return 1;
-
-    return 0;
+    return x;
 }
 
-f32 squareIn(f32 var) {
-    return var * var;
+f32 cubeRoot(f32 x) {
+    f32 onethird = 1.0f / 3.0f;
+
+    u32 i = 0x54a0fc86 - sead::BitUtil::bitCast<u32>(x) / 3;
+    f32 y = sead::BitUtil::bitCast<f32>(i);
+
+    y = y * onethird * (4.0f - x * y * y * y);
+    y = y * onethird * (4.0f - x * y * y * y);
+    y = y * onethird * (4.0f - x * y * y * y);
+    return x * y * y;
 }
 
-f32 squareOut(f32 var) {
-    return (2.0f - var) * var;
+f32 easeIn(f32 t) {
+    return (((t * -0.5f) + 1.5f) * t) * t;
 }
 
-f32 powerIn(f32 x, f32 y) {
-    return powf(x, y);
+f32 easeOut(f32 t) {
+    return (((t * -0.5f) * t) + 1.5f) * t;
 }
 
-f32 powerOut(f32 x, f32 y) {
-    return powf(x, 1.0 / y);
+f32 easeInOut(f32 t) {
+    return (((t * -2.0f) + 3.0f) * t) * t;
 }
 
-f32 lerpValue(f32 x, f32 y, f32 time) {
-    if (time < 0.0f)
-        time = 0.0f;
-    else if (time > 1.0f)
-        time = 1.0f;
-    return (x * (1.0f - time)) + (time * y);
+f32 squareIn(f32 t) {
+    return t * t;
 }
 
-void calcParabolicFunctionParam(f32* gravity, f32* initialVelY, f32 maxHeight,
-                                f32 verticalDistance) {
-    // can be 0, 1, or -1
-    f32 signOfA3 = maxHeight < 0.0f ? -1.0f : maxHeight > 0.0f ? 1.0f : maxHeight;
+f32 squareOut(f32 t) {
+    return (2.0f - t) * t;
+}
 
-    f32 maxHeightAdjusted =
-        sead::Mathf::sqrt(sead::Mathf::clampMin((maxHeight - verticalDistance) * maxHeight, 0.0));
-    *initialVelY = 2 * ((signOfA3 * maxHeightAdjusted) + maxHeight);
-    *gravity = verticalDistance - *initialVelY;
+f32 powerIn(f32 t, f32 exp) {
+    return sead::Mathf::pow(t, exp);
+}
+
+f32 powerOut(f32 t, f32 exp) {
+    return sead::Mathf::pow(t, 1.0 / exp);
+}
+
+f32 logarithmIn(f32 t, f32 base) {
+    f32 base1 = base + sead::Mathf::epsilon();
+    f32 a = powf(base1 + 0.0f, 1.0 - t);
+    f32 b = powf(base1 + 1.0f, t);
+    return a * b - base1;
+}
+
+f32 logarithmOut(f32 t, f32 base) {
+    return 1.0f - logarithmIn(1.0f - t, base);
+}
+
+f32 exponentIn(f32 t, f32 exp) {
+    return t * exp2f(exp * (t - 1.0f));
+}
+
+f32 exponentOut(f32 t, f32 exp) {
+    return 1.0f - exponentIn(1.0f - t, exp);
+}
+
+f32 hermiteRate(f32 t, f32 m0, f32 m1) {
+    return hermite(0.0f, m0, 1.0f, m1, t);
+}
+
+f32 lerpValue(f32 a, f32 b, f32 t) {
+    t = sead::Mathf::clamp(t, 0.0f, 1.0f);
+    return (a * (1.0f - t)) + (t * b);
+}
+
+/**
+ * Interpolates between `y0` and `y1` as `t` goes from 0.0 to 1.0. This interpolation is defined by
+ * `m0` and `m1`, which are the rates of change of `t` at the points `y0` and `y1` respectively.
+ */
+f32 hermite(f32 y0, f32 m0, f32 y1, f32 m1, f32 t) {
+    f32 coef_m1 = t * (t * t - t);
+    f32 coef_y1 = t * t + -2.0f * coef_m1;
+    f32 coef_m0 = coef_m1 - (t * t - t);
+    return y0 - coef_y1 * y0 + coef_y1 * y1 + coef_m0 * m0 + coef_m1 * m1;
+}
+
+f32 hermite(f32 y0, f32 m0, f32 y1, f32 m1, f32 t, f32 width) {
+    t *= 1.0f / width;
+    f32 a1 = y0 - y1;
+    f32 a2 = t - 1.0f;
+    f32 a3 = t + t - 3.0f;
+    return y0 + (a1 * a3) * t * t + (t * a2) * (t * m1 + a2 * m0);
+}
+
+f32 calcFourthOrderRate(f32 t, f32 scale) {
+    return ((scale + -3.0f) * t * t + (scale * -2.0f + 4.0f) * t + scale) * t * t;
 }
 
 f32 getRandom() {
@@ -157,4 +474,14 @@ void getRandomDir(sead::Vector3f* vec) {
     vec->normalize();
 }
 
+void calcParabolicFunctionParam(f32* gravity, f32* initialVelY, f32 maxHeight,
+                                f32 verticalDistance) {
+    f32 maxHeightSign = sign(maxHeight);
+
+    f32 maxHeightAdjusted =
+        sead::Mathf::sqrt(sead::Mathf::clampMin((maxHeight - verticalDistance) * maxHeight, 0.0));
+    *initialVelY = 2 * ((maxHeightSign * maxHeightAdjusted) + maxHeight);
+    *gravity = verticalDistance - *initialVelY;
+}
+
 }  // namespace al

lib/al/Library/Math/MathUtil.h

@@ -27,31 +27,34 @@ enum EaseType : s32 {
     EaseType_SquareOut
 };
 
-f32 calcAngleRadian(const sead::Vector3f&, const sead::Vector3f&);
-f32 calcAngleDegree(const sead::Vector3f&, const sead::Vector3f&);
-f32 calcAngleDegree(const sead::Vector2f&, const sead::Vector2f&);
+f32 calcAngleRadian(const sead::Vector3f& a, const sead::Vector3f& b);
+f32 calcAngleDegree(const sead::Vector3f& a, const sead::Vector3f& b);
+f32 calcAngleDegree(const sead::Vector2f& a, const sead::Vector2f& b);
 bool isNearZero(const sead::Vector2f& vec, f32 tolerance = 0.001f);
-bool tryCalcAngleDegree(f32*, const sead::Vector3f&, const sead::Vector3f&);
+bool tryCalcAngleDegree(f32* angle, const sead::Vector3f& a, const sead::Vector3f& b);
 bool isNearZero(const sead::Vector3f& vec, f32 tolerance = 0.001f);
-f32 calcAngleOnPlaneRadian(const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&);
+f32 calcAngleOnPlaneRadian(const sead::Vector3f& a, const sead::Vector3f& b,
+                           const sead::Vector3f& vertical);
 void verticalizeVec(sead::Vector3f* out, const sead::Vector3f& vertical, const sead::Vector3f& vec);
-f32 calcAngleOnPlaneDegree(const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&);
-f32 calcAngleOnPlaneDegreeOrZero(const sead::Vector3f&, const sead::Vector3f&,
-                                 const sead::Vector3f&);
-bool tryCalcAngleOnPlaneDegree(f32*, const sead::Vector3f&, const sead::Vector3f&,
-                               const sead::Vector3f&);
-bool isParallelDirection(const sead::Vector3f&, const sead::Vector3f&, f32);
-s32 calcAngleSignOnPlane(const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&);
-bool isNearAngleRadian(const sead::Vector2f&, const sead::Vector2f&, f32);
-void normalize(sead::Vector2f*, const sead::Vector2f&);
-bool isNearAngleRadian(const sead::Vector3f&, const sead::Vector3f&, f32);
-void normalize(sead::Vector3f*, const sead::Vector3f&);
-bool isNearAngleDegree(const sead::Vector2f&, const sead::Vector2f&, f32);
-bool isNearAngleDegree(const sead::Vector3f&, const sead::Vector3f&, f32);
+f32 calcAngleOnPlaneDegree(const sead::Vector3f& a, const sead::Vector3f& b,
+                           const sead::Vector3f& vertical);
+f32 calcAngleOnPlaneDegreeOrZero(const sead::Vector3f& a, const sead::Vector3f& b,
+                                 const sead::Vector3f& vertical);
+bool tryCalcAngleOnPlaneDegree(f32* angle, const sead::Vector3f& a, const sead::Vector3f& b,
+                               const sead::Vector3f& vertical);
+bool isParallelDirection(const sead::Vector3f& a, const sead::Vector3f& b, f32 tolerance = 0.01f);
+s32 calcAngleSignOnPlane(const sead::Vector3f& a, const sead::Vector3f& b,
+                         const sead::Vector3f& vertical);
+bool isNearAngleRadian(const sead::Vector2f& a, const sead::Vector2f& b, f32 tolerance);
+void normalize(sead::Vector2f* out, const sead::Vector2f& vec);
+bool isNearAngleRadian(const sead::Vector3f& a, const sead::Vector3f& b, f32 tolerance);
+void normalize(sead::Vector3f* out, const sead::Vector3f& vec);
+bool isNearAngleDegree(const sead::Vector2f& a, const sead::Vector2f& b, f32 tolerance);
+bool isNearAngleDegree(const sead::Vector3f& a, const sead::Vector3f& b, f32 tolerance);
 bool isNearAngleRadianHV(const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&, f32,
                          f32);
-bool tryNormalizeOrZero(sead::Vector3f*, const sead::Vector3f&);
-bool tryNormalizeOrZero(sead::Vector3f*);
+bool tryNormalizeOrZero(sead::Vector3f* out, const sead::Vector3f& vec);
+bool tryNormalizeOrZero(sead::Vector3f* out);
 bool isNearAngleDegreeHV(const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&, f32,
                          f32);
 bool isInAngleOnPlaneDegreeHV(const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&,
@@ -64,55 +67,55 @@ bool isNearZero(f32 value, f32 tolerance = 0.001f);
 bool isNearZero(const sead::Matrix34f& value, f32 tolerance = 0.001f);
 bool isNearZeroOrGreater(f32 value, f32 tolerance = 0.001f);
 bool isNearZeroOrLess(f32 value, f32 tolerance = 0.001f);
-bool isExistNearZeroVal(const sead::Vector3f&, f32);
-bool isNormalize(const sead::Vector3f&, f32);
-bool isNormalize(const sead::Matrix34f&);
-bool isParallelDirection(const sead::Vector2f&, const sead::Vector2f&, f32);
-bool isReverseDirection(const sead::Vector3f&, const sead::Vector3f&, f32);
-bool isNearDirection(const sead::Vector2f&, const sead::Vector2f&, f32);
-bool isNearDirection(const sead::Vector3f&, const sead::Vector3f&, f32);
-bool isInRange(s32, s32, s32);
-bool isInRange(f32, f32, f32);
-void normalize(sead::Vector2f*);
-void normalize(sead::Vector3f*);
-void normalize(sead::Matrix33f*);
-void normalize(sead::Matrix34f*);
-bool tryNormalizeOrZero(sead::Vector2f*);
-bool tryNormalizeOrZero(sead::Vector2f*, const sead::Vector2f&);
-bool tryNormalizeOrDirZ(sead::Vector3f*);
-bool tryNormalizeOrDirZ(sead::Vector3f*, const sead::Vector3f&);
-void normalizeComplement(sead::Matrix34f*);
-u32 getMaxAbsElementIndex(const sead::Vector3f&);
-void setLength(sead::Vector3f*, f32);
-void setProjectionLength(sead::Vector3f*, const sead::Vector3f&, f32);
-bool limitLength(sead::Vector2f*, const sead::Vector2f&, f32);
-bool limitLength(sead::Vector3f*, const sead::Vector3f&, f32);
-f32 normalizeAbs(f32, f32, f32);
-f32 normalize(f32, f32, f32);
-f32 normalize(s32, s32, s32);
-f32 sign(f32);
-s32 sign(s32);
-f32 cubeRoot(f32);
+bool isExistNearZeroVal(const sead::Vector3f& vec, f32 tolerance);
+bool isNormalize(const sead::Vector3f& vec, f32 tolerance = 0.001f);
+bool isNormalize(const sead::Matrix34f& mtx);
+bool isParallelDirection(const sead::Vector2f& a, const sead::Vector2f& b, f32 tolerance = 0.01f);
+bool isReverseDirection(const sead::Vector3f& a, const sead::Vector3f& b, f32 tolerance = 0.01f);
+bool isNearDirection(const sead::Vector2f& a, const sead::Vector2f& b, f32 tolerance = 0.01f);
+bool isNearDirection(const sead::Vector3f& a, const sead::Vector3f& b, f32 tolerance = 0.01f);
+bool isInRange(s32 x, s32 a, s32 b);
+bool isInRange(f32 x, f32 a, f32 b);
+void normalize(sead::Vector2f* vec);
+void normalize(sead::Vector3f* vec);
+void normalize(sead::Matrix33f* mtx);
+void normalize(sead::Matrix34f* mtx);
+bool tryNormalizeOrZero(sead::Vector2f* vec);
+bool tryNormalizeOrZero(sead::Vector2f* out, const sead::Vector2f& vec);
+bool tryNormalizeOrDirZ(sead::Vector3f* vec);
+bool tryNormalizeOrDirZ(sead::Vector3f* out, const sead::Vector3f& vec);
+void normalizeComplement(sead::Matrix34f* mtx);
+u32 getMaxAbsElementIndex(const sead::Vector3f& vec);
+void setLength(sead::Vector3f* vec, f32 length);
+void setProjectionLength(sead::Vector3f* out, const sead::Vector3f& vec, f32 length);
+bool limitLength(sead::Vector2f* out, const sead::Vector2f& vec, f32 limit);
+bool limitLength(sead::Vector3f* out, const sead::Vector3f& vec, f32 limit);
+f32 normalizeAbs(f32 x, f32 min, f32 max);
+f32 normalize(f32 x, f32 min, f32 max);
+f32 normalize(s32 x, s32 min, s32 max);
+f32 sign(f32 x);
+s32 sign(s32 x);
+f32 cubeRoot(f32 x);
 void clampV3f(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&);
 void clampV2f(sead::Vector2f*, const sead::Vector2f&, const sead::Vector2f&);
-f32 easeIn(f32);
-f32 easeOut(f32);
-f32 easeInOut(f32);
-f32 squareIn(f32);
-f32 squareOut(f32);
-f32 powerIn(f32, f32);
-f32 powerOut(f32, f32);
-f32 logarithmIn(f32, f32);
-f32 logarithmOut(f32, f32);
-f32 exponentIn(f32, f32);
-f32 exponentOut(f32, f32);
-f32 hermiteRate(f32, f32, f32);
-f32 calcFourthOrderRate(f32, f32);
+f32 easeIn(f32 t);
+f32 easeOut(f32 t);
+f32 easeInOut(f32 t);
+f32 squareIn(f32 t);
+f32 squareOut(f32 t);
+f32 powerIn(f32 t, f32 exp);
+f32 powerOut(f32 t, f32 exp);
+f32 logarithmIn(f32 t, f32 base);
+f32 logarithmOut(f32 t, f32 base);
+f32 exponentIn(f32 t, f32 exp);
+f32 exponentOut(f32 t, f32 exp);
+f32 hermiteRate(f32 t, f32 m0, f32 m1);
+f32 calcFourthOrderRate(f32 t, f32 scale);
 f32 calcTriangleWave01(f32, f32);
 f32 calcTriangleWave(f32, f32, f32, f32);
-f32 lerpValue(f32, f32, f32);
+f32 lerpValue(f32 a, f32 b, f32 t);
 f32 calcRate01(f32, f32, f32);
-f32 easeByType(f32, s32);
+f32 easeByType(f32 t, s32 easeType);
 f32 lerpValue(f32, f32, f32, f32, f32);
 f32 lerpDegree(f32, f32, f32);
 f32 lerpRadian(f32, f32, f32);
@@ -133,10 +136,10 @@ void lerpExponentVecEaseIn(sead::Vector3f*, const sead::Vector3f&, const sead::V
 void lerpExponentVecEaseOut(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&, f32,
                             f32);
 f32 clampLeapMinAbs(f32, f32, f32, f32);
-f32 hermite(f32, f32, f32, f32, f32);
-f32 hermite(f32, f32, f32, f32, f32, f32);
-void hermiteVec(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&,
-                const sead::Vector3f&, const sead::Vector3f&, f32);
+f32 hermite(f32 y0, f32 m0, f32 y1, f32 m1, f32 t);
+f32 hermite(f32 y0, f32 m0, f32 y1, f32 m1, f32 t, f32 width);
+void hermiteVec(sead::Vector3f* out, const sead::Vector3f& p0, const sead::Vector3f& v0,
+                const sead::Vector3f& p1, const sead::Vector3f& v1, f32 t);
 s32 converge(s32, s32, s32);
 f32 converge(f32, f32, f32);
 f32 convergeDegree(f32, f32, f32);
@@ -157,14 +160,14 @@ s32 findMaxFromArray(const s32*, s32);
 void separateMinMax(sead::Vector3f*, sead::Vector3f*, const sead::Vector3f&);
 s32 findMinFromArray(const s32*, s32);
 f32 getRandom();
-f32 getRandom(f32);
-f32 getRandom(f32, f32);
-s32 getRandom(s32);
-s32 getRandom(s32, s32);
+f32 getRandom(f32 max);
+f32 getRandom(f32 min, f32 max);
+s32 getRandom(s32 max);
+s32 getRandom(s32 min, s32 max);
 f32 getRandomDegree();
 f32 getRandomRadian();
-void getRandomVector(sead::Vector3f*, f32);
-void getRandomDir(sead::Vector3f*);
+void getRandomVector(sead::Vector3f* vec, f32 maxComponent);
+void getRandomDir(sead::Vector3f* vec);
 void getRandomDirH(sead::Vector3f*, const sead::Vector3f&);
 void rotateVectorDegree(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&, f32);
 void getRandomOnCircle(sead::Vector2f*, f32);
@@ -427,7 +430,8 @@ bool calcBetweenTwoLinkPos(sead::Vector3f*, const sead::Vector3f&, const sead::V
                            const sead::Vector3f&);
 bool calcReflectionVector(sead::Vector3f*, const sead::Vector3f&, f32, f32);
 void calcReverseVector(sead::Vector3f*, const sead::Vector3f&, f32);
-void calcParabolicFunctionParam(f32*, f32*, f32, f32 verticalDistance);
+void calcParabolicFunctionParam(f32* gravity, f32* initialVelY, f32 maxHeight,
+                                f32 verticalDistance);
 f32 calcConvergeVibrationValue(f32, f32, f32, f32, f32);
 bool calcSphericalPolarCoordPY(sead::Vector2f*, const sead::Vector3f&, const sead::Vector3f&,
                                const sead::Vector3f&);

tools/check-format.py

@@ -275,6 +275,8 @@ def common_sead_math_template(c, path):
                 continue
             if "Vector3CalcCommon" in line:
                 continue
+            if "BitUtil" in line:
+                continue
             FAIL("Use short sead types: sead::Vector3f, sead::Mathi and similar!", line, path)
 
 def common_string_finder(c, path):