CollisionShape.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once 
 
#include "Math/Vector.h"
 
namespace ECollisionShape
{
    enum Type
    {
        Line,
        Box,
        Sphere,
        Capsule
    };
};
 
struct FCollisionShape
{
    ECollisionShape::Type ShapeType;
 
    static constexpr float MinBoxExtent() { return UE_KINDA_SMALL_NUMBER; }
    static constexpr float MinSphereRadius() { return UE_KINDA_SMALL_NUMBER; }
    static constexpr float MinCapsuleRadius() { return UE_KINDA_SMALL_NUMBER; }
    static constexpr float MinCapsuleAxisHalfHeight() { return UE_KINDA_SMALL_NUMBER; }
 
    union
    {
        struct
        {
            float HalfExtentX;
            float HalfExtentY;
            float HalfExtentZ;
        } Box;
 
        struct
        {
            float Radius;
        } Sphere;
 
        struct
        {
            float Radius;
            float HalfHeight;
        } Capsule;
    };
 
    FCollisionShape()
    {
        ShapeType = ECollisionShape::Line;
    }
 
    bool IsLine() const
    {
        return ShapeType == ECollisionShape::Line;
    }
 
    bool IsBox() const
    {
        return ShapeType == ECollisionShape::Box;
    }
 
    bool IsSphere() const
    {
        return ShapeType == ECollisionShape::Sphere;
    }
 
    bool IsCapsule() const
    {
        return ShapeType == ECollisionShape::Capsule;
    }
 
    void SetBox(const FVector3f& HalfExtent)
    {
        ShapeType = ECollisionShape::Box;
        Box.HalfExtentX = HalfExtent.X;
        Box.HalfExtentY = HalfExtent.Y;
        Box.HalfExtentZ = HalfExtent.Z;
    }
 
    void SetSphere(const float Radius)
    {
        ShapeType = ECollisionShape::Sphere;
        Sphere.Radius = Radius;
    }
 
    void SetCapsule(const float Radius, const float HalfHeight)
    {
        ShapeType = ECollisionShape::Capsule;
        Capsule.Radius = Radius;
        Capsule.HalfHeight = HalfHeight;
    }
 
    void SetCapsule(const FVector3f& Extent)
    {
        ShapeType = ECollisionShape::Capsule;
        Capsule.Radius = FMath::Max(Extent.X, Extent.Y);
        Capsule.HalfHeight = Extent.Z;
    }
 
    void SetShape(const ECollisionShape::Type InShapeType, const FVector& Extent)
    {
        switch (InShapeType)
        {
        case ECollisionShape::Box:
            {
                SetBox(FVector3f(Extent));
            }
            break;
        case ECollisionShape::Sphere:
            {
                SetSphere(static_cast<float>(Extent[0]));
            }
            break;
        case ECollisionShape::Capsule:
            {
                SetCapsule(FVector3f(Extent));
            }
            break;
        case ECollisionShape::Line:
        default:
            ShapeType = InShapeType;
        }
    }
 
    bool IsNearlyZero() const
    {
        switch (ShapeType)
        {
        case ECollisionShape::Box:
        {
            return (Box.HalfExtentX <= FCollisionShape::MinBoxExtent() && Box.HalfExtentY <= FCollisionShape::MinBoxExtent() && Box.HalfExtentZ <= FCollisionShape::MinBoxExtent());
        }
        case ECollisionShape::Sphere:
        {
            return (Sphere.Radius <= FCollisionShape::MinSphereRadius());
        }
        case ECollisionShape::Capsule:
        {
            // @Todo check height? It didn't check before, so I'm keeping this way for time being
            return (Capsule.Radius <= FCollisionShape::MinCapsuleRadius());
        }
        }
 
        return true;
    }
 
    FVector GetExtent() const
    {
        switch (ShapeType)
        {
        case ECollisionShape::Box:
        {
            return FVector(Box.HalfExtentX, Box.HalfExtentY, Box.HalfExtentZ);
        }
        case ECollisionShape::Sphere:
        {
            return FVector(Sphere.Radius, Sphere.Radius, Sphere.Radius);
        }
        case ECollisionShape::Capsule:
        {
            // @Todo check height? It didn't check before, so I'm keeping this way for time being
            return FVector(Capsule.Radius, Capsule.Radius, Capsule.HalfHeight);
        }
        }
 
        return FVector::ZeroVector;
    }
 
