OrientedBox.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "Math/Vector.h"
#include "Math/Interval.h"
 
struct FOrientedBox
{
    FVector Center;
 
    FVector AxisX;
    
    FVector AxisY;
    
    FVector AxisZ;
 
    FVector::FReal ExtentX;
    
    FVector::FReal ExtentY;
 
    FVector::FReal ExtentZ;
 
public:
 
    [[nodiscard]] FOrientedBox()
        : Center(0.0f)
        , AxisX(1.0f, 0.0f, 0.0f)
        , AxisY(0.0f, 1.0f, 0.0f)
        , AxisZ(0.0f, 0.0f, 1.0f)
        , ExtentX(1.0f)
        , ExtentY(1.0f)
        , ExtentZ(1.0f)
    { }
 
public:
 
    inline void CalcVertices(FVector* Verts) const;
 
    [[nodiscard]] inline FFloatInterval Project(const FVector& Axis) const;
};
 
 
/* FOrientedBox inline functions
 *****************************************************************************/
 
inline void FOrientedBox::CalcVertices( FVector* Verts ) const
{
    const float Signs[] = { -1.0f, 1.0f };
 
    for (int32 i = 0; i < 2; i++)
    {
        for (int32 j = 0; j < 2; j++)
        {
            for (int32 k = 0; k < 2; k++)
            {
                *Verts++ = Center + (Signs[i] * ExtentX) * AxisX + (Signs[j] * ExtentY) * AxisY + (Signs[k] * ExtentZ) * AxisZ;
            }
        }
    }
}
 
inline FFloatInterval FOrientedBox::Project( const FVector& Axis ) const
{
    // Consider:
    //   max { dot(Center +- ExtentX * AxisX +- ExtentY * AxisY +- ExtentZ * AxisZ, Axis) }
    //  =max { dot(Center, Axis) +- ExtentX * dot(AxisX, Axis) +- ExtentY * dot(AxisY, Axis) +- ExtentZ * dot(AxisZ, Axis) }
    //
    // These individual terms can be maximized separately and are clearly maximal when their effective signs
    // are all positive. Analogous for the min with all-negative signs.
 
    // Calculate the projections of the box center and the extent-scaled axes.
    FVector::FReal ProjectedCenter = Axis | Center;
    FVector::FReal AbsProjectedAxisX = FMath::Abs(ExtentX * (Axis | AxisX));
    FVector::FReal AbsProjectedAxisY = FMath::Abs(ExtentY * (Axis | AxisY));
    FVector::FReal AbsProjectedAxisZ = FMath::Abs(ExtentZ * (Axis | AxisZ));
 
    FVector::FReal AbsProjectedExtent = AbsProjectedAxisX + AbsProjectedAxisY + AbsProjectedAxisZ;
    return FFloatInterval {
        float(ProjectedCenter - AbsProjectedExtent),
        float(ProjectedCenter + AbsProjectedExtent)
    };
}
 
template <> struct TIsPODType<FOrientedBox> { enum { Value = true }; };