PhysicsEngine.h

#pragma once
 
#include <btBulletDynamicsCommon.h>
#include "Engine/Physics/CollisionProfile.h"
#include <glm/mat4x4.hpp>
#include <glm/vec3.hpp>
#include <map>
#include <set>
#include <unordered_map>
 
namespace Engine
{
    namespace Components
    {
        class PhysicsBody;
    }
 
    namespace Physics
    {
        class CollisionProfileRegistry;
        struct CollisionEvent;
        struct PhysicsQueryFilter;

        struct RaycastHit
        {
            glm::vec3 point{ 0.0f };  
 
            glm::vec3 normal{ 0.0f };  
 
            float fraction = 0.0f;  
 
            float distance = 0.0f;  

            const btCollisionObject* collisionObject = nullptr;

            [[nodiscard]] Components::PhysicsBody* getPhysicsBody() const;
        };

        struct RigidBodyCreateInfo
        {
            glm::mat4 transform {1.0f};

            float mass = 1.0f;

            btCollisionShape* shape = nullptr;

            float friction = 0.5f;

            float restitution = 0.0f;
        };
    }
 
    namespace Core
    {
        class PhysicsEngine
        {
        public:
            PhysicsEngine();

            explicit PhysicsEngine( Physics::CollisionProfileRegistry * collisionProfileRegistry );

            ~PhysicsEngine();

            void setCollisionProfileRegistry( Physics::CollisionProfileRegistry * collisionProfileRegistry );

            [[nodiscard]] Physics::CollisionProfileRegistry * getCollisionProfileRegistry() const;

            void onPhysicsComponentDestroyed( entt::registry & registry, entt::entity entity );

            void update(double deltaTimeSeconds);

            void dispatchQueuedCollisionEvents();

            [[nodiscard]] Physics::PhysicsBodyHandle registerBody( Components::PhysicsBody * body );

            void unregisterBody( Physics::PhysicsBodyHandle handle );

            [[nodiscard]] Components::PhysicsBody * resolve( Physics::PhysicsBodyHandle handle ) const;

            [[nodiscard]] Physics::CollisionHandle registerCollision( Components::Collision * collision );

            void unregisterCollision( Physics::CollisionHandle handle );

            [[nodiscard]] Components::Collision * resolve( Physics::CollisionHandle handle ) const;

            [[nodiscard]] btDiscreteDynamicsWorld * getDynamicsWorld() const;

            [[nodiscard]] bool raycastClosest(
                const glm::vec3& origin,
                const glm::vec3& direction,
                float maxDistance,
                Physics::RaycastHit& outHit
            ) const;

            [[nodiscard]] bool raycastClosest(
                const glm::vec3& origin,
                const glm::vec3& direction,
                float maxDistance,
                const Physics::PhysicsQueryFilter& filter,
                Physics::RaycastHit& outHit
            ) const;

            [[nodiscard]] bool sphereSweepClosest(
                const glm::vec3& from,
                const glm::vec3& to,
                float radius,
                Physics::RaycastHit& outHit,
                const btCollisionObject* ignoredObject = nullptr
            ) const;

            [[nodiscard]] bool sphereSweepClosest(
                const glm::vec3& from,
                const glm::vec3& to,
                float radius,
                const Physics::PhysicsQueryFilter& filter,
                Physics::RaycastHit& outHit,
                const btCollisionObject* ignoredObject = nullptr
            ) const;

            [[nodiscard]] bool sphereClosest(
                const glm::vec3& position,
                float radius,
                Physics::RaycastHit& outHit,
                const btCollisionObject* ignoredObject = nullptr
            ) const;

            [[nodiscard]] bool sphereClosest(
                const glm::vec3& position,
                float radius,
                const Physics::PhysicsQueryFilter& filter,
                Physics::RaycastHit& outHit,
                const btCollisionObject* ignoredObject = nullptr
            ) const;

            static btCollisionShape * createBoxShape(const glm::vec3& halfExtents);

            static btCollisionShape * createSphereShape(float radius);

