KartPhysics.hh

#pragma once
 
#include "game/kart/CollisionGroup.hh"
#include "game/kart/KartDynamics.hh"
#include "game/kart/KartParam.hh"
 
#include <egg/math/Matrix.hh>
 
namespace Kinoko::Kart {
 
class KartPhysics {
public:
    KartPhysics(bool isBike);
    ~KartPhysics();
 
    void reset();
    void updatePose();
 
    void calc(f32 dt, f32 maxSpeed, const EGG::Vector3f &scale, bool air);
 
    void setPos(const EGG::Vector3f &pos) {
        m_pos = pos;
    }
 
    void setVelocity(const EGG::Vector3f &vel) {
        m_velocity = vel;
    }
 
    void set_fc(f32 val) {
        m_fc = val;
    }
 
    void composeStuntRot(const EGG::Quatf &rot) {
        m_instantaneousStuntRot *= rot;
    }
 
    void composeExtraRot(const EGG::Quatf &rot) {
        m_instantaneousExtraRot *= rot;
    }
 
    void composeDecayingStuntRot(const EGG::Quatf &rot) {
        m_decayingStuntRot *= rot;
    }
 
    void composeDecayingExtraRot(const EGG::Quatf &rot) {
        m_decayingExtraRot *= rot;
    }
 
    void composeMovingObjVel(const EGG::Vector3f &vel, f32 t) {
        m_movingObjVel += (vel - m_movingObjVel) * t;
        dynamics()->setMovingObjVel(m_movingObjVel);
    }
 
    void composeDecayingMovingObjVel(f32 floorScalar, f32 airScalar, bool floor) {
        m_movingObjVel *= floor ? floorScalar : airScalar;
        dynamics()->setMovingObjVel(m_movingObjVel);
    }
 
    void composeMovingRoadVel(const EGG::Vector3f &vel, f32 t) {
        m_movingRoadVel += (vel - m_movingRoadVel) * t;
        dynamics()->setMovingRoadVel(m_movingRoadVel);
    }
 
    void shiftDecayMovingRoadVel(const EGG::Vector3f &v, f32 maxPullSpeed);
 
    void decayMovingRoadVel(f32 floorScalar, f32 airScalar, bool floor) {
        m_movingRoadVel *= floor ? floorScalar : airScalar;
        m_movingRoadVel.y = 0.0f;
        dynamics()->setMovingRoadVel(m_movingRoadVel);
    }
 
    void clearDecayingRot() {
        m_decayingStuntRot = EGG::Quatf::ident;
        m_decayingExtraRot = EGG::Quatf::ident;
    }
 
    [[nodiscard]] KartDynamics *dynamics() {
        return m_dynamics;
    }
 
    [[nodiscard]] const KartDynamics *dynamics() const {
        return m_dynamics;
    }
 
    [[nodiscard]] const EGG::Matrix34f &pose() const {
        return m_pose;
    }
 
    [[nodiscard]] CollisionGroup *hitboxGroup() {
        return m_hitboxGroup;
    }
 
    [[nodiscard]] const EGG::Vector3f &xAxis() const {
        return m_xAxis;
    }
 
    [[nodiscard]] const EGG::Vector3f &yAxis() const {
        return m_yAxis;
    }
 
    [[nodiscard]] const EGG::Vector3f &zAxis() const {
        return m_zAxis;
    }
 
    [[nodiscard]] const EGG::Vector3f &pos() const {
        return m_pos;
    }
 
    [[nodiscard]] f32 fc() const {
        return m_fc;
    }
 
    [[nodiscard]] static KartPhysics *Create(const KartParam &param);
 
private:
    KartDynamics *m_dynamics;
    CollisionGroup *m_hitboxGroup;
    EGG::Vector3f m_pos;
    EGG::Quatf m_decayingStuntRot;
    EGG::Quatf m_instantaneousStuntRot;
    EGG::Quatf m_specialRot;
    EGG::Quatf m_decayingExtraRot;
    EGG::Quatf m_instantaneousExtraRot;
    EGG::Quatf m_extraRot;
    EGG::Vector3f m_movingObjVel;
    EGG::Vector3f m_movingRoadVel;
    EGG::Matrix34f m_pose;    
    EGG::Vector3f m_xAxis;    
    EGG::Vector3f m_yAxis;    
    EGG::Vector3f m_zAxis;    
    EGG::Vector3f m_velocity; 
    f32 m_fc;                 
};
 
} // namespace Kinoko::Kart