CollisionGroup.hh

#pragma once
 
#include "game/kart/KartParam.hh"
 
#include "game/field/KCollisionTypes.hh"
 
#include <egg/math/Matrix.hh>
 
#include <array>
#include <span>
 
namespace Kinoko::Kart {
 
struct CollisionData {
    void reset();
 
    EGG::Vector3f tangentOff;
    EGG::Vector3f floorNrm;
    EGG::Vector3f wallNrm;
    EGG::Vector3f noBounceWallNrm;
    EGG::Vector3f vel;
    EGG::Vector3f relPos;
    EGG::Vector3f movement;
    EGG::Vector3f roadVelocity;
    f32 speedFactor;
    f32 rotFactor;
    Field::KCLTypeMask closestFloorFlags; 
    u32 closestFloorSettings;             
    Field::KCLTypeMask closestWallFlags;  
    u32 closestWallSettings;              
    s32 intensity;                        
    f32 colPerpendicularity;
 
    bool bFloor; 
    bool bWall;  
    bool bInvisibleWall;
    bool bTrickable;
    bool bMovingWaterMomentum; 
    bool bWall3;               
    bool bInvisibleWallOnly;
    bool bMovingWaterDecaySpeed; 
    bool bSoftWall;
    bool bMovingWaterStickyRoad;   
    bool bMovingWaterDisableAccel; 
    bool bHasRoadVel;
    bool bWallAtLeftCloser;
    bool bWallAtRightCloser;
    bool bMovingWaterVertical; 
};
 
class Hitbox {
public:
    Hitbox();
    ~Hitbox();
 
    void calc(f32 totalScale, f32 sinkDepth, const EGG::Vector3f &scale, const EGG::Quatf &rot,
            const EGG::Vector3f &pos);
 
    void reset();
 
    void setRadius(f32 radius) {
        m_radius = radius;
    }
 
    void setBspHitbox(const BSP::Hitbox *hitbox, bool owns = false) {
        m_ownsBSP = owns;
        m_bspHitbox = hitbox;
    }
 
    void setWorldPos(const EGG::Vector3f &pos) {
        m_worldPos = pos;
    }
 
    void setLastPos(const EGG::Vector3f &pos) {
        m_lastPos = pos;
    }
 
    void setLastPos(const EGG::Vector3f &scale, const EGG::Matrix34f &pose);
 
    [[nodiscard]] const BSP::Hitbox *bspHitbox() const {
        return m_bspHitbox;
    }
 
    [[nodiscard]] const EGG::Vector3f &worldPos() const {
        return m_worldPos;
    }
 
    [[nodiscard]] const EGG::Vector3f &lastPos() const {
        return m_lastPos;
    }
 
    [[nodiscard]] const EGG::Vector3f &relPos() const {
        return m_relPos;
    }
 
    [[nodiscard]] f32 radius() const {
        return m_radius;
    }
 
private:
    const BSP::Hitbox *m_bspHitbox;
    f32 m_radius;
    EGG::Vector3f m_worldPos;
    EGG::Vector3f m_lastPos;
    EGG::Vector3f m_relPos;
 
    bool m_ownsBSP;
};
 
class CollisionGroup {
public:
    CollisionGroup();
    ~CollisionGroup();
 
    [[nodiscard]] f32 initHitboxes(const std::array<BSP::Hitbox, 16> &hitboxes);
    [[nodiscard]] f32 computeCollisionLimits();
    void createSingleHitbox(f32 radius, const EGG::Vector3f &relPos);
 
    void reset();
    void resetCollision();
    void setHitboxScale(f32 scale);
 
    [[nodiscard]] f32 boundingRadius() const {
        return m_boundingRadius;
    }
 
    [[nodiscard]] Hitbox &hitbox(u16 hitboxIdx) {
        return m_hitboxes[hitboxIdx];
    }
 
    [[nodiscard]] u16 hitboxCount() const {
        return m_hitboxes.size();
    }
 
    [[nodiscard]] CollisionData &collisionData() {
        return m_collisionData;
    }
 
    [[nodiscard]] const CollisionData &collisionData() const {
        return m_collisionData;
    }
 
private:
    f32 m_boundingRadius;
    CollisionData m_collisionData;
    owning_span<Hitbox> m_hitboxes;
    f32 m_hitboxScale;
};
 
} // namespace Kinoko::Kart