Ray.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Math/MathFwd.h" // IWYU pragma: export
#include "Math/Vector.h"
 
 
namespace UE
{
namespace Math
{
 
template<typename T>
struct TRay
{
public:
    using FReal = T;
 
    TVector<T> Origin;
 
    TVector<T> Direction;
 
public:
 
    [[nodiscard]] TRay()
    {
        Init();
    }
 
    [[nodiscard]] explicit TRay<T>( EForceInit )
    {
        Init();
    }
 
 
    [[nodiscard]] TRay(const TVector<T>& Origin, const TVector<T>& Direction, bool bDirectionIsNormalized = false)
    {
        this->Origin = Origin;
        this->Direction = Direction;
        if (bDirectionIsNormalized == false)
        {
            this->Direction.Normalize();    // is this a full-accuracy sqrt?
        }
    }
 
 
    void Init()
    {
        Origin = TVector<T>::ZeroVector;
        Direction = TVector<T>(0, 0, 1);
    }
 
    [[nodiscard]] bool operator==( const TRay<T>& Other ) const
    {
        return (Origin == Other.Origin) && (Direction == Other.Direction);
    }
 
    [[nodiscard]] bool operator!=( const TRay<T>& Other ) const
    {
        return !(*this == Other);
    }
 
 
public:
 
    [[nodiscard]] TVector<T> PointAt(T RayParameter) const
    {
        return Origin + RayParameter * Direction;
    }
 
    [[nodiscard]] T GetParameter(const TVector<T>& Point) const
    {
        return TVector<T>::DotProduct((Point - Origin), Direction);
    }
 
    [[nodiscard]] T DistSquared(const TVector<T>& Point) const
    {
        T RayParameter = TVector<T>::DotProduct((Point - Origin), Direction);
        if (RayParameter < 0)
        {
            return TVector<T>::DistSquared(Origin, Point);
        }
        else 
        {
            TVector<T> ProjectionPt = Origin + RayParameter * Direction;
            return TVector<T>::DistSquared(ProjectionPt, Point);
        }
    }
 
    [[nodiscard]] T Dist(const TVector<T>& Point) const
    {
        return FMath::Sqrt(DistSquared(Point));
    }
 
    [[nodiscard]] TVector<T> ClosestPoint(const TVector<T>& Point) const
    {
        T RayParameter = TVector<T>::DotProduct((Point - Origin), Direction);
        if (RayParameter < 0) 
        {
            return Origin;
        }
        else 
        {
            return Origin + RayParameter * Direction;
        }
    }
 
 
 
public:
 
    [[nodiscard]] FString ToString() const
    {
        return FString::Printf(TEXT("Origin=(%s), Direction=(%s)"), *Origin.ToString(), *Direction.ToString());
    }
 
    friend FArchive& operator<<( FArchive& Ar, TRay<T>& Ray )
    {
        return Ar << Ray.Origin << Ray.Direction;
    }
 
    // Note: TRay is usually written via binary serialization. This function exists for SerializeFromMismatchedTag conversion usage. 
    bool Serialize(FArchive& Ar)
    {
        Ar << *this;
        return true;
    }
 
    bool SerializeFromMismatchedTag(FName StructTag, FArchive& Ar)
    {
        if constexpr (std::is_same_v<T, float>)
        {
            return UE_SERIALIZE_VARIANT_FROM_MISMATCHED_TAG(Ar, Ray, Ray3f, Ray3d);
        }
        else if constexpr (std::is_same_v<T, double>)
        {
            return UE_SERIALIZE_VARIANT_FROM_MISMATCHED_TAG(Ar, Ray, Ray3d, Ray3f);
        }
        else
        {
            static_assert(sizeof(T) == 0, "Unimplemented");
            return false;
        }
    }
 
    // Conversion to other type.
    template<typename FArg UE_REQUIRES(!std::is_same_v<T, FArg>)>
    explicit TRay(const TRay<FArg>& From)
        : TRay<T>(TVector<T>(From.Origin), TVector<T>(From.Direction), true)
    {
    }
};
 
}   // namespace UE::Math
}   // namespace UE
 
UE_DECLARE_LWC_TYPE(Ray, 3);
 
template<> struct TIsPODType<FRay3f> { enum { Value = true }; };
template<> struct TIsPODType<FRay3d> { enum { Value = true }; };
template<> struct TIsUECoreVariant<FRay3f> { enum { Value = true }; };
template<> struct TIsUECoreVariant<FRay3d> { enum { Value = true }; };
template<> struct TCanBulkSerialize<FRay3f> { enum { Value = true }; };
template<> struct TCanBulkSerialize<FRay3d> { enum { Value = true }; };