Seele/src/Engine/Physics/CollisionSystem.cpp

#include "CollisionSystem.h"

using namespace Seele;
using namespace Seele::Component;

CollisionSystem::CollisionSystem(entt::registry& registry)
    : registry(registry)
{
    registry.on_construct<Component::Collider>().connect<&BVH::colliderCallback>(bvh);
}

CollisionSystem::~CollisionSystem()
{
    
}

void CollisionSystem::detectCollisions(Array<Collision>& collisions)
{
    collisions.clear();
    auto view = registry.view<Collider, Transform>();
    for(auto && [entity, collider, transform] : view.each())
    {
        if(collider.type == ColliderType::DYNAMIC)
        {
            bvh.updateDynamicCollider(entity, collider.boundingbox.getTransformedBox(transform.toMatrix()));
        }
        collider.physicsMesh.transform(transform).visualize();
    }
    bvh.visualize();
    Array<Pair<entt::entity, entt::entity>> overlaps;
    bvh.findOverlaps(overlaps);
    for(auto pair : overlaps)
    {
        if(checkCollision(pair))
        {
            collisions.add(Collision {
                .a = pair.key,
                .b = pair.value,
            });
        }
    }
}

bool CollisionSystem::checkCollision(Pair<entt::entity, entt::entity> pair)
{
    const auto&[collider1, transform1] = registry.get<Collider, Transform>(pair.key);
    const auto&[collider2, transform2] = registry.get<Collider, Transform>(pair.value);
    ShapeBase shape1 = collider1.physicsMesh.transform(transform1);
    ShapeBase shape2 = collider2.physicsMesh.transform(transform2);
    Witness witness;
    if(cachedWitness.exists(pair))
    {
        witness = cachedWitness[pair];
    }
    if(witnessValid(witness, shape1, shape2))
    {
        return false;
    }
    return createWitness(witness, shape1, shape2);
}

void CollisionSystem::updateWitness(Witness& result, const glm::vec3& point, const glm::vec3& v1, const glm::vec3& v2)
{
    const glm::vec3 faceNormal = glm::normalize(glm::cross(v1, v2));

    result.n = faceNormal;
    result.p = point;
}

bool CollisionSystem::createWitness(Witness& result, const ShapeBase& source, const ShapeBase& other)
{
    for (size_t i = 0; i < source.indices.size(); i += 3)
    {
        const glm::vec3 point1 = source.vertices[source.indices[i + 0]];
        const glm::vec3 point2 = source.vertices[source.indices[i + 1]];
        const glm::vec3 point3 = source.vertices[source.indices[i + 2]];
        const glm::vec3 v1 = point2 - point1;
        const glm::vec3 v2 = point3 - point1;
        
        updateWitness(result, point1, v1, v2);
        result.point1Index = source.indices[i + 0];
        result.point2Index = source.indices[i + 1];
        result.point3Index = source.indices[i + 2];
        result.point4Index = UINT32_MAX;
        bool valid = witnessValid(result, source, other);
        // if not, it is a valid separating plane, so no collision
        if (valid)
        {
            return false;
        }
    }
    for (size_t i = 0; i < source.indices.size(); i += 3)
    {
        auto findEdgePlane = [this, &source, &other, &result](uint32_t point1Index, uint32_t point2Index)
        {
            const glm::vec3 point1 = source.vertices[point1Index];
            const glm::vec3 point2 = source.vertices[point2Index];
            result.point1Index = point1Index;
            result.point2Index = point2Index;
            const glm::vec3 d1 = point2 - point1;
            for (size_t j = 0; j < other.indices.size(); j += 3)
            {
                for (const auto& [point3Index, point4Index] : { std::pair(j+1, j), std::pair(j+2, j+1), std::pair(j, j+2) })
                {
                    result.point3Index = other.indices[point3Index];
                    result.point4Index = other.indices[point4Index];
                    const glm::vec3 point3 = other.vertices[result.point3Index];
                    const glm::vec3 point4 = other.vertices[result.point4Index];
                    const glm::vec3 d2 = point3 - point4;
                    updateWitness(result, point1, d2, d1);
                    if (witnessValid(result, source, other))
                    {
                        return true;
                    }
                }
            }
            return false;
        };
        if(findEdgePlane(source.indices[i], source.indices[i+1]))
        {
            return false;
        }
        if(findEdgePlane(source.indices[i+1], source.indices[i+2]))
        {
            return false;
        }
        if(findEdgePlane(source.indices[i+2], source.indices[i]))
        {
            return false;
        }
    }
    // no separating plane was found, collision
    return true;
}

bool CollisionSystem::witnessValid(const Witness& witness, const Component::ShapeBase& shape1, const Component::ShapeBase& shape2)
{
    const float e = 0.0001f;

    for (size_t i = 0; i < shape1.vertices.size(); i++)
    {
        if(glm::dot(witness.n, shape1.vertices[i] - witness.p) > e)
        {
            // something intersecting the separating plane
            // it is not valid anymore
            return false;
        }
    }
    for (size_t i = 0; i < shape2.vertices.size(); i++)
    {
        if(glm::dot(witness.n, shape2.vertices[i] - witness.p) < -e)
        {
            // something intersecting the separating plane
            // it is not valid anymore
            return false;
        }
    }
    return true;
}