            static btCollisionShape * createCapsuleShape(float radius, float height);

            static btCollisionShape * createPlaneShape(const glm::vec3& surfaceNormal, float distanceFromOrigin);

            static btCollisionShape * createConvexHullShape(const std::vector<glm::vec3>& vertices);

            static btCollisionShape * createTriangleMeshShape(
                const std::vector<glm::vec3>& vertices,
                const std::vector<uint32_t>& indices,
                btTriangleMesh*& triangleMeshOut);

            static btCompoundShape * createCompoundShape();

            [[nodiscard]] btRigidBody * createRigidBody( const Physics::RigidBodyCreateInfo & info ) const;

            [[nodiscard]] btRigidBody * createRigidBody(
                const Physics::RigidBodyCreateInfo & info,
                std::uint16_t collisionGroup,
                std::uint16_t collisionMask
            ) const;

            void removeRigidBody(btRigidBody* body ) const;

            void debugDrawAll() const;
 
        private:
            struct RuntimeBodySlot
            {
                Components::PhysicsBody * body = nullptr;
                std::uint32_t generation = 0;
            };
 
            struct RuntimeCollisionSlot
            {
                Components::Collision * collision = nullptr;
                std::uint32_t generation = 0;
            };
 
            struct ComponentPairKey
            {
                Physics::CollisionHandle componentA;
                Physics::CollisionHandle componentB;
                Physics::PhysicsBodyHandle bodyA;
                Physics::PhysicsBodyHandle bodyB;
                Physics::CollisionResponse response = Physics::CollisionResponse::Ignore;
 
                friend bool operator==( const ComponentPairKey &, const ComponentPairKey & ) = default;
                friend auto operator<=>( const ComponentPairKey &, const ComponentPairKey & ) = default;
            };
 
            struct PendingComponentEvent
            {
                Physics::CollisionHandle selfComponent;
                Physics::CollisionHandle otherComponent;
                Physics::PhysicsBodyHandle selfBody;
                Physics::PhysicsBodyHandle otherBody;
                Physics::CollisionResponse response = Physics::CollisionResponse::Ignore;
                Physics::CollisionEventType eventType = Physics::CollisionEventType::Begin;
            };
 
            struct PendingActorEvent
            {
                Physics::PhysicsBodyHandle selfBody;
                Physics::PhysicsBodyHandle otherBody;
                Physics::CollisionResponse response = Physics::CollisionResponse::Ignore;
                Physics::CollisionEventType eventType = Physics::CollisionEventType::Begin;
                std::vector<PendingComponentEvent> componentEvents;
            };
 
            void collectCollisionEvents();
            void queueDirectedEvents( const ComponentPairKey & pair, Physics::CollisionEventType eventType );
            void queueInvalidationEndEvents(
                Physics::PhysicsBodyHandle bodyHandle,
                Physics::CollisionHandle collisionHandle
            );
            void buildActorEvents();
            [[nodiscard]] bool bodyMatchesQueryFilter(
                const Components::PhysicsBody * body,
                const Physics::PhysicsQueryFilter & filter
            ) const;
 
            Physics::CollisionProfileRegistry * collisionProfileRegistry_ = nullptr;
            std::vector<RuntimeBodySlot> bodySlots_;
            std::vector<RuntimeCollisionSlot> collisionSlots_;
            std::uint32_t nextBodyId_ = 1;
            std::uint32_t nextCollisionId_ = 1;
            std::set<ComponentPairKey> previousComponentPairs_;
            std::vector<PendingComponentEvent> pendingLifetimeComponentEvents_;
            std::vector<PendingComponentEvent> pendingComponentEvents_;
            std::vector<PendingActorEvent> pendingActorEvents_;
 
            btBroadphaseInterface* broadphase;
            btCollisionConfiguration* collisionConfiguration;
            btCollisionDispatcher* dispatcher;
            btConstraintSolver* solver;
            btDiscreteDynamicsWorld* dynamicsWorld;
        };
    }
}