PlaneTypes.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
// Port of geometry3sharp Plane3
 
#pragma once
 
#include "VectorTypes.h"
#include "VectorUtil.h"
#include "Math/Plane.h"
#include "Math/Transform.h"
 
namespace UE
{
namespace Geometry
{
 
using namespace UE::Math;
 
template<typename RealType>
struct TPlane3
{
    TVector<RealType> Normal;
    RealType Constant;
 
    TPlane3() {}
 
    TPlane3(const UE::Math::TVector<RealType>& Normal, double Constant) : Normal(Normal), Constant(Constant)
    {
    }
 
    TPlane3(const UE::Math::TVector<RealType>& Normal, const UE::Math::TVector<RealType>& Point) : Normal(Normal), Constant(Normal.Dot(Point))
    {
    }
 
    TPlane3(const UE::Math::TVector<RealType>& P0, const UE::Math::TVector<RealType>& P1, const UE::Math::TVector<RealType>& P2)
    {
        Normal = VectorUtil::Normal(P0, P1, P2);
        Constant = Normal.Dot(P0);
    }
    
    explicit TPlane3(const FPlane& Plane) : TPlane3(Plane.GetNormal(), Plane.W)
    {
    }
    
    explicit operator FPlane() const
    {
        return FPlane(Normal.X, Normal.Y, Normal.Z, Constant);
    }
 
    void Transform(const TTransform<RealType>& Tr)
    {
        TVector<RealType> TransformedOrigin = Tr.TransformPosition(Normal * Constant);
        // Transform the normal
        Normal = VectorUtil::TransformNormal(Tr, Normal);
        // Update the plane constant using the transformed normal and origin
        Constant = Normal.Dot(TransformedOrigin);
    }
 
    void InverseTransform(const TTransform<RealType>& Tr)
    {
        TVector<RealType> TransformedOrigin = Tr.InverseTransformPosition(Normal * Constant);
        // Inverse transform the normal
        Normal = VectorUtil::InverseTransformNormal(Tr, Normal);
        // Update the plane constant using the transformed normal and origin
        Constant = Normal.Dot(TransformedOrigin);
    }
 
    double DistanceTo(const UE::Math::TVector<RealType>& P) const
    {
        return Normal.Dot(P) - Constant;
    }
 
    int WhichSide(const UE::Math::TVector<RealType>& P) const
    {
        double Distance = DistanceTo(P);
        if (Distance < 0)
        {
            return -1;
        }
        else if (Distance > 0)
        {
            return +1;
        }
        else
        {
            return 0;
        }
    }
 
 
 
 
    bool FindLineIntersection(
        const UE::Math::TVector<RealType>& LineOrigin, 
        const UE::Math::TVector<RealType>& LineDirection, 
        UE::Math::TVector<RealType>& IntersectionPointOut) const
    {
        RealType NormalDot = LineDirection.Dot(Normal);
        if ( TMathUtil<RealType>::Abs(NormalDot) < TMathUtil<RealType>::ZeroTolerance )
        {
            IntersectionPointOut = TVector<RealType>(TNumericLimits<RealType>::Max(), TNumericLimits<RealType>::Max(), TNumericLimits<RealType>::Max());
            return false;
        }
        RealType t = -(LineOrigin.Dot(Normal) - Constant) / NormalDot;
        IntersectionPointOut = LineOrigin + t * LineDirection;
        return true;
    }
 
 
    enum EClipSegmentType
    {
        FullyClipped,
        FirstClipped,
        SecondClipped,
        NotClipped
    };
 
    EClipSegmentType ClipSegment(UE::Math::TVector<RealType>& Point0, UE::Math::TVector<RealType>& Point1) const
    {
        RealType Dist0 = DistanceTo(Point0);
        RealType Dist1 = DistanceTo(Point1);
        if (Dist0 <= 0 && Dist1 <= 0)
        {
            return EClipSegmentType::FullyClipped;
        }
        else if (Dist0 * Dist1 > 0)
        {
            return EClipSegmentType::NotClipped;
        }
 
        TVector<RealType> DirectionVec = Point1 - Point0;
        TVector<RealType> Direction = Normalized(DirectionVec);
        RealType Length = DirectionVec.Dot(Direction);
 
        // test if segment is parallel to plane, if so, no intersection
        RealType NormalDot = Direction.Dot(Normal);
        if ( TMathUtil<RealType>::Abs(NormalDot) < TMathUtil<RealType>::ZeroTolerance )
        {
            return EClipSegmentType::NotClipped;
        }
 
        RealType LineT = -Dist0 / NormalDot;  // calculate line parameter for line/plane intersection
        if (LineT > 0 && LineT < Length)   // verify segment intersection  (should always be true...)
        {
            if (NormalDot < 0)
            {
                Point1 = Point0 + LineT * Direction;
                return EClipSegmentType::SecondClipped;
            }
            else
            {
                Point0 += LineT * Direction;
                return EClipSegmentType::FirstClipped;
            }
        }
        return EClipSegmentType::NotClipped;
    }
 
};
 
typedef TPlane3<float> FPlane3f;
typedef TPlane3<double> FPlane3d;
 
} // end namespace UE::Geometry
} // end namespace UE