physics_system.h

#pragma once
 
#include <cstdint>
#include <utility>
#include <vector>
 
#include <glm/glm.hpp>
 
#include "core/system.h"
#include "debug/fault_latch.h"
#include "ecs/entity.h"
#include "system/physics/physics_internal.h"
#include "system/physics/collision/contact.h"
#include "system/physics/collision/narrowphase.h"
#include "system/physics/collision/support.h"
#include "system/physics/solver/joint_solver.h"
#include "system/physics/solver/solver.h"
#include "system/physics/solver/contact_cache.h"
 
namespace Vkm::Engine {
 
class NetSession;
 
struct PhysicsSettings;
 
class EventBus;
class ResourceManager;
class Scene;

class PhysicsSystem : public System {
    public:
        PhysicsSystem() = default;
        ~PhysicsSystem() override = default;
 
        PhysicsSystem(const PhysicsSystem& other) = delete;
        PhysicsSystem& operator=(const PhysicsSystem& other) = delete;
 
        PhysicsSystem(PhysicsSystem && other) = delete;
        PhysicsSystem& operator=(PhysicsSystem && other) = delete;
 
    public:
        void fixedUpdate(FrameContext& ctx) override;

        bool isReplayed() const override { return true; }
 
    private:
        struct HeldJoint {
            EntityId  owner;        
            glm::vec3 impulse;      
            glm::vec3 holdImpulse;  
        };
 
    private:
        bool gatherBodies(Scene& scene, const ResourceManager& resources, const NetSession& net);

        void integrateForces(const PhysicsSettings& physics, float dt);

        void broadphase();

        void narrowphase(bool replaying);

        void collidePair(uint32_t pair, NarrowphaseChunk& chunk) const;

        void buildIslands();

        bool isIslandMember(uint32_t body) const;

        void gatherJoints(Scene& scene);

        void solve(const PhysicsSettings& physics, float dt);

        void sleepIslands(bool replaying);

        void writeback(Scene& scene, bool replaying, float dt);

        void reportContacts(const Scene& scene, EventBus& events);

        void leaseContacts(Scene& scene, NetSession& net);
 
    private:
        std::vector<EntityId>        m_bodies;  

        std::vector<PhysicsBody>     m_solverBodies;
        std::vector<EntityId>        m_leased;          
        std::vector<uint8_t>         m_leaseCarries;    
        BodyIslands                  m_leaseIslands;    
        std::vector<ContactManifold> m_manifolds;       
        ContactCache                 m_contactCache;
        uint64_t                     m_worldEpoch = 0;  
        std::vector<JointConstraint> m_joints;          

        std::vector<HeldJoint> m_jointImpulses;

        std::vector<uint32_t> m_bodyIndexBySlot;

        std::vector<uint64_t> m_jointedPairs;

        std::vector<ColliderProxy> m_proxies;
        std::vector<BodyFrame>     m_bodyFrames;

        BodyIslands                m_islands;
        std::vector<uint8_t>       m_islandHeld;
        std::vector<uint8_t>       m_islandDisturbed;  
        std::vector<uint8_t>       m_islandReady;
        std::vector<BodyContacts>  m_contacts;

        std::vector<TrackedPair> m_touchingThisTick;

        std::vector<TrackedPair> m_touchingLastTick;
 
        FaultLatch m_massless;  
 
        std::vector<uint32_t>                      m_sorted;  
        std::vector<std::pair<uint32_t, uint32_t>> m_pairs;   
 
        std::vector<BoxShape>     m_shapeBoxes;         
        std::vector<Math::AABB>   m_shapeBoxBounds;     
        std::vector<CapsuleShape> m_shapeCapsules;      
        std::vector<Math::AABB>   m_shapeCapsuleBounds;

        std::vector<NarrowphaseChunk> m_narrowphaseChunks;
 
        std::vector<bool> m_posedBone;  
};
 
} // namespace Vkm::Engine