WallDetection.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "SweptCollision.hpp"
#include "TriMeshCollision.hpp"
 
#include <cmath>
#include <cstdint>
#include <glm/vec3.hpp>

namespace physics
{

struct WallDetectionResult
{
    // Side walls (wallrunning)
    bool wallLeft{false};                   
    bool wallRight{false};                  
    glm::vec3 leftNormal{0.0f};             
    glm::vec3 rightNormal{0.0f};            
    glm::vec3 leftPoint{0.0f};              
    glm::vec3 rightPoint{0.0f};             
    uint32_t leftMeshIndex{UINT32_MAX};     
    uint32_t rightMeshIndex{UINT32_MAX};    
    uint32_t leftTriId{UINT32_MAX};         
    uint32_t rightTriId{UINT32_MAX};        
    TriRegion leftRegion{TriRegion::Face};  
    TriRegion rightRegion{TriRegion::Face}; 
 
    // Front wall diagnostics.
    bool wallFront{false};                  
    glm::vec3 frontNormal{0.0f};            
    glm::vec3 frontPoint{0.0f};             
    uint32_t frontMeshIndex{UINT32_MAX};    
    uint32_t frontTriId{UINT32_MAX};        
    TriRegion frontRegion{TriRegion::Face}; 
 
    // Ground distance
    float groundDistance{1e10f}; 
};

struct WallAttachmentResult
{
    bool found{false};
    glm::vec3 anchor{0.0f};
    glm::vec3 normal{0.0f};
    uint32_t meshIndex{UINT32_MAX};
    uint32_t triId{UINT32_MAX};
    TriRegion region{TriRegion::Face};
};

WallDetectionResult detectWalls(glm::vec3 pos,
                                float yaw,
                                glm::vec3 halfExtents,
                                const WorldGeometry& world,
                                float checkDist,
                                float sphereRadius,
                                glm::vec3 prevWallNormal = glm::vec3(0.0f),
                                bool gravityFlipped = false,
                                bool includeGroundDistance = true);

float probeWallrunGroundDistance(
    glm::vec3 pos, glm::vec3 halfExtents, const WorldGeometry& world, float sphereRadius, bool gravityFlipped = false);

WallAttachmentResult findWallRunAttachment(CapsuleShape capsule,
                                           glm::vec3 pos,
                                           const WorldGeometry& world,
                                           glm::vec3 continuityNormal,
                                           glm::vec3 travelDir = glm::vec3{0.0f},
                                           float lookaheadDist = 0.0f,
                                           float checkDist = 24.0f,
                                           uint32_t previousMeshIndex = UINT32_MAX,
                                           uint32_t previousTriId = UINT32_MAX,
                                           TriRegion previousRegion = TriRegion::Face);

inline bool isWallNormal(glm::vec3 normal)
{
    return std::abs(normal.y) < 0.3f;
}
 
} // namespace physics