Namespaces
namespace	CurveUtil

namespace	Debug

namespace	Delaunay3Internal

namespace	DelaunayInternal

namespace	DenseGrid

namespace	ExactPredicates

namespace	FaceNormalClustering

namespace	LinearColors

namespace	Spline

namespace	TetUtil

namespace	TriangleUtil

namespace	VectorUtil

Classes
class	ExpandEnumerable

class	ExpandIterator

class	FAffineKelvinlet

class	FArrayIndexSetsDecomposition

class	FArrowGenerator

struct	FAxisAlignedBox2i

struct	FAxisAlignedBox3i

class	FBaseRevolveGenerator

class	FBCSplineFilter

class	FBiLaplacianPullKelvinlet

class	FBoxFilter

class	FBoxSphereGenerator

struct	FBRIOPoints

class	FCapsuleGenerator

struct	FClusterKMeans

class	FColliderMesh

class	FColliderMeshProjectionTarget

class	FCompactMaps

struct	FComputeTangentsOptions

class	FConvexDecomposition3

struct	FConvexPartHullMeshAdapter

class	FCurvedStairGenerator

class	FCylinderGenerator

class	FDelaunay2

struct	FDelaunay2Connectivity

class	FDelaunay3

struct	FDelaunay3Connectivity

class	FDiscMeshGenerator

class	FDynamicFlagArray

class	FDynamicGraph

class	FDynamicGraph2

class	FDynamicGraph3

class	FDynamicGraphN

class	FDynamicMesh3

class	FDynamicMeshAttributeChangeSet

class	FDynamicMeshAttributeSet

class	FDynamicMeshAttributeSetChangeTracker

class	FDynamicMeshChange

class	FDynamicMeshChangeTracker

class	FDynamicMeshEditor

struct	FDynamicMeshEditResult

class	FDynamicMeshOctree3

class	FDynamicMeshSculptLayers

class	FDynamicMeshTangents

class	FDynamicMeshTriangleAttributeChange

struct	FDynamicSubmesh3

class	FEdgeLoop

class	FEdgeSpan

struct	FEdgeSplitInfo

class	FElementLinearization

class	FFlatTriangulationMeshGenerator

struct	FFlipEdgeInfo

class	FFloatingStairGenerator

struct	FForceGeometryNamespaceToExist

class	FGeneralizedCylinderGenerator

struct	FGeometryCollectionToDynamicMeshes

struct	FGeometryError

struct	FGeometryResult

class	FGeometrySet3

struct	FGeometryWarning

class	FGridBoxMeshGenerator

struct	FHullConnectivity

class	FilteredIterator

class	FImageAdapter

class	FImageDimensions

class	FImageOccupancyMap

class	FImageTile

class	FImageTiling

struct	FIndex2i

struct	FIndex3i

struct	FIndex4i

class	FIndexFlagSet

class	FIndexPriorityQueue

struct	FInterval1i

class	FLaplacianPullKelvinlet

struct	FLinearIntersection

class	FLinearStairGenerator

class	FLocalPlanarSimplify

class	FMarchingCubes

class	FMergeCoincidentMeshEdges

class	FMeshBones

class	FMeshBoolean

class	FMeshBoundaryLoops

class	FMeshConnectedComponents

class	FMeshDescriptionUVsToDynamicMesh

class	FMeshEdgeSelection

class	FMeshFaceSelection

struct	FMeshIndexMappings

class	FMeshMeshCut

class	FMeshNormals

class	FMeshRegionBoundaryLoops

class	FMeshSelfCut

class	FMeshSelfUnion

class	FMeshShapeGenerator

class	FMeshSurfacePath

struct	FMeshSurfacePoint

class	FMeshSurfacePointSampling

struct	FMeshTriEdgeID

struct	FMeshTriInfoCache

struct	FMeshTriOrderedEdgeID

class	FMeshVertexSelection

class	FMinimalBoxMeshGenerator

struct	FModuloIteration

struct	FNegativeSpaceSampleSettings

class	FNonManifoldMappingSupport

class	FNonManifoldSourceVertexIdAttribute

class	FNonManifoldSourceVertexIdAttributeChange

struct	FOccupancyGrid3

struct	FOptionallySparseIndexMap

class	FPinchKelvinlet

class	FPlanarPolygonMeshGenerator

class	FPointSetHashtable

struct	FPokeInfo

class	FPolygonEdgeMeshGenerator

struct	FPriorityOrderPoints

class	FProfileSweepGenerator

class	FPullKelvinlet

class	FPuncturedDiscMeshGenerator

class	FRectangleMeshGenerator

class	FRefCountVector

class	FRevolvePlanarPathGenerator

class	FRevolvePlanarPolygonGenerator

class	FRoundedRectangleMeshGenerator

class	FScaleKelvinlet

class	FSegmentTree3

class	FSharpBiLaplacianPullKelvinlet

class	FSharpLaplacianPullKelvinlet

struct	FSizedDisjointSet
	Disjoint set with additional storage to track the size of each set. More...

class	FSkeletalMeshLODRenderDataToDynamicMesh

class	FSmallListSet

class	FSparseDynamicOctree3

class	FSparseDynamicPointOctree3

struct	FSparseOctreeCell

struct	FSparsePointOctreeCell

struct	FSpatialPhotoParams

class	FSphereCovering

class	FSphereGenerator

class	FSpiralRevolvePlanarPolygonGenerator

class	FSpiralStairGenerator

class	FSplitAttributeWelder

class	FStairGenerator

class	FStaticMeshLODResourcesToDynamicMesh

class	FSweepGeneratorBase

class	FTriangleMeshAdapterEdgeConnectivity

class	FTwistKelvinlet

class	FUniqueIndexSet

class	FUVPacker

class	FUVSpaceAllocator

struct	FVector2i

struct	FVector3i

class	FVertexConnectedComponents

struct	FVertexInfo

class	FVerticalCylinderGeneratorBase

class	FWindingNumberBasedSolidify

struct	FZOrderCurvePoints

class	IIntersectionTarget

class	IMeshSpatial

class	IOrientedProjectionTarget

class	IProjectionTarget

class	ISpatial

class	MappedIterator

class	TAdaptiveTessellator

class	TAttrBasedQuadricError

class	TAttrWelder

struct	TAxisAlignedBox2

struct	TAxisAlignedBox3

class	TBaseKelvinlet

class	TBasicBlockedDenseGrid3

class	TBlendPairedKelvinlet

class	TBlockData3

class	TBlockData3< bool, BlockSize_ >

struct	TBlockData3Layout

class	TBlockedDenseGrid3

class	TBlockedGrid3

class	TBlockedGrid3Layout

struct	TBoundedImplicitFunction3

struct	TBoundsGridIndexer3

class	TCachingMeshSDF

struct	TCapsule3

struct	TCircle2

struct	TCircle3

struct	TClusterCenterArray

class	TConstObjectSharedAccess

class	TConvexHull2

class	TConvexHull3

struct	TConvexHullSimplificationSettings

class	TDenseGrid2

class	TDenseGrid3

class	TDiscreteKernel2

struct	TDistanceFieldToSkeletalField

class	TDistLine2AxisAlignedBox2

class	TDistLine3Line3

class	TDistLine3Ray3

class	TDistLine3Segment3

class	TDistLine3Triangle3

class	TDistPoint3Triangle3

class	TDistRay3Segment3

class	TDistSegment2AxisAlignedBox2

class	TDistSegment3Triangle3

class	TDistTriangle3Triangle3

class	TDynamicAttributeBase

class	TDynamicAttributeChangeBase

class	TDynamicAttributeSetBase

class	TDynamicBoneAttributeBase

class	TDynamicMeshAttributeChange

class	TDynamicMeshOverlay

class	TDynamicMeshScalarTriangleAttribute

class	TDynamicMeshTriangleAttribute

class	TDynamicMeshVectorOverlay

class	TDynamicPointSet3

class	TDynamicVector

class	TDynamicVectorN

class	TDynamicVertexAttribute

class	TDynamicVertexAttributeChange

class	TDynamicVertexSkinWeightsAttribute

class	TDynamicVertexSkinWeightsAttributeChange

class	TDynamicVerticesOctree3

class	TExactIntrTriangle3Triangle3

struct	TExtremePoints3

class	TFastWindingTree

class	TFibonacciLattice

struct	TFrame3

class	TGaussian1

class	TGaussian2

class	TGaussian3

class	TGeneralPolygon2

class	TGridSampler

struct	THalfspace3

class	THemisphericalFibonacci

class	TImageBuilder

class	TImplicitBlend

struct	TImplicitFunction3

struct	TImplicitLine3

class	TImplicitMorphology

struct	TImplicitPoint3

class	TImplicitSolidify

class	TIncrementalMeshDijkstra

class	TIndexedWeightMap

struct	TIndexMap

struct	TIndexMeshArrayAdapter

struct	TIndexVectorMeshArrayAdapter

class	TIntersector1

struct	TInterval1

class	TIntrLine2Line2

class	TIntrLine2Triangle2

class	TIntrRay3AxisAlignedBox3

class	TIntrRay3OrientedBox3

class	TIntrRay3Triangle3

class	TIntrSegment2Segment2

class	TIntrSegment2Triangle2

class	TIntrTriangle2AxisAlignedBox2

class	TIntrTriangle2Triangle2

class	TIntrTriangle3Triangle3

class	TKelvinletIntegrator

struct	TLine2

struct	TLine3

class	TMarchingPixelInfill

struct	TMatrix2

struct	TMatrix3

class	TMeshAABBTree3

class	TMeshDijkstra

class	TMeshLocalParam

class	TMeshQueries

class	TMeshSpatialSort

class	TMeshTangents

class	TMeshUniformSurfaceSampling

class	TMeshWindingNumberGrid

struct	TMeshWrapperAdapterd

class	TNormalHistogram

struct	TOrientedBox2

struct	TOrientedBox3

struct	TOverlayTraits

struct	TOverlayTraits< FVector2f >

struct	TOverlayTraits< FVector3f >

struct	TOverlayTraits< FVector4f >

class	TPairExpandEnumerable

class	TPairExpandIterator

class	TParallelAdaptiveRefinement

struct	TPlanarComplex

struct	TPlane3

class	TPointHashGrid2

class	TPointHashGrid3

struct	TPointSetAdapter

class	TPolygon2

class	TPolyline

class	TPolylinePolicy

class	TPolylinePolicy< T, 2 >

class	TPolylinePolicy< T, 3 >

struct	TQuadricError

struct	TQuaternion

class	TSampledScalarField2

struct	TSampleSetStatisticBuilder

struct	TSampleSetStatistics

struct	TScaleGridIndexer2

struct	TScaleGridIndexer3

struct	TSegment2

struct	TSegment3

struct	TShiftGridIndexer2

struct	TShiftGridIndexer3

struct	TSkeletalImplicitLine3

struct	TSkeletalRicciNaryBlend3

class	TSparseGrid2

class	TSparseGrid3

struct	TSparseListSet

class	TSparseNarrowBandMeshSDF

struct	TSpatialPhoto

class	TSpatialPhotoSet

struct	TSphere3

class	TSphericalFibonacci

class	TSweepingMeshSDF

struct	TTetrahedron3

class	TToDynamicMesh

class	TToDynamicMeshBase

class	TTransformSequence3

class	TTransformSRT3

struct	TTriangle2

struct	TTriangle3

struct	TTriangleMeshAdapter

class	TTriangleMeshAdapterEdgeConnectivity

class	TTridiagonalSolver

class	TTriLinearGridInterpolant

class	TVector2Arrays

class	TVector3Arrays

class	TVectorSetAnalysis3

struct	TVertexAttr

class	TVolPresQuadricError

struct	TWatertightRay3

class	TWeightedSamplingAliasTable

struct	TWrapAroundGridIndexer3

Typedefs
typedef TInterval1< float >	FInterval1f

typedef TInterval1< double >	FInterval1d

typedef TAxisAlignedBox2< float >	FAxisAlignedBox2f

typedef TAxisAlignedBox2< double >	FAxisAlignedBox2d

typedef TAxisAlignedBox3< float >	FAxisAlignedBox3f

typedef TAxisAlignedBox3< double >	FAxisAlignedBox3d

typedef TCapsule3< float >	FCapsule3f

typedef TCapsule3< double >	FCapsule3d

typedef TCircle2< float >	FCircle2f

typedef TCircle2< double >	FCircle2d

typedef TCircle3< float >	FCircle3f

typedef TCircle3< double >	FCircle3d

typedef TConvexHull2< float >	FConvexHull2f

typedef TConvexHull2< double >	FConvexHull2d

typedef TExtremePoints3< float >	FExtremePoints3f

typedef TExtremePoints3< double >	FExtremePoints3d

typedef TConvexHull3< float >	FConvexHull3f

typedef TConvexHull3< double >	FConvexHull3d

typedef FDynamicGraph2< double >	FDynamicGraph2d

typedef FDynamicGraph3< double >	FDynamicGraph3d

typedef TGeneralPolygon2< double >	FGeneralPolygon2d

typedef TGeneralPolygon2< float >	FGeneralPolygon2f

typedef TPlanarComplex< double >	FPlanarComplexd

typedef TPlanarComplex< float >	FPlanarComplexf

typedef TBlendPairedKelvinlet< FTwistKelvinlet, FLaplacianPullKelvinlet >	FLaplacianTwistPullKelvinlet

typedef TBlendPairedKelvinlet< FTwistKelvinlet, FBiLaplacianPullKelvinlet >	FBiLaplacianTwistPullKelvinlet

typedef TBlendPairedKelvinlet< FBiLaplacianPullKelvinlet, FLaplacianPullKelvinlet >	FBlendPullKelvinlet

typedef TBlendPairedKelvinlet< FSharpBiLaplacianPullKelvinlet, FSharpLaplacianPullKelvinlet >	FBlendPullSharpKelvinlet

typedef TDistLine2AxisAlignedBox2< float >	FDistLine2AxisAlignedBox2f

typedef TDistLine2AxisAlignedBox2< double >	FDistLine2AxisAlignedBox2d

typedef TDistLine3Line3< float >	FDistLine3Line3f

typedef TDistLine3Line3< double >	FDistLine3Line3d

typedef TDistLine3Ray3< float >	FDistLine3Ray3f

typedef TDistLine3Ray3< double >	FDistLine3Ray3d

typedef TDistLine3Segment3< float >	FDistLine3Segment3f

typedef TDistLine3Segment3< double >	FDistLine3Segment3d

typedef TDistLine3Triangle3< float >	FDistLine3Triangle3f

typedef TDistLine3Triangle3< double >	FDistLine3Triangle3d

typedef TDistPoint3Triangle3< float >	FDistPoint3Triangle3f

typedef TDistPoint3Triangle3< double >	FDistPoint3Triangle3d

typedef TDistRay3Segment3< float >	FDistRay3Segment3f

typedef TDistRay3Segment3< double >	FDistRay3Segment3d

typedef TDistSegment2AxisAlignedBox2< float >	FDistSegment2AxisAlignedBox2f

typedef TDistSegment2AxisAlignedBox2< double >	FDistSegment2AxisAlignedBox2d

typedef TDistSegment3Triangle3< float >	FDistSegment3Triangle3f

typedef TDistSegment3Triangle3< double >	FDistSegment3Triangle3d

typedef TDistTriangle3Triangle3< float >	FDistTriangle3Triangle3f

typedef TDistTriangle3Triangle3< double >	FDistTriangle3Triangle3d

typedef TDynamicAttributeChangeBase< FDynamicMesh3 >	FDynamicMeshAttributeChangeBase

typedef TDynamicAttributeBase< FDynamicMesh3 >	FDynamicMeshAttributeBase

typedef TDynamicAttributeSetBase< FDynamicMesh3 >	FDynamicMeshAttributeSetBase

using	FDynamicMeshBoneNameAttribute = TDynamicBoneAttributeBase< FDynamicMesh3, FName >

using	FDynamicMeshBoneParentIndexAttribute = TDynamicBoneAttributeBase< FDynamicMesh3, int32 >

using	FDynamicMeshBoneColorAttribute = TDynamicBoneAttributeBase< FDynamicMesh3, FVector4f >

using	FDynamicMeshBonePoseAttribute = TDynamicBoneAttributeBase< FDynamicMesh3, FTransform >

typedef TMeshAABBTree3< FDynamicMesh3 >	FDynamicMeshAABBTree3

typedef TDynamicMeshVectorOverlay< float, 2, FVector2f >	FDynamicMeshUVOverlay

typedef TDynamicMeshVectorOverlay< float, 3, FVector3f >	FDynamicMeshNormalOverlay

typedef TDynamicMeshVectorOverlay< float, 4, FVector4f >	FDynamicMeshColorOverlay

typedef TDynamicMeshScalarTriangleAttribute< int32 >	FDynamicMeshMaterialAttribute

typedef TDynamicMeshScalarTriangleAttribute< int32 >	FDynamicMeshPolygroupAttribute

typedef TDynamicMeshVertexAttribute< float, 1 >	FDynamicMeshWeightAttribute

typedef TDynamicMeshVertexAttribute< float, 3 >	FDynamicMeshMorphTargetAttribute

using	FDynamicMeshVertexSkinWeightsAttribute = TDynamicVertexSkinWeightsAttribute< FDynamicMesh3 >

typedef TDynamicMeshAttributeChange< float, 2 >	FDynamicMeshUVChange

typedef TDynamicMeshAttributeChange< float, 3 >	FDynamicMeshNormalChange

typedef TDynamicMeshAttributeChange< float, 4 >	FDynamicMeshColorChange

typedef FDynamicMeshTriangleAttributeChange< int32, 1 >	FDynamicMeshTriGroupChange

typedef TDynamicMeshAttributeChange< float, 1 >	FDynamicMeshWeightChange

typedef TDynamicMeshVertexAttribute< double, 3 >	FDynamicMeshSculptLayerAttribute

typedef TDynamicPointSet3< float >	FDynamicPointSet3f

typedef TDynamicPointSet3< double >	FDynamicPointSet3d

template<typename AttribValueType , int AttribDimension>
using	TDynamicMeshVertexAttribute = TDynamicVertexAttribute< AttribValueType, AttribDimension, FDynamicMesh3 >

typedef TConstObjectSharedAccess< FDynamicMesh3 >	FSharedConstDynamicMesh3

typedef TMeshTangents< float >	FMeshTangentsf

typedef TMeshTangents< double >	FMeshTangentsd

typedef TFrame3< float >	FFrame3f

typedef TFrame3< double >	FFrame3d

typedef TIndexMap< int >	FIndexMapi

typedef THalfspace3< float >	FHalfspace3f

typedef THalfspace3< double >	FHalfspace3d

using	FBSplineFilter = FBCSplineFilter< EBCSplineType::BSpline, false >

using	FCatmullRomFilter = FBCSplineFilter< EBCSplineType::CatmullRom, false >

using	FMitchellNetravaliFilter = FBCSplineFilter< EBCSplineType::MitchellNetravali, false >

typedef TSpatialPhoto< FVector4f >	FSpatialPhoto4f

typedef TSpatialPhoto< FVector3f >	FSpatialPhoto3f

typedef TSpatialPhoto< float >	FSpatialPhoto1f

typedef TSpatialPhotoSet< FVector4f, float >	FSpatialPhotoSet4f

typedef TSpatialPhotoSet< FVector3f, float >	FSpatialPhotoSet3f

typedef TSpatialPhotoSet< float, float >	FSpatialPhotoSet1f

typedef TImplicitPoint3< float >	FImplicitPoint3f

typedef TImplicitPoint3< double >	FImplicitPoint3d

typedef TImplicitLine3< float >	FImplicitLine3f

typedef TImplicitLine3< double >	FImplicitLine3d

typedef TSkeletalImplicitLine3< float >	FSkeletalImplicitLine3f

typedef TSkeletalImplicitLine3< double >	FSkeletalImplicitLine3d

typedef TExactIntrTriangle3Triangle3< float >	FExactIntrTriangle3Triangle3f

typedef TExactIntrTriangle3Triangle3< double >	FExactIntrTriangle3Triangle3d

typedef TIntersector1< double >	FIntersector1d

typedef TIntersector1< float >	FIntersector1f

typedef TIntrLine2Line2< double >	FIntrLine2Line2d

typedef TIntrLine2Line2< float >	FIntrLine2Line2f

typedef TIntrLine2Triangle2< float >	FIntrLine2Triangle2f

typedef TIntrLine2Triangle2< double >	FIntrLine2Triangle2d

typedef TIntrRay3AxisAlignedBox3< float >	FIntrRay3AxisAlignedBox3f

typedef TIntrRay3AxisAlignedBox3< double >	FIntrRay3AxisAlignedBox3d

typedef TIntrRay3OrientedBox3< float >	FIntrRay3OrientedBox3f

typedef TIntrRay3OrientedBox3< double >	FIntrRay3OrientedBox3d

typedef TWatertightRay3< float >	FWatertightRay3f

typedef TWatertightRay3< double >	FWatertightRay3d

typedef TIntrRay3Triangle3< float >	FIntrRay3Triangle3f

typedef TIntrRay3Triangle3< double >	FIntrRay3Triangle3d

typedef TIntrSegment2Segment2< double >	FIntrSegment2Segment2d

typedef TIntrSegment2Segment2< float >	FIntrSegment2Segment2f

typedef TIntrSegment2Triangle2< float >	FIntrSegment2Triangle2f

typedef TIntrSegment2Triangle2< double >	FIntrSegment2Triangle2d

typedef TIntrTriangle2AxisAlignedBox2< float >	FIntrTriangle2AxisAlignedBox2f

typedef TIntrTriangle2AxisAlignedBox2< double >	FIntrTriangle2AxisAlignedBox2d

typedef TIntrTriangle2Triangle2< float >	FIntrTriangle2Triangle2f

typedef TIntrTriangle2Triangle2< double >	FIntrTriangle2Triangle2d

typedef TIntrTriangle3Triangle3< float >	FIntrTriangle3Triangle3f

typedef TIntrTriangle3Triangle3< double >	FIntrTriangle3Triangle3d

typedef TLine2< double >	FLine2d

typedef TLine2< float >	FLine2f

typedef TLine3< double >	FLine3d

typedef TLine3< float >	FLine3f

typedef TMatrix3< float >	FMatrix3f

typedef TMatrix3< double >	FMatrix3d

typedef TMatrix2< float >	FMatrix2f

typedef TMatrix2< double >	FMatrix2d

typedef TTriangleMeshAdapter< double >	FTriangleMeshAdapterd

typedef TTriangleMeshAdapter< float >	FTriangleMeshAdapterf

typedef TIndexMeshArrayAdapter< uint32, double >	FIndexMeshArrayAdapterd

typedef TOrientedBox2< float >	FOrientedBox2f

typedef TOrientedBox2< double >	FOrientedBox2d

typedef TOrientedBox3< float >	FOrientedBox3f

typedef TOrientedBox3< double >	FOrientedBox3d

typedef TPlane3< float >	FPlane3f

typedef TPlane3< double >	FPlane3d

typedef TPointSetAdapter< double >	FPointSetAdapterd

typedef TPointSetAdapter< float >	FPointSetAdapterf

