Petari/source/Game/Map/BezierRail.cpp

#include "Game/Map/BezierRail.hpp"
#include "Game/Map/RailPart.hpp"
#include "Game/Util/MathUtil.hpp"
#include <revolution/mtx.h>

#include "JSystem/JGeometry/TMatrix.hpp"

namespace {
    void calcRailDirection(TVec3f *pOut, const RailPart *pRailPart, f32 a3) {
        pRailPart->calcVelocity(pOut, a3);

        f32 v8;

        if (MR::isNearZero(*pOut, 0.001f)) {
            if ((a3 < 0.5f)) {
                v8 = 0.0099999998f + a3;
            }
            else {
                v8 = a3;
                a3 = a3 - 0.0099999998f;
            }

            TVec3f pos;
            pRailPart->calcPos(&pos, a3);
            pRailPart->calcPos(pOut, v8);

            pOut->sub(pos);
        }

        MR::normalize(pOut);
    }
};

void BezierRailPart::set(const TVec3f &a1, const TVec3f &a2, const TVec3f &a3, const TVec3f &a4) {
    TVec3f v21, v20, v19, v18, v17, v16;

    TVec3f v15(a2);
    v15.sub(a2);

    v21 = v15;
    TVec3f v14(a3);
    v14.sub(a2);

    v20 = v14;
    TVec3f v13(a4);
    v13.sub(a3);

    v19 = v13;
    TVec3f v12(v20);
    v12.sub(v21);

    v18 = v12;
    TVec3f v11(v19);
    v11.sub(v20);

    v17 = v11;
    TVec3f v10(v17);
    v10.sub(v18);

    v16 = v10;
    _0 = a1;
    _C = v12;
    _18 = v18;
    _24 = v16;

    mLength = getLength(0.0f, 1.0f, 0xA);
}

void BezierRailPart::calcPos(TVec3f *pOut, f32 a2) const {
    f32 v7 = 3.0f * a2;
    f32 v10 = ((3.0f * a2) * a2);
    f32 v9 = (a2 * (a2 * a2));

    TVec3f v16(_C);
    TVec3f v15(_18);
    TVec3f v14(_24);

    v16.scale(v7);
    v15.scale(v10);
    v14.scale(v9);

    pOut->set(_0);
    pOut->add(v16);
    pOut->add(v15);
    pOut->add(v14);
}

void BezierRailPart::calcVelocity(TVec3f *pOut, f32 a2) const {
    f32 v5 = (a2 * a2);
    f32 v7 = (2.0f * a2);

    TVec3f v12(_24);
    TVec3f v11(_18);
    v12.scale(v5);
    v11.scale(v7);

    pOut->set<f32>(_C);
    pOut->add(v11);
    pOut->add(v12);
    pOut->scale(3.0f);
}

// BezierRailPart::getLength
// BezierRailPart::getParam
// BezierRailPart::getNearestParam
// BezierRail::normalizePos

f32 BezierRail::getTotalLength() const {
    return _10[_8 - 1];
}

f32 BezierRail::getPartLength(int idx) const {
    return mRailParts[idx].getTotalLength();
}

void BezierRail::calcPos(TVec3f *pOut, f32 a2) const {
    const RailPart* part;
    f32 param;

    getIncludedSection(&part, &param, a2, 1);
    part->calcPos(pOut, part->getParam(param));
}

void BezierRail::calcDirection(TVec3f *pOut, f32 a2) const {
    const RailPart* part;
    f32 param;

    getIncludedSection(&part, &param, a2, 1);
    calcRailDirection(pOut, part, part->getParam(param));
}

void BezierRail::calcPosDir(TVec3f *pPos, TVec3f *pDir, f32 a3) const {
    const RailPart* part;
    f32 param;

    getIncludedSection(&part, &param, a3, 1);
    f32 val = part->getParam(param);
    part->calcPos(pPos, val);
    calcRailDirection(pDir, part, val);
}

#ifdef NON_MATCHING
// regalloc issues
f32 BezierRail::getNearestRailPosCoord(const TVec3f &a1) const {
    RailPart* part = mRailParts;
    int idx = 0;
    
    f32 length = part->getTotalLength();
    f32 nearestParam = part->getNearestParam(a1, 100.0f / length);

    TVec3f pos;
    part->calcPos(&pos, nearestParam);
    pos.sub(a1);

    f32 sqrt = pos.squared();

    for (int i = 1; i < _8; i++) {
        RailPart* curPart = &mRailParts[i];

        f32 curPartLength = curPart->getTotalLength();
        f32 curNearParam = curPart->getNearestParam(a1, 100.0f / curPartLength);
        curPart->calcPos(&pos, curNearParam);

        pos.sub(a1);
        f32 curSqrt = pos.squared();

        if (curSqrt < sqrt) {
            sqrt = curSqrt;
            idx = i;
            nearestParam = curNearParam;
        }
    }

    f32 val = !idx ? 0.0f : _10[idx - 1];
    return (val + mRailParts[idx].getLength(0.0f, nearestParam, 10));
}
#endif

f32 BezierRail::getRailPosCoord(int idx) const {
    if (!idx) {
        return 0.0f;
    }
    else {
        if (mIsClosed || mPointNum - 1 != idx) {
            return _10[idx - 1];
        }
    }

    return getTotalLength();
}

void BezierRail::calcCurrentRailCtrlPointIter(JMapInfoIter *pIter, f32 a2, bool a3) const {
    int idx = getCurrentCtrlPointIndex(a2, a3);
    calcRailCtrlPointIter(pIter, idx);
}

void BezierRail::calcRailCtrlPointIter(JMapInfoIter *pIter, int idx) const {
    pIter->_4 = idx;
    pIter->mInfo = _18;
}

// BezierRail::getIncludedSection
// BezierRail::getCurrentCtrlPointIndex
// BezierRail::BezierRail