PhysicsBodyComponent.h

#pragma once
 
#include "Engine/Component/LogicComponent.h"
#include "Engine/Physics/CollisionProfile.h"
#include <glm/glm.hpp>
#include <glm/gtc/quaternion.hpp>
#include <entt/entt.hpp>
#include <functional>
#include <memory>
#include <vector>
#include <set>
#include <utility>
 
namespace Engine::Core
{
    class PhysicsEngine;
}  // namespace Engine::Core
 
namespace Engine::Entities
{
    class Actor;
    class SceneNode;
}  // namespace Engine::Entities
 
class btRigidBody;
class btCompoundShape;
class btCollisionShape;
class btDiscreteDynamicsWorld;
 
namespace Engine::Components {
    class Collision;

    class PhysicsBody : public Logic {
    public:
        static constexpr bool IsUnique = true;  
        static constexpr const char* ComponentName = "PhysicsBody";  
        using PhysicsBodyCallbackHandle = std::uint64_t;  

        PhysicsBody(Entities::Scene* scene, entt::entity entity,
                             std::shared_ptr<Entities::SceneNode> sceneNode);

        ~PhysicsBody() override;
 
        void beginPlay() override;
        void endPlay() override;
        bool drawImGui() override;
 
        // =========================================================================
        // Physics Properties
        // =========================================================================

        void setMass(float mass);

        [[nodiscard]] float getMass() const { return mass_; }

        void setFriction(float friction);

        [[nodiscard]] float getFriction() const { return friction_; }

        void setRestitution(float restitution);

        [[nodiscard]] float getRestitution() const { return restitution_; }

        void setKinematic(bool kinematic);

        [[nodiscard]] bool isKinematic() const { return isKinematic_; }

        void setStatic(bool isStatic);

        [[nodiscard]] bool isStatic() const { return isStatic_; }
 
        // =========================================================================
        // Transform Control
        // =========================================================================

        void teleport(const glm::vec3& position);

        void teleport(const glm::vec3& position, const glm::quat& rotation);

        void setLinearVelocity(const glm::vec3& velocity);

        [[nodiscard]] glm::vec3 getLinearVelocity() const;

        void setAngularVelocity(const glm::vec3& velocity);

        [[nodiscard]] glm::vec3 getAngularVelocity() const;
 
        // =========================================================================
        // Collision Management (called by CollisionComponents)
        // =========================================================================

        void registerCollision(Components::Collision* collision);

        void unregisterCollision(Components::Collision* collision);

        void markShapeDirty();

        void markCollisionFiltersDirty();

        void rebuildIfDirty();

        [[nodiscard]] btRigidBody* getRigidBody() const { return rigidBody_; }

        [[nodiscard]] Entities::Actor* getHitActor() const;

        [[nodiscard]] Physics::PhysicsBodyHandle getPhysicsBodyHandle() const { return bodyHandle_; }

        void setPhysicsBodyHandle( Physics::PhysicsBodyHandle handle ) { bodyHandle_ = handle; }

        [[nodiscard]] const std::vector<Components::Collision*> & getCollisions() const { return collisions_; }

        [[nodiscard]] Components::Collision * findCollisionForShape( const btCollisionShape * shape ) const;

        [[nodiscard]] btDiscreteDynamicsWorld* getDynamicsWorld() const;
 
        // =========================================================================
        // Collision Callbacks
        // =========================================================================

        void processCollisions();

        template<typename ActorType, typename Callback>
        PhysicsBodyCallbackHandle onOverlapBegin( Callback && callback )
        {
            return addBodyCallback(
                overlapBeginCallbacks_,
                [callback = std::forward<Callback>( callback )]( const Physics::CollisionEvent & event ) mutable
                {
                    auto * actor = dynamic_cast<ActorType *>( event.otherActor );
                    if ( actor != nullptr )
                    {
                        callback( event, *actor );
                    }
                }
            );
        }

        template<typename ActorType, typename Callback>
        PhysicsBodyCallbackHandle onOverlapStay( Callback && callback )
        {
            return addBodyCallback(
                overlapStayCallbacks_,
                [callback = std::forward<Callback>( callback )]( const Physics::CollisionEvent & event ) mutable
                {
                    auto * actor = dynamic_cast<ActorType *>( event.otherActor );
                    if ( actor != nullptr )
                    {
                        callback( event, *actor );
                    }
                }
            );
        }