typedef TPolygon2< double >	FPolygon2d

typedef TPolygon2< float >	FPolygon2f

template<typename T >
using	TPolyline2 = TPolyline< T, 2 >

typedef TPolyline2< double >	FPolyline2d

typedef TPolyline2< float >	FPolyline2f

template<typename T >
using	TPolyline3 = TPolyline< T, 3 >

typedef TPolyline3< double >	FPolyline3d

typedef TPolyline3< float >	FPolyline3f

typedef TQuadricError< float >	FQuadricErrorf

typedef TQuadricError< double >	FQuadricErrord

typedef TVolPresQuadricError< float >	FVolPresQuadricErrorf

typedef TVolPresQuadricError< double >	FVolPresQuadricErrord

typedef TAttrBasedQuadricError< float >	FAttrBasedQuadricErrorf

typedef TAttrBasedQuadricError< double >	FAttrBasedQuadricErrord

typedef TQuaternion< float >	FQuaternionf

typedef TQuaternion< double >	FQuaterniond

typedef TGaussian1< float >	TGaussian1f

typedef TGaussian1< double >	TGaussian1d

typedef TDiscreteKernel2< float >	TDiscreteKernel2f

typedef TDiscreteKernel2< double >	TDiscreteKernel2d

typedef TGaussian2< float >	TGaussian2f

typedef TGaussian2< double >	TGaussian2d

typedef TGaussian3< float >	TGaussian3f

typedef TGaussian3< double >	TGaussian3d

using	FMeshUniformSurfaceSampling = TMeshUniformSurfaceSampling< FDynamicMesh3, double >

using	FWeightedSamplingAliasTabled = TWeightedSamplingAliasTable< double >

using	FWeightedSamplingAliasTablef = TWeightedSamplingAliasTable< float >

typedef TSampleSetStatistics< float >	FSampleSetStatisticsf

typedef TSampleSetStatistics< double >	FSampleSetStatisticsd

typedef TVectorSetAnalysis3< float >	FVectorSetAnalysis3f

typedef TVectorSetAnalysis3< double >	FVectorSetAnalysis3d

typedef TSegment2< float >	FSegment2f

typedef TSegment2< double >	FSegment2d

typedef TSegment3< float >	FSegment3f

typedef TSegment3< double >	FSegment3d

typedef TBlockedGrid3< float, 8 >	FBlockedGrid3f

typedef TBlockedGrid3< double, 8 >	FBlockedGrid3d

typedef TBlockedGrid3< int, 8 >	FBlockedGrid3i

typedef TBlockedGrid3< bool, 8 >	FBlockedGrid3b

typedef TBlockedDenseGrid3< float >	FBlockedDenseGrid3f

typedef TBlockedDenseGrid3< double >	FBlockedDenseGrid3d

typedef TBlockedDenseGrid3< int >	FBlockedDenseGrid3i

typedef TDenseGrid2< float >	FDenseGrid2f

typedef TDenseGrid2< double >	FDenseGrid2d

typedef TDenseGrid2< int32 >	FDenseGrid2i

typedef TDenseGrid3< float >	FDenseGrid3f

typedef TDenseGrid3< double >	FDenseGrid3d

typedef TDenseGrid3< int >	FDenseGrid3i

template<typename PointDataType >
using	TPointHashGrid2d = TPointHashGrid2< PointDataType, double >

template<typename PointDataType >
using	TPointHashGrid2f = TPointHashGrid2< PointDataType, float >

template<typename PointDataType >
using	TPointHashGrid3d = TPointHashGrid3< PointDataType, double >

template<typename PointDataType >
using	TPointHashGrid3f = TPointHashGrid3< PointDataType, float >

typedef TSampledScalarField2< double, double >	FSampledScalarField2d

typedef TSampledScalarField2< float, float >	FSampledScalarField2f

typedef TSphere3< float >	FSphere3f

typedef TSphere3< double >	FSphere3d

typedef TTransformSequence3< float >	FTransformSequence3f

typedef TTransformSequence3< double >	FTransformSequence3d

typedef TTransformSRT3< float >	FTransformSRT3f

typedef TTransformSRT3< double >	FTransformSRT3d

typedef TTriangle2< float >	FTriangle2f

typedef TTriangle2< double >	FTriangle2d

typedef TTriangle3< float >	FTriangle3f

typedef TTriangle3< double >	FTriangle3d

typedef TTriangle3< int >	FTriangle3i

typedef TTetrahedron3< float >	FTetrahedron3f

typedef TTetrahedron3< double >	FTetrahedron3d

using	TDynamicVector3f = TDynamicVectorN< float, 3 >

using	TDynamicVector2f = TDynamicVectorN< float, 2 >

using	TDynamicVector3d = TDynamicVectorN< double, 3 >

using	TDynamicVector2d = TDynamicVectorN< double, 2 >

using	TDynamicVector3i = TDynamicVectorN< int, 3 >

using	TDynamicVector2i = TDynamicVectorN< int, 2 >

typedef TScaleGridIndexer2< float >	FScaleGridIndexer2f

typedef TScaleGridIndexer2< double >	FScaleGridIndexer2d

typedef TShiftGridIndexer2< float >	FShiftGridIndexer2f

typedef TShiftGridIndexer2< double >	FShiftGridIndexer2d

typedef TScaleGridIndexer3< float >	FScaleGridIndexer3f

typedef TScaleGridIndexer3< double >	FScaleGridIndexer3d

typedef TWrapAroundGridIndexer3< float >	FWrapAroundGridIndexer3f

typedef TWrapAroundGridIndexer3< double >	FWrapAroundGridIndexer3d

typedef TShiftGridIndexer3< float >	FShiftGridIndexer3f

typedef TShiftGridIndexer3< double >	FShiftGridIndexer3d

typedef TBoundsGridIndexer3< float >	FBoundsGridIndexer3f

typedef TBoundsGridIndexer3< double >	FBoundsGridIndexer3d

typedef TIndexedWeightMap< float >	FIndexedWeightMap

typedef TIndexedWeightMap< float >	FIndexedWeightMap1f

typedef TIndexedWeightMap< double >	FIndexedWeightMap1d

Enumerations
enum class	EPointOrdering { Positive , Negative , CollinearLeft , CollinearRight , CollinearContain }

enum class	EConvexErrorMethod { RelativeVolume }

enum	EDiTO { DiTO_12 = 0 , DiTO_14 = 1 , DiTO_20 = 2 , DiTO_26 = 3 }

enum	EBox2FitCriteria { Area , Perimeter }

enum	EBox3FitCriteria { Volume , SurfaceArea }

enum class	EMeshComponents : uint8 { None = 0 , VertexNormals = 1 , VertexColors = 2 , VertexUVs = 4 , FaceGroups = 8 , All = 15 }

enum class	ERootfindingModes { SingleLerp , LerpSteps , Bisection }

enum class	ERoundedRectangleCorner : uint8 { None = 0 , BottomLeft = 1 , BottomRight = 2 , TopLeft = 4 , TopRight = 8 , All = 15 }

enum class	ECapType { None = 0 , FlatTriangulation = 1 , FlatMidpointFan = 2 }

enum class	EProfileSweepPolygonGrouping : uint8 { Single , PerFace , PerSweepSegment , PerProfileSegment }

enum class	EProfileSweepQuadSplit : uint8 { Uniform , ShortestDiagonal }

enum class	EMeshResult { Ok = 0 , Failed_NotAVertex = 1 , Failed_NotATriangle = 2 , Failed_NotAnEdge = 3 , Failed_BrokenTopology = 10 , Failed_HitValenceLimit = 11 , Failed_IsBoundaryEdge = 20 , Failed_FlippedEdgeExists = 21 , Failed_IsBowtieVertex = 22 , Failed_InvalidNeighbourhood = 23 , Failed_FoundDuplicateTriangle = 24 , Failed_CollapseTetrahedron = 25 , Failed_CollapseTriangle = 26 , Failed_NotABoundaryEdge = 27 , Failed_SameOrientation = 28 , Failed_CollapseQuad = 29 , Failed_WouldCreateBowtie = 30 , Failed_VertexAlreadyExists = 31 , Failed_CannotAllocateVertex = 32 , Failed_VertexStillReferenced = 33 , Failed_WouldCreateNonmanifoldEdge = 50 , Failed_TriangleAlreadyExists = 51 , Failed_CannotAllocateTriangle = 52 , Failed_UnrecoverableError = 1000 , Failed_Unsupported = 1001 }

enum class	EOperationValidationResult { Ok = 0 , Failed_UnknownReason = 1 , Failed_InvalidTopology = 2 }

enum class	EValidityCheckFailMode { ReturnOnly = 0 , Check = 1 , Ensure = 2 }

enum class	EBCSplineType { BSpline , CatmullRom , MitchellNetravali }

enum class	EImageTilingMethod { Clamp , Wrap }

enum class	ESurfacePointType { Vertex = 0 , Edge = 1 , Triangle = 2 }

enum class	ELocalParamTypes : uint8 { PlanarProjection = 1 , ExponentialMap = 2 , ExponentialMapUpwindAvg = 3 }

enum class	EFBMMode : uint8 { Standard , Turbulent , Ridge }

enum class	EGeometryResultType { Success = 0 , InProgress = 1 , Cancelled = 2 , PartialResult = 3 , Failure = 4 }

Functions
template<typename RealType >
EPointOrdering	PointOnLine (const TVector2< RealType > &P, const TVector2< RealType > &L0, const TVector2< RealType > &L1)

template TOrientedBox3< float > GEOMETRYCORE_API	ComputeOrientedBBox< float > (const UE::Geometry::EDiTO DiTOType, const int32 NumPoints, TFunctionRef< UE::Math::TVector< float >(int32)> GetPointFunc)

template TOrientedBox3< double > GEOMETRYCORE_API	ComputeOrientedBBox< double > (const UE::Geometry::EDiTO DiTOType, const int32 NumPoints, TFunctionRef< UE::Math::TVector< double >(int32)> GetPointFunc)

template TOrientedBox3< float > GEOMETRYCORE_API	ComputeOrientedBBox< float > (const TArray< UE::Math::TVector< float > > &SampleDirections, const int32 NumPoints, TFunctionRef< UE::Math::TVector< float >(int32)> GetPointFunc)

template TOrientedBox3< double > GEOMETRYCORE_API	ComputeOrientedBBox< double > (const TArray< UE::Math::TVector< double > > &SampleDirections, const int32 NumPoints, TFunctionRef< UE::Math::TVector< double >(int32)> GetPointFunc)

template<typename RealType >
bool	FitKDOPVertices3 (TArrayView< const UE::Math::TVector< RealType > > PlaneDirections, const int32 NumPoints, TFunctionRef< UE::Math::TVector< RealType >(int32)> GetPointFunc, TFunctionRef< bool(int32)> FilterFunc, TArray< UE::Math::TVector< RealType > > &OutVertices, TArray< UE::Math::TPlane< RealType > > *OptionalOutPlanes, RealType Epsilon, RealType VertexSnapDistance, RealType Inflate)

template bool GEOMETRYCORE_API	FitKDOPVertices3< float > (TArrayView< const UE::Math::TVector< float > > PlaneDirections, const int32 NumPoints, TFunctionRef< UE::Math::TVector< float >(int32)> GetPointFunc, TFunctionRef< bool(int32)> FilterFunc, TArray< UE::Math::TVector< float > > &OutVertices, TArray< UE::Math::TPlane< float > > *OptionalOutPlanes, float Epsilon, float VertexSnapDistance, float Inflate)

template bool GEOMETRYCORE_API	FitKDOPVertices3< double > (TArrayView< const UE::Math::TVector< double > > PlaneDirections, const int32 NumPoints, TFunctionRef< UE::Math::TVector< double >(int32)> GetPointFunc, TFunctionRef< bool(int32)> FilterFunc, TArray< UE::Math::TVector< double > > &OutVertices, TArray< UE::Math::TPlane< double > > *OptionalOutPlanes, double Epsilon, double VertexSnapDistance, double Inflate)

template<typename RealType >
TOrientedBox2< RealType >	FitOrientedBox2ConvexHull (int32 NumPts, TFunctionRef< TVector2< RealType >(int32)> GetHullPt, TFunctionRef< RealType(RealType, RealType)> FitFn)

template<typename RealType >
TOrientedBox2< RealType >	FitOrientedBox2SimplePolygon (TArrayView< const TVector2< RealType > > Polygon, TFunctionRef< RealType(RealType, RealType)> FitFn)

template<typename RealType >
TOrientedBox2< RealType >	FitOrientedBox2Points (TArrayView< const TVector2< RealType > > Points, TFunctionRef< RealType(RealType, RealType)> FitFn)

template TOrientedBox2< float > GEOMETRYCORE_API	FitOrientedBox2Points< float > (TArrayView< const TVector2< float > > Points, TFunctionRef< float(float, float)> FitFn)

template TOrientedBox2< double > GEOMETRYCORE_API	FitOrientedBox2Points< double > (TArrayView< const TVector2< double > > Points, TFunctionRef< double(double, double)> FitFn)

template TOrientedBox2< float > GEOMETRYCORE_API	FitOrientedBox2SimplePolygon< float > (TArrayView< const TVector2< float > > Points, TFunctionRef< float(float, float)> FitFn)

template TOrientedBox2< double > GEOMETRYCORE_API	FitOrientedBox2SimplePolygon< double > (TArrayView< const TVector2< double > > Points, TFunctionRef< double(double, double)> FitFn)

template TOrientedBox2< float > GEOMETRYCORE_API	FitOrientedBox2ConvexHull< float > (int32 NumPts, TFunctionRef< TVector2< float >(int32)> GetHullPt, TFunctionRef< float(float, float)> FitFn)

template TOrientedBox2< double > GEOMETRYCORE_API	FitOrientedBox2ConvexHull< double > (int32 NumPts, TFunctionRef< TVector2< double >(int32)> GetHullPt, TFunctionRef< double(double, double)> FitFn)

template<typename RealType >
TOrientedBox3< RealType >	OptimizeOrientedBox3Points (const TOrientedBox3< RealType > &InitialBox, int32 NumIterations, int32 NumPoints, TFunctionRef< TVector< RealType >(int32)> GetPointFunc, TFunctionRef< bool(int32)> Filter, EBox3FitCriteria FitMethod, FProgressCancel *ProgressCancel)

template<typename RealType >
TOrientedBox3< RealType >	FitOrientedBox3Points (int32 NumPts, TFunctionRef< TVector< RealType >(int32)> GetPtFn, TFunctionRef< bool(int32)> FilterFn, EBox3FitCriteria FitMethod, RealType SameNormalTolerance, FProgressCancel *ProgressCancel)

template TOrientedBox3< float > GEOMETRYCORE_API	FitOrientedBox3Points< float > (int32 NumPts, TFunctionRef< TVector< float >(int32)> GetPtFn, TFunctionRef< bool(int32)> FilterFn, EBox3FitCriteria FitMethod, float SameNormalTolerance, FProgressCancel *ProgressCancel)

template TOrientedBox3< double > GEOMETRYCORE_API	FitOrientedBox3Points< double > (int32 NumPts, TFunctionRef< TVector< double >(int32)> GetPtFn, TFunctionRef< bool(int32)> FilterFn, EBox3FitCriteria FitMethod, double SameNormalTolerance, FProgressCancel *ProgressCancel)

template TOrientedBox3< float > GEOMETRYCORE_API	OptimizeOrientedBox3Points (const TOrientedBox3< float > &InitialBox, int32 NumIterations, int32 NumPoints, TFunctionRef< TVector< float >(int32)> GetPointFunc, TFunctionRef< bool(int32)> Filter, EBox3FitCriteria FitMethod, FProgressCancel *ProgressCancel)

template TOrientedBox3< double > GEOMETRYCORE_API	OptimizeOrientedBox3Points (const TOrientedBox3< double > &InitialBox, int32 NumIterations, int32 NumPoints, TFunctionRef< TVector< double >(int32)> GetPointFunc, TFunctionRef< bool(int32)> Filter, EBox3FitCriteria FitMethod, FProgressCancel *ProgressCancel)

template bool GEOMETRYCORE_API	IsInside (const TSphere3< float > &OuterSphere, const TSphere3< float > &InnerSphere)

template bool GEOMETRYCORE_API	IsInside (const TSphere3< double > &OuterSphere, const TSphere3< double > &InnerSphere)

template bool GEOMETRYCORE_API	IsInside (const TSphere3< float > &OuterSphere, const TCapsule3< float > &InnerSphere)

template bool GEOMETRYCORE_API	IsInside (const TSphere3< double > &OuterSphere, const TCapsule3< double > &InnerSphere)

template bool GEOMETRYCORE_API	IsInside (const TSphere3< float > &OuterSphere, const TOrientedBox3< float > &InnerSphere)

template bool GEOMETRYCORE_API	IsInside (const TSphere3< double > &OuterSphere, const TOrientedBox3< double > &InnerSphere)

template bool GEOMETRYCORE_API	IsInside (const TCapsule3< float > &OuterSphere, const TCapsule3< float > &InnerSphere)

template bool GEOMETRYCORE_API	IsInside (const TCapsule3< double > &OuterSphere, const TCapsule3< double > &InnerSphere)

template bool GEOMETRYCORE_API	IsInside (const TCapsule3< float > &OuterSphere, const TSphere3< float > &InnerSphere)

template bool GEOMETRYCORE_API	IsInside (const TCapsule3< double > &OuterSphere, const TSphere3< double > &InnerSphere)

template bool GEOMETRYCORE_API	IsInside (const TCapsule3< float > &OuterSphere, const TOrientedBox3< float > &InnerSphere)

template bool GEOMETRYCORE_API	IsInside (const TCapsule3< double > &OuterSphere, const TOrientedBox3< double > &InnerSphere)

template bool GEOMETRYCORE_API	IsInside (const TOrientedBox3< float > &OuterSphere, const TOrientedBox3< float > &InnerSphere)

template bool GEOMETRYCORE_API	IsInside (const TOrientedBox3< double > &OuterSphere, const TOrientedBox3< double > &InnerSphere)

template bool GEOMETRYCORE_API	IsInside (const TOrientedBox3< float > &OuterSphere, const TSphere3< float > &InnerSphere)

template bool GEOMETRYCORE_API	IsInside (const TOrientedBox3< double > &OuterSphere, const TSphere3< double > &InnerSphere)

template bool GEOMETRYCORE_API	IsInside (const TOrientedBox3< float > &OuterSphere, const TCapsule3< float > &InnerSphere)

template bool GEOMETRYCORE_API	IsInside (const TOrientedBox3< double > &OuterSphere, const TCapsule3< double > &InnerSphere)

template bool GEOMETRYCORE_API	DoesCylinderContainPoint (const TVector< float > &CylinderCenter, const TVector< float > &CylinderAxis, float CylinderRadius, float CylinderHeight, const TVector< float > &QueryPoint)

template bool GEOMETRYCORE_API	DoesCylinderContainPoint (const TVector< double > &CylinderCenter, const TVector< double > &CylinderAxis, double CylinderRadius, double CylinderHeight, const TVector< double > &QueryPoint)

template bool GEOMETRYCORE_API	TestIntersection (const TSegment2< float > &Segment, const TAxisAlignedBox2< float > &Box)

template bool GEOMETRYCORE_API	TestIntersection (const TSegment2< double > &Segment, const TAxisAlignedBox2< double > &Box)

template bool GEOMETRYCORE_API	DoesTriangleIntersectCircle2D (const TVector2< float > &A, const TVector2< float > &B, const TVector2< float > &C, const TVector2< float > &Center, double RadiusSquared)

template bool GEOMETRYCORE_API	DoesTriangleIntersectCircle2D (const TVector2< double > &A, const TVector2< double > &B, const TVector2< double > &C, const TVector2< double > &Center, double RadiusSquared)

template bool GEOMETRYCORE_API	TestIntersection (const THalfspace3< float > &Halfspace, const TSphere3< float > &InnerSphere)

template bool GEOMETRYCORE_API	TestIntersection (const THalfspace3< double > &Halfspace, const TSphere3< double > &InnerSphere)

template bool GEOMETRYCORE_API	TestIntersection (const THalfspace3< float > &Halfspace, const TCapsule3< float > &InnerSphere)

template bool GEOMETRYCORE_API	TestIntersection (const THalfspace3< double > &Halfspace, const TCapsule3< double > &InnerSphere)

template bool GEOMETRYCORE_API	TestIntersection (const THalfspace3< float > &Halfspace, const TOrientedBox3< float > &InnerSphere)

template bool GEOMETRYCORE_API	TestIntersection (const THalfspace3< double > &Halfspace, const TOrientedBox3< double > &InnerSphere)

template<typename IntType , typename T , typename TransformFuncT , typename ReduceFuncT >
T	ParallelTransformReduce (IntType Num, const T &Init, TransformFuncT Transform, ReduceFuncT Reduce, int64 InNumTasks)

template<typename IntType , typename T , typename InitFuncT , typename TransformFuncT , typename ReduceFuncT >
void	ParallelTransformReduce (IntType Num, InitFuncT InitFunc, TransformFuncT Transform, ReduceFuncT Reduce, T &Out, int64 InNumTasks)

template<typename IterT >
int64	IteratorDistance (IterT Begin, IterT End)

template<typename IterT >
IterT	AdvanceIterator (IterT Start, int64 N)

template<typename ContainerType , typename ElementType , typename SizeType >
int64	IteratorDistance (TIndexedContainerIterator< ContainerType, ElementType, SizeType > Begin, TIndexedContainerIterator< ContainerType, ElementType, SizeType > End)

template<typename ContainerType , typename ElementType , typename SizeType >
TIndexedContainerIterator< ContainerType, ElementType, SizeType >	AdvanceIterator (TIndexedContainerIterator< ContainerType, ElementType, SizeType > Begin, SizeType N)

template<typename T , typename IterT , typename TransformFuncT , typename ReduceFuncT >
T	ParallelTransformReduce (IterT BeginIterator, IterT EndIterator, const T &Init, TransformFuncT Transform, ReduceFuncT Reduce, int64 InNumTasks)

template<typename T , typename IterT , typename InitFuncT , typename TransformFuncT , typename ReduceFuncT >
void	ParallelTransformReduce (IterT BeginIterator, IterT EndIterator, InitFuncT InitFunc, TransformFuncT Transform, ReduceFuncT Reduce, T &Out, int64 InNumTasks)

template<typename RealType >
TOrientedBox3< RealType > GEOMETRYCORE_API	ComputeOrientedBBox (const EDiTO DiTO_K, const int32 NumPoints, TFunctionRef< UE::Math::TVector< RealType >(int32)> GetPointFunc)

template<typename RealType >
TOrientedBox3< RealType > GEOMETRYCORE_API	ComputeOrientedBBox (const TArray< TVector< RealType > > &SampleDirections, const int32 NumPoints, TFunctionRef< UE::Math::TVector< RealType >(int32)> GetPointFunc)

