CollisionProfile.h

#pragma once
 
#include <cstdint>
#include <compare>
#include <string>
#include <vector>
 
namespace Engine::Components
{
    class Collision;
    class PhysicsBody;
}  // namespace Engine::Components
 
namespace Engine::Entities
{
    class Actor;
}  // namespace Engine::Entities
 
namespace Engine::Physics
{
    enum class CollisionResponse
    {
        Ignore,  
        Overlap,  
        Block  
    };

    enum class CollisionProfile
    {
        BlockAll,  
        OverlapAll,  
        IgnoreAll,  
        WorldStatic,  
        WorldDynamic,  
        Pawn  
    };

    enum class CollisionEventType
    {
        Begin,  
        Stay,  
        End  
    };

    struct CollisionProfileHandle
    {
        std::uint32_t id = 0;  

        [[nodiscard]] bool isValid() const { return id != 0; }

        friend bool operator==( const CollisionProfileHandle &, const CollisionProfileHandle & ) = default;
        friend auto operator<=>( const CollisionProfileHandle &, const CollisionProfileHandle & ) = default;
    };

    struct PhysicsBodyHandle
    {
        std::uint32_t id         = 0;  
        std::uint32_t generation = 0;  

        [[nodiscard]] bool isValid() const { return id != 0 && generation != 0; }

        friend bool operator==( const PhysicsBodyHandle &, const PhysicsBodyHandle & ) = default;
        friend auto operator<=>( const PhysicsBodyHandle &, const PhysicsBodyHandle & ) = default;
    };

    struct CollisionHandle
    {
        std::uint32_t id         = 0;  
        std::uint32_t generation = 0;  

        [[nodiscard]] bool isValid() const { return id != 0 && generation != 0; }

        friend bool operator==( const CollisionHandle &, const CollisionHandle & ) = default;
        friend auto operator<=>( const CollisionHandle &, const CollisionHandle & ) = default;
    };

    struct PhysicsQueryFilter
    {
        CollisionProfileHandle profile;  
        bool includeOverlaps = true;  
        bool includeBlocks = true;  
    };

    struct CollisionEvent
    {
        Components::PhysicsBody * selfBody  = nullptr;  
        Components::PhysicsBody * otherBody = nullptr;  
 
        Entities::Actor * selfActor  = nullptr;  
        Entities::Actor * otherActor = nullptr;  
 
        CollisionResponse response  = CollisionResponse::Ignore;  
        CollisionEventType eventType = CollisionEventType::Begin;  

        std::vector<Components::Collision *> selfComponents;

        std::vector<Components::Collision *> otherComponents;
    };

    [[nodiscard]] const char * toString( CollisionResponse response );

    [[nodiscard]] bool fromString( const std::string & value, CollisionResponse & outResponse );

    [[nodiscard]] CollisionResponse resolvePairResponse( CollisionResponse responseAB, CollisionResponse responseBA );
}  // namespace Engine::Physics