KartDynamics.hh

#pragma once
 
#include <egg/math/Matrix.hh>
 
namespace Kinoko::Kart {

class KartDynamics {
public:
    KartDynamics();
    virtual ~KartDynamics();
 
    virtual void forceUpright() {}
    virtual void stabilize();
 
    void init();
 
    void resetInternalVelocity() {
        m_intVel.setZero();
    }
 
    void setInertia(const EGG::Vector3f &m, const EGG::Vector3f &n);
    void setBspParams(f32 rotSpeed, const EGG::Vector3f &m, const EGG::Vector3f &n,
            bool skipInertia);
 
    void calc(f32 maxSpeed, bool air);
    void reset();
 
    void applySuspensionWrench(const EGG::Vector3f &p, const EGG::Vector3f &Flinear,
            const EGG::Vector3f &Frot, bool ignoreX);
    void applyWrenchScaled(const EGG::Vector3f &p, const EGG::Vector3f &f, f32 scale);

    void addForce(const EGG::Vector3f &pos) {
        m_totalForce += pos;
    }
 
    [[nodiscard]] EGG::Matrix34f calcWorldInertiaTensor() const;

    void setPos(const EGG::Vector3f &pos) {
        m_pos = pos;
    }
 
    void setGravity(f32 gravity) {
        m_gravity = gravity;
    }
 
    void setMainRot(const EGG::Quatf &q) {
        m_mainRot = q;
    }
 
    void setFullRot(const EGG::Quatf &q) {
        m_fullRot = q;
    }
 
    void setSpecialRot(const EGG::Quatf &q) {
        m_specialRot = q;
    }
 
    void setExtraRot(const EGG::Quatf &q) {
        m_extraRot = q;
    }
 
    void setIntVel(const EGG::Vector3f &v) {
        m_intVel = v;
    }
 
    void setTop(const EGG::Vector3f &v) {
        m_top = v;
    }
 
    void setStabilizationFactor(f32 val) {
        m_stabilizationFactor = val;
    }
 
    void setTotalForce(const EGG::Vector3f &v) {
        m_totalForce = v;
    }
 
    void setExtVel(const EGG::Vector3f &v) {
        m_extVel = v;
    }
 
    void setAngVel0(const EGG::Vector3f &v) {
        m_angVel0 = v;
    }
 
    void setMovingObjVel(const EGG::Vector3f &v) {
        m_movingObjVel = v;
    }
 
    void setMovingRoadVel(const EGG::Vector3f &v) {
        m_movingRoadVel = v;
    }
 
    void setAngVel2(const EGG::Vector3f &v) {
        m_angVel2 = v;
    }
 
    void setAngVel0YFactor(f32 val) {
        m_angVel0YFactor = val;
    }
 
    void setScale(const EGG::Vector3f &v) {
        m_scale = v;
    }
 
    void setTop_(const EGG::Vector3f &v) {
        m_top_ = v;
    }
 
    void setForceUpright(bool isSet) {
        m_forceUpright = isSet;
    }
 
    void setNoGravity(bool isSet) {
        m_noGravity = isSet;
    }
 
    void setKillExtVelY(bool isSet) {
        m_killExtVelY = isSet;
    }

    [[nodiscard]] const EGG::Matrix34f &invInertiaTensor() const {
        return m_invInertiaTensor;
    }
 
    [[nodiscard]] f32 angVel0Factor() const {
        return m_angVel0Factor;
    }
 
    [[nodiscard]] const EGG::Vector3f &pos() const {
        return m_pos;
    }
 
    [[nodiscard]] const EGG::Vector3f &velocity() const {
        return m_velocity;
    }
 
    [[nodiscard]] f32 gravity() const {
        return m_gravity;
    }
 
    [[nodiscard]] const EGG::Vector3f &intVel() const {
        return m_intVel;
    }
 
    [[nodiscard]] const EGG::Quatf &mainRot() const {
        return m_mainRot;
    }
 
    [[nodiscard]] const EGG::Quatf &fullRot() const {
        return m_fullRot;
    }
 
    [[nodiscard]] const EGG::Vector3f &totalForce() const {
        return m_totalForce;
    }
 
    [[nodiscard]] const EGG::Vector3f &extVel() const {
        return m_extVel;
    }
 
    [[nodiscard]] const EGG::Vector3f &angVel0() const {
        return m_angVel0;
    }
 
    [[nodiscard]] const EGG::Vector3f &movingObjVel() const {
        return m_movingObjVel;
    }
 
    [[nodiscard]] const EGG::Vector3f &movingRoadVel() const {
        return m_movingRoadVel;
    }
 
    [[nodiscard]] const EGG::Vector3f &angVel2() const {
        return m_angVel2;
    }
 
    [[nodiscard]] f32 speedFix() const {
        return m_speedFix;
    }
 
protected:
    EGG::Matrix34f m_inertiaTensor;    
    EGG::Matrix34f m_invInertiaTensor; 
    f32 m_angVel0Factor;               
    EGG::Vector3f m_pos;               
    EGG::Vector3f m_extVel;            
    EGG::Vector3f m_acceleration;      
    EGG::Vector3f m_angVel0;           
    EGG::Vector3f m_movingObjVel;      
    EGG::Vector3f m_angVel1;           
    EGG::Vector3f m_movingRoadVel;     
    EGG::Vector3f m_velocity;          
    f32 m_speedNorm;                   
    EGG::Vector3f m_angVel2;           
    EGG::Quatf m_mainRot;              
    EGG::Quatf m_fullRot;              
    EGG::Vector3f m_totalForce;        
    EGG::Vector3f m_totalTorque;       
    EGG::Quatf m_specialRot;           
    EGG::Quatf m_extraRot;             
    f32 m_gravity;                     
    EGG::Vector3f m_intVel;            
    EGG::Vector3f m_top;               
    f32 m_stabilizationFactor;         
    f32 m_speedFix;                    
    EGG::Vector3f m_top_;              
 
    f32 m_angVel0YFactor; 
    EGG::Vector3f m_scale;
    bool m_forceUpright; 
    bool m_noGravity;    
    bool m_killExtVelY;  
};

class KartDynamicsBike : public KartDynamics {
public:
    KartDynamicsBike();
    ~KartDynamicsBike();
 
private:
    void forceUpright() override;
    void stabilize() override;
};
 
} // namespace Kinoko::Kart