template<typename RealType >
bool GEOMETRYCORE_API	FitKDOPVertices3 (TArrayView< const UE::Math::TVector< RealType > > PlaneDirections, const int32 NumPoints, TFunctionRef< UE::Math::TVector< RealType >(int32)> GetPointFunc, TFunctionRef< bool(int32)> FilterFunc, TArray< UE::Math::TVector< RealType > > &OutVertices, TArray< UE::Math::TPlane< RealType > > *OptionalOutPlanes=nullptr, RealType Epsilon=TMathUtil< RealType >::Epsilon, RealType VertexSnapDistance=(RealType) 0.1, RealType Inflate=(RealType) 0.1)

template<typename RealType >
bool	FitKDOPVertices3 (TArrayView< const UE::Math::TVector< RealType > > PlaneDirections, const int32 NumPoints, TFunctionRef< UE::Math::TVector< RealType >(int32)> GetPointFunc, TArray< UE::Math::TVector< RealType > > &OutVertices, TArray< UE::Math::TPlane< RealType > > *OptionalOutPlanes=nullptr, RealType Epsilon=TMathUtil< RealType >::Epsilon, RealType VertexSnapDistance=(RealType) 0.1, RealType Inflate=(RealType) 0.1)

template<typename RealType >
bool	FitKDOPVertices3 (TArrayView< const UE::Math::TVector< RealType > > PlaneDirections, const TArray< UE::Math::TVector< RealType > > &Points, TArray< UE::Math::TVector< RealType > > &OutVertices, TArray< UE::Math::TPlane< RealType > > *OptionalOutPlanes=nullptr, RealType Epsilon=TMathUtil< RealType >::Epsilon, RealType VertexSnapDistance=(RealType) 0.1, RealType Inflate=(RealType) 0.1)

template<typename RealType >
TOrientedBox2< RealType > GEOMETRYCORE_API	FitOrientedBox2Points (TArrayView< const TVector2< RealType > > Points, TFunctionRef< RealType(RealType, RealType)> FitFn)

template<typename RealType >
TOrientedBox2< RealType >	FitOrientedBox2Points (TArrayView< const TVector2< RealType > > Points, EBox2FitCriteria FitMethod=EBox2FitCriteria::Area)

template<typename RealType >
TOrientedBox2< RealType > GEOMETRYCORE_API	FitOrientedBox2SimplePolygon (TArrayView< const TVector2< RealType > > Polygon, TFunctionRef< RealType(RealType, RealType)> FitFn)

template<typename RealType >
TOrientedBox2< RealType >	FitOrientedBox2SimplePolygon (TArrayView< const TVector2< RealType > > Polygon, EBox2FitCriteria FitMethod=EBox2FitCriteria::Area)

template<typename RealType >
TOrientedBox2< RealType > GEOMETRYCORE_API	FitOrientedBox2ConvexHull (int32 NumPts, TFunctionRef< TVector2< RealType >(int32)> GetHullPt, TFunctionRef< RealType(RealType, RealType)> FitFn)

template<typename RealType >
TOrientedBox2< RealType >	FitOrientedBox2ConvexHull (int32 NumPts, TFunctionRef< TVector2< RealType >(int32)> GetHullPt, EBox2FitCriteria FitMethod=EBox2FitCriteria::Area)

template<typename RealType >
TOrientedBox3< RealType > GEOMETRYCORE_API	FitOrientedBox3Points (int32 NumPoints, TFunctionRef< TVector< RealType >(int32)> GetPointFunc, TFunctionRef< bool(int32)> Filter, EBox3FitCriteria FitMethod=EBox3FitCriteria::Volume, RealType SameNormalTolerance=0, FProgressCancel *ProgressCancel=nullptr)

template<typename RealType >
TOrientedBox3< RealType >	FitOrientedBox3Points (TArrayView< const TVector< RealType > > Points, EBox3FitCriteria FitMethod=EBox3FitCriteria::Volume, RealType SameNormalTolerance=0, FProgressCancel *ProgressCancel=nullptr)

template<typename RealType >
TOrientedBox3< RealType > GEOMETRYCORE_API	OptimizeOrientedBox3Points (const TOrientedBox3< RealType > &InitialBox, int32 NumIterations, int32 NumPoints, TFunctionRef< TVector< RealType >(int32)> GetPointFunc, TFunctionRef< bool(int32)> Filter, EBox3FitCriteria FitMethod=EBox3FitCriteria::Volume, FProgressCancel *ProgressCancel=nullptr)

template<typename Real >
double	SquaredDistanceFromLineIntegratedAlongSegment (const TLine3< Real > &Line, const TSegment3< Real > &Segment)

FTriangleMeshAdapterd GEOMETRYCORE_API	MakeTransformedDynamicMeshAdapter (const FDynamicMesh3 *Mesh, FTransform3d Transform)

FTriangleMeshAdapterd GEOMETRYCORE_API	MakeDynamicMeshAdapter (const FDynamicMesh3 *Mesh)

FPointSetAdapterd GEOMETRYCORE_API	MakeVerticesAdapter (const FDynamicMesh3 *Mesh)

FPointSetAdapterd GEOMETRYCORE_API	MakePointsAdapter (const FDynamicPointSet3d *PointSet)

FPointSetAdapterd GEOMETRYCORE_API	MakeTriCentroidsAdapter (const FDynamicMesh3 *Mesh)

FPointSetAdapterd GEOMETRYCORE_API	MakeEdgeMidpointsAdapter (const FDynamicMesh3 *Mesh)

FPointSetAdapterd GEOMETRYCORE_API	MakeBoundaryEdgeMidpointsAdapter (const FDynamicMesh3 *Mesh)

GEOMETRYCORE_API bool	CompactAttributeValues (const FDynamicMesh3 &Mesh, TDynamicMeshScalarTriangleAttribute< int32 > &TriangleAttrib, FInterval1i &OldMaxAttributeRangeOut, int &NewMaxAttributeValueOut, TArray< int32 > &OldToNewMapOut, TArray< int32 > &NewToOldMapOut, bool &bWasCompactOut)

GEOMETRYCORE_API bool	CopyVertexUVsToOverlay (const FDynamicMesh3 &Mesh, FDynamicMeshUVOverlay &UVOverlayOut, bool bCompactElements=false)

GEOMETRYCORE_API bool	CopyVertexNormalsToOverlay (const FDynamicMesh3 &Mesh, FDynamicMeshNormalOverlay &NormalOverlayOut, bool bCompactElements=false)

GEOMETRYCORE_API void	TriangleToVertexIDs (const FDynamicMesh3 *Mesh, TConstArrayView< int > TriangleIDs, TArray< int > &VertexIDsOut)

GEOMETRYCORE_API void	VertexToTriangleOneRing (const FDynamicMesh3 *Mesh, TConstArrayView< int > VertexIDs, TSet< int > &TriangleIDsOut)

template<typename OverlayType , typename EnumeratorType , typename OutputSetType >
void	TrianglesToOverlayElements (const OverlayType *Overlay, EnumeratorType TriangleEnumeration, OutputSetType &ElementsOut)

GEOMETRYCORE_API FIndex2i	FindVertexEdgesInTriangle (const FDynamicMesh3 &Mesh, int32 TriangleID, int32 VertexID)

GEOMETRYCORE_API int32	FindSharedEdgeInTriangles (const FDynamicMesh3 &Mesh, int32 Triangle0, int32 Triangle1)

template<typename EnumeratorType , typename SetType >
void	CollectVertexPositions (const FDynamicMesh3 &Mesh, EnumeratorType Enumeration, SetType &Output)

template<typename TrisConnectedPredicate >
FIndex3i	FindNextAdjacentTriangleAroundVtx (const FDynamicMesh3 *Mesh, int32 VertexID, int32 FromTriangleID, int32 PrevTriangleID, TrisConnectedPredicate TrisConnectedTest)

GEOMETRYCORE_API bool	SplitBoundaryVertexTrianglesIntoSubsets (const FDynamicMesh3 *Mesh, int32 VertexID, int32 SplitEdgeID, TArray< int32 > &TriangleSet0, TArray< int32 > &TriangleSet1)

GEOMETRYCORE_API bool	SplitInteriorVertexTrianglesIntoSubsets (const FDynamicMesh3 *Mesh, int32 VertexID, int32 SplitEdgeID0, int32 SplitEdgeID1, TArray< int32 > &TriangleSet0, TArray< int32 > &TriangleSet1)

GEOMETRYCORE_API bool	ConvertLoopToTriOrderedEdgeLoop (const FDynamicMesh3 &Mesh, const TArray< int32 > &VertexLoop, const TArray< int32 > &EdgeLoop, TFunctionRef< int(int EdgeID, int TriangleA, int TriangleB)> SelectEdgeTriangleFunc, TArray< FMeshTriOrderedEdgeID > &TriOrderedEdgesLoopOut)

GEOMETRYCORE_API bool	ConvertLoopToTriOrderedEdgeLoop (const FDynamicMesh3 &Mesh, const TArray< int32 > &VertexLoop, const TArray< int32 > &EdgeLoop, TArray< FMeshTriOrderedEdgeID > &TriOrderedEdgesLoopOut)

GEOMETRYCORE_API bool	ConvertTriOrderedEdgeLoopToLoop (const FDynamicMesh3 &Mesh, const TArray< FMeshTriOrderedEdgeID > &TriOrderedEdgesLoopOut, TArray< int32 > &VertexLoop, TArray< int32 > *EdgeLoop=nullptr)

template<typename T >
TFrame3< T >	Lerp (const TFrame3< T > &A, const TFrame3< T > &B, T Alpha)

template<typename RealType >
void	GenerateBoxSegments (const TVector< RealType > &HalfDimensions, const TVector< RealType > &Center, const TVector< RealType > &AxisX, const TVector< RealType > &AxisY, const TVector< RealType > &AxisZ, const TTransformSRT3< RealType > &Transform, TFunctionRef< void(const TVector< RealType > &A, const TVector< RealType > &B)> EmitLineFunc)

template<typename RealType >
void	GenerateCircleSegments (int32 NumSteps, RealType Radius, const TVector< RealType > &Center, const TVector< RealType > &AxisX, const TVector< RealType > &AxisY, const TTransformSRT3< RealType > &Transform, TFunctionRef< void(const TVector< RealType > &A, const TVector< RealType > &B)> EmitLineFunc)

template<typename RealType >
void	GenerateArcSegments (int32 NumSteps, RealType Radius, RealType StartAngle, RealType EndAngle, const TVector< RealType > &Center, const TVector< RealType > &AxisX, const TVector< RealType > &AxisY, const TTransformSRT3< RealType > &Transform, TFunctionRef< void(const TVector< RealType > &A, const TVector< RealType > &B)> EmitLineFunc)

	ENUM_CLASS_FLAGS (ERoundedRectangleCorner)

template<typename RealType >
void	HeatEquationImplicitAOS (TSampledScalarField2< RealType, RealType > &Field, const RealType SigmaX, const RealType SigmaY)

GEOMETRYCORE_API double	PointTriangleDistance (const FVector3d &x0, const FVector3d &x1, const FVector3d &x2, const FVector3d &x3)

GEOMETRYCORE_API float	PointTriangleDistance (const FVector3f &x0, const FVector3f &x1, const FVector3f &x2, const FVector3f &x3)

GEOMETRYCORE_API bool	PointInTriangle2d (double X0, double Y0, double X1, double Y1, double X2, double Y2, double X3, double Y3, double &A, double &B, double &C)

template<typename RealType >
RealType	PointSegmentDistance (const TVector< RealType > &x0, const TVector< RealType > &x1, const TVector< RealType > &x2)

template<typename RealType >
int	Orientation (RealType X1, RealType Y1, RealType X2, RealType Y2, RealType &TwiceSignedArea)

uint32	GetTypeHash (const FIndex2i &Index)

uint32	GetTypeHash (const FIndex3i &Index)

uint32	GetTypeHash (const FIndex4i &Index)

template<typename RealType >
GEOMETRYCORE_API bool	IsInside (const TSphere3< RealType > &OuterSphere, const TSphere3< RealType > &InnerSphere)

template<typename RealType >
GEOMETRYCORE_API bool	IsInside (const TSphere3< RealType > &OuterSphere, const TCapsule3< RealType > &InnerCapsule)

template<typename RealType >
GEOMETRYCORE_API bool	IsInside (const TSphere3< RealType > &OuterSphere, const TOrientedBox3< RealType > &InnerBox)

template<typename RealType , typename EnumerablePointsType , typename E = decltype(DeclVal<EnumerablePointsType>().begin())>
bool	IsInside (const TSphere3< RealType > &OuterSphere, EnumerablePointsType EnumerablePts)

template<typename RealType , typename GridType >
bool	IsInside (const TSphere3< RealType > &OuterSphere, const TTriLinearGridInterpolant< GridType > &InnerGrid)

template<typename RealType >
GEOMETRYCORE_API bool	IsInside (const TCapsule3< RealType > &OuterCapsule, const TCapsule3< RealType > &InnerCapsule)

template<typename RealType >
GEOMETRYCORE_API bool	IsInside (const TCapsule3< RealType > &OuterCapsule, const TSphere3< RealType > &InnerSphere)

template<typename RealType >
GEOMETRYCORE_API bool	IsInside (const TCapsule3< RealType > &OuterCapsule, const TOrientedBox3< RealType > &InnerBox)

template<typename RealType , typename EnumerablePointsType , typename E = decltype(DeclVal<EnumerablePointsType>().begin())>
bool	IsInside (const TCapsule3< RealType > &OuterCapsule, EnumerablePointsType EnumerablePts)

template<typename RealType , typename GridType >
bool	IsInside (const TCapsule3< RealType > &OuterCapsule, const TTriLinearGridInterpolant< GridType > &InnerGrid)

template<typename RealType >
GEOMETRYCORE_API bool	IsInside (const TOrientedBox3< RealType > &OuterBox, const TOrientedBox3< RealType > &InnerBox)

template<typename RealType >
GEOMETRYCORE_API bool	IsInside (const TOrientedBox3< RealType > &OuterBox, const TSphere3< RealType > &InnerSphere)

template<typename RealType >
GEOMETRYCORE_API bool	IsInside (const TOrientedBox3< RealType > &OuterBox, const TCapsule3< RealType > &InnerCapsule)

template<typename RealType , typename EnumerablePointsType , typename E = decltype(DeclVal<EnumerablePointsType>().begin())>
bool	IsInside (const TOrientedBox3< RealType > &OuterBox, EnumerablePointsType EnumerablePts)

template<typename RealType , typename GridType >
bool	IsInside (const TOrientedBox3< RealType > &OuterBox, const TTriLinearGridInterpolant< GridType > &InnerGrid)

template<typename RealType >
bool	IsInsideHull (TArrayView< THalfspace3< RealType > > Halfspaces, const TSphere3< RealType > &InnerSphere)

template<typename RealType >
bool	IsInsideHull (TArrayView< THalfspace3< RealType > > Halfspaces, const TCapsule3< RealType > &InnerCapsule)

template<typename RealType >
bool	IsInsideHull (TArrayView< THalfspace3< RealType > > Halfspaces, const TOrientedBox3< RealType > &InnerBox)

template<typename RealType , typename EnumerablePointsType , typename E = decltype(DeclVal<EnumerablePointsType>().begin())>
bool	IsInsideHull (TArrayView< THalfspace3< RealType > > Halfspaces, EnumerablePointsType EnumerablePts)

template<typename RealType , typename GridType >
bool	IsInsideHull (TArrayView< THalfspace3< RealType > > Halfspaces, const TTriLinearGridInterpolant< GridType > &InnerGrid)

template<typename RealType , typename GridType >
bool	IsInside (const TTriLinearGridInterpolant< GridType > &OuterGrid, const TTransform< RealType > &OuterGridTransform, const TSphere3< RealType > &InnerSphere)

template<typename RealType , typename GridType >
bool	IsInside (const TTriLinearGridInterpolant< GridType > &OuterGrid, const TTransform< RealType > &OuterGridTransform, const TCapsule3< RealType > &InnerCapsule)

template<typename RealType , typename GridType >
bool	IsInside (const TTriLinearGridInterpolant< GridType > &OuterGrid, const TTransform< RealType > &OuterGridTransform, const TOrientedBox3< RealType > &InnerBox)

template<typename RealType , typename GridType , typename EnumerablePointsType , typename E = decltype(DeclVal<EnumerablePointsType>().begin())>
bool	IsInside (const TTriLinearGridInterpolant< GridType > &OuterGrid, const TTransform< RealType > &OuterGridTransform, EnumerablePointsType EnumerablePts)

template<typename RealType , typename GridType1 , typename GridType2 >
bool	IsInside (const TTriLinearGridInterpolant< GridType1 > &OuterGrid, const TTransform< RealType > &OuterGridTransform, const TTriLinearGridInterpolant< GridType2 > &InnerGrid, const TTransform< RealType > &InnerGridTransform)

template<typename RealType >
bool	DoesCylinderContainPoint (const TVector< RealType > &CylinderCenter, const TVector< RealType > &NormalizedCylinderAxis, RealType CylinderRadius, RealType CylindeHeight, const TVector< RealType > &QueryPoint)

template<typename RealType , typename GridType >
bool	IsInside (const TTriLinearGridInterpolant< GridType > &OuterGrid, const UE::Geometry::TAxisAlignedBox3< RealType > &InnerAABB)

template<typename Real >
GEOMETRYCORE_API bool	TestIntersection (const TSegment2< Real > &Segment, const TAxisAlignedBox2< Real > &Box)

template<typename Real >
GEOMETRYCORE_API bool	DoesTriangleIntersectCircle2D (const TVector2< Real > &A, const TVector2< Real > &B, const TVector2< Real > &C, const TVector2< Real > &Center, double RadiusSquared)

template<typename RealType >
GEOMETRYCORE_API bool	TestIntersection (const THalfspace3< RealType > &Halfspace, const TSphere3< RealType > &Sphere)

template<typename RealType >
GEOMETRYCORE_API bool	TestIntersection (const THalfspace3< RealType > &Halfspace, const TCapsule3< RealType > &Capsule)

template<typename RealType >
GEOMETRYCORE_API bool	TestIntersection (const THalfspace3< RealType > &Halfspace, const TOrientedBox3< RealType > &Box)

FVector2i	operator* (int32 Scalar, const FVector2i &V)

std::ostream &	operator<< (std::ostream &os, const FVector2i &Vec)

uint32	GetTypeHash (const FVector2i &Vector)

FVector3i	operator* (int32 Scalar, const FVector3i &V)

FVector3i	Min (const FVector3i &V0, const FVector3i &V1)

FVector3i	Max (const FVector3i &V0, const FVector3i &V1)

std::ostream &	operator<< (std::ostream &os, const FVector3i &Vec)

uint32	GetTypeHash (const FVector3i &Vector)

template<typename RealType >
TMatrix3< RealType >	operator* (RealType Scale, const TMatrix3< RealType > &Mat)

template<typename RealType >
TMatrix2< RealType >	operator* (RealType Scale, const TMatrix2< RealType > &Mat)

FTriangleMeshAdapterd	GetArrayMesh (TArray< FVector > &Vertices, TArray< FIntVector > &Triangles)

bool GEOMETRYCORE_API	EmbedProjectedPath (FDynamicMesh3 Mesh, int StartTriID, FFrame3d Frame, const TArray< FVector2d > &Path2D, TArray< int > &OutPathVertices, TArray< int > &OutVertexCorrespondence, bool bClosePath, FMeshFaceSelection EnclosedFaces=nullptr, double PtSnapVertexOrEdgeThresholdSq=FMathf::ZeroTolerance *100)

bool GEOMETRYCORE_API	EmbedProjectedPaths (FDynamicMesh3 Mesh, const TArrayView< const int > StartTriIDs, FFrame3d Frame, const TArrayView< const TArray< FVector2d > > AllPaths, TArray< TArray< int > > &OutAllPathVertices, TArray< TArray< int > > &OutAllVertexCorrespondence, bool bClosePaths, FMeshFaceSelection EnclosedFaces, double PtSnapVertexOrEdgeThresholdSq=FMathf::ZeroTolerance *100)

template<typename T >
T	FractalBrownianMotionNoise (const EFBMMode FBMMode, const uint32 OctaveCount, const Math::TVector2< T > Coords, const T Lacunarity, const T Gain, const T Smoothness, const T Gamma)

template<typename RealType >
TQuadricError< RealType >	CreateSeamQuadric (const TVector< RealType > &p0, const TVector< RealType > &p1, const TVector< RealType > &AdjFaceNormal)

template<typename RealType >
TQuaternion< RealType >	operator* (const TQuaternion< RealType > &A, const TQuaternion< RealType > &B)

template<typename RealType >
TQuaternion< RealType >	operator* (RealType Scalar, const TQuaternion< RealType > &Q)

template<typename RealType >
TQuaternion< RealType >	operator* (const TQuaternion< RealType > &Q, RealType Scalar)

template<typename RealType >
TQuaternion< RealType >	operator+ (const TQuaternion< RealType > &A, const TQuaternion< RealType > &B)

template<typename RealType >
TQuaternion< RealType >	operator- (const TQuaternion< RealType > &A, const TQuaternion< RealType > &B)

template<typename RealType >
TVector< RealType >	operator* (const TQuaternion< RealType > &Q, const UE::Math::TVector< RealType > &V)

template<typename T >
constexpr T	DotPerp (const UE::Math::TVector2< T > &V1, const UE::Math::TVector2< T > &V2)

template<typename T >
constexpr UE::Math::TVector2< T >	PerpCW (const UE::Math::TVector2< T > &V)

template<typename T >
T	Orient (const UE::Math::TVector2< T > &A, const UE::Math::TVector2< T > &B, const UE::Math::TVector2< T > &C)

template<typename T >
constexpr bool	IsNormalized (const UE::Math::TVector2< T > &Vector, const T Tolerance=TMathUtil< T >::ZeroTolerance)

template<typename T >
T	Normalize (UE::Math::TVector2< T > &Vector, const T Epsilon=0)

template<typename T >
UE::Math::TVector2< T >	Normalized (const UE::Math::TVector2< T > &Vector, const T Epsilon=0)

template<typename T >
T	Distance (const UE::Math::TVector2< T > &V1, const UE::Math::TVector2< T > &V2)

template<typename T >
T	DistanceSquared (const UE::Math::TVector2< T > &V1, const UE::Math::TVector2< T > &V2)

template<typename T >
T	AngleD (const UE::Math::TVector2< T > &V1, const UE::Math::TVector2< T > &V2)

template<typename T >
T	AngleR (const UE::Math::TVector2< T > &V1, const UE::Math::TVector2< T > &V2)

template<typename T >
T	SignedAngleR (const UE::Math::TVector2< T > &V1, const UE::Math::TVector2< T > &V2)

template<typename T >
UE::Math::TVector2< T >	Lerp (const UE::Math::TVector2< T > &A, const UE::Math::TVector2< T > &B, T Alpha)

template<typename T >
constexpr UE::Math::TVector< T >	MakeUnitVector3 (int32 Axis)

template<typename T >
T	Length (const UE::Math::TVector< T > &V)

template<typename T >
T	SquaredLength (const UE::Math::TVector< T > &V)

template<typename T >
constexpr bool	IsNormalized (const UE::Math::TVector< T > &Vector, const T Tolerance=TMathUtil< T >::ZeroTolerance)

