CollisionComponent.h

#pragma once
 
#include "Engine/Component/LogicComponent.h"
#include "Engine/Component/PhysicsBodyComponent.h"
#include "Engine/Physics/CollisionProfileRegistry.h"
#include <glm/glm.hpp>
#include <glm/gtc/quaternion.hpp>
#include <entt/entt.hpp>
#include <functional>
#include <string>
#include <vector>
 
namespace Engine::Entities
{
    class Scene;
}  // namespace Engine::Entities
class btCollisionShape;
 
namespace Engine::Components {

    class Collision : public Logic {
        friend class PhysicsBody;
 
    public:
        static constexpr bool IsUnique = false;  
        static constexpr const char* ComponentName = "Collision";  

        using CollisionCallbackHandle = std::uint64_t;

        Collision(Engine::Entities::Scene* scene, entt::entity entity);

        ~Collision() override;

        void beginPlay() override;

        void endPlay() override;

        bool drawImGui() override;
 
        // =========================================================================
        // Shape Management
        // =========================================================================

        virtual btCollisionShape* createShape() = 0;

        virtual void destroyShape();

        void markDirty();

        void rebuild();

        [[nodiscard]] btCollisionShape* getShape() const { return shape_; }
 
        // =========================================================================
        // Local Transform (offset from body center)
        // =========================================================================

        void setLocalOffset(const glm::vec3& offset);

        [[nodiscard]] glm::vec3 getLocalOffset() const { return localOffset_; }

        void setLocalRotation(const glm::quat& rotation);

        [[nodiscard]] glm::quat getLocalRotation() const { return localRotation_; }

        [[nodiscard]] glm::mat4 getLocalTransform() const;
 
        // =========================================================================
        // Trigger Mode
        // =========================================================================

        [[deprecated("Use setCollisionProfile() with an overlap profile instead")]] void setIsTrigger(bool trigger);

        [[nodiscard]] bool isTrigger() const { return isTrigger_; }
 
        // =========================================================================
        // Collision Profiles
        // =========================================================================

        void setCollisionProfile( Physics::CollisionProfileHandle profile );

        void setCollisionProfileByName( const std::string & profileName );

        [[nodiscard]] Physics::CollisionProfileHandle getCollisionProfile() const;

        template < typename ProfileEnum >
        void setCollisionProfile( ProfileEnum profile )
        {
            if ( Physics::CollisionProfileRegistry * registry = Physics::getActiveCollisionProfileRegistry() )
            {
                setCollisionProfile( registry->resolve( profile ) );
            }
        }
 
        // =========================================================================
        // Collision Callbacks
        // =========================================================================

        virtual void onCollisionBegin(Components::Collision* other);

        virtual void onCollisionEnd(Components::Collision* other);

        virtual void onCollisionStay(Components::Collision* other);

        virtual void onOverlapBegin(Components::Collision* other);

        virtual void onOverlapEnd(Components::Collision* other);

        virtual void onOverlapStay(Components::Collision* other);

        template<typename ActorType, typename Callback>
        CollisionCallbackHandle onOverlapBegin( Callback && callback )
        {
            return addOverlapBeginCallback(
                [callback = std::forward<Callback>( callback )]( Components::Collision * other ) mutable
                {
                    Components::PhysicsBody * otherBody = other != nullptr ? other->getBodyComponent() : nullptr;
                    auto * actor = otherBody != nullptr
                        ? dynamic_cast<ActorType *>( otherBody->getHitActor() )
                        : nullptr;
                    if ( actor != nullptr )
                    {
                        callback( *actor );
                    }
                }
            );
        }

        template<typename ActorType, typename Callback>
        CollisionCallbackHandle onOverlapEnd( Callback && callback )
        {
            return addOverlapEndCallback(
                [callback = std::forward<Callback>( callback )]( Components::Collision * other ) mutable
                {
                    Components::PhysicsBody * otherBody = other != nullptr ? other->getBodyComponent() : nullptr;
                    auto * actor = otherBody != nullptr
                        ? dynamic_cast<ActorType *>( otherBody->getHitActor() )
                        : nullptr;
                    if ( actor != nullptr )
                    {
                        callback( *actor );
                    }
                }
            );
        }

        void removeOverlapCallback( CollisionCallbackHandle handle );

        void dispatchOverlapBegin( Components::Collision * other );

        void dispatchOverlapEnd( Components::Collision * other );

        void dispatchOverlapStay( Components::Collision * other );

        void dispatchCollisionBegin( Components::Collision * other );

        void dispatchCollisionEnd( Components::Collision * other );

        void dispatchCollisionStay( Components::Collision * other );

        [[nodiscard]] Components::PhysicsBody* getBodyComponent() const { return bodyComponent_; }

        [[nodiscard]] Physics::CollisionHandle getCollisionHandle() const { return collisionHandle_; }

        void setCollisionHandle( Physics::CollisionHandle handle ) { collisionHandle_ = handle; }
 
        // =========================================================================
        // Debug Visualization
        // =========================================================================

        virtual void debugDraw(const glm::mat4& worldTransform) const;

        void setDebugColorSeed(std::uint64_t seed);

        void setDebugName(std::string name);

        [[nodiscard]] const std::string& getDebugName() const { return debugName_; }

        static void setDebugDrawEnabled(bool enabled);

        [[nodiscard]] static bool isDebugDrawEnabled();
 
    protected:
        [[nodiscard]] glm::vec4 getDebugDrawColor(const glm::vec4& fallbackColor) const;
 
        static bool debugDrawEnabled_;  
        entt::entity entity_;  
        btCollisionShape* shape_ = nullptr;  
        glm::vec3 localOffset_{0.0f};  
        glm::quat localRotation_{glm::identity<glm::quat>()};  
        Components::PhysicsBody* bodyComponent_ = nullptr;  
        std::string debugName_;  
        std::uint64_t debugColorSeed_ = 0;  
        bool hasDebugColorSeed_ = false;  
        bool isTrigger_ = false;  
        bool isDirty_ = false;  
        Physics::CollisionProfileHandle collisionProfile_;  
        Physics::CollisionHandle collisionHandle_;  
 
    private:
        struct CallbackSubscription
        {
            CollisionCallbackHandle handle = 0;
            std::function<void( Components::Collision * )> callback;
        };
 
        CollisionCallbackHandle addOverlapBeginCallback( std::function<void( Components::Collision * )> callback );
        CollisionCallbackHandle addOverlapEndCallback( std::function<void( Components::Collision * )> callback );
        void clearCallbacks();
 
        void registerWithBody();
        void unregisterFromBody();
 
        CollisionCallbackHandle nextCallbackHandle_ = 1;
        std::vector<CallbackSubscription> overlapBeginCallbacks_;
        std::vector<CallbackSubscription> overlapEndCallbacks_;
    };
 
}  // namespace EngineCore