LineTypes.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
// line types ported from WildMagic and geometry3Sharp
 
#pragma once
 
#include "Math/UnrealMath.h"
#include "VectorTypes.h"
 
namespace UE
{
namespace Geometry
{
 
using namespace UE::Math;
 
template<typename T>
struct TLine2
{
    TVector2<T> Origin;
 
    TVector2<T> Direction;
 
    TLine2()
    {
        Origin = TVector2<T>::Zero();
        Direction = TVector2<T>::UnitX();
    }
 
    TLine2(const TVector2<T>& OriginIn, const TVector2<T>& DirectionIn)
        : Origin(OriginIn), Direction(DirectionIn)
    {
    }
 
 
    static TLine2<T> FromPoints(const TVector2<T>& Point0, const TVector2<T>& Point1)
    {
        return TLine2<T>(Point0, Normalized(Point1 - Point0) );
    }
 
 
    inline TVector2<T> PointAt(T LineParameter) const
    {
        return Origin + LineParameter * Direction;
    }
 
 
    inline T Project(const TVector2<T>& QueryPoint) const
    {
        return (QueryPoint - Origin).Dot(Direction);
    }
 
    inline T DistanceSquared(const TVector2<T>& QueryPoint) const
    {
        T ParameterT = (QueryPoint - Origin).Dot(Direction);
        TVector2<T> proj = Origin + ParameterT * Direction;
        return (proj - QueryPoint).SquaredLength();
    }
 
    inline TVector2<T> NearestPoint(const TVector2<T>& QueryPoint) const
    {
        T ParameterT = (QueryPoint - Origin).Dot(Direction);
        return Origin + ParameterT * Direction;
    }
 
 
    inline int WhichSide(const TVector2<T>& QueryPoint, T OnLineTolerance = 0) const
    {
        T x0 = QueryPoint.X - Origin.X;
        T y0 = QueryPoint.Y - Origin.Y;
        T x1 = Direction.X;
        T y1 = Direction.Y;
        T det = x0 * y1 - x1 * y0;
        return (det > OnLineTolerance ? +1 : (det < -OnLineTolerance ? -1 : 0));
    }
 
 
    bool IntersectionPoint(const TLine2<T>& OtherLine, TVector2<T>& IntersectionPointOut, T ParallelDotTolerance = TMathUtil<T>::ZeroTolerance) const
    {
        // see IntrTLine2TLine2 for more detailed explanation
        TVector2<T> diff = OtherLine.Origin - Origin;
        T D0DotPerpD1 = DotPerp(Direction, OtherLine.Direction);
        if (TMathUtil<T>::Abs(D0DotPerpD1) > ParallelDotTolerance)                     // TLines intersect in a single point.
        {
            T invD0DotPerpD1 = ((T)1) / D0DotPerpD1;
            T diffDotPerpD1 = DotPerp(diff, OtherLine.Direction);
            T s = diffDotPerpD1 * invD0DotPerpD1;
            IntersectionPointOut = Origin + s * Direction;
            return true;
        }
        // TLines are parallel.
        return false;
    }
};
 
 
typedef TLine2<double> FLine2d;
typedef TLine2<float> FLine2f;
 
 
 
 
 
 
template<typename T>
struct TLine3
{
    TVector<T> Origin;
 
    TVector<T> Direction;
 
    TLine3()
    {
        Origin = TVector<T>::Zero();
        Direction = TVector<T>::UnitX();
    }
 
    TLine3(const TVector<T>& OriginIn, const TVector<T>& DirectionIn)
        : Origin(OriginIn), Direction(DirectionIn)
    {
    }
 
 
    static TLine3<T> FromPoints(const TVector<T>& Point0, const TVector<T>& Point1)
    {
        return TLine3<T>(Point0, Normalized(Point1 - Point0) );
    }
 
 
    inline TVector<T> PointAt(T LineParameter) const
    {
        return Origin + LineParameter * Direction;
    }
 
 
    inline T Project(const TVector<T>& QueryPoint) const
    {
        return (QueryPoint - Origin).Dot(Direction);
    }
 
    inline T DistanceSquared(const TVector<T>& QueryPoint) const
    {
        T t = (QueryPoint - Origin).Dot(Direction);
        TVector<T> proj = Origin + t * Direction;
        return (proj - QueryPoint).SquaredLength();
    }
 
    inline TVector<T> NearestPoint(const TVector<T>& QueryPoint) const
    {
        T ParameterT = (QueryPoint - Origin).Dot(Direction);
        return Origin + ParameterT * Direction;
    }
 
 
};
 
typedef TLine3<double> FLine3d;
typedef TLine3<float> FLine3f;
 
} // end namespace UE::Geometry
} // end namespace UE