physics_internal.h

#pragma once
 
#include <cstdint>
#include <utility>
#include <vector>
 
#include <glm/glm.hpp>
#include <glm/gtc/quaternion.hpp>
 
#include "core/math/bounds.h"
#include "ecs/entity.h"
#include "ecs/component/physics/collider.h"
#include "ecs/component/physics/rigidbody.h"
#include "system/physics/body_pose.h"
#include "system/physics/collision/contact.h"
 
namespace Vkm::Engine {

struct ColliderProxy {
    uint32_t body = 0;

    uint32_t boxFirst     = 0;
    uint32_t boxCount     = 0;
    uint32_t capsuleFirst = 0;
    uint32_t capsuleCount = 0;

    const Collider* collider = nullptr;
    Math::AABB bounds;  
    bool immovable = false;
    bool fixed     = false;  
 
    // Copied at gather, so the pair loop does not reach back into the scene.
    bool isTrigger = false;
    int layer = 1;
    int collidesWith = ~0;
};

inline constexpr uint32_t NARROWPHASE_CHUNK_PAIRS = 64;

struct TouchingPair {
    uint32_t  pair          = 0;                            
    uint32_t  manifoldCount = 0;
    glm::vec3 point         = glm::vec3(0.0f);
    glm::vec3 normal        = glm::vec3(0.0f, 1.0f, 0.0f);  
};

struct TrackedPair {
    EntityId  a;                                       
    EntityId  b;
    bool      aTrigger = false;                        
    bool      bTrigger = false;                        
    glm::vec3 point    = glm::vec3(0.0f);              
    glm::vec3 normal   = glm::vec3(0.0f, 1.0f, 0.0f);  

    static bool before(const TrackedPair& x, const TrackedPair& y) {
        if (x.a.slot() != y.a.slot())             return x.a.slot() < y.a.slot();
        if (x.b.slot() != y.b.slot())             return x.b.slot() < y.b.slot();
        if (x.a.generation() != y.a.generation()) return x.a.generation() < y.a.generation();
        if (x.b.generation() != y.b.generation()) return x.b.generation() < y.b.generation();
        if (x.aTrigger != y.aTrigger)             return y.aTrigger;
        return !x.bTrigger && y.bTrigger;
    }
};

struct NarrowphaseChunk {
    std::vector<TouchingPair>    touching;        
    std::vector<ContactManifold> manifolds;       
    std::vector<uint32_t>        meshCandidates;  
};

class BodyIslands {
    public:
        BodyIslands() = default;
        ~BodyIslands() = default;
 
        BodyIslands(const BodyIslands& other) = delete;
        BodyIslands& operator=(const BodyIslands& other) = delete;
 
        BodyIslands(BodyIslands && other) = delete;
        BodyIslands& operator=(BodyIslands && other) = delete;
 
    public:
        void reset(size_t count) {
            m_parent.resize(count);
            m_size.assign(count, 1);
            for (size_t i = 0; i < count; ++i) m_parent[i] = static_cast<uint32_t>(i);
        }
 
        uint32_t find(uint32_t i) {
            while (m_parent[i] != i) {
                m_parent[i] = m_parent[m_parent[i]];
                i = m_parent[i];
            }
            return i;
        }
 
        void join(uint32_t a, uint32_t b) {
            a = find(a);
            b = find(b);
            if (a == b) return;
            if (m_size[a] < m_size[b]) std::swap(a, b);
            m_parent[b] = a;
            m_size[a]  += m_size[b];
        }
 
    private:
        std::vector<uint32_t> m_parent;
        std::vector<uint32_t> m_size;
};

struct BodyFrame {
    Rigidbody*      rb              = nullptr;
    BodyPose        pose;                        
    RigidbodyMotion motion          = RigidbodyMotion::Dynamic;
    bool            decided         = false;     
    float           invMass         = 0.0f;      
    float           reach           = 0.0f;      
    glm::mat3       invInertiaLocal = glm::mat3(0.0f);
};

struct BodyContacts {
    // Below any unit normal, so the first contact replaces it, even a vertical wall's.
    glm::vec3 support = {0.0f, -2.0f, 0.0f};  
 
    // World up has no horizontal part, so level floor leaves "nothing in the way".
    glm::vec3 block = {0.0f, 1.0f, 0.0f};  
 
    bool touched = false;  
};
 
} // namespace Vkm::Engine