template<typename T >
T	Normalize (UE::Math::TVector< T > &Vector, const T Epsilon=0)

template<typename T >
constexpr UE::Math::TVector< T >	Normalized (const UE::Math::TVector< T > &Vector, const T Epsilon=0)

template<typename T >
T	Distance (const UE::Math::TVector< T > &V1, const UE::Math::TVector< T > &V2)

template<typename T >
T	DistanceSquared (const UE::Math::TVector< T > &V1, const UE::Math::TVector< T > &V2)

template<typename T >
T	Dot (const UE::Math::TVector< T > &V1, const UE::Math::TVector< T > &V2)

template<typename T >
UE::Math::TVector< T >	Cross (const UE::Math::TVector< T > &V1, const UE::Math::TVector< T > &V2)

template<typename T >
UE::Math::TVector< T >	UnitCross (const UE::Math::TVector< T > &V1, const UE::Math::TVector< T > &V2)

template<typename T >
T	AngleD (const UE::Math::TVector< T > &V1, const UE::Math::TVector< T > &V2)

template<typename T >
T	AngleR (const UE::Math::TVector< T > &V1, const UE::Math::TVector< T > &V2)

template<typename T >
constexpr UE::Math::TVector2< T >	GetXY (const UE::Math::TVector< T > &V)

template<typename T >
constexpr UE::Math::TVector2< T >	GetXZ (const UE::Math::TVector< T > &V)

template<typename T >
constexpr UE::Math::TVector2< T >	GetYZ (const UE::Math::TVector< T > &V)

template<typename T >
constexpr UE::Math::TVector< T >	Min (const UE::Math::TVector< T > &V0, const UE::Math::TVector< T > &V1)

template<typename T >
constexpr UE::Math::TVector< T >	Max (const UE::Math::TVector< T > &V0, const UE::Math::TVector< T > &V1)

template<typename T >
constexpr T	MaxElement (const UE::Math::TVector< T > &Vector)

template<typename T >
constexpr int32	MaxElementIndex (const UE::Math::TVector< T > &Vector)

template<typename T >
constexpr T	MinElement (const UE::Math::TVector< T > &Vector)

template<typename T >
constexpr int32	MinElementIndex (const UE::Math::TVector< T > &Vector)

template<typename T >
constexpr T	MaxAbsElement (const UE::Math::TVector< T > &Vector)

template<typename T >
constexpr int32	MaxAbsElementIndex (const UE::Math::TVector< T > &Vector)

template<typename T >
constexpr T	MinAbsElement (const UE::Math::TVector< T > &Vector)

template<typename T >
constexpr int32	MinAbsElementIndex (const UE::Math::TVector< T > &Vector)

template<typename T >
constexpr FLinearColor	ToLinearColor (const UE::Math::TVector< T > &Vector)

template<typename T >
UE::Math::TVector< T >	Lerp (const UE::Math::TVector< T > &A, const UE::Math::TVector< T > &B, T Alpha)

template<typename T >
UE::Math::TVector< T >	Blend3 (const UE::Math::TVector< T > &A, const UE::Math::TVector< T > &B, const UE::Math::TVector< T > &C, const T &WeightA, const T &WeightB, const T &WeightC)

template<typename RealType >
std::ostream &	operator<< (std::ostream &os, const UE::Math::TVector< RealType > &Vec)

template<typename T >
FLinearColor	ToLinearColor (const UE::Math::TVector4< T > &V)

template<typename T >
UE::Math::TVector4< T >	ToVector4 (const FLinearColor &Color)

template<typename T >
constexpr FColor	ToFColor (const UE::Math::TVector4< T > &Vector)

template<typename T >
UE::Math::TVector4< T >	Lerp (const UE::Math::TVector4< T > &A, const UE::Math::TVector4< T > &B, T Alpha)

template<typename RealType >
RealType	SnapToIncrement (RealType Value, RealType Increment, RealType Offset=0)

template<typename AttrType >
uint32	GetTypeHash (const TVertexAttr< AttrType > &Vector)

Variables
template class GEOMETRYCORE_API	TDynamicMeshOverlay< float, 1 >

template class GEOMETRYCORE_API	TDynamicMeshOverlay< double, 1 >

template class GEOMETRYCORE_API	TDynamicMeshOverlay< int, 1 >

template class GEOMETRYCORE_API	TDynamicMeshOverlay< float, 2 >

template class GEOMETRYCORE_API	TDynamicMeshOverlay< double, 2 >

template class GEOMETRYCORE_API	TDynamicMeshOverlay< int, 2 >

template class GEOMETRYCORE_API	TDynamicMeshOverlay< float, 3 >

template class GEOMETRYCORE_API	TDynamicMeshOverlay< double, 3 >

template class GEOMETRYCORE_API	TDynamicMeshOverlay< int, 3 >

template class GEOMETRYCORE_API	TDynamicMeshOverlay< float, 4 >

template class GEOMETRYCORE_API	TDynamicMeshOverlay< double, 4 >

template class GEOMETRYCORE_API	TDynamicMeshVectorOverlay< float, 2, FVector2f >

template class GEOMETRYCORE_API	TDynamicMeshVectorOverlay< double, 2, FVector2d >

template class GEOMETRYCORE_API	TDynamicMeshVectorOverlay< int, 2, FVector2i >

template class GEOMETRYCORE_API	TDynamicMeshVectorOverlay< float, 3, FVector3f >

template class GEOMETRYCORE_API	TDynamicMeshVectorOverlay< double, 3, FVector3d >

template class GEOMETRYCORE_API	TDynamicMeshVectorOverlay< int, 3, FVector3i >

template class GEOMETRYCORE_API	TDynamicMeshVectorOverlay< float, 4, FVector4f >

template class GEOMETRYCORE_API	TDynamicMeshVectorOverlay< double, 4, FVector4d >

template class UE_EXTERN_TEMPLATE_API	TMeshTangents< float >

template class UE_EXTERN_TEMPLATE_API	TMeshTangents< double >

Typedef Documentation

◆ FAttrBasedQuadricErrord

typedef TAttrBasedQuadricError<double> UE::Geometry::FAttrBasedQuadricErrord

◆ FAttrBasedQuadricErrorf

typedef TAttrBasedQuadricError<float> UE::Geometry::FAttrBasedQuadricErrorf

◆ FAxisAlignedBox2d

typedef TAxisAlignedBox2<double> UE::Geometry::FAxisAlignedBox2d

◆ FAxisAlignedBox2f

typedef TAxisAlignedBox2<float> UE::Geometry::FAxisAlignedBox2f

◆ FAxisAlignedBox3d

typedef TAxisAlignedBox3<double> UE::Geometry::FAxisAlignedBox3d

◆ FAxisAlignedBox3f

typedef TAxisAlignedBox3<float> UE::Geometry::FAxisAlignedBox3f

◆ FBiLaplacianTwistPullKelvinlet

typedef TBlendPairedKelvinlet< FTwistKelvinlet, FBiLaplacianPullKelvinlet > UE::Geometry::FBiLaplacianTwistPullKelvinlet

◆ FBlendPullKelvinlet

typedef TBlendPairedKelvinlet< FBiLaplacianPullKelvinlet, FLaplacianPullKelvinlet > UE::Geometry::FBlendPullKelvinlet

◆ FBlendPullSharpKelvinlet

typedef TBlendPairedKelvinlet< FSharpBiLaplacianPullKelvinlet, FSharpLaplacianPullKelvinlet > UE::Geometry::FBlendPullSharpKelvinlet

◆ FBlockedDenseGrid3d

typedef TBlockedDenseGrid3<double> UE::Geometry::FBlockedDenseGrid3d

◆ FBlockedDenseGrid3f

typedef TBlockedDenseGrid3<float> UE::Geometry::FBlockedDenseGrid3f

◆ FBlockedDenseGrid3i

typedef TBlockedDenseGrid3<int> UE::Geometry::FBlockedDenseGrid3i

◆ FBlockedGrid3b

typedef TBlockedGrid3<bool, 8> UE::Geometry::FBlockedGrid3b

◆ FBlockedGrid3d

typedef TBlockedGrid3<double, 8> UE::Geometry::FBlockedGrid3d

◆ FBlockedGrid3f

typedef TBlockedGrid3<float, 8> UE::Geometry::FBlockedGrid3f

◆ FBlockedGrid3i

typedef TBlockedGrid3<int, 8> UE::Geometry::FBlockedGrid3i

◆ FBoundsGridIndexer3d

typedef TBoundsGridIndexer3<double> UE::Geometry::FBoundsGridIndexer3d

◆ FBoundsGridIndexer3f

typedef TBoundsGridIndexer3<float> UE::Geometry::FBoundsGridIndexer3f

◆ FBSplineFilter

using UE::Geometry::FBSplineFilter = typedef FBCSplineFilter<EBCSplineType::BSpline, false>

◆ FCapsule3d

typedef TCapsule3<double> UE::Geometry::FCapsule3d

◆ FCapsule3f

typedef TCapsule3<float> UE::Geometry::FCapsule3f

◆ FCatmullRomFilter

using UE::Geometry::FCatmullRomFilter = typedef FBCSplineFilter<EBCSplineType::CatmullRom, false>

◆ FCircle2d

typedef TCircle2<double> UE::Geometry::FCircle2d

◆ FCircle2f

typedef TCircle2<float> UE::Geometry::FCircle2f

◆ FCircle3d

typedef TCircle3<double> UE::Geometry::FCircle3d

◆ FCircle3f

typedef TCircle3<float> UE::Geometry::FCircle3f

◆ FConvexHull2d

typedef TConvexHull2<double> UE::Geometry::FConvexHull2d

◆ FConvexHull2f

typedef TConvexHull2<float> UE::Geometry::FConvexHull2f

◆ FConvexHull3d

typedef TConvexHull3<double> UE::Geometry::FConvexHull3d

◆ FConvexHull3f

typedef TConvexHull3<float> UE::Geometry::FConvexHull3f

◆ FDenseGrid2d

typedef TDenseGrid2<double> UE::Geometry::FDenseGrid2d

◆ FDenseGrid2f

typedef TDenseGrid2<float> UE::Geometry::FDenseGrid2f

◆ FDenseGrid2i

typedef TDenseGrid2<int32> UE::Geometry::FDenseGrid2i

◆ FDenseGrid3d

typedef TDenseGrid3<double> UE::Geometry::FDenseGrid3d

◆ FDenseGrid3f

typedef TDenseGrid3<float> UE::Geometry::FDenseGrid3f

◆ FDenseGrid3i

typedef TDenseGrid3<int> UE::Geometry::FDenseGrid3i

◆ FDistLine2AxisAlignedBox2d

typedef TDistLine2AxisAlignedBox2<double> UE::Geometry::FDistLine2AxisAlignedBox2d

◆ FDistLine2AxisAlignedBox2f

typedef TDistLine2AxisAlignedBox2<float> UE::Geometry::FDistLine2AxisAlignedBox2f

◆ FDistLine3Line3d

typedef TDistLine3Line3<double> UE::Geometry::FDistLine3Line3d

◆ FDistLine3Line3f

typedef TDistLine3Line3<float> UE::Geometry::FDistLine3Line3f

◆ FDistLine3Ray3d

typedef TDistLine3Ray3<double> UE::Geometry::FDistLine3Ray3d

◆ FDistLine3Ray3f

typedef TDistLine3Ray3<float> UE::Geometry::FDistLine3Ray3f

◆ FDistLine3Segment3d

typedef TDistLine3Segment3<double> UE::Geometry::FDistLine3Segment3d

◆ FDistLine3Segment3f

typedef TDistLine3Segment3<float> UE::Geometry::FDistLine3Segment3f

◆ FDistLine3Triangle3d

typedef TDistLine3Triangle3<double> UE::Geometry::FDistLine3Triangle3d

◆ FDistLine3Triangle3f

typedef TDistLine3Triangle3<float> UE::Geometry::FDistLine3Triangle3f

◆ FDistPoint3Triangle3d

typedef TDistPoint3Triangle3<double> UE::Geometry::FDistPoint3Triangle3d

◆ FDistPoint3Triangle3f

typedef TDistPoint3Triangle3<float> UE::Geometry::FDistPoint3Triangle3f

◆ FDistRay3Segment3d

typedef TDistRay3Segment3<double> UE::Geometry::FDistRay3Segment3d

◆ FDistRay3Segment3f

typedef TDistRay3Segment3<float> UE::Geometry::FDistRay3Segment3f

◆ FDistSegment2AxisAlignedBox2d

typedef TDistSegment2AxisAlignedBox2<double> UE::Geometry::FDistSegment2AxisAlignedBox2d

◆ FDistSegment2AxisAlignedBox2f

typedef TDistSegment2AxisAlignedBox2<float> UE::Geometry::FDistSegment2AxisAlignedBox2f

◆ FDistSegment3Triangle3d

typedef TDistSegment3Triangle3<double> UE::Geometry::FDistSegment3Triangle3d

◆ FDistSegment3Triangle3f

typedef TDistSegment3Triangle3<float> UE::Geometry::FDistSegment3Triangle3f

◆ FDistTriangle3Triangle3d

typedef TDistTriangle3Triangle3<double> UE::Geometry::FDistTriangle3Triangle3d

◆ FDistTriangle3Triangle3f

typedef TDistTriangle3Triangle3<float> UE::Geometry::FDistTriangle3Triangle3f

◆ FDynamicGraph2d

typedef FDynamicGraph2<double> UE::Geometry::FDynamicGraph2d

◆ FDynamicGraph3d

typedef FDynamicGraph3<double> UE::Geometry::FDynamicGraph3d

◆ FDynamicMeshAABBTree3

typedef TMeshAABBTree3<FDynamicMesh3> UE::Geometry::FDynamicMeshAABBTree3

◆ FDynamicMeshAttributeBase

typedef TDynamicAttributeBase<FDynamicMesh3> UE::Geometry::FDynamicMeshAttributeBase

◆ FDynamicMeshAttributeChangeBase

typedef TDynamicAttributeChangeBase<FDynamicMesh3> UE::Geometry::FDynamicMeshAttributeChangeBase

◆ FDynamicMeshAttributeSetBase

typedef TDynamicAttributeSetBase<FDynamicMesh3> UE::Geometry::FDynamicMeshAttributeSetBase

◆ FDynamicMeshBoneColorAttribute

typedef TDynamicBoneAttributeBase< FDynamicMesh3, FVector4f > UE::Geometry::FDynamicMeshBoneColorAttribute

◆ FDynamicMeshBoneNameAttribute

typedef TDynamicBoneAttributeBase< FDynamicMesh3, FName > UE::Geometry::FDynamicMeshBoneNameAttribute

◆ FDynamicMeshBoneParentIndexAttribute

typedef TDynamicBoneAttributeBase< FDynamicMesh3, int32 > UE::Geometry::FDynamicMeshBoneParentIndexAttribute

◆ FDynamicMeshBonePoseAttribute

typedef TDynamicBoneAttributeBase< FDynamicMesh3, FTransform > UE::Geometry::FDynamicMeshBonePoseAttribute

◆ FDynamicMeshColorChange

typedef TDynamicMeshAttributeChange<float, 4> UE::Geometry::FDynamicMeshColorChange

Standard Color overlay change type - 4-element float

◆ FDynamicMeshColorOverlay

typedef TDynamicMeshVectorOverlay<float, 4, FVector4f> UE::Geometry::FDynamicMeshColorOverlay

Standard Color overlay type - 4-element float (rbga)

◆ FDynamicMeshMaterialAttribute

typedef TDynamicMeshScalarTriangleAttribute<int32> UE::Geometry::FDynamicMeshMaterialAttribute

Standard per-triangle integer material ID

◆ FDynamicMeshMorphTargetAttribute

typedef TDynamicMeshVertexAttribute<float, 3> UE::Geometry::FDynamicMeshMorphTargetAttribute

Per-vertex 3-element float morph target

◆ FDynamicMeshNormalChange

typedef TDynamicMeshAttributeChange<float,3> UE::Geometry::FDynamicMeshNormalChange

Standard Normal overlay change type - 3-element float

◆ FDynamicMeshNormalOverlay

typedef TDynamicMeshVectorOverlay<float, 3, FVector3f> UE::Geometry::FDynamicMeshNormalOverlay

Standard Normal overlay type - 3-element float

◆ FDynamicMeshPolygroupAttribute

typedef TDynamicMeshScalarTriangleAttribute<int32> UE::Geometry::FDynamicMeshPolygroupAttribute

Per-triangle integer polygroup ID

◆ FDynamicMeshSculptLayerAttribute

typedef TDynamicMeshVertexAttribute<double, 3> UE::Geometry::FDynamicMeshSculptLayerAttribute

Per-vertex position offsets

◆ FDynamicMeshTriGroupChange

typedef FDynamicMeshTriangleAttributeChange<int32,1> UE::Geometry::FDynamicMeshTriGroupChange

Standard per-triangle integer attribute change type

◆ FDynamicMeshUVChange

typedef TDynamicMeshAttributeChange<float,2> UE::Geometry::FDynamicMeshUVChange

Standard UV overlay change type - 2-element float

◆ FDynamicMeshUVOverlay

typedef TDynamicMeshVectorOverlay<float, 2, FVector2f> UE::Geometry::FDynamicMeshUVOverlay

Standard UV overlay type - 2-element float

◆ FDynamicMeshVertexSkinWeightsAttribute

typedef TDynamicVertexSkinWeightsAttribute< FDynamicMesh3 > UE::Geometry::FDynamicMeshVertexSkinWeightsAttribute

◆ FDynamicMeshWeightAttribute

typedef TDynamicMeshVertexAttribute<float, 1> UE::Geometry::FDynamicMeshWeightAttribute

Per-vertex scalar float weight

◆ FDynamicMeshWeightChange

typedef TDynamicMeshAttributeChange<float, 1> UE::Geometry::FDynamicMeshWeightChange

Standard weight map change type - 1-element float

◆ FDynamicPointSet3d

typedef TDynamicPointSet3<double> UE::Geometry::FDynamicPointSet3d

◆ FDynamicPointSet3f

typedef TDynamicPointSet3<float> UE::Geometry::FDynamicPointSet3f

◆ FExactIntrTriangle3Triangle3d

typedef TExactIntrTriangle3Triangle3<double> UE::Geometry::FExactIntrTriangle3Triangle3d

◆ FExactIntrTriangle3Triangle3f

typedef TExactIntrTriangle3Triangle3<float> UE::Geometry::FExactIntrTriangle3Triangle3f

◆ FExtremePoints3d

typedef TExtremePoints3<double> UE::Geometry::FExtremePoints3d

◆ FExtremePoints3f

typedef TExtremePoints3<float> UE::Geometry::FExtremePoints3f

◆ FFrame3d

typedef TFrame3<double> UE::Geometry::FFrame3d

◆ FFrame3f

typedef TFrame3<float> UE::Geometry::FFrame3f

◆ FGeneralPolygon2d

typedef TGeneralPolygon2<double> UE::Geometry::FGeneralPolygon2d

◆ FGeneralPolygon2f

typedef TGeneralPolygon2<float> UE::Geometry::FGeneralPolygon2f

◆ FHalfspace3d

typedef THalfspace3<double> UE::Geometry::FHalfspace3d

◆ FHalfspace3f

typedef THalfspace3<float> UE::Geometry::FHalfspace3f

◆ FImplicitLine3d

typedef TImplicitLine3<double> UE::Geometry::FImplicitLine3d

◆ FImplicitLine3f

typedef TImplicitLine3<float> UE::Geometry::FImplicitLine3f

◆ FImplicitPoint3d

typedef TImplicitPoint3<double> UE::Geometry::FImplicitPoint3d

◆ FImplicitPoint3f

typedef TImplicitPoint3<float> UE::Geometry::FImplicitPoint3f

◆ FIndexedWeightMap

typedef TIndexedWeightMap<float> UE::Geometry::FIndexedWeightMap

◆ FIndexedWeightMap1d

typedef TIndexedWeightMap<double> UE::Geometry::FIndexedWeightMap1d

◆ FIndexedWeightMap1f

typedef TIndexedWeightMap<float> UE::Geometry::FIndexedWeightMap1f

◆ FIndexMapi

typedef TIndexMap<int> UE::Geometry::FIndexMapi

◆ FIndexMeshArrayAdapterd

typedef TIndexMeshArrayAdapter<uint32, double> UE::Geometry::FIndexMeshArrayAdapterd

◆ FIntersector1d

typedef TIntersector1<double> UE::Geometry::FIntersector1d

◆ FIntersector1f

typedef TIntersector1<float> UE::Geometry::FIntersector1f

◆ FInterval1d

typedef TInterval1<double> UE::Geometry::FInterval1d

◆ FInterval1f

typedef TInterval1<float> UE::Geometry::FInterval1f

◆ FIntrLine2Line2d

typedef TIntrLine2Line2<double> UE::Geometry::FIntrLine2Line2d

◆ FIntrLine2Line2f

typedef TIntrLine2Line2<float> UE::Geometry::FIntrLine2Line2f

◆ FIntrLine2Triangle2d

typedef TIntrLine2Triangle2<double> UE::Geometry::FIntrLine2Triangle2d

◆ FIntrLine2Triangle2f

typedef TIntrLine2Triangle2<float> UE::Geometry::FIntrLine2Triangle2f

◆ FIntrRay3AxisAlignedBox3d

typedef TIntrRay3AxisAlignedBox3<double> UE::Geometry::FIntrRay3AxisAlignedBox3d

◆ FIntrRay3AxisAlignedBox3f

typedef TIntrRay3AxisAlignedBox3<float> UE::Geometry::FIntrRay3AxisAlignedBox3f

◆ FIntrRay3OrientedBox3d

typedef TIntrRay3OrientedBox3<double> UE::Geometry::FIntrRay3OrientedBox3d

◆ FIntrRay3OrientedBox3f

typedef TIntrRay3OrientedBox3<float> UE::Geometry::FIntrRay3OrientedBox3f

◆ FIntrRay3Triangle3d

typedef TIntrRay3Triangle3<double> UE::Geometry::FIntrRay3Triangle3d

◆ FIntrRay3Triangle3f

typedef TIntrRay3Triangle3<float> UE::Geometry::FIntrRay3Triangle3f

◆ FIntrSegment2Segment2d

typedef TIntrSegment2Segment2<double> UE::Geometry::FIntrSegment2Segment2d

◆ FIntrSegment2Segment2f

typedef TIntrSegment2Segment2<float> UE::Geometry::FIntrSegment2Segment2f

◆ FIntrSegment2Triangle2d

typedef TIntrSegment2Triangle2<double> UE::Geometry::FIntrSegment2Triangle2d

◆ FIntrSegment2Triangle2f

typedef TIntrSegment2Triangle2<float> UE::Geometry::FIntrSegment2Triangle2f

◆ FIntrTriangle2AxisAlignedBox2d

typedef TIntrTriangle2AxisAlignedBox2<double> UE::Geometry::FIntrTriangle2AxisAlignedBox2d

◆ FIntrTriangle2AxisAlignedBox2f

typedef TIntrTriangle2AxisAlignedBox2<float> UE::Geometry::FIntrTriangle2AxisAlignedBox2f

◆ FIntrTriangle2Triangle2d