        template<typename ActorType, typename Callback>
        PhysicsBodyCallbackHandle onOverlapEnd( Callback && callback )
        {
            return addBodyCallback(
                overlapEndCallbacks_,
                [callback = std::forward<Callback>( callback )]( const Physics::CollisionEvent & event ) mutable
                {
                    auto * actor = dynamic_cast<ActorType *>( event.otherActor );
                    if ( actor != nullptr )
                    {
                        callback( event, *actor );
                    }
                }
            );
        }

        template<typename ActorType, typename Callback>
        PhysicsBodyCallbackHandle onCollisionBegin( Callback && callback )
        {
            return addBodyCallback(
                collisionBeginCallbacks_,
                [callback = std::forward<Callback>( callback )]( const Physics::CollisionEvent & event ) mutable
                {
                    auto * actor = dynamic_cast<ActorType *>( event.otherActor );
                    if ( actor != nullptr )
                    {
                        callback( event, *actor );
                    }
                }
            );
        }

        template<typename ActorType, typename Callback>
        PhysicsBodyCallbackHandle onCollisionStay( Callback && callback )
        {
            return addBodyCallback(
                collisionStayCallbacks_,
                [callback = std::forward<Callback>( callback )]( const Physics::CollisionEvent & event ) mutable
                {
                    auto * actor = dynamic_cast<ActorType *>( event.otherActor );
                    if ( actor != nullptr )
                    {
                        callback( event, *actor );
                    }
                }
            );
        }

        template<typename ActorType, typename Callback>
        PhysicsBodyCallbackHandle onCollisionEnd( Callback && callback )
        {
            return addBodyCallback(
                collisionEndCallbacks_,
                [callback = std::forward<Callback>( callback )]( const Physics::CollisionEvent & event ) mutable
                {
                    auto * actor = dynamic_cast<ActorType *>( event.otherActor );
                    if ( actor != nullptr )
                    {
                        callback( event, *actor );
                    }
                }
            );
        }

        void removeCollisionCallback( PhysicsBodyCallbackHandle handle );

        void dispatchCollisionEvent( const Physics::CollisionEvent & event );
 
        // =========================================================================
        // Debug Visualization
        // =========================================================================

        void debugDraw() const;
 
    private:
        void rebuildCollisionShape();
        void createRigidBody();
        void destroyRigidBody();
        void updateEcsComponent();
        void applyCollisionFlags();
        void readdRigidBodyWithCurrentFilters();
        [[nodiscard]] std::uint16_t getBulletCollisionGroup() const;
        [[nodiscard]] std::uint16_t getBulletCollisionMask() const;
        [[nodiscard]] bool shouldUseNoContactResponse() const;
        [[nodiscard]] Core::PhysicsEngine * getPhysicsEngine() const;
 
        struct BodyCallbackSubscription
        {
            PhysicsBodyCallbackHandle handle = 0;
            std::function<void( const Physics::CollisionEvent & )> callback;
        };
 
        PhysicsBodyCallbackHandle addBodyCallback(
            std::vector<BodyCallbackSubscription> & callbacks,
            std::function<void( const Physics::CollisionEvent & )> callback
        );
        void clearCallbacks();
 
        entt::entity entity_;
        std::weak_ptr<Entities::SceneNode> sceneNode_;
 
        std::vector<Components::Collision*> collisions_;
        btCompoundShape* compoundShape_ = nullptr;
        btRigidBody* rigidBody_ = nullptr;
 
        float mass_ = 1.0f;
        float friction_ = 0.5f;
        float restitution_ = 0.0f;
        bool isKinematic_ = false;
        bool isStatic_ = false;
        bool shapeDirty_ = true;
        bool isInitialized_ = false;
        bool collisionFiltersDirty_ = true;
        Physics::PhysicsBodyHandle bodyHandle_;
        PhysicsBodyCallbackHandle nextCallbackHandle_ = 1;
        std::vector<BodyCallbackSubscription> overlapBeginCallbacks_;
        std::vector<BodyCallbackSubscription> overlapStayCallbacks_;
        std::vector<BodyCallbackSubscription> overlapEndCallbacks_;
        std::vector<BodyCallbackSubscription> collisionBeginCallbacks_;
        std::vector<BodyCallbackSubscription> collisionStayCallbacks_;
        std::vector<BodyCallbackSubscription> collisionEndCallbacks_;
 
        // For collision callbacks - track previous frame's collisions
        std::set<Components::Collision*> previousCollisions_;
    };
 
}  // namespace EngineCore