CollisionDirector.hh

#pragma once
 
#include "game/field/CourseColMgr.hh"
 
#include <egg/math/Vector.hh>
 
#define COLLISION_ARR_LENGTH 0x40
 
namespace Kinoko {
 
namespace Host {
 
class Context;
 
} // namespace Host
 
namespace Field {
 
class CollisionDirector : EGG::Disposer {
    friend class Host::Context;
 
public:
    enum class eCollisionAttribute {
        Trickable = 13,
        RejectRoad = 14,
        Soft = 15,
    };
    typedef EGG::TBitFlag<u16, eCollisionAttribute> CollisionAttribute;
 
    struct CollisionEntry {
        KCLTypeMask typeMask;
        CollisionAttribute attribute;
        f32 dist;
 
        u16 baseType() const {
            return attribute & 0x1F;
        }
 
        u16 variant() const {
            return (attribute >> 5) & 7;
        }
 
        u16 intensity() const {
            return (attribute >> 11) & 3;
        }
 
        void setVariant(u16 variant) {
            u16 current = static_cast<u16>(attribute);
            attribute = static_cast<CollisionAttribute>((current & ~0xE0) | ((variant & 7) << 5));
        }
    };
 
    void checkCourseColNarrScLocal(f32 radius, const EGG::Vector3f &pos, KCLTypeMask mask,
            u32 timeOffset);
 
    [[nodiscard]] bool checkSpherePartialPush(f32 radius, const EGG::Vector3f &pos,
            const EGG::Vector3f &prevPos, KCLTypeMask flags, CollisionInfoPartial *info,
            KCLTypeMask *typeMaskOut, u32 timeOffset);
    [[nodiscard]] bool checkSphereFull(f32 radius, const EGG::Vector3f &v0, const EGG::Vector3f &v1,
            KCLTypeMask flags, CollisionInfo *pInfo, KCLTypeMask *pFlagsOut, u32 timeOffset);
    [[nodiscard]] bool checkSphereFullPush(f32 radius, const EGG::Vector3f &v0,
            const EGG::Vector3f &v1, KCLTypeMask flags, CollisionInfo *pInfo,
            KCLTypeMask *pFlagsOut, u32 timeOffset);
 
    [[nodiscard]] bool checkSphereCachedPartial(f32 radius, const EGG::Vector3f &pos,
            const EGG::Vector3f &prevPos, KCLTypeMask typeMask, CollisionInfoPartial *info,
            KCLTypeMask *typeMaskOut, u32 timeOffset);
    [[nodiscard]] bool checkSphereCachedPartialPush(f32 radius, const EGG::Vector3f &pos,
            const EGG::Vector3f &prevPos, KCLTypeMask typeMask, CollisionInfoPartial *info,
            KCLTypeMask *typeMaskOut, u32 timeOffset);
    [[nodiscard]] bool checkSphereCachedFullPush(f32 radius, const EGG::Vector3f &pos,
            const EGG::Vector3f &prevPos, KCLTypeMask typeMask, CollisionInfo *info,
            KCLTypeMask *typeMaskOut, u32 timeOffset);
 
    void resetCollisionEntries(KCLTypeMask *ptr);
    void pushCollisionEntry(f32 dist, KCLTypeMask *typeMask, KCLTypeMask kclTypeBit,
            CollisionAttribute attribute);
 
    void setCurrentCollisionVariant(u16 attribute) {
        ASSERT(m_collisionEntryCount > 0);
        m_entries[m_collisionEntryCount - 1].setVariant(attribute);
    }
 
    void setCurrentCollisionTrickable(bool trickable) {
        ASSERT(m_collisionEntryCount > 0);
        CollisionEntry &entry = m_entries[m_collisionEntryCount - 1];
        entry.attribute.changeBit(trickable, eCollisionAttribute::Trickable);
    }
 
    bool findClosestCollisionEntry(KCLTypeMask *typeMask, KCLTypeMask type);
 
    [[nodiscard]] const CollisionEntry *closestCollisionEntry() const {
        return m_closestCollisionEntry;
    }
 
    static CollisionDirector *CreateInstance();
    static void DestroyInstance();
 
    [[nodiscard]] static CollisionDirector *Instance() {
        return s_instance;
    }
 
private:
    CollisionDirector();
    ~CollisionDirector() override;
 
    const CollisionEntry *m_closestCollisionEntry;
    std::array<CollisionEntry, COLLISION_ARR_LENGTH> m_entries;
    size_t m_collisionEntryCount;
 
    static CollisionDirector *s_instance; 
};
 
} // namespace Field
 
} // namespace Kinoko