    float GetCapsuleAxisHalfLength() const
    {
        ensure(ShapeType == ECollisionShape::Capsule);
        return FMath::Max<float>(Capsule.HalfHeight - Capsule.Radius, FCollisionShape::FCollisionShape::MinCapsuleAxisHalfHeight());
    }
 
    FVector GetBox() const
    {
        return FVector(Box.HalfExtentX, Box.HalfExtentY, Box.HalfExtentZ);
    }
 
    const float GetSphereRadius() const
    {
        return Sphere.Radius;
    }
 
    const float GetCapsuleRadius() const
    {
        return Capsule.Radius;
    }
 
    const float GetCapsuleHalfHeight() const
    {
        return Capsule.HalfHeight;
    }
 
    FCollisionShape Inflate(const float Inflation) const
    {
        FCollisionShape InflatedShape;
 
        if (Inflation == 0.f)
        {
            InflatedShape = *this;
        }
        else
        {
            // Don't shrink below zero size.
            switch (ShapeType)
            {
            case ECollisionShape::Box:
                {
                    const FVector3f InflatedExtent = FVector3f(Box.HalfExtentX + Inflation, Box.HalfExtentY + Inflation, Box.HalfExtentZ + Inflation).ComponentMax(FVector3f::ZeroVector);
                    InflatedShape.SetBox(InflatedExtent);
                }
                break;
            case ECollisionShape::Sphere:
                {
                    InflatedShape.SetSphere(FMath::Max(Sphere.Radius + Inflation, 0));
                }
                break;
            case ECollisionShape::Capsule:
                {
                    InflatedShape.SetCapsule(FMath::Max(Capsule.Radius + Inflation, 0), FMath::Max(Capsule.HalfHeight + Inflation, 0));
                }
                break;
            case ECollisionShape::Line:
            default:
                {
                    // do not inflate for unsupported shapes
                    InflatedShape = *this;
                }
            }
        }
 
        return InflatedShape;
    }
 
    inline FString ToString() const
    {
        switch (ShapeType)
        {
        case ECollisionShape::Box:
            {
                return FString::Printf(TEXT("Box=(X=%3.3f Y=%3.3f Z=%3.3f)"), Box.HalfExtentX, Box.HalfExtentY, Box.HalfExtentZ);
            }
        case ECollisionShape::Sphere:
            {
                return FString::Printf(TEXT("Sphere=(Radius=%3.3f)"), Sphere.Radius);
            }
        case ECollisionShape::Capsule:
            {
                return FString::Printf(TEXT("Capsule=(Radius=%3.3f HalfHeight=%3.3f)"), Capsule.Radius, Capsule.HalfHeight);
            }
        case ECollisionShape::Line:
        default:
            {
                return TEXT("Line");
            }
        }
    }
 
    static struct FCollisionShape LineShape;
 
    static FCollisionShape MakeBox(const FVector& BoxHalfExtent)
    {
        FCollisionShape BoxShape;
        BoxShape.SetBox(FVector3f(BoxHalfExtent));
        return BoxShape;
    }
 
    static FCollisionShape MakeBox(const FVector3f& BoxHalfExtent)
    {
        FCollisionShape BoxShape;
        BoxShape.SetBox(BoxHalfExtent);
        return BoxShape;
    }
 
    static FCollisionShape MakeSphere(const float SphereRadius)
    {
        FCollisionShape SphereShape;
        SphereShape.SetSphere(SphereRadius);
        return SphereShape;
    }
 
    static FCollisionShape MakeCapsule(const float CapsuleRadius, const float CapsuleHalfHeight)
    {
        FCollisionShape CapsuleShape;
        CapsuleShape.SetCapsule(CapsuleRadius, CapsuleHalfHeight);
        return CapsuleShape;
    }
 
    static FCollisionShape MakeCapsule(const FVector& Extent)
    {
        FCollisionShape CapsuleShape;
        CapsuleShape.SetCapsule(FVector3f(Extent));
        return CapsuleShape;
    }
};