CollisionProfileRegistry.h

#pragma once
 
#include "Engine/Physics/CollisionProfile.h"
 
#include <initializer_list>
#include <optional>
#include <string>
#include <string_view>
#include <type_traits>
#include <typeindex>
#include <unordered_map>
#include <utility>
#include <vector>
 
namespace Engine::Physics
{
    class CollisionProfileRegistry
    {
    public:
        CollisionProfileRegistry();

        template < typename ProfileEnum >
        void registerProfileEnum(
            std::string domain,
            std::initializer_list<std::pair<ProfileEnum, std::string_view>> values
        )
        {
            static_assert( std::is_enum_v<ProfileEnum>, "Collision profiles must be enum values" );
 
            auto & enumMap = enumProfiles_[std::type_index( typeid( ProfileEnum ) )];
            for ( const auto & [value, name] : values )
            {
                const std::string fullName = domain + "." + std::string( name );
                const auto        handle   = registerProfileName( fullName );
                enumMap[static_cast<std::int64_t>( value )] = handle;
            }
        }

        template < typename ProfileEnum >
        [[nodiscard]] CollisionProfileHandle resolve( ProfileEnum value ) const
        {
            static_assert( std::is_enum_v<ProfileEnum>, "Collision profiles must be enum values" );
 
            const auto domainIt = enumProfiles_.find( std::type_index( typeid( ProfileEnum ) ) );
            if ( domainIt == enumProfiles_.end() )
            {
                return {};
            }
 
            const auto valueIt = domainIt->second.find( static_cast<std::int64_t>( value ) );
            return valueIt != domainIt->second.end() ? valueIt->second : CollisionProfileHandle{};
        }

        void registerEngineProfiles();

        bool loadProfileResponses( const std::string & path );

        void warnAboutAsymmetricResponses() const;

        [[nodiscard]] CollisionProfileHandle registerProfileName( const std::string & fullName );

        [[nodiscard]] CollisionProfileHandle findProfile( const std::string & fullName ) const;

        [[nodiscard]] CollisionProfileHandle getFallbackProfile() const;

        [[nodiscard]] CollisionResponse getResponse(
            CollisionProfileHandle profileA,
            CollisionProfileHandle profileB
        ) const;

        [[nodiscard]] CollisionResponse getResolvedResponse(
            CollisionProfileHandle profileA,
            CollisionProfileHandle profileB
        ) const;

        [[nodiscard]] std::uint16_t getBulletGroup( CollisionProfileHandle profile ) const;

        [[nodiscard]] std::uint16_t getBulletMask( CollisionProfileHandle profile ) const;

        [[nodiscard]] bool profileCanBlockAny( CollisionProfileHandle profile ) const;

        [[nodiscard]] std::vector<CollisionProfileHandle> getProfiles() const;

        [[nodiscard]] const std::string & getProfileName( CollisionProfileHandle profile ) const;
 
    private:
        struct ProfileData
        {
            std::string fullName;
            CollisionResponse defaultResponse = CollisionResponse::Block;
            std::unordered_map<std::uint32_t, CollisionResponse> responses;
        };
 
        [[nodiscard]] ProfileData * findData( CollisionProfileHandle profile );
        [[nodiscard]] const ProfileData * findData( CollisionProfileHandle profile ) const;
        void setDefaultResponse( CollisionProfileHandle profile, CollisionResponse response );
        void setResponse( CollisionProfileHandle profileA, CollisionProfileHandle profileB, CollisionResponse response );
        void logMaskOverflowIfNeeded() const;
 
        std::vector<ProfileData> profiles_;
        std::unordered_map<std::string, CollisionProfileHandle> profilesByName_;
        std::unordered_map<std::type_index, std::unordered_map<std::int64_t, CollisionProfileHandle>> enumProfiles_;
    };

    void setActiveCollisionProfileRegistry( CollisionProfileRegistry * registry );

    [[nodiscard]] CollisionProfileRegistry * getActiveCollisionProfileRegistry();
}  // namespace Engine::Physics