typedef TIntrTriangle2Triangle2<double> UE::Geometry::FIntrTriangle2Triangle2d

◆ FIntrTriangle2Triangle2f

typedef TIntrTriangle2Triangle2<float> UE::Geometry::FIntrTriangle2Triangle2f

◆ FIntrTriangle3Triangle3d

typedef TIntrTriangle3Triangle3<double> UE::Geometry::FIntrTriangle3Triangle3d

◆ FIntrTriangle3Triangle3f

typedef TIntrTriangle3Triangle3<float> UE::Geometry::FIntrTriangle3Triangle3f

◆ FLaplacianTwistPullKelvinlet

typedef TBlendPairedKelvinlet< FTwistKelvinlet, FLaplacianPullKelvinlet > UE::Geometry::FLaplacianTwistPullKelvinlet

◆ FLine2d

typedef TLine2<double> UE::Geometry::FLine2d

◆ FLine2f

typedef TLine2<float> UE::Geometry::FLine2f

◆ FLine3d

typedef TLine3<double> UE::Geometry::FLine3d

◆ FLine3f

typedef TLine3<float> UE::Geometry::FLine3f

◆ FMatrix2d

typedef TMatrix2<double> UE::Geometry::FMatrix2d

◆ FMatrix2f

typedef TMatrix2<float> UE::Geometry::FMatrix2f

◆ FMatrix3d

typedef TMatrix3<double> UE::Geometry::FMatrix3d

◆ FMatrix3f

typedef TMatrix3<float> UE::Geometry::FMatrix3f

◆ FMeshTangentsd

typedef TMeshTangents<double> UE::Geometry::FMeshTangentsd

◆ FMeshTangentsf

typedef TMeshTangents<float> UE::Geometry::FMeshTangentsf

◆ FMeshUniformSurfaceSampling

using UE::Geometry::FMeshUniformSurfaceSampling = typedef TMeshUniformSurfaceSampling<FDynamicMesh3, double>

◆ FMitchellNetravaliFilter

using UE::Geometry::FMitchellNetravaliFilter = typedef FBCSplineFilter<EBCSplineType::MitchellNetravali, false>

◆ FOrientedBox2d

typedef TOrientedBox2<double> UE::Geometry::FOrientedBox2d

◆ FOrientedBox2f

typedef TOrientedBox2<float> UE::Geometry::FOrientedBox2f

◆ FOrientedBox3d

typedef TOrientedBox3<double> UE::Geometry::FOrientedBox3d

◆ FOrientedBox3f

typedef TOrientedBox3<float> UE::Geometry::FOrientedBox3f

◆ FPlanarComplexd

typedef TPlanarComplex<double> UE::Geometry::FPlanarComplexd

◆ FPlanarComplexf

typedef TPlanarComplex<float> UE::Geometry::FPlanarComplexf

◆ FPlane3d

typedef TPlane3<double> UE::Geometry::FPlane3d

◆ FPlane3f

typedef TPlane3<float> UE::Geometry::FPlane3f

◆ FPointSetAdapterd

typedef TPointSetAdapter<double> UE::Geometry::FPointSetAdapterd

◆ FPointSetAdapterf

typedef TPointSetAdapter<float> UE::Geometry::FPointSetAdapterf

◆ FPolygon2d

typedef TPolygon2<double> UE::Geometry::FPolygon2d

◆ FPolygon2f

typedef TPolygon2<float> UE::Geometry::FPolygon2f

◆ FPolyline2d

typedef TPolyline2<double> UE::Geometry::FPolyline2d

◆ FPolyline2f

typedef TPolyline2<float> UE::Geometry::FPolyline2f

◆ FPolyline3d

typedef TPolyline3<double> UE::Geometry::FPolyline3d

◆ FPolyline3f

typedef TPolyline3<float> UE::Geometry::FPolyline3f

◆ FQuadricErrord

typedef TQuadricError<double> UE::Geometry::FQuadricErrord

◆ FQuadricErrorf

typedef TQuadricError<float> UE::Geometry::FQuadricErrorf

◆ FQuaterniond

typedef TQuaternion<double> UE::Geometry::FQuaterniond

◆ FQuaternionf

typedef TQuaternion<float> UE::Geometry::FQuaternionf

◆ FSampledScalarField2d

typedef TSampledScalarField2<double, double> UE::Geometry::FSampledScalarField2d

◆ FSampledScalarField2f

typedef TSampledScalarField2<float, float> UE::Geometry::FSampledScalarField2f

◆ FSampleSetStatisticsd

typedef TSampleSetStatistics<double> UE::Geometry::FSampleSetStatisticsd

◆ FSampleSetStatisticsf

typedef TSampleSetStatistics<float> UE::Geometry::FSampleSetStatisticsf

◆ FScaleGridIndexer2d

typedef TScaleGridIndexer2<double> UE::Geometry::FScaleGridIndexer2d

◆ FScaleGridIndexer2f

typedef TScaleGridIndexer2<float> UE::Geometry::FScaleGridIndexer2f

◆ FScaleGridIndexer3d

typedef TScaleGridIndexer3<double> UE::Geometry::FScaleGridIndexer3d

◆ FScaleGridIndexer3f

typedef TScaleGridIndexer3<float> UE::Geometry::FScaleGridIndexer3f

◆ FSegment2d

typedef TSegment2<double> UE::Geometry::FSegment2d

◆ FSegment2f

typedef TSegment2<float> UE::Geometry::FSegment2f

◆ FSegment3d

typedef TSegment3<double> UE::Geometry::FSegment3d

◆ FSegment3f

typedef TSegment3<float> UE::Geometry::FSegment3f

◆ FSharedConstDynamicMesh3

typedef TConstObjectSharedAccess<FDynamicMesh3> UE::Geometry::FSharedConstDynamicMesh3

◆ FShiftGridIndexer2d

typedef TShiftGridIndexer2<double> UE::Geometry::FShiftGridIndexer2d

◆ FShiftGridIndexer2f

typedef TShiftGridIndexer2<float> UE::Geometry::FShiftGridIndexer2f

◆ FShiftGridIndexer3d

typedef TShiftGridIndexer3<double> UE::Geometry::FShiftGridIndexer3d

◆ FShiftGridIndexer3f

typedef TShiftGridIndexer3<float> UE::Geometry::FShiftGridIndexer3f

◆ FSkeletalImplicitLine3d

typedef TSkeletalImplicitLine3<double> UE::Geometry::FSkeletalImplicitLine3d

◆ FSkeletalImplicitLine3f

typedef TSkeletalImplicitLine3<float> UE::Geometry::FSkeletalImplicitLine3f

◆ FSpatialPhoto1f

typedef TSpatialPhoto<float> UE::Geometry::FSpatialPhoto1f

◆ FSpatialPhoto3f

typedef TSpatialPhoto<FVector3f> UE::Geometry::FSpatialPhoto3f

◆ FSpatialPhoto4f

typedef TSpatialPhoto<FVector4f> UE::Geometry::FSpatialPhoto4f

◆ FSpatialPhotoSet1f

typedef TSpatialPhotoSet<float, float> UE::Geometry::FSpatialPhotoSet1f

◆ FSpatialPhotoSet3f

typedef TSpatialPhotoSet<FVector3f, float> UE::Geometry::FSpatialPhotoSet3f

◆ FSpatialPhotoSet4f

typedef TSpatialPhotoSet<FVector4f, float> UE::Geometry::FSpatialPhotoSet4f

◆ FSphere3d

typedef TSphere3<double> UE::Geometry::FSphere3d

◆ FSphere3f

typedef TSphere3<float> UE::Geometry::FSphere3f

◆ FTetrahedron3d

typedef TTetrahedron3<double> UE::Geometry::FTetrahedron3d

◆ FTetrahedron3f

typedef TTetrahedron3<float> UE::Geometry::FTetrahedron3f

◆ FTransformSequence3d

typedef TTransformSequence3<double> UE::Geometry::FTransformSequence3d

◆ FTransformSequence3f

typedef TTransformSequence3<float> UE::Geometry::FTransformSequence3f

◆ FTransformSRT3d

typedef TTransformSRT3<double> UE::Geometry::FTransformSRT3d

◆ FTransformSRT3f

typedef TTransformSRT3<float> UE::Geometry::FTransformSRT3f

◆ FTriangle2d

typedef TTriangle2<double> UE::Geometry::FTriangle2d

◆ FTriangle2f

typedef TTriangle2<float> UE::Geometry::FTriangle2f

◆ FTriangle3d

typedef TTriangle3<double> UE::Geometry::FTriangle3d

◆ FTriangle3f

typedef TTriangle3<float> UE::Geometry::FTriangle3f

◆ FTriangle3i

typedef TTriangle3<int> UE::Geometry::FTriangle3i

◆ FTriangleMeshAdapterd

typedef TTriangleMeshAdapter<double> UE::Geometry::FTriangleMeshAdapterd

◆ FTriangleMeshAdapterf

typedef TTriangleMeshAdapter<float> UE::Geometry::FTriangleMeshAdapterf

◆ FVectorSetAnalysis3d

typedef TVectorSetAnalysis3<double> UE::Geometry::FVectorSetAnalysis3d

◆ FVectorSetAnalysis3f

typedef TVectorSetAnalysis3<float> UE::Geometry::FVectorSetAnalysis3f

◆ FVolPresQuadricErrord

typedef TVolPresQuadricError<double> UE::Geometry::FVolPresQuadricErrord

◆ FVolPresQuadricErrorf

typedef TVolPresQuadricError<float> UE::Geometry::FVolPresQuadricErrorf

◆ FWatertightRay3d

typedef TWatertightRay3<double> UE::Geometry::FWatertightRay3d

◆ FWatertightRay3f

typedef TWatertightRay3<float> UE::Geometry::FWatertightRay3f

◆ FWeightedSamplingAliasTabled

using UE::Geometry::FWeightedSamplingAliasTabled = typedef TWeightedSamplingAliasTable<double>

◆ FWeightedSamplingAliasTablef

using UE::Geometry::FWeightedSamplingAliasTablef = typedef TWeightedSamplingAliasTable<float>

◆ FWrapAroundGridIndexer3d

typedef TWrapAroundGridIndexer3<double> UE::Geometry::FWrapAroundGridIndexer3d

◆ FWrapAroundGridIndexer3f

typedef TWrapAroundGridIndexer3<float> UE::Geometry::FWrapAroundGridIndexer3f

◆ TDiscreteKernel2d

typedef TDiscreteKernel2<double> UE::Geometry::TDiscreteKernel2d

◆ TDiscreteKernel2f

typedef TDiscreteKernel2<float> UE::Geometry::TDiscreteKernel2f

◆ TDynamicMeshVertexAttribute

template<typename AttribValueType , int AttribDimension>

using UE::Geometry::TDynamicMeshVertexAttribute = typedef TDynamicVertexAttribute<AttribValueType, AttribDimension, FDynamicMesh3>

◆ TDynamicVector2d

using UE::Geometry::TDynamicVector2d = typedef TDynamicVectorN<double, 2>

◆ TDynamicVector2f

using UE::Geometry::TDynamicVector2f = typedef TDynamicVectorN<float, 2>

◆ TDynamicVector2i

using UE::Geometry::TDynamicVector2i = typedef TDynamicVectorN<int, 2>

◆ TDynamicVector3d

using UE::Geometry::TDynamicVector3d = typedef TDynamicVectorN<double, 3>

◆ TDynamicVector3f

using UE::Geometry::TDynamicVector3f = typedef TDynamicVectorN<float, 3>

◆ TDynamicVector3i

using UE::Geometry::TDynamicVector3i = typedef TDynamicVectorN<int, 3>

◆ TGaussian1d

typedef TGaussian1<double> UE::Geometry::TGaussian1d

◆ TGaussian1f

typedef TGaussian1<float> UE::Geometry::TGaussian1f

◆ TGaussian2d

typedef TGaussian2<double> UE::Geometry::TGaussian2d

◆ TGaussian2f

typedef TGaussian2<float> UE::Geometry::TGaussian2f

◆ TGaussian3d

typedef TGaussian3<double> UE::Geometry::TGaussian3d

◆ TGaussian3f

typedef TGaussian3<float> UE::Geometry::TGaussian3f

◆ TPointHashGrid2d

template<typename PointDataType >

using UE::Geometry::TPointHashGrid2d = typedef TPointHashGrid2<PointDataType, double>

◆ TPointHashGrid2f

template<typename PointDataType >

using UE::Geometry::TPointHashGrid2f = typedef TPointHashGrid2<PointDataType, float>

◆ TPointHashGrid3d

template<typename PointDataType >

using UE::Geometry::TPointHashGrid3d = typedef TPointHashGrid3<PointDataType, double>

◆ TPointHashGrid3f

template<typename PointDataType >

using UE::Geometry::TPointHashGrid3f = typedef TPointHashGrid3<PointDataType, float>

◆ TPolyline2

template<typename T >

using UE::Geometry::TPolyline2 = typedef TPolyline<T, 2>

◆ TPolyline3

template<typename T >

using UE::Geometry::TPolyline3 = typedef TPolyline<T, 3>

Enumeration Type Documentation

◆ EBCSplineType

enum class UE::Geometry::EBCSplineType

strong

Enumerator
BSpline
CatmullRom
MitchellNetravali

◆ EBox2FitCriteria

enum UE::Geometry::EBox2FitCriteria

Enumerator
Area
Perimeter

◆ EBox3FitCriteria

enum UE::Geometry::EBox3FitCriteria

Enumerator
Volume
SurfaceArea

◆ ECapType

enum class UE::Geometry::ECapType

strong

ECapType indicates the type of cap to use on a sweep

Enumerator
None
FlatTriangulation
FlatMidpointFan

◆ EConvexErrorMethod

enum class UE::Geometry::EConvexErrorMethod

strong

Enumerator
RelativeVolume

◆ EDiTO

enum UE::Geometry::EDiTO

selects the number of extremal vertices and directional vector family for the DiTO - K algorithm, with implementations for K = {12, 14, 20, 26}

Enumerator
DiTO_12
DiTO_14
DiTO_20
DiTO_26

◆ EFBMMode

enum class UE::Geometry::EFBMMode : uint8

strong

Enumerator
Standard	Classic Perlin Noise
Turbulent	Turbulent Modifier, creating upward bumps.
Ridge	Ridge Modifier, creating sharper creases and ridges.

◆ EGeometryResultType

enum class UE::Geometry::EGeometryResultType

strong

EGeometryResultType is a generic result-code for use by geometry operations.

Enumerator
Success	The Geometry Operation successfully completed
InProgress	The Geometry Operation is in progress (this is intended for use in cases where there is a background computation that can be queried for incremental status/etc)
Cancelled	The Geometry Operation was Cancelled and did not complete
PartialResult	The Geometry Operation completed but was not fully successful (eg some sub-computation failed and was gracefully handled, etc)
Failure	The Geometry Operation failed and no valid result was produced

◆ EImageTilingMethod

enum class UE::Geometry::EImageTilingMethod

strong

Enumerator
Clamp
Wrap

◆ ELocalParamTypes

enum class UE::Geometry::ELocalParamTypes : uint8

strong

Type of local parameterization

Enumerator
PlanarProjection	Calculate a planar projection
ExponentialMap	Calculate Discrete Exponential Map
ExponentialMapUpwindAvg	Calculate Discrete Exponential Map with Upwind-Averaging

◆ EMeshComponents

enum class UE::Geometry::EMeshComponents : uint8

strong

Enumerator
None
VertexNormals
VertexColors
VertexUVs
FaceGroups
All

◆ EMeshResult

enum class UE::Geometry::EMeshResult

strong

EMeshResult is returned by various mesh/graph operations to either indicate success, or communicate which type of error ocurred (some errors are recoverable, and some not).

Enumerator
Ok
Failed_NotAVertex
Failed_NotATriangle
Failed_NotAnEdge
Failed_BrokenTopology
Failed_HitValenceLimit
Failed_IsBoundaryEdge
Failed_FlippedEdgeExists
Failed_IsBowtieVertex
Failed_InvalidNeighbourhood
Failed_FoundDuplicateTriangle
Failed_CollapseTetrahedron
Failed_CollapseTriangle
Failed_NotABoundaryEdge
Failed_SameOrientation
Failed_CollapseQuad
Failed_WouldCreateBowtie
Failed_VertexAlreadyExists
Failed_CannotAllocateVertex
Failed_VertexStillReferenced
Failed_WouldCreateNonmanifoldEdge
Failed_TriangleAlreadyExists
Failed_CannotAllocateTriangle
Failed_UnrecoverableError
Failed_Unsupported

◆ EOperationValidationResult

enum class UE::Geometry::EOperationValidationResult

strong

EOperationValidationResult is meant to be returned by Validate() functions of Operation classes (eg like ExtrudeMesh, etc) to indicate whether the operation can be successfully applied.

Enumerator
Ok
Failed_UnknownReason
Failed_InvalidTopology

◆ EPointOrdering

enum class UE::Geometry::EPointOrdering

strong

Enumerator
Positive
Negative
CollinearLeft
CollinearRight
CollinearContain

◆ EProfileSweepPolygonGrouping

enum class UE::Geometry::EProfileSweepPolygonGrouping : uint8

strong

Enumerator
Single	One polygroup for entire output mesh
PerFace	One polygroup per mesh quad/triangle
PerSweepSegment
PerProfileSegment

◆ EProfileSweepQuadSplit

enum class UE::Geometry::EProfileSweepQuadSplit : uint8

strong

Enumerator
Uniform	Always split the quad in the same way relative sweep direction and profile direction.
ShortestDiagonal	Split the quad to connect the shortest diagonal.

◆ ERootfindingModes

enum class UE::Geometry::ERootfindingModes

strong

Enumerator
SingleLerp
LerpSteps
Bisection

◆ ERoundedRectangleCorner

enum class UE::Geometry::ERoundedRectangleCorner : uint8

strong

Enumerator
None
BottomLeft
BottomRight
TopLeft
TopRight
All

◆ ESurfacePointType

enum class UE::Geometry::ESurfacePointType

strong

Enumerator
Vertex
Edge
Triangle

◆ EValidityCheckFailMode

enum class UE::Geometry::EValidityCheckFailMode

strong

EValidityCheckFailMode is passed to CheckValidity() functions of various classes to specify how validity checks should fail.

Enumerator
ReturnOnly	Function returns false if a failure is encountered
Check	Function check()'s if a failure is encountered
Ensure	Function ensure()'s if a failure is encountered

Function Documentation

◆ AdvanceIterator() [1/2]

template<typename IterT >

IterT UE::Geometry::AdvanceIterator	(	IterT	Start,
		int64	N
	)

◆ AdvanceIterator() [2/2]

template<typename ContainerType , typename ElementType , typename SizeType >

TIndexedContainerIterator< ContainerType, ElementType, SizeType > UE::Geometry::AdvanceIterator	(	TIndexedContainerIterator< ContainerType, ElementType, SizeType >	Begin,
		SizeType	N
	)

◆ AngleD() [1/2]

template<typename T >

T UE::Geometry::AngleD	(	const UE::Math::TVector2< T > &	V1,
		const UE::Math::TVector2< T > &	V2
	)

◆ AngleD() [2/2]

template<typename T >

T UE::Geometry::AngleD	(	const UE::Math::TVector< T > &	V1,
		const UE::Math::TVector< T > &	V2
	)

Computes the Angle between V1 and V2, assuming they are already normalized

Returns: the (positive) angle between V1 and V2 in degrees

◆ AngleR() [1/2]

template<typename T >

T UE::Geometry::AngleR	(	const UE::Math::TVector2< T > &	V1,
		const UE::Math::TVector2< T > &	V2
	)

◆ AngleR() [2/2]

template<typename T >

T UE::Geometry::AngleR	(	const UE::Math::TVector< T > &	V1,
		const UE::Math::TVector< T > &	V2
	)

Computes the Angle between V1 and V2, assuming they are already normalized

Returns: the (positive) angle between V1 and V2 in radians

◆ Blend3()

template<typename T >

UE::Math::TVector< T > UE::Geometry::Blend3	(	const UE::Math::TVector< T > &	A,
		const UE::Math::TVector< T > &	B,
		const UE::Math::TVector< T > &	C,
		const T &	WeightA,
		const T &	WeightB,
		const T &	WeightC
	)

◆ CollectVertexPositions()

template<typename EnumeratorType , typename SetType >

void UE::Geometry::CollectVertexPositions	(	const FDynamicMesh3 &	Mesh,
		EnumeratorType	Enumeration,
		SetType &	Output
	)

Call SetType.Add(VertexPosition) for all valid vertex indices in for_each(Enumeration)

◆ CompactAttributeValues()

bool UE::Geometry::CompactAttributeValues	(	const FDynamicMesh3 &	Mesh,
		TDynamicMeshScalarTriangleAttribute< int32 > &	TriangleAttrib,
		FInterval1i &	OldMaxAttributeRangeOut,
		int &	NewMaxAttributeValueOut,
		TArray< int32 > &	OldToNewMapOut,
		TArray< int32 > &	NewToOldMapOut,
		bool &	bWasCompactOut
	)

Compact the values of an integer Triangle Attribute, ie so that the attribute values are dense in range 0..N. Useful for (eg) compacting MaterialIDs or Polygroups. Note that this function cannot tell if values were removed from the "end" of the attribute value list. Some care must be taken in calling code to handle this case if using this function to determine whether compaction of other data structures is needed. Currently OldToNewMapOut and NewToOldMapOut are always populated even if the input is compact.

Parameters

OldMaxAttributeRangeOut	min and max input attribute values, ie pre-compaction
NewMaxAttributeValueOut	new max attribute value after compacting.
OldToNewMapOut	generated mapping from previous IDs to new IDs (ie size is maximum input attrib value (+1), will contain InvalidID for any compacted values )
NewToOldMapOut	generated mapping from new IDs to previous IDs (ie size is maximum output attribute value (+1), no invalid values)
bWasCompactOut	set to true if the attribute set was already compact, IE was not modified by the operation

Returns: true on success (including if already compact). false if any Attribute Values were negative/InvalidID, cannot compact in this case

◆ ComputeOrientedBBox() [1/2]

template<typename RealType >

TOrientedBox3< RealType > GEOMETRYCORE_API UE::Geometry::ComputeOrientedBBox	(	const EDiTO	DiTO_K,
		const int32	NumPoints,
		TFunctionRef< UE::Math::TVector< RealType >(int32)>	GetPointFunc
	)

Returns: OrientedBox3 that contains the points provided by the given GetPointFunc

Heuristic-based computation of an object oriented bounding box that utilizes a small number of extremal vertices and an internal Di-Tetrahedron to generate the box orientation. Based on "Fast Computation of Tight-Fitting Oriented Bounding Boxes" by Larson and Kallberg ( cf., Game Engine Gems 2)

Parameters

DiTO_K	- selects the number of extremal vertices used by the method. More extremal vertices may produces a better result, but at a slightly higher cost
NumPoints	- number points used in constructing the OrientedBox
GetPointFunc	- returns a point for every index i = [0, NumPoints)

◆ ComputeOrientedBBox() [2/2]

template<typename RealType >

