d_a_obj_tumble_weed mostly done (#88)

* mostly done

* Update d_t_tumble_weed.cpp

* remove cM::calcTimer

* just regswap on adjustSpeed

* Create inlines for angle between vectors

* name data symbols

---------

Co-authored-by: robojumper <robojumper@gmail.com>

src/REL/d/a/obj/d_a_obj_tumble_weed.cpp

@@ -1,13 +1,403 @@
 #include "d/a/obj/d_a_obj_tumble_weed.h"
 
+#include "c/c_math.h"
+#include "common.h"
+#include "d/a/d_a_player.h"
+#include "d/a/obj/d_a_obj_base.h"
+#include "d/col/bg/d_bg_s.h"
+#include "d/col/bg/d_bg_s_gnd_chk.h"
+#include "d/col/c/c_cc_d.h"
+#include "d/col/c/c_m3d_g_pla.h"
+#include "d/col/cc/d_cc_d.h"
+#include "d/col/cc/d_cc_s.h"
+#include "egg/math/eggMath.h"
+#include "egg/math/eggQuat.h"
+#include "f/f_base.h"
+#include "m/m_angle.h"
+#include "m/m_mtx.h"
+#include "m/m_quat.h"
+#include "m/m_vec.h"
+#include "nw4r/math/math_triangular.h"
+#include "rvl/MTX/mtx.h"
+#include "rvl/MTX/vec.h"
+#include "s/s_Math.h"
+#include "toBeSorted/dowsing_target.h"
+
+void float_ordering() {
+    const f32 arr[] = {5.f, 15.f, 7.f, 0.5f, 0.1f};
+}
+
 SPECIAL_ACTOR_PROFILE(OBJ_TUMBLE_WEED, dAcOTumbleWeed_c, fProfile::OBJ_TUMBLE_WEED, 0x243, 0, 2);
 
 STATE_DEFINE(dAcOTumbleWeed_c, Wait);
 STATE_DEFINE(dAcOTumbleWeed_c, Slope);
 
-void dAcOTumbleWeed_c::initializeState_Wait() {}
-void dAcOTumbleWeed_c::executeState_Wait() {}
+dCcD_SrcSph dAcOTumbleWeed_c::sSphSrc = {
+  /* mObjInf */
+    {/* mObjAt */ {0, 0, {0, 0, 0}, 0, 0, 0, 0, 0, 0},
+     /* mObjTg */ {0xFFB77FFF, 0x111, {8, 0x40F}, 0, 0},
+     /* mObjCo */ {0xE9}},
+ /* mSphInf */
+    {60.f},
+};
+
+bool dAcOTumbleWeed_c::createHeap() {
+    mResFile = getOarcResFile("GrassRollDry");
+    TRY_CREATE(mMdl.create(mResFile.GetResMdl("GrassRollDry"), &heap_allocator, 0x120, 1, nullptr));
+    return true;
+}
+
+int dAcOTumbleWeed_c::actorCreate() {
+    CREATE_ALLOCATOR(dAcOTumbleWeed_c);
+
+    mObjAcch.Set(this, 1, &mAcchCir);
+    mAcchCir.SetWall(20.f, 60.f);
+    mObjAcch.OffClrSpeedY();
+    mObjAcch.SetGndThinCellingOff();
+
+    mStts.SetRank(3);
+
+    mSph.Set(sSphSrc);
+    mSph.SetStts(mStts);
+
+    mDowsingTarget.initialize(DowsingTarget::SLOT_TREASURE, 0, nullptr, 0.0f);
+    mDowsingTarget.doRegister();
+
+    forwardAccel = -2.f;
+    forwardMaxSpeed = -40.f;
+
+    mField_0x974 = 0.0f;
+    mField_0x98B = true;
+
+    mWind = mVec3_c::Zero;
+
+    mSpeedTarget = cM::rndFX(2.5f) + 15.f;
+    mField_0x978 = cM::rndF(40.f);
+    mField_0x97C = cM::rndFX(0.25f) + 1.f;
+    mTumbleTimer = (150);
+
+    mField_0x910.set(1.f, 0.f, 0.f, 0.f);
+    mScale.set(1.f, 1.f, 1.f);
+
+    mStateMgr.changeState(StateID_Wait);
+
+    boundingBox.Set(mVec3_c(-50.f, -20.f, -50.f), mVec3_c(50.f, 60.f, 50.f));
+
+    return SUCCEEDED;
+}
+
+int dAcOTumbleWeed_c::actorPostCreate() {
+    return SUCCEEDED;
+}
+
+int dAcOTumbleWeed_c::doDelete() {
+    return SUCCEEDED;
+}
+
+extern "C" void fn_800247D0(void *, mVec3_c, f32);
+extern "C" UNKWORD BLUR_AND_PALETTE_MGR;
+
+int dAcOTumbleWeed_c::actorExecute() {
+    if (!mField_0x98C && !isStopped()) {
+        mField_0x968 = velocity;
+        mField_0x968.y = 0.0f;
+        mField_0x968.normalize();
+        mField_0x98C = true;
+    }
+
+    mStateMgr.executeState();
+    calcWind();
+
+    sLib::chase(&mField_0x980, 1.f, 0.1f);
+    fn_800247D0(&BLUR_AND_PALETTE_MGR, mField_0x968, mField_0x980);
+
+    calcVelocity();
+    position += velocity;
+    position += mStts.GetCcMove();
+
+    mObjAcch.CrrPos(*dBgS::GetInstance());
+    mField_0x974 += position.y - mOldPosition.y;
+    if (checkCollect()) {
+        dAcPy_c::LINK->bugNetCollectTreasure(0xA3 /* TODO(Item Id) ITEM_TUMBLEWEED */);
+        FUN_8002dcd0();
+        return SUCCEEDED;
+    }
+    if (checkBreak()) {
+        doBreak();
+        return SUCCEEDED;
+    }
+
+    if (mSph.ChkTgHit() && mSph.ChkTgAtHitType(AT_TYPE_0x10000 | AT_TYPE_0x200)) {
+        mField_0x974 = 0.f;
+        adjustTumble(mSph.GetTg_0x2C() * 0.06f);
+    }
+    adjustTimeScale();
+
+    // TODO(mObjectActorFlags)
+    if (mObjectActorFlags & 0x2) {
+        // Weak function not being placed right
+        if (sLib::calcTimer(&mTumbleTimer) == 0) {
+            FUN_8002dcd0();
+            return SUCCEEDED;
+        }
+    } else {
+        mTumbleTimer = 150;
+    }
+    mSph.SetC(getPosition());
+    mSph.SetR(mScale.x * 60.f);
+    dCcS::GetInstance()->Set(&mSph);
+    updateMatrix();
+    calcMatrix();
+    playSoundEffect1(0xC2C); // TODO(Sound Id)
+    mMdl.setLocalMtx(mWorldMtx);
+    mMdl.setScale(mScale);
+    mMdl.calc(false);
+
+    return SUCCEEDED;
+}
+
+int dAcOTumbleWeed_c::draw() {
+    drawModelType1(&mMdl);
+
+    static mQuat_c shadowRot(0.f, 30.f, 0.f, 50.f);
+    if (0.f < mScale.x) {
+        drawShadow(mShdw, nullptr, mShadowMtx, &shadowRot, -1, -1, -1, -1, -1, position.y - mObjAcch.GetGroundH());
+    }
+
+    return SUCCEEDED;
+}
+
+void dAcOTumbleWeed_c::initializeState_Wait() {
+    mbOnGround = false;
+}
+
+void dAcOTumbleWeed_c::executeState_Wait() {
+    if (mObjAcch.ChkGroundLanding() && !mbOnGround) {
+        tumbleBounceMaybe();
+        return;
+    }
+
+    if (!mObjAcch.ChkGndHit()) {
+        return;
+    }
+
+    velocity.y = 0.f;
+    mField_0x974 = 0.f;
+    if (checkSlope()) {
+        mStateMgr.changeState(StateID_Slope);
+    } else {
+        adjustSpeed();
+        if (forwardSpeed < 0.1f) {
+            mField_0x98B = false;
+            sLib::chase(&forwardSpeed, 0.f, 0.05f);
+        }
+    }
+}
+
 void dAcOTumbleWeed_c::finalizeState_Wait() {}
+
 void dAcOTumbleWeed_c::initializeState_Slope() {}
-void dAcOTumbleWeed_c::executeState_Slope() {}
+
+void dAcOTumbleWeed_c::executeState_Slope() {
+    if (mObjAcch.ChkGroundLanding() && !mbOnGround) {
+        tumbleBounceMaybe();
+        return;
+    }
+
+    if (!mObjAcch.ChkGndHit()) {
+        return;
+    }
+
+    velocity.y = 0.f;
+    adjustAngle();
+    adjustSpeed();
+    if (!checkSlope()) {
+        mStateMgr.changeState(StateID_Wait);
+    }
+}
+
 void dAcOTumbleWeed_c::finalizeState_Slope() {}
+
+bool dAcOTumbleWeed_c::checkBreak() {
+    if (mObjAcch.ChkWallHit(nullptr) && forwardSpeed > 5.f) {
+        return true;
+    }
+
+    if (mSph.ChkTgHit() && !mSph.ChkTgAtHitType(AT_TYPE_BUGNET)) {
+        return true;
+    }
+
+    if (mObjAcch.ChkGndHit() && mField_0x974 < -300.f) {
+        return true;
+    }
+
+    if (fn_475_E40()) {
+        return true;
+    }
+
+    if (mObjAcch.ChkGndHit() && checkInvalidGround()) {
+        return true;
+    }
+
+    return false;
+}
+
+bool dAcOTumbleWeed_c::fn_475_E40() const {
+    return mField_0x974 < -10000.f;
+}
+
+bool dAcOTumbleWeed_c::checkSlope() {
+    cM3dGPla pla;
+    dBgS::GetInstance()->GetTriPla(mObjAcch.mGnd, &pla);
+
+    mAng ang = mAng::angle(mVec3_c::Ey, pla.GetN());
+    return sLib::absDiff(ang, 0) > mAng::deg2short(1);
+}
+
+bool dAcOTumbleWeed_c::checkCollect() {
+    return mSph.ChkTgHit() && mSph.ChkTgAtHitType(AT_TYPE_BUGNET) ? true : false;
+}
+
+bool dAcOTumbleWeed_c::checkInvalidGround() const {
+    u32 code = dBgS::GetInstance()->GetSpecialCode(mObjAcch.mGnd);
+
+    return code == POLY_ATTR_LAVA || code == POLY_ATTR_SAND_MED || code == POLY_ATTR_SAND_DEEP_INSTANT ||
+           code == POLY_ATTR_SAND_DEEP_SLOW;
+}
+
+extern "C" u16 PARTICLE_RESOURCE_ID_MAPPING_743_;
+extern "C" void fn_800298B0(u16, mVec3_c *, mAng3_c *, u32, u32, u32, u32, u32);
+
+void dAcOTumbleWeed_c::doBreak() {
+    playSound(0xC2D); // TODO(Sound Id)
+    mVec3_c pos = getPosition();
+    fn_800298B0(PARTICLE_RESOURCE_ID_MAPPING_743_, &pos, nullptr, 0, 0, 0, 0, 0);
+    deleteRequest();
+}
+
+void dAcOTumbleWeed_c::calcMatrix() {
+    if (mField_0x98B) {
+        f32 vel_mag = PSVECMag(velocity);
+        f32 f1 = mAng(vel_mag * (mField_0x978 + 200.f)).radian();
+        f32 f2 = mAng(vel_mag * 182.0f * 0.2f).radian();
+        f32 f0 = mAng(angle.y - rotation.y).radian();
+
+        mQuat_c q0, q1, q2, q3;
+        q1.setAxisRotation(mVec3_c::Ey, f0);
+        q0.setAxisRotation(mVec3_c::Ey, -f0);
+        q3.setAxisRotation(mVec3_c::Ex, f1);
+        q2.setAxisRotation(mVec3_c::Ey, f2);
+
+        mField_0x910 = q1 * q3 * q2 * q0 * mField_0x910;
+    }
+
+    mMtx_c mtx0, mtx1, mtx2;
+    mShadowMtx.copyFrom(mWorldMtx);
+    mtx1.trans(getPosition() - position);
+    mShadowMtx += mtx1;
+    mtx0.fromQuat(mField_0x910);
+    mtx2.trans(0.f, 40.f, 0.f);
+    mWorldMtx += mtx2;
+    mWorldMtx += mtx0;
+}
+
+void dAcOTumbleWeed_c::adjustAngle() {
+    cM3dGPla pla;
+    dBgS::GetInstance()->GetTriPla(mObjAcch.mGnd, &pla);
+    mVec3_c vel = velocity; // ok?
+    angle.y = mAng::fromVec(velocity);
+}
+
+void dAcOTumbleWeed_c::adjustSpeed() {
+    cM3dGPla pla;
+
+    // BUG
+    // the ground angle calculation happens before retrieving the grounds normal
+    // this is probably hard to notice due to the little effect it has.
+    // Effect:
+    //  Tumbleweed slows to the target much quicker than intended
+    //  Tumbleweed speeds to the target + 5.0f much quicker than intended
+    mAng gndAngle = mAng::angle(mVec3_c::Ey, pla.GetN());
+
+    dBgS::GetInstance()->GetTriPla(mObjAcch.mGnd, &pla);
+
+    f32 speedStep = 0.5f;
+    f32 step = gndAngle.cos() * speedStep;
+
+    // Flat Ground or not in the direction of the slope
+    //  Slows down
+    if (gndAngle < mAng::deg2short(1) ||
+        sLib::absDiff(cM::atan2s(pla.GetN().x, pla.GetN().z), GetAngle().y) > mAng::deg2short(90)) {
+        sLib::chase(&forwardSpeed, mSpeedTarget, step);
+    }
+    // Sloped Ground and in the direction of the slope
+    //  Speeds up
+    else {
+        forwardSpeed = cM::minMaxLimit(forwardSpeed + step, mSpeedTarget, mSpeedTarget + 5.0f);
+    }
+}
+
+void dAcOTumbleWeed_c::tumbleBounceMaybe() {
+    velocity.y *= -0.75f;
+    forwardSpeed *= 0.9f;
+
+    if (forwardSpeed < 15.f) {
+        forwardSpeed = mSpeedTarget;
+    }
+
+    mbOnGround = false;
+    if (velocity.y < 5.f) {
+        velocity.y = 0.f;
+        mbOnGround = true;
+    }
+}
+
+void dAcOTumbleWeed_c::adjustTimeScale() {
+    mTimeArea.check(getRoomId(), GetPostion(), 0, 30.f, 0.1f);
+    if (0.f < mTimeArea.getDistMaybe()) {
+        sLib::chase(&mScale.y, 0.f, 0.07f);
+        mScale.z = mScale.y;
+        mScale.x = mScale.y;
+    } else {
+        sLib::chase(&mScale.y, 1.f, 0.07f);
+        mScale.z = mScale.y;
+        mScale.x = mScale.y;
+    }
+}
+
+void dAcOTumbleWeed_c::adjustTumble(const mVec3_c &dir) {
+    mField_0x98B = true;
+
+    velocity.x += dir.x;
+    velocity.z += dir.z;
+
+    forwardSpeed = mField_0x97C * EGG::Math<f32>::sqrt(velocity.x * velocity.x + velocity.z * velocity.z);
+    angle.y = mAng::fromVec(dir);
+}
+
+void dAcOTumbleWeed_c::setWind(const mVec3_c &wind) {
+    mWind = wind;
+    mWindTimer = cM::rndInt(10);
+}
+
+void dAcOTumbleWeed_c::calcWind() {
+    if (!isWindStop() && sLib::calcTimer(&mWindTimer) == 0) {
+        velocity.y = cM::rndFX(3.0f) + 15.f;
+        forwardSpeed = cM::rndFX(5.0f) + 15.f;
+
+        mWind = mVec3_c::Zero;
+        mField_0x980 = 0.f;
+    }
+}
+
+mVec3_c dAcOTumbleWeed_c::getPosition() const {
+    mMtx_c mtx;
+    mVec3_c vec;
+    mtx.ZXYrotS(rotation.x, rotation.y, rotation.z);
+    PSMTXMultVecSR(mtx, mVec3_c::Ey, vec);
+    return position + vec * 40.f;
+}
+
+void float_ordering2() {
+    const f32 arr[] = {30.f, 0.07f, 20.f, -10000.f, 5.f};
+}

src/REL/d/t/d_t_gekotag.cpp

@@ -1,13 +1,12 @@
 #include "d/t/d_t_gekotag.h"
 
-#include "c/c_math.h"
 #include "common.h"
 #include "d/a/d_a_player.h"
 #include "d/a/e/d_a_e_geko.h"
 #include "d/a/obj/d_a_obj_base.h"
-#include "f/f_base.h"
 #include "f/f_profile_name.h"
 #include "m/m_angle.h"
+#include "s/s_Math.h"
 
 #pragma explicit_zero_data on
 static u32 initialRotX = 0;
@@ -60,8 +59,8 @@ void dTgGekoTag::executeState_Wait() {
 void dTgGekoTag::finalizeState_Wait() {}
 
 void dTgGekoTag::doExecute() {
-    cM::calcTimer(&mTimer2);
-    if (cM::calcTimer(&mTimer1) != 0) {
+    sLib::calcTimer(&mTimer2);
+    if (sLib::calcTimer(&mTimer1) != 0) {
         return;
     }
 

src/REL/d/t/d_t_touch.cpp

@@ -1,9 +1,9 @@
 #include "d/t/d_t_touch.h"
 
 #include "c/c_math.h"
-#include "toBeSorted/area_math.h"
 #include "d/flag/sceneflag_manager.h"
-
+#include "s/s_Math.h"
+#include "toBeSorted/area_math.h"
 
 SPECIAL_ACTOR_PROFILE(TOUCH_TAG, dTgTouchTag, fProfile::TOUCH_TAG, 0x028E, 0, 0);
 
@@ -59,7 +59,7 @@ void dTgTouchTag::executeState_Wait() {
         actor = static_cast<dAcBase_c *>(fManager_c::searchBaseByProfName(ACTIVATORS[mActivatorIndex], actor));
     }
 
-    if (cM::calcTimer(&mFlagTimer) == 0) {
+    if (sLib::calcTimer(&mFlagTimer) == 0) {
         if (mZoneFlag != 0xFF && SceneflagManager::sInstance->checkBoolFlag(roomid, mZoneFlag)) {
             SceneflagManager::sInstance->unsetFlag(roomid, mZoneFlag);
         }

src/REL/d/t/d_t_tumble_weed.cpp

@@ -1,7 +1,7 @@
 #include "d/t/d_t_tumble_weed.h"
 
-#include "c/c_math.h"
 #include "m/m_vec.h"
+#include "s/s_Math.h"
 
 
 SPECIAL_ACTOR_PROFILE(TUMBLE_WEED_TAG, dTgTumbleWeed_c, fProfile::TUMBLE_WEED_TAG, 0x0244, 0, 0);
@@ -17,32 +17,23 @@ int dTgTumbleWeed_c::create() {
     return SUCCEEDED;
 }
 
-u16 decr(u16 *num);
-
 int dTgTumbleWeed_c::doDelete() {
     return SUCCEEDED;
 }
 
 int dTgTumbleWeed_c::actorExecute() {
     mStateMgr.executeState();
-    decr(&tumbleweedTimer);
+    sLib::calcTimer(&tumbleweedTimer);
     return SUCCEEDED;
 }
 
-u16 decr(u16 *num) {
-    if (*num != 0) {
-        (*num)--;
-    }
-    return *num;
-}
-
 int dTgTumbleWeed_c::draw() {
     return SUCCEEDED;
 }
 
 void dTgTumbleWeed_c::initializeState_AreaOut() {}
 void dTgTumbleWeed_c::executeState_AreaOut() {
-    if (decr(&windTimer) == 0) {
+    if (sLib::calcTimer(&windTimer) == 0) {
         windTimer = 0x96;
         if (shouldDoWind()) {
             mStateMgr.changeState(StateID_Wind);
@@ -63,7 +54,7 @@ void dTgTumbleWeed_c::executeState_AreaIn() {
         }
         tumbleweedTimer = 600;
     }
-    if (decr(&windTimer) == 0) {
+    if (sLib::calcTimer(&windTimer) == 0) {
         windTimer = 0x96;
         if (shouldDoWind()) {
             mStateMgr.changeState(StateID_Wind);
@@ -76,12 +67,11 @@ void dTgTumbleWeed_c::executeState_AreaIn() {
 }
 void dTgTumbleWeed_c::finalizeState_AreaIn() {}
 
-extern "C" void fn_475_1B00(fBase_c *, mVec3_c &);
 void dTgTumbleWeed_c::initializeState_Wind() {
     mVec3_c vec;
     getWind(&vec);
     if (childTumbleweed.get() != nullptr) {
-        fn_475_1B00(childTumbleweed.get(), vec);
+        childTumbleweed.get()->setWind(vec);
     }
 }
 

src/d/a/obj/d_a_obj_switch.cpp

@@ -1,12 +1,11 @@
 #include "d/a/obj/d_a_obj_switch.h"
 
-#include "c/c_math.h"
 #include "d/a/d_a_player.h"
 #include "d/col/bg/d_bg_s.h"
 #include "d/col/bg/d_bg_w.h"
+#include "d/flag/sceneflag_manager.h"
 #include "nw4r/g3d/g3d_resfile.h"
 #include "s/s_Math.h"
-#include "d/flag/sceneflag_manager.h"
 
 SPECIAL_ACTOR_PROFILE(OBJ_SW, dAcOsw_c, fProfile::OBJ_SW, 0x12B, 0, 0x1002);
 
@@ -269,7 +268,7 @@ void dAcOsw_c::executeState_OffWait() {
     if (field_0x5F1 != 0) {
         field_0x5F3 = 1;
     }
-    if (mSwitchType != 1 && cM::calcTimer(&field_0x5EC) == 0 && field_0x5F3 == 0) {
+    if (mSwitchType != 1 && sLib::calcTimer(&field_0x5EC) == 0 && field_0x5F3 == 0) {
         mStateMgr.changeState(StateID_Off);
     }
 }

src/d/col/c/c_m3d_g_pla.cpp

@@ -29,7 +29,7 @@ bool cM3dGPla::getCrossYLessD(const mVec3_c &point, f32 *out) const {
 }
 
 mAng cM3dGPla::GetAngle(mAng ang) const {
-    mAng angleY = mNormal.getAngleY();
+    mAng angleY = GetAngleY();
 
     angleY = angleY - ang;
 

src/d/tg/d_t_switch.cpp

@@ -1,8 +1,8 @@
 #include "d/t/d_t_switch.h"
 
-#include "c/c_math.h"
-#include "toBeSorted/event.h"
 #include "d/flag/sceneflag_manager.h"
+#include "s/s_Math.h"
+#include "toBeSorted/event.h"
 #include "toBeSorted/scgame.h"
 
 
@@ -144,7 +144,7 @@ void dTgSw_c::initializeState_On() {
     mTimer = 4;
 }
 void dTgSw_c::executeState_On() {
-    if (cM::calcTimer(&mTimer) == 0) {
+    if (sLib::calcTimer(&mTimer) == 0) {
         mStateMgr.changeState(StateID_OffWait);
     }
 }
@@ -173,7 +173,7 @@ void dTgSw_c::executeState_Off() {
         mActorEvent.scheduleEvent(event, 0);
         return;
     }
-    if (cM::calcTimer(&mTimer) == 0) {
+    if (sLib::calcTimer(&mTimer) == 0) {
         if (mThird2 == 1) {
             resetAllSwitches();
         } else if (mThird2 != 2) {

src/egg/math/eggMatrix.cpp

@@ -126,15 +126,15 @@ void Matrix34f::makeST(const Vector3f &s, const Vector3f &t) {
 }
 
 void Matrix34f::makeSQT(const Vector3f &s, const Quatf &q, const Vector3f &t) {
-    f32 yy = 2.0f * q.y * q.y;
-    f32 zz = 2.0f * q.z * q.z;
-    f32 xx = 2.0f * q.x * q.x;
-    f32 xy = 2.0f * q.x * q.y;
-    f32 xz = 2.0f * q.x * q.z;
-    f32 yz = 2.0f * q.y * q.z;
-    f32 wz = 2.0f * q.w * q.z;
-    f32 wx = 2.0f * q.w * q.x;
-    f32 wy = 2.0f * q.w * q.y;
+    f32 yy = 2.0f * q.v.y * q.v.y;
+    f32 zz = 2.0f * q.v.z * q.v.z;
+    f32 xx = 2.0f * q.v.x * q.v.x;
+    f32 xy = 2.0f * q.v.x * q.v.y;
+    f32 xz = 2.0f * q.v.x * q.v.z;
+    f32 yz = 2.0f * q.v.y * q.v.z;
+    f32 wz = 2.0f * q.w * q.v.z;
+    f32 wx = 2.0f * q.w * q.v.x;
+    f32 wy = 2.0f * q.w * q.v.y;
 
     m[0][0] = s.x * (1.0f - yy - zz);
     m[0][1] = s.y * (xy - wz);
@@ -154,15 +154,15 @@ void Matrix34f::makeSQT(const Vector3f &s, const Quatf &q, const Vector3f &t) {
 }
 
 void Matrix34f::makeQT(const Quatf &q, const Vector3f &t) {
-    f32 yy = 2.0f * q.y * q.y;
-    f32 zz = 2.0f * q.z * q.z;
-    f32 xx = 2.0f * q.x * q.x;
-    f32 xy = 2.0f * q.x * q.y;
-    f32 xz = 2.0f * q.x * q.z;
-    f32 yz = 2.0f * q.y * q.z;
-    f32 wz = 2.0f * q.w * q.z;
-    f32 wx = 2.0f * q.w * q.x;
-    f32 wy = 2.0f * q.w * q.y;
+    f32 yy = 2.0f * q.v.y * q.v.y;
+    f32 zz = 2.0f * q.v.z * q.v.z;
+    f32 xx = 2.0f * q.v.x * q.v.x;
+    f32 xy = 2.0f * q.v.x * q.v.y;
+    f32 xz = 2.0f * q.v.x * q.v.z;
+    f32 yz = 2.0f * q.v.y * q.v.z;
+    f32 wz = 2.0f * q.w * q.v.z;
+    f32 wx = 2.0f * q.w * q.v.x;
+    f32 wy = 2.0f * q.w * q.v.y;
 
     m[0][0] = 1.0f - yy - zz;
     m[0][1] = xy - wz;
@@ -182,15 +182,15 @@ void Matrix34f::makeQT(const Quatf &q, const Vector3f &t) {
 }
 
 void Matrix34f::makeQ(const Quatf &q) {
-    f32 yy = 2.0f * q.y * q.y;
-    f32 zz = 2.0f * q.z * q.z;
-    f32 xx = 2.0f * q.x * q.x;
-    f32 xy = 2.0f * q.x * q.y;
-    f32 xz = 2.0f * q.x * q.z;
-    f32 yz = 2.0f * q.y * q.z;
-    f32 wz = 2.0f * q.w * q.z;
-    f32 wx = 2.0f * q.w * q.x;
-    f32 wy = 2.0f * q.w * q.y;
+    f32 yy = 2.0f * q.v.y * q.v.y;
+    f32 zz = 2.0f * q.v.z * q.v.z;
+    f32 xx = 2.0f * q.v.x * q.v.x;
+    f32 xy = 2.0f * q.v.x * q.v.y;
+    f32 xz = 2.0f * q.v.x * q.v.z;
+    f32 yz = 2.0f * q.v.y * q.v.z;
+    f32 wz = 2.0f * q.w * q.v.z;
+    f32 wx = 2.0f * q.w * q.v.x;
+    f32 wy = 2.0f * q.w * q.v.y;
 
     m[0][0] = 1.0f - yy - zz;
     m[0][1] = xy - wz;
@@ -240,17 +240,17 @@ void Matrix34f::makeT(const Vector3f &t) {
 }
 
 void Matrix34f::fromQuat(const Quatf &q) {
-    m[0][0] = 1.0f - (2 * q.y * q.y) - (2.0f * q.z * q.z);
-    m[0][1] = (2.0f * q.x * q.y) - (2.0f * q.w * q.z);
-    m[0][2] = (2.0f * q.x * q.z) + (2.0f * q.w * q.y);
+    m[0][0] = 1.0f - (2 * q.v.y * q.v.y) - (2.0f * q.v.z * q.v.z);
+    m[0][1] = (2.0f * q.v.x * q.v.y) - (2.0f * q.w * q.v.z);
+    m[0][2] = (2.0f * q.v.x * q.v.z) + (2.0f * q.w * q.v.y);
 
-    m[1][0] = (2.0f * q.x * q.y) + (2.0f * q.w * q.z);
-    m[1][1] = 1.0f - (2.0f * q.x * q.x) - (2.0f * q.z * q.z);
-    m[1][2] = (2.0f * q.y * q.z) - (2.0f * q.w * q.x);
+    m[1][0] = (2.0f * q.v.x * q.v.y) + (2.0f * q.w * q.v.z);
+    m[1][1] = 1.0f - (2.0f * q.v.x * q.v.x) - (2.0f * q.v.z * q.v.z);
+    m[1][2] = (2.0f * q.v.y * q.v.z) - (2.0f * q.w * q.v.x);
 
-    m[2][0] = (2.0f * q.x * q.z) - (2.0f * q.w * q.y);
-    m[2][1] = (2.0f * q.y * q.z) + (2.0f * q.w * q.x);
-    m[2][2] = 1.0f - (2.0f * q.x * q.x) - (2.0f * q.y * q.y);
+    m[2][0] = (2.0f * q.v.x * q.v.z) - (2.0f * q.w * q.v.y);
+    m[2][1] = (2.0f * q.v.y * q.v.z) + (2.0f * q.w * q.v.x);
+    m[2][2] = 1.0f - (2.0f * q.v.x * q.v.x) - (2.0f * q.v.y * q.v.y);
 
     m[2][3] = 0.0f;
     m[1][3] = 0.0f;
@@ -298,38 +298,38 @@ void Matrix34f::toQuat(Quatf &q) const {
     switch (tempMax) {
         case 0:
             q.w = Math<f32>::sqrt(temp0);
-            q.x = (0.25f / q.w) * (m[2][1] - m[1][2]);
-            q.y = (0.25f / q.w) * (m[0][2] - m[2][0]);
-            q.z = (0.25f / q.w) * (m[1][0] - m[0][1]);
+            q.v.x = (0.25f / q.w) * (m[2][1] - m[1][2]);
+            q.v.y = (0.25f / q.w) * (m[0][2] - m[2][0]);
+            q.v.z = (0.25f / q.w) * (m[1][0] - m[0][1]);
             break;
         case 1:
-            q.x = Math<f32>::sqrt(temp1);
-            q.w = (0.25f / q.x) * (m[2][1] - m[1][2]);
-            q.y = (0.25f / q.x) * (m[0][1] + m[1][0]);
-            q.z = (0.25f / q.x) * (m[0][2] + m[2][0]);
+            q.v.x = Math<f32>::sqrt(temp1);
+            q.w = (0.25f / q.v.x) * (m[2][1] - m[1][2]);
+            q.v.y = (0.25f / q.v.x) * (m[0][1] + m[1][0]);
+            q.v.z = (0.25f / q.v.x) * (m[0][2] + m[2][0]);
             break;
         case 2:
-            q.y = Math<f32>::sqrt(temp2);
-            q.w = (0.25f / q.y) * (m[0][2] - m[2][0]);
-            q.z = (0.25f / q.y) * (m[1][2] + m[2][1]);
-            q.x = (0.25f / q.y) * (m[1][0] + m[0][1]);
+            q.v.y = Math<f32>::sqrt(temp2);
+            q.w = (0.25f / q.v.y) * (m[0][2] - m[2][0]);
+            q.v.z = (0.25f / q.v.y) * (m[1][2] + m[2][1]);
+            q.v.x = (0.25f / q.v.y) * (m[1][0] + m[0][1]);
             break;
         case 3:
-            q.z = Math<f32>::sqrt(temp3);
-            q.w = (0.25f / q.z) * (m[1][0] - m[0][1]);
-            q.x = (0.25f / q.z) * (m[2][0] + m[0][2]);
-            q.y = (0.25f / q.z) * (m[2][1] + m[1][2]);
+            q.v.z = Math<f32>::sqrt(temp3);
+            q.w = (0.25f / q.v.z) * (m[1][0] - m[0][1]);
+            q.v.x = (0.25f / q.v.z) * (m[2][0] + m[0][2]);
+            q.v.y = (0.25f / q.v.z) * (m[2][1] + m[1][2]);
             break;
         default: break;
     }
 
     if (q.w < 0.0f) {
         q.w = -q.w;
-        q.x = -q.x;
-        q.y = -q.y;
-        q.z = -q.z;
+        q.v.x = -q.v.x;
+        q.v.y = -q.v.y;
+        q.v.z = -q.v.z;
     }
-    q.multScalar(Math<f32>::inv(q.length()));
+    q.multScalar(Math<f32>::inv(Math<f32>::sqrt(q.w * q.w + q.v.dot(q.v))));
 }
 
 void Matrix34f::slerpTo(const Matrix34f &m2, Matrix34f &out, f32 t) const {

src/egg/math/eggQuat.cpp

@@ -5,9 +5,9 @@ namespace EGG {
 /* 8049b390 */
 void Quatf::set(f32 fw, f32 fx, f32 fy, f32 fz) {
     w = fw;
-    x = fx;
-    y = fy;
-    z = fz;
+    v.x = fx;
+    v.y = fy;
+    v.z = fz;
 }
 
 void Quatf::set(f32 fw, const Vector3f &vec) {
@@ -30,9 +30,9 @@ void Quatf::setRPY(const EGG::Vector3f &rpy) {
     const f32 sy_cp = sy * cp;
 
     w = (cy_cp * cr) + (sy_sp * sr);
-    x = (cy_cp * sr) - (sy_sp * cr);
-    y = (cy_sp * cr) + (sy_cp * sr);
-    z = (sy_cp * cr) - (cy_sp * sr);
+    v.x = (cy_cp * sr) - (sy_sp * cr);
+    v.y = (cy_sp * cr) + (sy_cp * sr);
+    v.z = (sy_cp * cr) - (cy_sp * sr);
 }
 
 /* NOT IN SS */
@@ -84,7 +84,7 @@ void Quatf::setAxisRotation(const Vector3f &axis, f32 rot) {
 
 /* 8049b450 */
 f32 Quatf::norm() {
-    return w * w + Vector3f::dot(*this);
+    return w * w + v.dot(v);
 }
 
 /* 8049b480 */
@@ -99,7 +99,7 @@ void Quatf::normalise() {
 Quatf Quatf::conjugate() {
     Quatf q;
     q.w = w;
-    (Vector3f &)q = -1.0f * *this;
+    q.v = -1.0f * v;
     return q;
 }
 
@@ -109,7 +109,7 @@ Vector3f Quatf::rotateVector(const Vector3f &vec) {
     conj = conjugate();
     mult = *this * vec;
     mult = mult * conj;
-    return (mult);
+    return (mult.v);
 }
 
 // /* NOT IN SS */
@@ -122,7 +122,7 @@ Vector3f Quatf::rotateVector(const Vector3f &vec) {
 
 /* 8049b800 */
 void Quatf::slerpTo(const Quatf &q2, f32 t, Quatf &out) const {
-    f32 dot = x * q2.x + y * q2.y + z * q2.z + w * q2.w;
+    f32 dot = v.x * q2.v.x + v.y * q2.v.y + v.z * q2.v.z + w * q2.w;
 
     if (dot > 1.0f) {
         dot = 1.0f;
@@ -156,9 +156,9 @@ void Quatf::slerpTo(const Quatf &q2, f32 t, Quatf &out) const {
         b = -b;
     }
 
-    out.x = a * x + b * q2.x;
-    out.y = a * y + b * q2.y;
-    out.z = a * z + b * q2.z;
+    out.v.x = a * v.x + b * q2.v.x;
+    out.v.y = a * v.y + b * q2.v.y;
+    out.v.z = a * v.z + b * q2.v.z;
     out.w = a * w + b * q2.w;
 }
 
@@ -166,7 +166,7 @@ void Quatf::slerpTo(const Quatf &q2, f32 t, Quatf &out) const {
 void Quatf::limitSlerpTo(const Quatf &q2, f32 t, f32 t2, Quatf &out) const {
     t2 *= 0.5f;
 
-    f32 dot = x * q2.x + y * q2.y + z * q2.z + w * q2.w;
+    f32 dot = v.x * q2.v.x + v.y * q2.v.y + v.z * q2.v.z + w * q2.w;
 
     if (dot > 1.0f) {
         dot = 1.0f;
@@ -204,9 +204,9 @@ void Quatf::limitSlerpTo(const Quatf &q2, f32 t, f32 t2, Quatf &out) const {
         b = -b;
     }
 
-    out.x = a * x + b * q2.x;
-    out.y = a * y + b * q2.y;
-    out.z = a * z + b * q2.z;
+    out.v.x = a * v.x + b * q2.v.x;
+    out.v.y = a * v.y + b * q2.v.y;
+    out.v.z = a * v.z + b * q2.v.z;
     out.w = a * w + b * q2.w;
 }
 

src/m/m3d/m_shadow.cpp

@@ -488,7 +488,7 @@ bool mShadowChild_c::addMdl(scnLeaf_c &mdl, const mQuat_c &quat) {
 
     // TODO this copy is a bit weird (reads members in a different order)
     mQuat_c q = quat;
-    PSMTXMultVec(mtx.m, q, q);
+    PSMTXMultVec(mtx.m, q.v, q.v);
 
     if (mNumLeaves == 0) {
         mQuat = q;
@@ -501,7 +501,7 @@ bool mShadowChild_c::addMdl(scnLeaf_c &mdl, const mQuat_c &quat) {
 
 bool mShadowChild_c::setGeom(const GXTexObj *texObj, const mMtx_c &mtx, const mQuat_c &quat) {
     mQuat = quat;
-    PSMTXMultVec(mtx.m, mQuat, mQuat);
+    PSMTXMultVec(mtx.m, mQuat.v, mQuat.v);
     if (texObj == nullptr) {
         mTexObj = *mShadow_c::sTexObj;
     } else {

src/m/m_angle.cpp

@@ -8,7 +8,7 @@ mAng3_c mAng3_c::Zero = mAng3_c(0, 0, 0);
 const f32 mAng::sHalfCircleDeg = 360.0f / 2;
 const f32 mAng::sAngToDeg = 360.0f / (1 << 16);
 const f32 mAng::sAngToRad = 2 * M_PI / (1 << 16);
-const f32 mAng::NotSure = 2.0f / (1 << 16);
+const f32 mAng::sAngToNorm = 2.0f / (1 << 16);
 const f32 mAng::sDegToRad = M_PI / 180.0f;
 const f32 mAng::sDegToAng = (1 << 16) / 360.0f;
 const f32 mAng::sRadToAng = (1 << 16) / (2 * M_PI);