ObjectPropeller.cc

#include "ObjectPropeller.hh"
 
#include "game/field/ObjectDirector.hh"
 
namespace Kinoko::Field {
 
ObjectPropeller::ObjectPropeller(const System::MapdataGeoObj &params)
    : ObjectCollidable(params), m_angle(0.0f) {
    m_blades.fill(nullptr);
}
 
ObjectPropeller::~ObjectPropeller() {
    for (auto *&blade : m_blades) {
        delete blade;
    }
}
 
void ObjectPropeller::init() {
    ASSERT(m_mapObj);
    m_angVel = static_cast<f32>(static_cast<s16>(m_mapObj->setting(0)));
    if (m_mapObj->setting(1) == 1) {
        m_angVel = -m_angVel;
    }
 
    m_rotMat.makeR(m_rot);
    m_rotMat.setBase(3, m_pos);
    m_axis = m_rotMat.base(2);
}
 
void ObjectPropeller::calc() {
    m_angle += m_angVel * 0.5f;
    m_curRot = EGG::Matrix34f::ident;
    m_curRot.setAxisRotation(m_angle * DEG2RAD, m_axis);
    m_transform = m_curRot.multiplyTo(m_rotMat);
    m_flags.setBit(eFlags::Matrix);
    m_transform.setBase(3, m_pos);
}
 
void ObjectPropeller::createCollision() {
    ObjectCollidable::createCollision();
 
    const auto &colCenter = collisionCenter();
    const auto &flowTable = ObjectDirector::Instance()->flowTable();
    const auto &params = flowTable.set(flowTable.slot(id()))->params.cylinder;
    f32 radius = static_cast<f32>(parse<s16>(params.radius));
    f32 height = static_cast<f32>(parse<s16>(params.height));
 
    for (auto *&blade : m_blades) {
        blade = new ObjectCollisionCylinder(radius, height, colCenter);
    }
}
 
void ObjectPropeller::calcCollisionTransform() {
    constexpr f32 BLADE_LENGTH = 250.0f;
 
    for (u32 i = 0; i < m_blades.size(); ++i) {
        EGG::Matrix34f mat;
        mat.setBase(3, EGG::Vector3f::zero);
        mat.setAxisRotation(static_cast<f32>(i * 120) * DEG2RAD, m_axis);
        calcTransform();
        mat = mat.multiplyTo(m_transform);
        EGG::Vector3f dir = mat.base(1);
        dir.normalise();
        dir *= BLADE_LENGTH;
        mat.setBase(3, m_pos + dir);
 
        auto *&blade = m_blades[i];
        blade->transform(mat, m_scale);
    }
}
 
f32 ObjectPropeller::getCollisionRadius() const {
    const auto &flowTable = ObjectDirector::Instance()->flowTable();
    const auto &params = flowTable.set(flowTable.slot(id()))->params.box;
    f32 z = m_scale.z * static_cast<f32>(parse<s16>(params.z));
    f32 x = m_scale.x * static_cast<f32>(parse<s16>(params.x));
 
    return 5.0f * std::max(z, x);
}
 
bool ObjectPropeller::checkCollision(ObjectCollisionBase *lhs, EGG::Vector3f &dist) {
    EGG::Vector3f dist0 = EGG::Vector3f::zero;
    EGG::Vector3f dist1 = EGG::Vector3f::zero;
    EGG::Vector3f dist2 = EGG::Vector3f::zero;
 
    bool hasCol = lhs->check(*m_blades[0], dist0);
    hasCol = hasCol || lhs->check(*m_blades[1], dist1);
    hasCol = hasCol || lhs->check(*m_blades[2], dist2);
 
    dist = dist0 + dist1 + dist2;
 
    return hasCol;
}
 
} // namespace Kinoko::Field