TOrientedBox3< RealType > GEOMETRYCORE_API UE::Geometry::ComputeOrientedBBox	(	const TArray< TVector< RealType > > &	SampleDirections,
		const int32	NumPoints,
		TFunctionRef< UE::Math::TVector< RealType >(int32)>	GetPointFunc
	)

Returns: OrientedBox3 that contains the points provided by the given GetPointFunc

Heuristic-based computation of an object oriented bounding box that utilizes a small number of extremal vertices and an internal Di-Tetrahedron to generate the box orientation. Based on "Fast Computation of Tight-Fitting Oriented Bounding Boxes" by Larson and Kallberg ( cf., Game Engine Gems 2)

Parameters

SampleDirections	- array of sample directions, ideally the direction vectors should be of the same length but no length checks are done internally.
NumPoints	- number points used in constructing the OrientedBox
GetPointFunc	- returns a point for every index i = [0, NumPoints)

The number of extreme vertices used by the method will be twice the number of sample directions.

◆ ComputeOrientedBBox< double >() [1/2]

template TOrientedBox3< double > GEOMETRYCORE_API UE::Geometry::ComputeOrientedBBox< double >	(	const TArray< UE::Math::TVector< double > > &	SampleDirections,
		const int32	NumPoints,
		TFunctionRef< UE::Math::TVector< double >(int32)>	GetPointFunc
	)

◆ ComputeOrientedBBox< double >() [2/2]

template TOrientedBox3< double > GEOMETRYCORE_API UE::Geometry::ComputeOrientedBBox< double >	(	const UE::Geometry::EDiTO	DiTOType,
		const int32	NumPoints,
		TFunctionRef< UE::Math::TVector< double >(int32)>	GetPointFunc
	)

◆ ComputeOrientedBBox< float >() [1/2]

template TOrientedBox3< float > GEOMETRYCORE_API UE::Geometry::ComputeOrientedBBox< float >	(	const TArray< UE::Math::TVector< float > > &	SampleDirections,
		const int32	NumPoints,
		TFunctionRef< UE::Math::TVector< float >(int32)>	GetPointFunc
	)

◆ ComputeOrientedBBox< float >() [2/2]

template TOrientedBox3< float > GEOMETRYCORE_API UE::Geometry::ComputeOrientedBBox< float >	(	const UE::Geometry::EDiTO	DiTOType,
		const int32	NumPoints,
		TFunctionRef< UE::Math::TVector< float >(int32)>	GetPointFunc
	)

◆ ConvertLoopToTriOrderedEdgeLoop() [1/2]

bool UE::Geometry::ConvertLoopToTriOrderedEdgeLoop	(	const FDynamicMesh3 &	Mesh,
		const TArray< int32 > &	VertexLoop,
		const TArray< int32 > &	EdgeLoop,
		TArray< FMeshTriOrderedEdgeID > &	TriOrderedEdgesLoopOut
	)

Variant of ConvertLoopToTriOrderedEdgeLoop that always encodes using EdgeTriangles.A, ie suitable for encoding open border loops

◆ ConvertLoopToTriOrderedEdgeLoop() [2/2]

GEOMETRYCORE_API bool UE::Geometry::ConvertLoopToTriOrderedEdgeLoop	(	const FDynamicMesh3 &	Mesh,
		const TArray< int32 > &	VertexLoop,
		const TArray< int32 > &	EdgeLoop,
		TFunctionRef< int(int EdgeID, int TriangleA, int TriangleB)>	SelectEdgeTriangleFunc,
		TArray< FMeshTriOrderedEdgeID > &	TriOrderedEdgesLoopOut
	)

Convert the input Vertex/Edge loop into an edge loop representation that is independent of Vertex/Edge IDs. See description of FMeshTriOrderedEdgeID for more information on how this works. But essentially the resulting TriOrderedEdgesLoopOut is stable across some topological changes, in particular if the vertices of the loop change but the triangle topology remains the same (eg if a bowtie vertex is disconnected, or if the mesh is disconnected along the edge loop), the encoded loop remains valid, while an explicit vertex or edge loop would not.

Parameters

SelectEdgeTriangleFunc This function is used to select which triangle to use for encoding at each edge

◆ ConvertTriOrderedEdgeLoopToLoop()

bool UE::Geometry::ConvertTriOrderedEdgeLoopToLoop	(	const FDynamicMesh3 &	Mesh,
		const TArray< FMeshTriOrderedEdgeID > &	TriOrderedEdgesLoopOut,
		TArray< int32 > &	VertexLoop,
		TArray< int32 > *	EdgeLoop = `nullptr`
	)

Recover the current Vertex and Edge loops given an encoded loop of FMeshTriOrderedEdgeID. See FMeshTriOrderedEdgeID for details on this encoding, this function basically reverses ConvertLoopToTriOrderedEdgeLoop() for the current mesh topology

◆ CopyVertexNormalsToOverlay()

bool UE::Geometry::CopyVertexNormalsToOverlay	(	const FDynamicMesh3 &	Mesh,
		FDynamicMeshNormalOverlay &	NormalOverlayOut,
		bool	bCompactElements = `false`
	)

Copies vertex normals to a given overlay (clearing it before use if it has any elements).

Parameters

bCompactElements If true, elements are compacted in the overlay

Returns: true if successful

◆ CopyVertexUVsToOverlay()

bool UE::Geometry::CopyVertexUVsToOverlay	(	const FDynamicMesh3 &	Mesh,
		FDynamicMeshUVOverlay &	UVOverlayOut,
		bool	bCompactElements = `false`
	)

Copies vertex UVs to a given overlay (clearing it before use if it has any elements).

Parameters

bCompactElements If true, elements are compacted in the overlay

Returns: true if successful

◆ CreateSeamQuadric()

template<typename RealType >

TQuadricError< RealType > UE::Geometry::CreateSeamQuadric	(	const TVector< RealType > &	p0,
		const TVector< RealType > &	p1,
		const TVector< RealType > &	AdjFaceNormal
	)

A "Seam Quadric" is a quadric defined with respect to the plane passing through the edge p1-p0, but perpendicular to the adjacent face. On return the quadric has been weighted by the length of the (p1-p0).

◆ Cross()

template<typename T >

UE::Math::TVector< T > UE::Geometry::Cross	(	const UE::Math::TVector< T > &	V1,
		const UE::Math::TVector< T > &	V2
	)

◆ Distance() [1/2]

template<typename T >

T UE::Geometry::Distance	(	const UE::Math::TVector2< T > &	V1,
		const UE::Math::TVector2< T > &	V2
	)

◆ Distance() [2/2]

template<typename T >

T UE::Geometry::Distance	(	const UE::Math::TVector< T > &	V1,
		const UE::Math::TVector< T > &	V2
	)

◆ DistanceSquared() [1/2]

template<typename T >

T UE::Geometry::DistanceSquared	(	const UE::Math::TVector2< T > &	V1,
		const UE::Math::TVector2< T > &	V2
	)

◆ DistanceSquared() [2/2]

template<typename T >

T UE::Geometry::DistanceSquared	(	const UE::Math::TVector< T > &	V1,
		const UE::Math::TVector< T > &	V2
	)

◆ DoesCylinderContainPoint() [1/3]

template bool GEOMETRYCORE_API UE::Geometry::DoesCylinderContainPoint	(	const TVector< double > &	CylinderCenter,
		const TVector< double > &	CylinderAxis,
		double	CylinderRadius,
		double	CylinderHeight,
		const TVector< double > &	QueryPoint
	)

◆ DoesCylinderContainPoint() [2/3]

template bool GEOMETRYCORE_API UE::Geometry::DoesCylinderContainPoint	(	const TVector< float > &	CylinderCenter,
		const TVector< float > &	CylinderAxis,
		float	CylinderRadius,
		float	CylinderHeight,
		const TVector< float > &	QueryPoint
	)

◆ DoesCylinderContainPoint() [3/3]

template<typename RealType >

bool UE::Geometry::DoesCylinderContainPoint	(	const TVector< RealType > &	CylinderCenter,
		const TVector< RealType > &	NormalizedCylinderAxis,
		RealType	CylinderRadius,
		RealType	CylindeHeight,
		const TVector< RealType > &	QueryPoint
	)

Test if QueryPoint is inside (or on) the given cylinder.

◆ DoesTriangleIntersectCircle2D() [1/3]

template bool GEOMETRYCORE_API UE::Geometry::DoesTriangleIntersectCircle2D	(	const TVector2< double > &	A,
		const TVector2< double > &	B,
		const TVector2< double > &	C,
		const TVector2< double > &	Center,
		double	RadiusSquared
	)

◆ DoesTriangleIntersectCircle2D() [2/3]

template bool GEOMETRYCORE_API UE::Geometry::DoesTriangleIntersectCircle2D	(	const TVector2< float > &	A,
		const TVector2< float > &	B,
		const TVector2< float > &	C,
		const TVector2< float > &	Center,
		double	RadiusSquared
	)

◆ DoesTriangleIntersectCircle2D() [3/3]

template<typename Real >

GEOMETRYCORE_API bool UE::Geometry::DoesTriangleIntersectCircle2D	(	const TVector2< Real > &	A,
		const TVector2< Real > &	B,
		const TVector2< Real > &	C,
		const TVector2< Real > &	Center,
		double	RadiusSquared
	)

◆ Dot()

template<typename T >

T UE::Geometry::Dot	(	const UE::Math::TVector< T > &	V1,
		const UE::Math::TVector< T > &	V2
	)

◆ DotPerp()

template<typename T >

constexpr T UE::Geometry::DotPerp	(	const UE::Math::TVector2< T > &	V1,
		const UE::Math::TVector2< T > &	V2
	)

constexpr

Returns: dot product of V1 with PerpCW(V2), ie V2 rotated 90 degrees clockwise

◆ EmbedProjectedPath()

bool UE::Geometry::EmbedProjectedPath	(	FDynamicMesh3 *	Mesh,
		int	StartTriID,
		FFrame3d	Frame,
		const TArray< FVector2d > &	Path2D,
		TArray< int > &	OutPathVertices,
		TArray< int > &	OutVertexCorrespondence,
		bool	bClosePath,
		FMeshFaceSelection *	EnclosedFaces = `nullptr`,
		double	PtSnapVertexOrEdgeThresholdSq = `FMathf::ZeroTolerance*100`
	)

Embed a 2D path into a mesh by projection, starting the walk from a given triangle. Optionally select the triangles inside the path.

◆ EmbedProjectedPaths()

bool UE::Geometry::EmbedProjectedPaths	(	FDynamicMesh3 *	Mesh,
		const TArrayView< const int >	StartTriIDs,
		FFrame3d	Frame,
		const TArrayView< const TArray< FVector2d > >	AllPaths,
		TArray< TArray< int > > &	OutAllPathVertices,
		TArray< TArray< int > > &	OutAllVertexCorrespondence,
		bool	bClosePaths,
		FMeshFaceSelection *	EnclosedFaces,
		double	PtSnapVertexOrEdgeThresholdSq = `FMathf::ZeroTolerance*100`
	)

Embed multiple 2D paths into a mesh by projection, starting the walks from the given triangles. Optionally select the triangles inside the paths.

◆ ENUM_CLASS_FLAGS()

UE::Geometry::ENUM_CLASS_FLAGS ( ERoundedRectangleCorner )

◆ FindNextAdjacentTriangleAroundVtx()

template<typename TrisConnectedPredicate >

FIndex3i UE::Geometry::FindNextAdjacentTriangleAroundVtx	(	const FDynamicMesh3 *	Mesh,
		int32	VertexID,
		int32	FromTriangleID,
		int32	PrevTriangleID,
		TrisConnectedPredicate	TrisConnectedTest
	)

Walk around VertexID from FromTriangleID to next connected triangle if it exists, walking "away" from PrevTriangleID.

Parameters

TrisConnectedFunc returns true if two triangles should be considered connected, to support breaking at seams/etc that are not in base mesh topology

Returns: triplet of values (FoundTriangleID, SharedEdgeID, IndexOfEdgeInFromTri), or all IndexConstants::InvalidID if not found

◆ FindSharedEdgeInTriangles()

int32 UE::Geometry::FindSharedEdgeInTriangles	(	const FDynamicMesh3 &	Mesh,
		int32	Triangle0,
		int32	Triangle1
	)

Returns: the ID of the shared edge betwen two given triangles, or IndexConstants::InvalidID if not found / invalid input

◆ FindVertexEdgesInTriangle()

FIndex2i UE::Geometry::FindVertexEdgesInTriangle	(	const FDynamicMesh3 &	Mesh,
		int32	TriangleID,
		int32	VertexID
	)

Find the two edges in a Triangle that are connected to a given Vertex of the triangle

Returns: edge pair, or (IndexConstants::InvalidID, IndexConstants::InvalidID) on error

◆ FitKDOPVertices3() [1/4]

template<typename RealType >

bool UE::Geometry::FitKDOPVertices3	(	TArrayView< const UE::Math::TVector< RealType > >	PlaneDirections,
		const int32	NumPoints,
		TFunctionRef< UE::Math::TVector< RealType >(int32)>	GetPointFunc,
		TArray< UE::Math::TVector< RealType > > &	OutVertices,
		TArray< UE::Math::TPlane< RealType > > *	OptionalOutPlanes = `nullptr`,
		RealType	Epsilon = `TMathUtil<RealType>::Epsilon`,
		RealType	VertexSnapDistance = `(RealType)0.1`,
		RealType	Inflate = `(RealType)0.1`
	)

Compute the vertices (and optionally planes) of a k-DOP bounding convex hull containing the points returned by GetPointFunc

◆ FitKDOPVertices3() [2/4]

template<typename RealType >

bool UE::Geometry::FitKDOPVertices3	(	TArrayView< const UE::Math::TVector< RealType > >	PlaneDirections,
		const int32	NumPoints,
		TFunctionRef< UE::Math::TVector< RealType >(int32)>	GetPointFunc,
		TFunctionRef< bool(int32)>	FilterFunc,
		TArray< UE::Math::TVector< RealType > > &	OutVertices,
		TArray< UE::Math::TPlane< RealType > > *	OptionalOutPlanes = `nullptr`,
		RealType	Epsilon = `TMathUtil< RealType >::Epsilon`,
		RealType	VertexSnapDistance = `(RealType) 0.1`,
		RealType	Inflate = `(RealType) 0.1`
	)

Compute the vertices (and optionally planes) of a k-DOP bounding convex hull containing the points returned by GetPointFunc where FilterFunc returns true

◆ FitKDOPVertices3() [3/4]

template<typename RealType >

bool GEOMETRYCORE_API UE::Geometry::FitKDOPVertices3	(	TArrayView< const UE::Math::TVector< RealType > >	PlaneDirections,
		const int32	NumPoints,
		TFunctionRef< UE::Math::TVector< RealType >(int32)>	GetPointFunc,
		TFunctionRef< bool(int32)>	FilterFunc,
		TArray< UE::Math::TVector< RealType > > &	OutVertices,
		TArray< UE::Math::TPlane< RealType > > *	OptionalOutPlanes = `nullptr`,
		RealType	Epsilon = `TMathUtil< RealType >::Epsilon`,
		RealType	VertexSnapDistance = `(RealType) 0.1`,
		RealType	Inflate = `(RealType) 0.1`
	)

Compute the vertices (and optionally planes) of a k-DOP bounding convex hull containing the points returned by GetPointFunc where FilterFunc returns true

◆ FitKDOPVertices3() [4/4]

template<typename RealType >

bool UE::Geometry::FitKDOPVertices3	(	TArrayView< const UE::Math::TVector< RealType > >	PlaneDirections,
		const TArray< UE::Math::TVector< RealType > > &	Points,
		TArray< UE::Math::TVector< RealType > > &	OutVertices,
		TArray< UE::Math::TPlane< RealType > > *	OptionalOutPlanes = `nullptr`,
		RealType	Epsilon = `TMathUtil<RealType>::Epsilon`,
		RealType	VertexSnapDistance = `(RealType)0.1`,
		RealType	Inflate = `(RealType)0.1`
	)

Compute the vertices (and optionally planes) of a k-DOP bounding convex hull containing Points

◆ FitKDOPVertices3< double >()

template bool GEOMETRYCORE_API UE::Geometry::FitKDOPVertices3< double >	(	TArrayView< const UE::Math::TVector< double > >	PlaneDirections,
		const int32	NumPoints,
		TFunctionRef< UE::Math::TVector< double >(int32)>	GetPointFunc,
		TFunctionRef< bool(int32)>	FilterFunc,
		TArray< UE::Math::TVector< double > > &	OutVertices,
		TArray< UE::Math::TPlane< double > > *	OptionalOutPlanes,
		double	Epsilon,
		double	VertexSnapDistance,
		double	Inflate
	)

◆ FitKDOPVertices3< float >()

template bool GEOMETRYCORE_API UE::Geometry::FitKDOPVertices3< float >	(	TArrayView< const UE::Math::TVector< float > >	PlaneDirections,
		const int32	NumPoints,
		TFunctionRef< UE::Math::TVector< float >(int32)>	GetPointFunc,
		TFunctionRef< bool(int32)>	FilterFunc,
		TArray< UE::Math::TVector< float > > &	OutVertices,
		TArray< UE::Math::TPlane< float > > *	OptionalOutPlanes,
		float	Epsilon,
		float	VertexSnapDistance,
		float	Inflate
	)

◆ FitOrientedBox2ConvexHull() [1/3]

template<typename RealType >

TOrientedBox2< RealType > UE::Geometry::FitOrientedBox2ConvexHull	(	int32	NumPts,
		TFunctionRef< TVector2< RealType >(int32)>	GetHullPt,
		EBox2FitCriteria	FitMethod = `EBox2FitCriteria::Area`
	)

Use the rotating calipers algorithm to find a best-fit oriented bounding box of a convex hull.

Parameters

NumPts	Number of points in the convex hull
GetHullPt	Function(hull point index) -> hull point
FitMethod	What criteria to optimize

Returns: A best-fit TOrientedBox2 that contains the points

◆ FitOrientedBox2ConvexHull() [2/3]

template<typename RealType >

TOrientedBox2< RealType > UE::Geometry::FitOrientedBox2ConvexHull	(	int32	NumPts,
		TFunctionRef< TVector2< RealType >(int32)>	GetHullPt,
		TFunctionRef< RealType(RealType, RealType)>	FitFn
	)

Use the rotating calipers algorithm to find a best-fit oriented bounding box of a convex hull.

Parameters

NumPts	Number of points in the convex hull
GetHullPt	Function(hull point index) -> hull point
FitFn	Function from (Width, Height) -> Fit metric; The box with the lowest fit metric will be chosen

Returns: A best-fit TOrientedBox2 that contains the points

◆ FitOrientedBox2ConvexHull() [3/3]

template<typename RealType >

TOrientedBox2< RealType > GEOMETRYCORE_API UE::Geometry::FitOrientedBox2ConvexHull	(	int32	NumPts,
		TFunctionRef< TVector2< RealType >(int32)>	GetHullPt,
		TFunctionRef< RealType(RealType, RealType)>	FitFn
	)

Use the rotating calipers algorithm to find a best-fit oriented bounding box of a convex hull.

Parameters

NumPts	Number of points in the convex hull
GetHullPt	Function(hull point index) -> hull point
FitFn	Function from (Width, Height) -> Fit metric; The box with the lowest fit metric will be chosen

Returns: A best-fit TOrientedBox2 that contains the points

◆ FitOrientedBox2ConvexHull< double >()

template TOrientedBox2< double > GEOMETRYCORE_API UE::Geometry::FitOrientedBox2ConvexHull< double >	(	int32	NumPts,
		TFunctionRef< TVector2< double >(int32)>	GetHullPt,
		TFunctionRef< double(double, double)>	FitFn
	)

◆ FitOrientedBox2ConvexHull< float >()

template TOrientedBox2< float > GEOMETRYCORE_API UE::Geometry::FitOrientedBox2ConvexHull< float >	(	int32	NumPts,
		TFunctionRef< TVector2< float >(int32)>	GetHullPt,
		TFunctionRef< float(float, float)>	FitFn
	)

◆ FitOrientedBox2Points() [1/3]

template<typename RealType >

TOrientedBox2< RealType > UE::Geometry::FitOrientedBox2Points	(	TArrayView< const TVector2< RealType > >	Points,
		EBox2FitCriteria	FitMethod = `EBox2FitCriteria::Area`
	)

Use the rotating calipers algorithm to find a best-fit oriented bounding box of a point set. Note it internally computes a 2D convex hull of a point set, and is currently O(n log n) in the number of points.

Parameters

Points	The points to fit
FitMethod	What criteria to optimize

Returns: A best-fit TOrientedBox2 that contains the points

◆ FitOrientedBox2Points() [2/3]

template<typename RealType >

TOrientedBox2< RealType > UE::Geometry::FitOrientedBox2Points	(	TArrayView< const TVector2< RealType > >	Points,
		TFunctionRef< RealType(RealType, RealType)>	FitFn
	)

Use the rotating calipers algorithm to find a best-fit oriented bounding box of a point set. Note it internally computes a 2D convex hull of a point set, and is currently O(n log n) in the number of points.

Parameters

Points	The points to fit
FitFn	Function from (Width, Height) -> Fit metric; The box with the lowest fit metric will be chosen

Returns: A best-fit TOrientedBox2 that contains the points

◆ FitOrientedBox2Points() [3/3]

template<typename RealType >

TOrientedBox2< RealType > GEOMETRYCORE_API UE::Geometry::FitOrientedBox2Points	(	TArrayView< const TVector2< RealType > >	Points,
		TFunctionRef< RealType(RealType, RealType)>	FitFn
	)

Use the rotating calipers algorithm to find a best-fit oriented bounding box of a point set. Note it internally computes a 2D convex hull of a point set, and is currently O(n log n) in the number of points.

Parameters

Points	The points to fit
FitFn	Function from (Width, Height) -> Fit metric; The box with the lowest fit metric will be chosen

Returns: A best-fit TOrientedBox2 that contains the points

◆ FitOrientedBox2Points< double >()

template TOrientedBox2< double > GEOMETRYCORE_API UE::Geometry::FitOrientedBox2Points< double >	(	TArrayView< const TVector2< double > >	Points,
		TFunctionRef< double(double, double)>	FitFn
	)

◆ FitOrientedBox2Points< float >()

template TOrientedBox2< float > GEOMETRYCORE_API UE::Geometry::FitOrientedBox2Points< float >	(	TArrayView< const TVector2< float > >	Points,
		TFunctionRef< float(float, float)>	FitFn
	)

◆ FitOrientedBox2SimplePolygon() [1/3]

template<typename RealType >

TOrientedBox2< RealType > UE::Geometry::FitOrientedBox2SimplePolygon	(	TArrayView< const TVector2< RealType > >	Polygon,
		EBox2FitCriteria	FitMethod = `EBox2FitCriteria::Area`
	)

Use the rotating calipers algorithm to find a best-fit oriented bounding box of a simple polygon. Note the polygon should not be self-intersecting. O(n) in the number of points.

Parameters

Polygon	The vertices of the simple polygon to fit
FitMethod	What criteria to optimize

Returns: A best-fit TOrientedBox2 that contains the points

