TriMeshCollision.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "SweptCollision.hpp"
 
#include <cstdint>
#include <glm/glm.hpp>
 
namespace physics
{

enum class TriRegion : uint8_t
{
    Face = 0,
    Edge0 = 1, 
    Edge1 = 2, 
    Edge2 = 3, 
    Vert0 = 4,
    Vert1 = 5,
    Vert2 = 6,
};

void buildTriMeshBVH(WorldTriMesh& mesh);

void weldTriMesh(WorldTriMesh& mesh, float coplanarTolerance = 0.0349065850f /* 2° */);

struct TriMeshValidationReport
{
    uint32_t triangleCount{0};
    uint32_t degenerateTriangles{0};
    uint32_t duplicatedOppositeWindingFaces{0};
    uint32_t nonManifoldEdges{0};
    uint32_t invalidIndices{0};
 
    [[nodiscard]] bool valid() const noexcept
    {
        return degenerateTriangles == 0 && duplicatedOppositeWindingFaces == 0 && nonManifoldEdges == 0 &&
               invalidIndices == 0;
    }
};

struct TriMeshValidationTotals
{
    uint32_t meshCount{0};
    uint32_t invalidMeshCount{0};
    uint32_t triangleCount{0};
    uint32_t degenerateTriangles{0};
    uint32_t duplicatedOppositeWindingFaces{0};
    uint32_t nonManifoldEdges{0};
    uint32_t invalidIndices{0};
 
    [[nodiscard]] bool valid() const noexcept
    {
        return invalidMeshCount == 0 && degenerateTriangles == 0 && duplicatedOppositeWindingFaces == 0 &&
               nonManifoldEdges == 0 && invalidIndices == 0;
    }
};

TriMeshValidationReport validateTriMesh(const WorldTriMesh& mesh, float positionEpsilon = 1e-4f);

TriMeshValidationTotals validateTriMeshes(std::span<const WorldTriMesh> meshes, float positionEpsilon = 1e-4f);

struct TriMeshCookStats
{
    uint32_t meshCount{0};
    uint32_t vertexCount{0};
    uint32_t triangleCount{0};
    uint32_t meshBvhNodeCount{0};
    uint32_t meshBvhLeafCount{0};
    uint32_t maxMeshBvhDepth{0};
    uint32_t activeHalfEdges{0};
    uint32_t weldedHalfEdges{0};
    uint32_t boundaryHalfEdges{0};
    uint32_t invalidNormals{0};
};

TriMeshCookStats collectTriMeshCookStats(std::span<const WorldTriMesh> meshes);

HitResult sweepAABBvsTriMesh(glm::vec3 halfExtents, glm::vec3 start, glm::vec3 end, const WorldTriMesh& mesh);

void depenetrateAABBvsTriMesh(
    glm::vec3& pos, glm::vec3& vel, glm::vec3 halfExtents, const WorldTriMesh& mesh, float pushback = 0.03125f);

HitResult sweepCapsuleVsTriMesh(CapsuleShape capsule, glm::vec3 start, glm::vec3 end, const WorldTriMesh& mesh);

DepenContact
deepestCapsuleContactVsTriMesh(CapsuleShape capsule, glm::vec3 pos, glm::vec3 vel, const WorldTriMesh& mesh);

struct ClosestPointOnMeshResult
{
    bool found{false};
    float dist{1e30f};
    glm::vec3 pointOnSegment{0.0f};
    glm::vec3 pointOnMesh{0.0f};
    glm::vec3 normal{0.0f, 1.0f, 0.0f};
    uint32_t triId{UINT32_MAX};
    TriRegion region{TriRegion::Face};
};

ClosestPointOnMeshResult closestPointOnMesh(glm::vec3 segA, glm::vec3 segB, float maxDist, const WorldTriMesh& mesh);

ClosestPointOnMeshResult
closestPointOnMesh(CapsuleShape capsule, glm::vec3 center, float maxDist, const WorldTriMesh& mesh);

ClosestPointOnMeshResult closestPointOnMeshTriangle(
    CapsuleShape capsule, glm::vec3 center, float maxDist, const WorldTriMesh& mesh, uint32_t triId);

ClearanceResult
clearanceCapsuleVsTriMesh(CapsuleShape capsule, glm::vec3 pos, float maxReach, const WorldTriMesh& mesh);

GroundProbeResult groundProbeCapsuleVsTriMesh(
    CapsuleShape capsule, glm::vec3 pos, float maxDistance, float minWalkableDot, const WorldTriMesh& mesh);
 
} // namespace physics