◆ FitOrientedBox2SimplePolygon() [2/3]

template<typename RealType >

TOrientedBox2< RealType > UE::Geometry::FitOrientedBox2SimplePolygon	(	TArrayView< const TVector2< RealType > >	Polygon,
		TFunctionRef< RealType(RealType, RealType)>	FitFn
	)

Use the rotating calipers algorithm to find a best-fit oriented bounding box of a simple polygon. Note the polygon should not be self-intersecting. O(n) in the number of points.

Parameters

Polygon	The vertices of the simple polygon to fit
FitFn	Function from (Width, Height) -> Fit metric; The box with the lowest fit metric will be chosen

Returns: A best-fit TOrientedBox2 that contains the points

◆ FitOrientedBox2SimplePolygon() [3/3]

template<typename RealType >

TOrientedBox2< RealType > GEOMETRYCORE_API UE::Geometry::FitOrientedBox2SimplePolygon	(	TArrayView< const TVector2< RealType > >	Polygon,
		TFunctionRef< RealType(RealType, RealType)>	FitFn
	)

Use the rotating calipers algorithm to find a best-fit oriented bounding box of a simple polygon. Note the polygon should not be self-intersecting. O(n) in the number of points.

Parameters

Polygon	The vertices of the simple polygon to fit
FitFn	Function from (Width, Height) -> Fit metric; The box with the lowest fit metric will be chosen

Returns: A best-fit TOrientedBox2 that contains the points

◆ FitOrientedBox2SimplePolygon< double >()

template TOrientedBox2< double > GEOMETRYCORE_API UE::Geometry::FitOrientedBox2SimplePolygon< double >	(	TArrayView< const TVector2< double > >	Points,
		TFunctionRef< double(double, double)>	FitFn
	)

◆ FitOrientedBox2SimplePolygon< float >()

template TOrientedBox2< float > GEOMETRYCORE_API UE::Geometry::FitOrientedBox2SimplePolygon< float >	(	TArrayView< const TVector2< float > >	Points,
		TFunctionRef< float(float, float)>	FitFn
	)

◆ FitOrientedBox3Points() [1/3]

template<typename RealType >

TOrientedBox3< RealType > GEOMETRYCORE_API UE::Geometry::FitOrientedBox3Points	(	int32	NumPoints,
		TFunctionRef< TVector< RealType >(int32)>	GetPointFunc,
		TFunctionRef< bool(int32)>	Filter,
		EBox3FitCriteria	FitMethod = `EBox3FitCriteria::Volume`,
		RealType	SameNormalTolerance = `0`,
		FProgressCancel *	ProgressCancel = `nullptr`
	)

Compute a close-fitting oriented bounding box to the given points. Relatively expensive; for a faster approximation use DiTOrientedBox.h's ComputeOrientedBBox

Parameters

NumPoints	Number of points to consider
GetPointFunc	Function providing array-style access into points
Filter	Optional filter to include only a subset of the points in the output hull
FitMethod	What criteria to optimize
SameNormalTolerance	Tolerance for considering normals the same when choosing projection directions. If > 0, can save some computation if the convex hull is very large.

Returns: A best-fit TOrientedBox3 that contains the points

◆ FitOrientedBox3Points() [2/3]

template<typename RealType >

TOrientedBox3< RealType > UE::Geometry::FitOrientedBox3Points	(	int32	NumPoints,
		TFunctionRef< TVector< RealType >(int32)>	GetPointFunc,
		TFunctionRef< bool(int32)>	Filter,
		EBox3FitCriteria	FitMethod = `EBox3FitCriteria::Volume`,
		RealType	SameNormalTolerance = `0`,
		FProgressCancel *	ProgressCancel = `nullptr`
	)

Compute a close-fitting oriented bounding box to the given points. Relatively expensive; for a faster approximation use DiTOrientedBox.h's ComputeOrientedBBox

Parameters

NumPoints	Number of points to consider
GetPointFunc	Function providing array-style access into points
Filter	Optional filter to include only a subset of the points in the output hull
FitMethod	What criteria to optimize
SameNormalTolerance	Tolerance for considering normals the same when choosing projection directions. If > 0, can save some computation if the convex hull is very large.

Returns: A best-fit TOrientedBox3 that contains the points

◆ FitOrientedBox3Points() [3/3]

template<typename RealType >

TOrientedBox3< RealType > UE::Geometry::FitOrientedBox3Points	(	TArrayView< const TVector< RealType > >	Points,
		EBox3FitCriteria	FitMethod = `EBox3FitCriteria::Volume`,
		RealType	SameNormalTolerance = `0`,
		FProgressCancel *	ProgressCancel = `nullptr`
	)

Compute a close-fitting oriented bounding box to the given points. Relatively expensive; for a faster approximation use DiTOrientedBox.h's ComputeOrientedBBox

Parameters

Points	The points to fit
FitMethod	What criteria to optimize
SameNormalTolerance	Tolerance for considering normals the same when choosing projection directions. If > 0, can save some computation if the convex hull is very large.

Returns: A best-fit TOrientedBox3 that contains the points

◆ FitOrientedBox3Points< double >()

template TOrientedBox3< double > GEOMETRYCORE_API UE::Geometry::FitOrientedBox3Points< double >	(	int32	NumPts,
		TFunctionRef< TVector< double >(int32)>	GetPtFn,
		TFunctionRef< bool(int32)>	FilterFn,
		EBox3FitCriteria	FitMethod,
		double	SameNormalTolerance,
		FProgressCancel *	ProgressCancel
	)

◆ FitOrientedBox3Points< float >()

template TOrientedBox3< float > GEOMETRYCORE_API UE::Geometry::FitOrientedBox3Points< float >	(	int32	NumPts,
		TFunctionRef< TVector< float >(int32)>	GetPtFn,
		TFunctionRef< bool(int32)>	FilterFn,
		EBox3FitCriteria	FitMethod,
		float	SameNormalTolerance,
		FProgressCancel *	ProgressCancel
	)

◆ FractalBrownianMotionNoise()

template<typename T >

T UE::Geometry::FractalBrownianMotionNoise	(	const EFBMMode	FBMMode,
		const uint32	OctaveCount,
		const Math::TVector2< T >	Coords,
		const T	Lacunarity,
		const T	Gain,
		const T	Smoothness,
		const T	Gamma
	)

◆ GenerateArcSegments()

template<typename RealType >

void UE::Geometry::GenerateArcSegments	(	int32	NumSteps,
		RealType	Radius,
		RealType	StartAngle,
		RealType	EndAngle,
		const TVector< RealType > &	Center,
		const TVector< RealType > &	AxisX,
		const TVector< RealType > &	AxisY,
		const TTransformSRT3< RealType > &	Transform,
		TFunctionRef< void(const TVector< RealType > &A, const TVector< RealType > &B)>	EmitLineFunc
	)

call EmitLineFunc for the line segments that make up the Circular Arc defined by the given parameters and sampled with NumSteps vertices

Parameters

NumSteps	number of vertices used to approximate arc
Radius	radius of arc
StartAngle	arc starts at this angle
EndAngle	arc ends at this angle
AxisX	first axis of arc
AxisY	second axis of arc
Transform	transform applied to each point

◆ GenerateBoxSegments()

template<typename RealType >

void UE::Geometry::GenerateBoxSegments	(	const TVector< RealType > &	HalfDimensions,
		const TVector< RealType > &	Center,
		const TVector< RealType > &	AxisX,
		const TVector< RealType > &	AxisY,
		const TVector< RealType > &	AxisZ,
		const TTransformSRT3< RealType > &	Transform,
		TFunctionRef< void(const TVector< RealType > &A, const TVector< RealType > &B)>	EmitLineFunc
	)

call EmitLineFunc for the 12 line segments defined by the given box parameters

Parameters

HalfDimensions	X/Y/Z dimensions of box
Center	center of box
AxisX	X axis of box
AxisY	Y axis of box
AxisZ	Z axis of box
Transform	transform applied to points of box

◆ GenerateCircleSegments()

template<typename RealType >

void UE::Geometry::GenerateCircleSegments	(	int32	NumSteps,
		RealType	Radius,
		const TVector< RealType > &	Center,
		const TVector< RealType > &	AxisX,
		const TVector< RealType > &	AxisY,
		const TTransformSRT3< RealType > &	Transform,
		TFunctionRef< void(const TVector< RealType > &A, const TVector< RealType > &B)>	EmitLineFunc
	)

call EmitLineFunc for the line segments that make up the Circle defined by the given parameters and sampled with NumSteps vertices

Parameters

NumSteps	number of vertices used to approximate circle
Radius	radius of circle
Center	center of circle
AxisX	first axis of circle
AxisY	second axis of circle
Transform	transform applied to each point

◆ GetArrayMesh()

FTriangleMeshAdapterd UE::Geometry::GetArrayMesh	(	TArray< FVector > &	Vertices,
		TArray< FIntVector > &	Triangles
	)

inline

Example function to generate a generic mesh adapter from arrays

Parameters

Vertices	Array of mesh vertices
Triangles	Array of int-vectors, one per triangle, indexing into the vertices array

◆ GetTypeHash() [1/6]

uint32 UE::Geometry::GetTypeHash ( const FIndex2i & Index )

inline

◆ GetTypeHash() [2/6]

uint32 UE::Geometry::GetTypeHash ( const FIndex3i & Index )

inline

◆ GetTypeHash() [3/6]

uint32 UE::Geometry::GetTypeHash ( const FIndex4i & Index )

inline

◆ GetTypeHash() [4/6]

uint32 UE::Geometry::GetTypeHash ( const FVector2i & Vector )

inline

◆ GetTypeHash() [5/6]

uint32 UE::Geometry::GetTypeHash ( const FVector3i & Vector )

inline

◆ GetTypeHash() [6/6]

template<typename AttrType >

uint32 UE::Geometry::GetTypeHash ( const TVertexAttr< AttrType > & Vector )

inline

◆ GetXY()

template<typename T >

constexpr UE::Math::TVector2< T > UE::Geometry::GetXY ( const UE::Math::TVector< T > & V )

constexpr

◆ GetXZ()

template<typename T >

constexpr UE::Math::TVector2< T > UE::Geometry::GetXZ ( const UE::Math::TVector< T > & V )

constexpr

◆ GetYZ()

template<typename T >

constexpr UE::Math::TVector2< T > UE::Geometry::GetYZ ( const UE::Math::TVector< T > & V )

constexpr

◆ HeatEquationImplicitAOS()

template<typename RealType >

void UE::Geometry::HeatEquationImplicitAOS	(	TSampledScalarField2< RealType, RealType > &	Field,
		const RealType	SigmaX,
		const RealType	SigmaY
	)

◆ IsInside() [1/39]

template bool GEOMETRYCORE_API UE::Geometry::IsInside	(	const TCapsule3< double > &	OuterSphere,
		const TCapsule3< double > &	InnerSphere
	)

◆ IsInside() [2/39]

template bool GEOMETRYCORE_API UE::Geometry::IsInside	(	const TCapsule3< double > &	OuterSphere,
		const TOrientedBox3< double > &	InnerSphere
	)

◆ IsInside() [3/39]

template bool GEOMETRYCORE_API UE::Geometry::IsInside	(	const TCapsule3< double > &	OuterSphere,
		const TSphere3< double > &	InnerSphere
	)

◆ IsInside() [4/39]

template bool GEOMETRYCORE_API UE::Geometry::IsInside	(	const TCapsule3< float > &	OuterSphere,
		const TCapsule3< float > &	InnerSphere
	)

◆ IsInside() [5/39]

template bool GEOMETRYCORE_API UE::Geometry::IsInside	(	const TCapsule3< float > &	OuterSphere,
		const TOrientedBox3< float > &	InnerSphere
	)

◆ IsInside() [6/39]

template bool GEOMETRYCORE_API UE::Geometry::IsInside	(	const TCapsule3< float > &	OuterSphere,
		const TSphere3< float > &	InnerSphere
	)

◆ IsInside() [7/39]

template<typename RealType >

GEOMETRYCORE_API bool UE::Geometry::IsInside	(	const TCapsule3< RealType > &	OuterCapsule,
		const TCapsule3< RealType > &	InnerCapsule
	)

Returns: true if InnerCapsule is fully contained within OuterCapsule

◆ IsInside() [8/39]

template<typename RealType >

GEOMETRYCORE_API bool UE::Geometry::IsInside	(	const TCapsule3< RealType > &	OuterCapsule,
		const TOrientedBox3< RealType > &	InnerBox
	)

Returns: true if InnerBox is fully contained within OuterCapsule

◆ IsInside() [9/39]

template<typename RealType >

GEOMETRYCORE_API bool UE::Geometry::IsInside	(	const TCapsule3< RealType > &	OuterCapsule,
		const TSphere3< RealType > &	InnerSphere
	)

Returns: true if InnerSphere is fully contained within OuterCapsule

◆ IsInside() [10/39]

template<typename RealType , typename GridType >

bool UE::Geometry::IsInside	(	const TCapsule3< RealType > &	OuterCapsule,
		const TTriLinearGridInterpolant< GridType > &	InnerGrid
	)

Returns: true if the AABB of InnerGrid is completely inside OuterCapsule

◆ IsInside() [11/39]

template<typename RealType , typename EnumerablePointsType , typename E = decltype(DeclVal<EnumerablePointsType>().begin())>

bool UE::Geometry::IsInside	(	const TCapsule3< RealType > &	OuterCapsule,
		EnumerablePointsType	EnumerablePts
	)

Returns: true if all all points in range-based for over EnumerablePts are inside OuterCapsule

◆ IsInside() [12/39]

template bool GEOMETRYCORE_API UE::Geometry::IsInside	(	const TOrientedBox3< double > &	OuterSphere,
		const TCapsule3< double > &	InnerSphere
	)

◆ IsInside() [13/39]

template bool GEOMETRYCORE_API UE::Geometry::IsInside	(	const TOrientedBox3< double > &	OuterSphere,
		const TOrientedBox3< double > &	InnerSphere
	)

◆ IsInside() [14/39]

template bool GEOMETRYCORE_API UE::Geometry::IsInside	(	const TOrientedBox3< double > &	OuterSphere,
		const TSphere3< double > &	InnerSphere
	)

◆ IsInside() [15/39]

template bool GEOMETRYCORE_API UE::Geometry::IsInside	(	const TOrientedBox3< float > &	OuterSphere,
		const TCapsule3< float > &	InnerSphere
	)

◆ IsInside() [16/39]

template bool GEOMETRYCORE_API UE::Geometry::IsInside	(	const TOrientedBox3< float > &	OuterSphere,
		const TOrientedBox3< float > &	InnerSphere
	)

◆ IsInside() [17/39]

template bool GEOMETRYCORE_API UE::Geometry::IsInside	(	const TOrientedBox3< float > &	OuterSphere,
		const TSphere3< float > &	InnerSphere
	)

◆ IsInside() [18/39]

template<typename RealType >

GEOMETRYCORE_API bool UE::Geometry::IsInside	(	const TOrientedBox3< RealType > &	OuterBox,
		const TCapsule3< RealType > &	InnerCapsule
	)

Returns: true if InnerCapsule is fully contained within OuterBox

◆ IsInside() [19/39]

template<typename RealType >

GEOMETRYCORE_API bool UE::Geometry::IsInside	(	const TOrientedBox3< RealType > &	OuterBox,
		const TOrientedBox3< RealType > &	InnerBox
	)

Returns: true if InnerBox is fully contained within OuterBox

◆ IsInside() [20/39]

template<typename RealType >

GEOMETRYCORE_API bool UE::Geometry::IsInside	(	const TOrientedBox3< RealType > &	OuterBox,
		const TSphere3< RealType > &	InnerSphere
	)

Returns: true if InnerSphere is fully contained within OuterBox

◆ IsInside() [21/39]

template<typename RealType , typename GridType >

bool UE::Geometry::IsInside	(	const TOrientedBox3< RealType > &	OuterBox,
		const TTriLinearGridInterpolant< GridType > &	InnerGrid
	)

Returns: true if the AABB of InnerGrid is completely inside OuterBox

◆ IsInside() [22/39]

template<typename RealType , typename EnumerablePointsType , typename E = decltype(DeclVal<EnumerablePointsType>().begin())>

bool UE::Geometry::IsInside	(	const TOrientedBox3< RealType > &	OuterBox,
		EnumerablePointsType	EnumerablePts
	)

Returns: true if all all points in range-based for over EnumerablePts are inside OuterBox

◆ IsInside() [23/39]

template bool GEOMETRYCORE_API UE::Geometry::IsInside	(	const TSphere3< double > &	OuterSphere,
		const TCapsule3< double > &	InnerSphere
	)

◆ IsInside() [24/39]

template bool GEOMETRYCORE_API UE::Geometry::IsInside	(	const TSphere3< double > &	OuterSphere,
		const TOrientedBox3< double > &	InnerSphere
	)

◆ IsInside() [25/39]

template bool GEOMETRYCORE_API UE::Geometry::IsInside	(	const TSphere3< double > &	OuterSphere,
		const TSphere3< double > &	InnerSphere
	)

◆ IsInside() [26/39]

template bool GEOMETRYCORE_API UE::Geometry::IsInside	(	const TSphere3< float > &	OuterSphere,
		const TCapsule3< float > &	InnerSphere
	)

◆ IsInside() [27/39]

template bool GEOMETRYCORE_API UE::Geometry::IsInside	(	const TSphere3< float > &	OuterSphere,
		const TOrientedBox3< float > &	InnerSphere
	)

◆ IsInside() [28/39]

template bool GEOMETRYCORE_API UE::Geometry::IsInside	(	const TSphere3< float > &	OuterSphere,
		const TSphere3< float > &	InnerSphere
	)

◆ IsInside() [29/39]

template<typename RealType >

GEOMETRYCORE_API bool UE::Geometry::IsInside	(	const TSphere3< RealType > &	OuterSphere,
		const TCapsule3< RealType > &	InnerCapsule
	)

Returns: true if InnerCapsule is fully contained within OuterSphere

◆ IsInside() [30/39]

template<typename RealType >

GEOMETRYCORE_API bool UE::Geometry::IsInside	(	const TSphere3< RealType > &	OuterSphere,
		const TOrientedBox3< RealType > &	InnerBox
	)

Returns: true if InnerBox is fully contained within OuterSphere

◆ IsInside() [31/39]

template<typename RealType >

GEOMETRYCORE_API bool UE::Geometry::IsInside	(	const TSphere3< RealType > &	OuterSphere,
		const TSphere3< RealType > &	InnerSphere
	)

Returns: true if InnerSphere is fully contained within OuterSphere

◆ IsInside() [32/39]

template<typename RealType , typename GridType >

bool UE::Geometry::IsInside	(	const TSphere3< RealType > &	OuterSphere,
		const TTriLinearGridInterpolant< GridType > &	InnerGrid
	)

Returns: true if the AABB of InnerGrid is completely inside OuterSphere

◆ IsInside() [33/39]

template<typename RealType , typename EnumerablePointsType , typename E = decltype(DeclVal<EnumerablePointsType>().begin())>

bool UE::Geometry::IsInside	(	const TSphere3< RealType > &	OuterSphere,
		EnumerablePointsType	EnumerablePts
	)

Returns: true if all all points in range-based for over EnumerablePts are inside OuterSphere

◆ IsInside() [34/39]

template<typename RealType , typename GridType >

bool UE::Geometry::IsInside	(	const TTriLinearGridInterpolant< GridType > &	OuterGrid,
		const TTransform< RealType > &	OuterGridTransform,
		const TCapsule3< RealType > &	InnerCapsule
	)

Test if the axis-aligned bounding box of InnerCapsule is completely inside the negative region of the signed distance field discretized on OuterGrid

◆ IsInside() [35/39]

template<typename RealType , typename GridType >

bool UE::Geometry::IsInside	(	const TTriLinearGridInterpolant< GridType > &	OuterGrid,
		const TTransform< RealType > &	OuterGridTransform,
		const TOrientedBox3< RealType > &	InnerBox
	)

Test if the axis-aligned bounding box of InnerBox is completely inside the negative region of the signed distance field discretized on OuterGrid

◆ IsInside() [36/39]

template<typename RealType , typename GridType >

bool UE::Geometry::IsInside	(	const TTriLinearGridInterpolant< GridType > &	OuterGrid,
		const TTransform< RealType > &	OuterGridTransform,
		const TSphere3< RealType > &	InnerSphere
	)

Test if the axis-aligned bounding box of InnerSphere is completely inside the negative region of the signed distance field discretized on OuterGrid

◆ IsInside() [37/39]

template<typename RealType , typename GridType , typename EnumerablePointsType , typename E = decltype(DeclVal<EnumerablePointsType>().begin())>

bool UE::Geometry::IsInside	(	const TTriLinearGridInterpolant< GridType > &	OuterGrid,
		const TTransform< RealType > &	OuterGridTransform,
		EnumerablePointsType	EnumerablePts
	)

Test if all enumerable points are inside the negative region of the signed distance field discretized on OuterGrid

◆ IsInside() [38/39]

template<typename RealType , typename GridType >

bool UE::Geometry::IsInside	(	const TTriLinearGridInterpolant< GridType > &	OuterGrid,
		const UE::Geometry::TAxisAlignedBox3< RealType > &	InnerAABB
	)

◆ IsInside() [39/39]

template<typename RealType , typename GridType1 , typename GridType2 >

bool UE::Geometry::IsInside	(	const TTriLinearGridInterpolant< GridType1 > &	OuterGrid,
		const TTransform< RealType > &	OuterGridTransform,
		const TTriLinearGridInterpolant< GridType2 > &	InnerGrid,
		const TTransform< RealType > &	InnerGridTransform
	)

Test if the axis-aligned bounding box of InnerGrid is completely inside the negative region of the signed distance field discretized on OuterGrid

◆ IsInsideHull() [1/5]

template<typename RealType >

bool UE::Geometry::IsInsideHull	(	TArrayView< THalfspace3< RealType > >	Halfspaces,
		const TCapsule3< RealType > &	InnerCapsule
	)

Test if the convex volume defined by a set of Halfspaces contains InnerCapsule. Each Halfspace normal should point "outwards", ie it defines the outer halfspace that is not inside the Convex Volume.

Returns: false if InnerCapsule intersects any of the Halfspaces

◆ IsInsideHull() [2/5]

template<typename RealType >

bool UE::Geometry::IsInsideHull	(	TArrayView< THalfspace3< RealType > >	Halfspaces,
		const TOrientedBox3< RealType > &	InnerBox
	)

Test if the convex volume defined by a set of Halfspaces contains InnerBox. Each Halfspace normal should point "outwards", ie it defines the outer halfspace that is not inside the Convex Volume.

Returns: false if InnerBox intersects any of the Halfspaces

◆ IsInsideHull() [3/5]

template<typename RealType >

bool UE::Geometry::IsInsideHull	(	TArrayView< THalfspace3< RealType > >	Halfspaces,
		const TSphere3< RealType > &	InnerSphere
	)

Test if the convex volume defined by a set of Halfspaces contains InnerSphere. Each Halfspace normal should point "outwards", ie it defines the outer halfspace that is not inside the Convex Volume.

Returns: false if InnerSphere intersects any of the Halfspaces

◆ IsInsideHull() [4/5]

template<typename RealType , typename GridType >

bool UE::Geometry::IsInsideHull	(	TArrayView< THalfspace3< RealType > >	Halfspaces,
		const TTriLinearGridInterpolant< GridType > &	InnerGrid
	)

◆ IsInsideHull() [5/5]

template<typename RealType , typename EnumerablePointsType , typename E = decltype(DeclVal<EnumerablePointsType>().begin())>

bool UE::Geometry::IsInsideHull	(	TArrayView< THalfspace3< RealType > >	Halfspaces,
		EnumerablePointsType	EnumerablePts
	)

Test if the convex volume defined by a set of Halfspaces contains InnerSphere. Each Halfspace normal should point "outwards", ie it defines the outer halfspace that is not inside the Convex Volume.

Returns: false any of the Halfspaces contain any of the Points

◆ IsNormalized() [1/2]

template<typename T >

constexpr bool UE::Geometry::IsNormalized	(	const UE::Math::TVector2< T > &	Vector,
		const T	Tolerance = `TMathUtil<T>::ZeroTolerance`
	)

constexpr

◆ IsNormalized() [2/2]

template<typename T >

constexpr bool UE::Geometry::IsNormalized	(	const UE::Math::TVector< T > &	Vector,
		const T	Tolerance = `TMathUtil<T>::ZeroTolerance`
	)

constexpr

◆ IteratorDistance() [1/2]

template<typename IterT >

int64 UE::Geometry::IteratorDistance	(	IterT	Begin,
		IterT	End
	)

◆ IteratorDistance() [2/2]

template<typename ContainerType , typename ElementType , typename SizeType >

int64 UE::Geometry::IteratorDistance	(	TIndexedContainerIterator< ContainerType, ElementType, SizeType >	Begin,
		TIndexedContainerIterator< ContainerType, ElementType, SizeType >	End
	)

◆ Length()

template<typename T >

T UE::Geometry::Length ( const UE::Math::TVector< T > & V )

◆ Lerp() [1/4]

template<typename T >

TFrame3< T > UE::Geometry::Lerp	(	const TFrame3< T > &	A,
		const TFrame3< T > &	B,
		T	Alpha
	)

◆ Lerp() [2/4]

template<typename T >

UE::Math::TVector2< T > UE::Geometry::Lerp	(	const UE::Math::TVector2< T > &	A,
		const UE::Math::TVector2< T > &	B,
		T	Alpha
	)

◆ Lerp() [3/4]

template<typename T >

UE::Math::TVector4< T > UE::Geometry::Lerp	(	const UE::Math::TVector4< T > &	A,
		const UE::Math::TVector4< T > &	B,
		T	Alpha
	)

◆ Lerp() [4/4]

template<typename T >

UE::Math::TVector< T > UE::Geometry::Lerp	(	const UE::Math::TVector< T > &	A,
		const UE::Math::TVector< T > &	B,
		T	Alpha
	)

◆ MakeBoundaryEdgeMidpointsAdapter()

FPointSetAdapterd UE::Geometry::MakeBoundaryEdgeMidpointsAdapter ( const FDynamicMesh3 * Mesh )

Returns: Mesh boundary edge midpoints as a point set

◆ MakeDynamicMeshAdapter()

FTriangleMeshAdapterd UE::Geometry::MakeDynamicMeshAdapter ( const FDynamicMesh3 * Mesh )

Returns: 1:1 adapter of a FDynamicMesh; can be used as a starting point to create other adapters

◆ MakeEdgeMidpointsAdapter()

FPointSetAdapterd UE::Geometry::MakeEdgeMidpointsAdapter ( const FDynamicMesh3 * Mesh )

Returns: mesh edge midpoints as a point set

◆ MakePointsAdapter()

FPointSetAdapterd UE::Geometry::MakePointsAdapter ( const FDynamicPointSet3d * PointSet )

Returns: PointSet points as a point set

◆ MakeTransformedDynamicMeshAdapter()

FTriangleMeshAdapterd UE::Geometry::MakeTransformedDynamicMeshAdapter	(	const FDynamicMesh3 *	Mesh,
		FTransform3d	Transform
	)

Returns: Transformed adapter of a FDynamicMesh

◆ MakeTriCentroidsAdapter()

FPointSetAdapterd UE::Geometry::MakeTriCentroidsAdapter ( const FDynamicMesh3 * Mesh )

Returns: Mesh triangle centroids as a point set

◆ MakeUnitVector3()

template<typename T >

constexpr UE::Math::TVector< T > UE::Geometry::MakeUnitVector3 ( int32 Axis )

constexpr

Returns: unit vector along axis X=0, Y=1, Z=2

◆ MakeVerticesAdapter()

FPointSetAdapterd UE::Geometry::MakeVerticesAdapter ( const FDynamicMesh3 * Mesh )

Returns: Mesh vertices as a point set

◆ Max() [1/2]

FVector3i UE::Geometry::Max	(	const FVector3i &	V0,
		const FVector3i &	V1
	)

inline

◆ Max() [2/2]

template<typename T >

constexpr UE::Math::TVector< T > UE::Geometry::Max	(	const UE::Math::TVector< T > &	V0,
		const UE::Math::TVector< T > &	V1
	)

constexpr

◆ MaxAbsElement()

template<typename T >

constexpr T UE::Geometry::MaxAbsElement ( const UE::Math::TVector< T > & Vector )

constexpr

◆ MaxAbsElementIndex()

template<typename T >

constexpr int32 UE::Geometry::MaxAbsElementIndex ( const UE::Math::TVector< T > & Vector )

constexpr

Returns: 0/1/2 index of maximum absolute-value element

◆ MaxElement()

template<typename T >

constexpr T UE::Geometry::MaxElement ( const UE::Math::TVector< T > & Vector )

constexpr

◆ MaxElementIndex()

template<typename T >

constexpr int32 UE::Geometry::MaxElementIndex ( const UE::Math::TVector< T > & Vector )

constexpr

Returns: 0/1/2 index of maximum element

◆ Min() [1/2]

FVector3i UE::Geometry::Min	(	const FVector3i &	V0,
		const FVector3i &	V1
	)

inline

◆ Min() [2/2]

template<typename T >

constexpr UE::Math::TVector< T > UE::Geometry::Min	(	const UE::Math::TVector< T > &	V0,
		const UE::Math::TVector< T > &	V1
	)

constexpr

◆ MinAbsElement()

template<typename T >

constexpr T UE::Geometry::MinAbsElement ( const UE::Math::TVector< T > & Vector )

constexpr

◆ MinAbsElementIndex()

template<typename T >

constexpr int32 UE::Geometry::MinAbsElementIndex ( const UE::Math::TVector< T > & Vector )

constexpr

Returns: 0/1/2 index of minimum absolute-value element

◆ MinElement()

template<typename T >

constexpr T UE::Geometry::MinElement ( const UE::Math::TVector< T > & Vector )

constexpr

◆ MinElementIndex()

template<typename T >

constexpr int32 UE::Geometry::MinElementIndex ( const UE::Math::TVector< T > & Vector )

constexpr

Returns: 0/1/2 index of minimum element

◆ Normalize() [1/2]

template<typename T >

T UE::Geometry::Normalize	(	UE::Math::TVector2< T > &	Vector,
		const T	Epsilon = `0`
	)

◆ Normalize() [2/2]

template<typename T >

T UE::Geometry::Normalize	(	UE::Math::TVector< T > &	Vector,
		const T	Epsilon = `0`
	)

◆ Normalized() [1/2]

template<typename T >

UE::Math::TVector2< T > UE::Geometry::Normalized	(	const UE::Math::TVector2< T > &	Vector,
		const T	Epsilon = `0`
	)

◆ Normalized() [2/2]

template<typename T >

constexpr UE::Math::TVector< T > UE::Geometry::Normalized	(	const UE::Math::TVector< T > &	Vector,
		const T	Epsilon = `0`
	)

constexpr

◆ operator*() [1/8]

template<typename RealType >

TQuaternion< RealType > UE::Geometry::operator*	(	const TQuaternion< RealType > &	A,
		const TQuaternion< RealType > &	B
	)

◆ operator*() [2/8]

template<typename RealType >

TVector< RealType > UE::Geometry::operator*	(	const TQuaternion< RealType > &	Q,
		const UE::Math::TVector< RealType > &	V
	)

◆ operator*() [3/8]

template<typename RealType >

TQuaternion< RealType > UE::Geometry::operator*	(	const TQuaternion< RealType > &	Q,
		RealType	Scalar
	)

◆ operator*() [4/8]

FVector2i UE::Geometry::operator*	(	int32	Scalar,
		const FVector2i &	V
	)

inline

◆ operator*() [5/8]

FVector3i UE::Geometry::operator*	(	int32	Scalar,
		const FVector3i &	V
	)

inline

◆ operator*() [6/8]

template<typename RealType >

TQuaternion< RealType > UE::Geometry::operator*	(	RealType	Scalar,
		const TQuaternion< RealType > &	Q
	)

◆ operator*() [7/8]

template<typename RealType >

TMatrix2< RealType > UE::Geometry::operator*	(	RealType	Scale,
		const TMatrix2< RealType > &	Mat
	)

inline

◆ operator*() [8/8]

template<typename RealType >

TMatrix3< RealType > UE::Geometry::operator*	(	RealType	Scale,
		const TMatrix3< RealType > &	Mat
	)

inline

◆ operator+()

template<typename RealType >

TQuaternion< RealType > UE::Geometry::operator+	(	const TQuaternion< RealType > &	A,
		const TQuaternion< RealType > &	B
	)

◆ operator-()

template<typename RealType >

TQuaternion< RealType > UE::Geometry::operator-	(	const TQuaternion< RealType > &	A,
		const TQuaternion< RealType > &	B
	)

◆ operator<<() [1/3]

std::ostream & UE::Geometry::operator<<	(	std::ostream &	os,
		const FVector2i &	Vec
	)

inline

◆ operator<<() [2/3]

std::ostream & UE::Geometry::operator<<	(	std::ostream &	os,
		const FVector3i &	Vec
	)

inline

◆ operator<<() [3/3]

template<typename RealType >

std::ostream & UE::Geometry::operator<<	(	std::ostream &	os,
		const UE::Math::TVector< RealType > &	Vec
	)

◆ OptimizeOrientedBox3Points() [1/4]

template TOrientedBox3< double > GEOMETRYCORE_API UE::Geometry::OptimizeOrientedBox3Points	(	const TOrientedBox3< double > &	InitialBox,
		int32	NumIterations,
		int32	NumPoints,
		TFunctionRef< TVector< double >(int32)>	GetPointFunc,
		TFunctionRef< bool(int32)>	Filter,
		EBox3FitCriteria	FitMethod,
		FProgressCancel *	ProgressCancel
	)

◆ OptimizeOrientedBox3Points() [2/4]

template TOrientedBox3< float > GEOMETRYCORE_API UE::Geometry::OptimizeOrientedBox3Points	(	const TOrientedBox3< float > &	InitialBox,
		int32	NumIterations,
		int32	NumPoints,
		TFunctionRef< TVector< float >(int32)>	GetPointFunc,
		TFunctionRef< bool(int32)>	Filter,
		EBox3FitCriteria	FitMethod,
		FProgressCancel *	ProgressCancel
	)

◆ OptimizeOrientedBox3Points() [3/4]

template<typename RealType >

TOrientedBox3< RealType > UE::Geometry::OptimizeOrientedBox3Points	(	const TOrientedBox3< RealType > &	InitialBox,
		int32	NumIterations,
		int32	NumPoints,
		TFunctionRef< TVector< RealType >(int32)>	GetPointFunc,
		TFunctionRef< bool(int32)>	Filter,
		EBox3FitCriteria	FitMethod = `EBox3FitCriteria::Volume`,
		FProgressCancel *	ProgressCancel = `nullptr`
	)

Improve an oriented bounding box fit iteratively

Parameters

InitialBox	An initial guess at an oriented bounding box fitting the points
NumIterations	How many passes to take to improve the bounding
NumPoints	Number of points to consider
GetPointFunc	Function providing array-style access into points
Filter	Optional filter to include only a subset of the points in the output hull
FitMethod	What criteria to optimize

Returns: A best-fit TOrientedBox3 that contains the points

◆ OptimizeOrientedBox3Points() [4/4]

template<typename RealType >

TOrientedBox3< RealType > GEOMETRYCORE_API UE::Geometry::OptimizeOrientedBox3Points	(	const TOrientedBox3< RealType > &	InitialBox,
		int32	NumIterations,
		int32	NumPoints,
		TFunctionRef< TVector< RealType >(int32)>	GetPointFunc,
		TFunctionRef< bool(int32)>	Filter,
		EBox3FitCriteria	FitMethod = `EBox3FitCriteria::Volume`,
		FProgressCancel *	ProgressCancel = `nullptr`
	)

Improve an oriented bounding box fit iteratively

Parameters

InitialBox	An initial guess at an oriented bounding box fitting the points
NumIterations	How many passes to take to improve the bounding
NumPoints	Number of points to consider
GetPointFunc	Function providing array-style access into points
Filter	Optional filter to include only a subset of the points in the output hull
FitMethod	What criteria to optimize

Returns: A best-fit TOrientedBox3 that contains the points

◆ Orient()

template<typename T >

T UE::Geometry::Orient	(	const UE::Math::TVector2< T > &	A,
		const UE::Math::TVector2< T > &	B,
		const UE::Math::TVector2< T > &	C
	)

Returns: > 0 if C is to the left of the line from A to B, < 0 if to the right, 0 if on the line

◆ Orientation()

template<typename RealType >

int UE::Geometry::Orientation	(	RealType	X1,
		RealType	Y1,
		RealType	X2,
		RealType	Y2,
		RealType &	TwiceSignedArea
	)

◆ ParallelTransformReduce() [1/4]

template<typename IntType , typename T , typename TransformFuncT , typename ReduceFuncT >

T UE::Geometry::ParallelTransformReduce	(	IntType	Num,
		const T &	Init,
		TransformFuncT	Transform,
		ReduceFuncT	Reduce,
		int64	InNumTasks
	)

◆ ParallelTransformReduce() [2/4]

template<typename IntType , typename T , typename InitFuncT , typename TransformFuncT , typename ReduceFuncT >

void UE::Geometry::ParallelTransformReduce	(	IntType	Num,
		InitFuncT	InitFunc,
		TransformFuncT	Transform,
		ReduceFuncT	Reduce,
		T &	Out,
		int64	InNumTasks
	)

◆ ParallelTransformReduce() [3/4]

template<typename T , typename IterT , typename TransformFuncT , typename ReduceFuncT >

T UE::Geometry::ParallelTransformReduce	(	IterT	BeginIterator,
		IterT	EndIterator,
		const T &	Init,
		TransformFuncT	Transform,
		ReduceFuncT	Reduce,
		int64	InNumTasks
	)

◆ ParallelTransformReduce() [4/4]

template<typename T , typename IterT , typename InitFuncT , typename TransformFuncT , typename ReduceFuncT >

void UE::Geometry::ParallelTransformReduce	(	IterT	BeginIterator,
		IterT	EndIterator,
		InitFuncT	InitFunc,
		TransformFuncT	Transform,
		ReduceFuncT	Reduce,
		T &	Out,
		int64	InNumTasks
	)

◆ PerpCW()

template<typename T >

constexpr UE::Math::TVector2< T > UE::Geometry::PerpCW ( const UE::Math::TVector2< T > & V )

constexpr

Returns: right-Perpendicular vector to V, ie V rotated 90 degrees clockwise

◆ PointInTriangle2d()

bool UE::Geometry::PointInTriangle2d	(	double	X0,
		double	Y0,
		double	X1,
		double	Y1,
		double	X2,
		double	Y2,
		double	X3,
		double	Y3,
		double &	A,
		double &	B,
		double &	C
	)

◆ PointOnLine()

template<typename RealType >

EPointOrdering UE::Geometry::PointOnLine	(	const TVector2< RealType > &	P,
		const TVector2< RealType > &	L0,
		const TVector2< RealType > &	L1
	)

◆ PointSegmentDistance()

template<typename RealType >

RealType UE::Geometry::PointSegmentDistance	(	const TVector< RealType > &	x0,
		const TVector< RealType > &	x1,
		const TVector< RealType > &	x2
	)

◆ PointTriangleDistance() [1/2]

double UE::Geometry::PointTriangleDistance	(	const FVector3d &	x0,
		const FVector3d &	x1,
		const FVector3d &	x2,
		const FVector3d &	x3
	)

◆ PointTriangleDistance() [2/2]

float UE::Geometry::PointTriangleDistance	(	const FVector3f &	x0,
		const FVector3f &	x1,
		const FVector3f &	x2,
		const FVector3f &	x3
	)

◆ SignedAngleR()

template<typename T >

T UE::Geometry::SignedAngleR	(	const UE::Math::TVector2< T > &	V1,
		const UE::Math::TVector2< T > &	V2
	)

◆ SnapToIncrement()

template<typename RealType >

RealType UE::Geometry::SnapToIncrement	(	RealType	Value,
		RealType	Increment,
		RealType	Offset = `0`
	)

Snap Value to steps of Increment (centered at 0, ie steps are -Increment, 0, Increment, 2*Increment, ...). Optional Offset can be used to snap relative value.

◆ SplitBoundaryVertexTrianglesIntoSubsets()

bool UE::Geometry::SplitBoundaryVertexTrianglesIntoSubsets	(	const FDynamicMesh3 *	Mesh,
		int32	VertexID,
		int32	SplitEdgeID,
		TArray< int32 > &	TriangleSet0,
		TArray< int32 > &	TriangleSet1
	)

Split the triangle one-ring at VertexID into two triangle sets by "cutting" it with edge SplitEdgeID that is connected to VertexID. VertexID must be a boundary-vertex of the mesh, otherwise one edge is not enough to "split" it. Bowtie vertices are not supported.

Returns: false if the split failed, ie the inputs are invalid or one of the output sets is empty

◆ SplitInteriorVertexTrianglesIntoSubsets()

bool UE::Geometry::SplitInteriorVertexTrianglesIntoSubsets	(	const FDynamicMesh3 *	Mesh,
		int32	VertexID,
		int32	SplitEdgeID0,
		int32	SplitEdgeID1,
		TArray< int32 > &	TriangleSet0,
		TArray< int32 > &	TriangleSet1
	)

Split the triangle one-ring at VertexID into two triangle sets by "cutting" it with two edges SplitEdgeID0 and SplitEdgeID1 that are both connected to VertexID. VertexID must be an "interior" vertex of the mesh (ie not on boundary). Bowtie vertices are not supported.

Returns: false if the split failed, ie the inputs are invalid or one of the output sets is empty

◆ SquaredDistanceFromLineIntegratedAlongSegment()

template<typename Real >

double UE::Geometry::SquaredDistanceFromLineIntegratedAlongSegment	(	const TLine3< Real > &	Line,
		const TSegment3< Real > &	Segment
	)

Integrates the squared distance to a line along a given segment.

◆ SquaredLength()

template<typename T >

T UE::Geometry::SquaredLength ( const UE::Math::TVector< T > & V )

◆ TestIntersection() [1/12]

template bool GEOMETRYCORE_API UE::Geometry::TestIntersection	(	const THalfspace3< double > &	Halfspace,
		const TCapsule3< double > &	InnerSphere
	)

◆ TestIntersection() [2/12]

template bool GEOMETRYCORE_API UE::Geometry::TestIntersection	(	const THalfspace3< double > &	Halfspace,
		const TOrientedBox3< double > &	InnerSphere
	)

◆ TestIntersection() [3/12]

template bool GEOMETRYCORE_API UE::Geometry::TestIntersection	(	const THalfspace3< double > &	Halfspace,
		const TSphere3< double > &	InnerSphere
	)

◆ TestIntersection() [4/12]

template bool GEOMETRYCORE_API UE::Geometry::TestIntersection	(	const THalfspace3< float > &	Halfspace,
		const TCapsule3< float > &	InnerSphere
	)

◆ TestIntersection() [5/12]

template bool GEOMETRYCORE_API UE::Geometry::TestIntersection	(	const THalfspace3< float > &	Halfspace,
		const TOrientedBox3< float > &	InnerSphere
	)

◆ TestIntersection() [6/12]

template bool GEOMETRYCORE_API UE::Geometry::TestIntersection	(	const THalfspace3< float > &	Halfspace,
		const TSphere3< float > &	InnerSphere
	)

◆ TestIntersection() [7/12]

template<typename RealType >

GEOMETRYCORE_API bool UE::Geometry::TestIntersection	(	const THalfspace3< RealType > &	Halfspace,
		const TCapsule3< RealType > &	Capsule
	)

Returns: true if Halfspace and Capsule intersect

◆ TestIntersection() [8/12]

template<typename RealType >

GEOMETRYCORE_API bool UE::Geometry::TestIntersection	(	const THalfspace3< RealType > &	Halfspace,
		const TOrientedBox3< RealType > &	Box
	)

Returns: true if Halfspace and Box intersect

◆ TestIntersection() [9/12]

template<typename RealType >

GEOMETRYCORE_API bool UE::Geometry::TestIntersection	(	const THalfspace3< RealType > &	Halfspace,
		const TSphere3< RealType > &	Sphere
	)

Returns: true if Halfspace and Sphere intersect

◆ TestIntersection() [10/12]

template bool GEOMETRYCORE_API UE::Geometry::TestIntersection	(	const TSegment2< double > &	Segment,
		const TAxisAlignedBox2< double > &	Box
	)

◆ TestIntersection() [11/12]

template bool GEOMETRYCORE_API UE::Geometry::TestIntersection	(	const TSegment2< float > &	Segment,
		const TAxisAlignedBox2< float > &	Box
	)

◆ TestIntersection() [12/12]

template<typename Real >

GEOMETRYCORE_API bool UE::Geometry::TestIntersection	(	const TSegment2< Real > &	Segment,
		const TAxisAlignedBox2< Real > &	Box
	)

◆ ToFColor()

template<typename T >

constexpr FColor UE::Geometry::ToFColor ( const UE::Math::TVector4< T > & Vector )

constexpr

◆ ToLinearColor() [1/2]

template<typename T >

FLinearColor UE::Geometry::ToLinearColor ( const UE::Math::TVector4< T > & V )

◆ ToLinearColor() [2/2]

template<typename T >

constexpr FLinearColor UE::Geometry::ToLinearColor ( const UE::Math::TVector< T > & Vector )

constexpr

◆ ToVector4()

template<typename T >

UE::Math::TVector4< T > UE::Geometry::ToVector4 ( const FLinearColor & Color )

◆ TrianglesToOverlayElements()

template<typename OverlayType , typename EnumeratorType , typename OutputSetType >

void UE::Geometry::TrianglesToOverlayElements	(	const OverlayType *	Overlay,
		EnumeratorType	TriangleEnumeration,
		OutputSetType &	ElementsOut
	)

For a given list/enumeration of Triangles, and an Overlay, find all the Elements in all the Triangles. Note that if ElementsOut is a TArray, it may include an Element multiple times.

Parameters