code: template<typename RealType2> TQuaternion ( const [TQuaternion](API\Runtime\GeometryCore\TQuaternion)< RealType2 > & Copy )


module: GeometryCore

code: TQuaternion ( const [TVector](API\Runtime\Core\Math\TVector)< RealType > & Axis, RealType Angle, bool bAngleIsDegrees )


code: TQuaternion ( const [TMatrix3](API\Runtime\GeometryCore\TMatrix3)< RealType > & RotationMatrix )


code: TQuaternion ( const FQuat4d & Quat )


code: TQuaternion ( const FQuat4f & Quat )


code: TQuaternion ( const FRotator & Rotator )


className: TQuaternion

code: template<typename RealType> struct TQuaternion

type: union UE::Geome...

W

type: RealType

X

description: Note: in Wm5 version, this is a 4-element arraY stored in order (w,x,y,z).


code: TQuaternion ( const [TVector](API\Runtime\Core\Math\TVector)< RealType > & From, const [TVector](API\Runtime\Core\Math\TVector)< RealType > & To )


description: minimum squared distance from Point to Segment

code: T DistanceSquared ( const [TVector2](API\Runtime\Core\Math\TVector2)< T > & Point, T & DistParameterOut ) const


description: minimum squared distance from Point to segment

code: T DistanceSquared ( const [TVector2](API\Runtime\Core\Math\TVector2)< T > & Point ) const


description: end point of segment

code: [TVector2](API\Runtime\Core\Math\TVector2)< T > EndPoint() const


description: Calculate distance from QueryPoint to segment (StartPt,EndPt)

code: static T FastDistanceSquared ( const [TVector2](API\Runtime\Core\Math\TVector2)< T > & StartPt, const [TVector2](API\Runtime\Core\Math\TVector2)< T > & EndPt, const [TVector2](API\Runtime\Core\Math\TVector2)< T > & QueryPt, T Tolerance )


description: first (i == 0) or second (i == 1) endpoint of the Segment

code: [TVector2](API\Runtime\Core\Math\TVector2)< T > GetPointFromIndex ( int i ) const


description: nearest point on segment to QueryPoint

code: [TVector2](API\Runtime\Core\Math\TVector2)< T > NearestPoint ( const [TVector2](API\Runtime\Core\Math\TVector2)< T > & QueryPoint ) const


description: the Length of the segment

code: T Length() const


description:
Test if this segment intersects with OtherSegment. Returns true for parallel-line overlaps. Returns same result as IntrSegment2Segment2
true if segments intersect

code: bool Intersects ( const [TSegment2](API\Runtime\GeometryCore\TSegment2)< T > & OtherSegment, T DotThresh, T IntervalThresh ) const


description: point on segment at given (signed) Distance from the segment Origin

code: [TVector2](API\Runtime\Core\Math\TVector2)< T > PointAt ( T DistanceParameter ) const


description: scalar projection of QueryPoint onto line of Segment (not clamped to Extents)

code: T Project ( const [TVector2](API\Runtime\Core\Math\TVector2)< T > & QueryPoint ) const


description: point on segment at that linearly interpolates between start and end based on Unit Parameter

code: [TVector2](API\Runtime\Core\Math\TVector2)< T > PointBetween ( T UnitParameter ) const


description: scalar projection of QueryPoint onto line of Segment, mapped to [0,1] range along segment

code: T ProjectUnitRange ( const [TVector2](API\Runtime\Core\Math\TVector2)< T > & QueryPoint ) const


description: Reverse the segment

code: void Reverse()


description: Update the Segment with a new end point

code: void SetEndPoint ( const [TVector2](API\Runtime\Core\Math\TVector2)< T > & Point )


description: Update the Segment with a new start point

code: void SetStartPoint ( const [TVector2](API\Runtime\Core\Math\TVector2)< T > & Point )


description: start point of segment

code: [TVector2](API\Runtime\Core\Math\TVector2)< T > StartPoint() const


description: Update segment based on new endpoints

code: void update_from_endpoints ( const [TVector2](API\Runtime\Core\Math\TVector2)< T > & p0, const [TVector2](API\Runtime\Core\Math\TVector2)< T > & p1 )


description:
Determine which side of the segment the query point lies on
+1 if point is to right of line, -1 if left, and 0 if on line or within tolerance band

code: int WhichSide ( const [TVector2](API\Runtime\Core\Math\TVector2)< T > & QueryPoint, T Tolerance )


code: static int WhichSide ( const [TVector2](API\Runtime\Core\Math\TVector2)< T > & StartPt, const [TVector2](API\Runtime\Core\Math\TVector2)< T > & EndPt, const [TVector2](API\Runtime\Core\Math\TVector2)< T > & QueryPt, T Tolerance )


description: 2D Line Segment stored as Center point, normalized Direction vector, and scalar Extent

code: template<typename T> struct TSegment2

Center

type: TVector2< T >

description: Center point of segment

Direction

description: Normalized Direction vector of segment

Extent

type: T

description: Extent of segment, which is half the total length


description: Construct a Segment from two Points

code: TSegment2 ( const [TVector2](API\Runtime\Core\Math\TVector2)< T > & Point0, const [TVector2](API\Runtime\Core\Math\TVector2)< T > & Point1 )


description: Construct a segment from a Center Point, normalized Direction, and scalar Extent

code: TSegment2 ( const [TVector2](API\Runtime\Core\Math\TVector2)< T > & CenterIn, const [TVector2](API\Runtime\Core\Math\TVector2)< T > & DirectionIn, T ExtentIn )


code: T DistanceSquared ( const [TVector](API\Runtime\Core\Math\TVector)< T > & Point ) const


code: T DistanceSquared ( const [TVector](API\Runtime\Core\Math\TVector)< T > & Point, T & DistParameterOut ) const


description: end point of segment

code: [TVector](API\Runtime\Core\Math\TVector)< T > EndPoint() const


description: axis-aligned bounding box of line segment thickened to given SegmentRadius

code: [TAxisAlignedBox3](API\Runtime\GeometryCore\TAxisAlignedBox3)< T > GetBounds ( T SegmentRadius ) const


description: axis-aligned bounding box of line segment

code: [TAxisAlignedBox3](API\Runtime\GeometryCore\TAxisAlignedBox3)< T > GetBounds() const


code: [TVector](API\Runtime\Core\Math\TVector)< T > GetPointFromIndex ( int i ) const


description: the Length of the segment

code: T Length() const


code: [TVector](API\Runtime\Core\Math\TVector)< T > PointAt ( T DistanceParameter ) const


description: nearest point on segment to QueryPoint

code: [TVector](API\Runtime\Core\Math\TVector)< T > NearestPoint ( const [TVector](API\Runtime\Core\Math\TVector)< T > & QueryPoint ) const


code: [TVector](API\Runtime\Core\Math\TVector)< T > PointBetween ( T UnitParameter ) const


code: T ProjectUnitRange ( const [TVector](API\Runtime\Core\Math\TVector)< T > & QueryPoint ) const


code: T Project ( const [TVector](API\Runtime\Core\Math\TVector)< T > & QueryPoint ) const


description: Reverse the segment

code: void Reverse()


code: void SetStartPoint ( const [TVector](API\Runtime\Core\Math\TVector)< T > & Point )


description: Update the Segment with a new end point

code: void SetEndPoint ( const [TVector](API\Runtime\Core\Math\TVector)< T > & Point )


description: start point of segment

code: [TVector](API\Runtime\Core\Math\TVector)< T > StartPoint() const


description: Update segment based on new endpoints

code: void update_from_endpoints ( const [TVector](API\Runtime\Core\Math\TVector)< T > & p0, const [TVector](API\Runtime\Core\Math\TVector)< T > & p1 )


description: Construct a Segment from two Points

code: TSegment3 ( const [TVector](API\Runtime\Core\Math\TVector)< T > & Point0, const [TVector](API\Runtime\Core\Math\TVector)< T > & Point1 )


code: TSegment3 ( const [TVector](API\Runtime\Core\Math\TVector)< T > & CenterIn, const [TVector](API\Runtime\Core\Math\TVector)< T > & DirectionIn, T ExtentIn )


description: 3D Line Segment stored as Center point, normalized Direction vector, and scalar Extent

code: template<typename T> struct TSegment3

Center

type: TVector< T >

description: Center point of segment

Direction

description: Normalized Direction vector of segment


description: Area of sphere

code: T Area() const


description:
Sphere utility functions
Area of sphere with given Radius

code: static T Area ( T Radius )


description: Circumference of sphere

code: T Circumference() const


description: true if Sphere contains given OtherSphere

code: bool Contains ( const [TSphere3](API\Runtime\GeometryCore\TSphere3)< T > & OtherSphere ) const


description: true if Sphere contains given Point

code: bool Contains ( const [TVector](API\Runtime\Core\Math\TVector)< T > & Point ) const


description: minimum squared distance from Point to Sphere surface for points outside sphere, 0 for points inside

code: T DistanceSquared ( const [TVector](API\Runtime\Core\Math\TVector)< T > & Point ) const


description: signed distance from Point to Sphere surface. Points inside sphere return negative distance.

code: T SignedDistance ( const [TVector](API\Runtime\Core\Math\TVector)< T > & Point ) const


description: Volume of sphere

code: T Volume() const


description: Volume of sphere with given Radius

code: static T Volume ( T Radius )


code: TSphere3 ( const [TVector](API\Runtime\Core\Math\TVector)< T > & CenterIn, T RadiusIn )


description: 3D Sphere stored as Center point and Radius

code: template<typename T> struct TSphere3

Center

description: Center of the sphere

Radius

description: Radius of the sphere


code: [TVector](API\Runtime\Core\Math\TVector)< RealType > BarycentricPoint ( const [TVector4](API\Runtime\Core\Math\TVector4)< RealType > & BaryCoords ) const


description: Diameter of sphere

code: T Diameter() const


code: [TVector](API\Runtime\Core\Math\TVector)< RealType > BarycentricPoint ( RealType Bary0, RealType Bary1, RealType Bary2, RealType Bary3 ) const


code: [TAxisAlignedBox3](API\Runtime\GeometryCore\TAxisAlignedBox3)< RealType > Bounds() const


description: centroid of this tetrahedron

code: [TVector](API\Runtime\Core\Math\TVector)< RealType > Centroid() const


code: template<bool bReverseOrientation> [TTriangle3](API\Runtime\GeometryCore\TTriangle3)< RealType > GetFace ( int32 Idx ) const


description: Get the ith triangular face of the tetrahedron, as indices into the four tetrahedron vertices.

code: template<bool bReverseOrientation> static [FIndex3i](API\Runtime\GeometryCore\FIndex3i) GetFaceIndices ( int32 Idx )


code: TTetrahedron3 ( const [TVector](API\Runtime\Core\Math\TVector)< RealType > & V0, const [TVector](API\Runtime\Core\Math\TVector)< RealType > & V1, const [TVector](API\Runtime\Core\Math\TVector)< RealType > & V2, const [TVector](API\Runtime\Core\Math\TVector)< RealType > & V3 )


code: TTetrahedron3 ( const [TVector](API\Runtime\Core\Math\TVector)< RealType > VIn )


description: Add Transform to the end of the sequence, ie Seq(P) becomes NewTransform * Seq(P)

code: void Append ( const [TTransformSRT3](API\Runtime\GeometryCore\TTransformSRT3)< RealType > & Transform )


code: template<typename RealType> struct TTetrahedron3

V

type: TVector< RealTy...


code: void Append ( const FTransform & Transform )


description: Add all transforms in given sequence to the end of this sequence, ie Seq(P) becomes SequenceToAppend * Seq(P)

code: void Append ( const [TTransformSequence3](API\Runtime\GeometryCore\TTransformSequence3)< RealType > & SequenceToAppend )


description: Cumulative scale across Transforms.

code: [TVector](API\Runtime\Core\Math\TVector)< RealType > GetAccumulatedScale() const


description: Set scales of all transforms to (1,1,1)

code: void ClearScales()


description: transforms in the sequence

code: const [TArray](API\Runtime\Core\Containers\TArray)< [TTransformSRT3](API\Runtime\GeometryCore\TTransformSRT3)< RealType >, TInlineAllocator< 2 > > & GetTransforms() const


description: point P with inverse transform sequence applied

code: [TVector](API\Runtime\Core\Math\TVector)< RealType > InverseTransformPosition ( [UE::Math::TVector](API\Runtime\Core\Math\TVector)< RealType > P ) const


description: true if each Transform in this sequence is equivalent to each transform of another sequence under the given test

code: template<typename TransformsEquivalentFunc> bool IsEquivalent ( const [TTransformSequence3](API\Runtime\GeometryCore\TTransformSequence3)< RealType > & OtherSeq, TransformsEquivalentFunc TransformsTest ) const


description: true if any transform in the sequence has nonuniform scaling

code: bool HasNonUniformScale ( RealType Tolerance ) const


description: number of transforms in the sequence

code: int32 Num() const


description: Normal with transform sequence applied

code: [TVector](API\Runtime\Core\Math\TVector)< RealType > TransformNormal ( [UE::Math::TVector](API\Runtime\Core\Math\TVector)< RealType > Normal ) const


description: point P with transform sequence applied

code: [TVector](API\Runtime\Core\Math\TVector)< RealType > TransformPosition ( [UE::Math::TVector](API\Runtime\Core\Math\TVector)< RealType > P ) const


description: Vector V with transform sequence applied

code: [TVector](API\Runtime\Core\Math\TVector)< RealType > TransformVector ( [UE::Math::TVector](API\Runtime\Core\Math\TVector)< RealType > V ) const


description: Whether the sequence will invert a shape (by negative scaling) when applied

code: bool WillInvert() const


description: TTransformSequence3represents a sequence of 3D transforms.

code: template<typename RealType> class TTransformSequence3

Transforms

type: TArray<TTransf...


description: Clamp all scale components to a minimum value. Sign of scale components is preserved. This is used to remove uninvertible zero/near-zero scaling.

code: void ClampMinimumScale ( RealType MinimumScale )


description: determinant of scale matrix

code: RealType GetDeterminant() const


description: Rotation portion of Transform, as FRotator

code: FRotator GetRotator() const


code: static [TVector](API\Runtime\Core\Math\TVector)< RealType > GetSafeScaleReciprocal ( const [TVector](API\Runtime\Core\Math\TVector)< RealType > & InScale, RealType Tolerance )


description: Rotation portion of Transform, as Quaternion

code: const [TQuaternion](API\Runtime\GeometryCore\TQuaternion)< RealType > & GetRotation() const


description: Scale portion of transform

code: const [TVector](API\Runtime\Core\Math\TVector)< RealType > & GetScale() const


description: Scale portion of transform

code: const [TVector](API\Runtime\Core\Math\TVector)< RealType > & GetScale3D() const


description: Translation portion of transform

code: const [TVector](API\Runtime\Core\Math\TVector)< RealType > & GetTranslation() const


description: true if scale is nonuniform, within tolerance


description: identity transform, IE no rotation, zero origin, unit scale

code: static [TTransformSRT3](API\Runtime\GeometryCore\TTransformSRT3)< RealType > Identity()


description: Attempts to return an inverse, but will give an incorrect result if the transform has both non-uniform scaling and rotation, because TTransformSRT3cannot represent the true inverse in that case.

code: [TTransformSRT3](API\Runtime\GeometryCore\TTransformSRT3)< RealType > Inverse() const


description:
Surface Normals are special, their inverse transform is InverseRotate( Normalize(Scale * Normal) ) )
input surface normal with inverse transform applied.

code: [TVector](API\Runtime\Core\Math\TVector)< RealType > InverseTransformNormal ( const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< RealType > & Normal ) const


code: template<typename RealType2, typename [TEnableIf](API\Runtime\Core\Templates\TEnableIf)< std::is_same< RealType, RealType2 >::value==false, int >::type> [TVector](API\Runtime\Core\Math\TVector)< RealType2 > InverseTransformNormal ( const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< RealType2 > & V ) const


description: input vector with inverse-QST transformation applied, ie QSTinv(P) = InverseScale(InverseRotate(P - Translate))

code: [TVector](API\Runtime\Core\Math\TVector)< RealType > InverseTransformPosition ( const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< RealType > & P ) const


code: template<typename RealType2, typename [TEnableIf](API\Runtime\Core\Templates\TEnableIf)< std::is_same< RealType, RealType2 >::value==false, int >::type> [TVector](API\Runtime\Core\Math\TVector)< RealType2 > InverseTransformPosition ( const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< RealType2 > & P ) const


code: [UE::Math::TRay](API\Runtime\Core\Math\TRay)< RealType > InverseTransformRay ( const [UE::Math::TRay](API\Runtime\Core\Math\TRay)< RealType > & Ray ) const


description: input vector with inverse-QS transformation applied, ie QSinv(V) = InverseScale(InverseRotate(V))

code: [TVector](API\Runtime\Core\Math\TVector)< RealType > InverseTransformVector ( const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< RealType > & V ) const


code: template<typename RealType2, typename [TEnableIf](API\Runtime\Core\Templates\TEnableIf)< std::is_same< RealType, RealType2 >::value==false, int >::type> [TVector](API\Runtime\Core\Math\TVector)< RealType2 > InverseTransformVector ( const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< RealType2 > & V ) const


description: input vector with inverse-Q transformation applied, ie Qinv(V) = InverseRotate(V)

code: [TVector](API\Runtime\Core\Math\TVector)< RealType > InverseTransformVectorNoScale ( const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< RealType > & V ) const


code: template<typename RealType2, typename [TEnableIf](API\Runtime\Core\Templates\TEnableIf)< std::is_same< RealType, RealType2 >::value==false, int >::type> [TVector](API\Runtime\Core\Math\TVector)< RealType2 > InverseTransformVectorNoScale ( const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< RealType2 > & V ) const


code: [TTransformSRT3](API\Runtime\GeometryCore\TTransformSRT3)< RealType > InverseUnsafe() const


description: Set Rotation portion of Transform

code: void SetRotation ( const [TQuaternion](API\Runtime\GeometryCore\TQuaternion)< RealType > & RotationIn )


className: TTransformSRT3::operator FTransform3d

description: this transform converted to FTransform3d

code: operator FTransform3d() const


className: TTransformSRT3::operator FTransform3f

description: this transform converted to FTransform

code: operator FTransform3f() const


description: Set Scale portion of transform

code: void SetScale ( const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< RealType > & ScaleIn )


description: Set Translation portion of transform

code: void SetTranslation ( const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< RealType > & TranslationIn )


code: template<typename RealType2, typename [TEnableIf](API\Runtime\Core\Templates\TEnableIf)< std::is_same< RealType, RealType2 >::value==false, int >::type> [TVector](API\Runtime\Core\Math\TVector)< RealType2 > TransformNormal ( const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< RealType2 > & V ) const


description:
Surface Normals are special, their transform is Rotate( Normalize( (1/Scale) * Normal) ) ). However 1/Scale requires special handling in case any component is near-zero.
input surface normal with transform applied.

code: [TVector](API\Runtime\Core\Math\TVector)< RealType > TransformNormal ( const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< RealType > & Normal ) const


description: input point with QST transformation applied, ie QST(P) = Rotate(Scale*P) + Translate

code: [TVector](API\Runtime\Core\Math\TVector)< RealType > TransformPosition ( const [TVector](API\Runtime\Core\Math\TVector)< RealType > & P ) const


description: Vector-type-conversion variants. This allows applying a float transform to double vector and vice-versa. Whether this should be allowed is debatable. However in practice it is extremely rare to convert an entire float transform to a double transform in order to apply to a double vector, which is the only case where this conversion is an issue

code: template<typename RealType2, typename [TEnableIf](API\Runtime\Core\Templates\TEnableIf)< std::is_same< RealType, RealType2 >::value==false, int >::type> [TVector](API\Runtime\Core\Math\TVector)< RealType2 > TransformPosition ( const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< RealType2 > & P ) const


code: [UE::Math::TRay](API\Runtime\Core\Math\TRay)< RealType > TransformRay ( const [UE::Math::TRay](API\Runtime\Core\Math\TRay)< RealType > & Ray ) const


description: input vector with QS transformation applied, ie QS(V) = Rotate(Scale*V)

code: [TVector](API\Runtime\Core\Math\TVector)< RealType > TransformVector ( const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< RealType > & V ) const


code: template<typename RealType2, typename [TEnableIf](API\Runtime\Core\Templates\TEnableIf)< std::is_same< RealType, RealType2 >::value==false, int >::type> [TVector](API\Runtime\Core\Math\TVector)< RealType2 > TransformVector ( const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< RealType2 > & V ) const


description: input vector with Q transformation applied, ie Q(V) = Rotate(V)

code: [TVector](API\Runtime\Core\Math\TVector)< RealType > TransformVectorNoScale ( const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< RealType > & V ) const


code: template<typename RealType2, typename [TEnableIf](API\Runtime\Core\Templates\TEnableIf)< std::is_same< RealType, RealType2 >::value==false, int >::type> [TVector](API\Runtime\Core\Math\TVector)< RealType2 > TransformVectorNoScale ( const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< RealType2 > & V ) const


code: TTransformSRT3 ( const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< RealType > & TranslationIn )


code: TTransformSRT3 ( const FTransform3f & Transform )


code: TTransformSRT3 ( const [TQuaternion](API\Runtime\GeometryCore\TQuaternion)< RealType > & RotationIn, const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< RealType > & TranslationIn )


code: TTransformSRT3 ( const [TQuaternion](API\Runtime\GeometryCore\TQuaternion)< RealType > & RotationIn, const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< RealType > & TranslationIn, const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< RealType > & ScaleIn )


description: Implicit constructors/casts are defined to/from FTransform3d and FTransform3f. This will likely be revised in future so that conversions that lose precision are explicit.

code: template<typename RealType> class TTransformSRT3

Rotation

type: TQuaternion< Re...


description: unsigned area of the triangle

code: RealType Area() const


code: [TVector2](API\Runtime\Core\Math\TVector2)< RealType > BarycentricPoint ( RealType Bary0, RealType Bary1, RealType Bary2 ) const


code: [TVector2](API\Runtime\Core\Math\TVector2)< RealType > BarycentricPoint ( const [TVector](API\Runtime\Core\Math\TVector)< RealType > & BaryCoords ) const


code: TTransformSRT3 ( const FTransform3d & Transform )


code: [TVector](API\Runtime\Core\Math\TVector)< RealType > GetBarycentricCoords ( const [TVector2](API\Runtime\Core\Math\TVector2)< RealType > & Point ) const


description: true if QueryPoint is inside triangle

code: bool IsInside ( const [TVector2](API\Runtime\Core\Math\TVector2)< RealType > & QueryPoint ) const


description: true if QueryPoint is inside triangle

code: static bool IsInside ( const [TVector2](API\Runtime\Core\Math\TVector2)< RealType > & A, const [TVector2](API\Runtime\Core\Math\TVector2)< RealType > & B, const [TVector2](API\Runtime\Core\Math\TVector2)< RealType > & C, const [TVector2](API\Runtime\Core\Math\TVector2)< RealType > & QueryPoint )


description: true if QueryPoint is inside triangle or on edge

code: bool IsInsideOrOn ( const [TVector2](API\Runtime\Core\Math\TVector2)< RealType > & QueryPoint, RealType Epsilon ) const


code: static bool IsInsideOrOn ( const [TVector2](API\Runtime\Core\Math\TVector2)< RealType > & A, const [TVector2](API\Runtime\Core\Math\TVector2)< RealType > & B, const [TVector2](API\Runtime\Core\Math\TVector2)< RealType > & C, const [TVector2](API\Runtime\Core\Math\TVector2)< RealType > & QueryPoint )


description:
More robust (because it doesn't multiply orientation test results) inside-triangle test for oriented triangles only (the code early-outs at the first 'outside' edge, which only works if the triangle is oriented as expected)
1 if outside, -1 if inside, 0 if on boundary

code: int IsInsideOrOn_Oriented ( const [TVector2](API\Runtime\Core\Math\TVector2)< RealType > & QueryPoint ) const


code: static int IsInsideOrOn_Oriented ( const [TVector2](API\Runtime\Core\Math\TVector2)< RealType > & A, const [TVector2](API\Runtime\Core\Math\TVector2)< RealType > & B, const [TVector2](API\Runtime\Core\Math\TVector2)< RealType > & C, const [TVector2](API\Runtime\Core\Math\TVector2)< RealType > & QueryPoint )


description: signed area of triangle

code: RealType SignedArea() const


description: signed area of triangle

code: static RealType SignedArea ( const [TVector2](API\Runtime\Core\Math\TVector2)< RealType > & A, const [TVector2](API\Runtime\Core\Math\TVector2)< RealType > & B, const [TVector2](API\Runtime\Core\Math\TVector2)< RealType > & C )


code: TTriangle2 ( const [TVector2](API\Runtime\Core\Math\TVector2)< RealType > VIn )


code: TTriangle2 ( const [TVector2](API\Runtime\Core\Math\TVector2)< RealType > & V0, const [TVector2](API\Runtime\Core\Math\TVector2)< RealType > & V1, const [TVector2](API\Runtime\Core\Math\TVector2)< RealType > & V2 )


code: [TVector](API\Runtime\Core\Math\TVector)< RealType > BarycentricPoint ( const [TVector](API\Runtime\Core\Math\TVector)< RealType > & BaryCoords ) const


code: template<typename RealType> struct TTriangle2

V

type: TVector2< RealT...


code: [TVector](API\Runtime\Core\Math\TVector)< RealType > BarycentricPoint ( RealType Bary0, RealType Bary1, RealType Bary2 ) const


description: centroid of this triangle

code: [TVector](API\Runtime\Core\Math\TVector)< RealType > Centroid() const


description: Grow the triangle around the centroid

code: void Expand ( RealType Delta )


code: [TVector](API\Runtime\Core\Math\TVector)< RealType > GetBarycentricCoords ( const [TVector](API\Runtime\Core\Math\TVector)< RealType > & Point ) const


description: vector that is perpendicular to the plane of this triangle

code: [TVector](API\Runtime\Core\Math\TVector)< RealType > Normal() const


code: TTriangle3 ( const [TVector](API\Runtime\Core\Math\TVector)< RealType > VIn )


code: TTriangle3 ( const [TVector](API\Runtime\Core\Math\TVector)< RealType > & V0, const [TVector](API\Runtime\Core\Math\TVector)< RealType > & V1, const [TVector](API\Runtime\Core\Math\TVector)< RealType > & V2 )


code: void GetTriVertices ( int TID, [UE::Math::TVector](API\Runtime\Core\Math\TVector)< RealType > & V0, [UE::Math::TVector](API\Runtime\Core\Math\TVector)< RealType > & V1, [UE::Math::TVector](API\Runtime\Core\Math\TVector)< RealType > & V2 ) const


code: template<typename RealType> struct TTriangle3


description: Area Weighted Add

code: void Add ( RealType w, const [TVolPresQuadricError](API\Runtime\GeometryCore\TVolPresQuadricError) & b )


className: TTriangleMeshAdapter

description: Most generic / lazy example of a triangle mesh adapter; possibly useful for prototyping / building on top of (but slower than making a more specific-case adapter)

code: template<typename RealType> struct TTriangleMeshAdapter

GetChangeStamp

type: TFunction< uint...

GetTriangle

type: TFunction<FInd...

GetVertex

type: TFunction<TVec...

IsTriangle

type: TFunction< bool...

MaxTriangleID

type: TFunction< int3...


className: BaseStruct

code: typedef [TQuadricError](API\Runtime\GeometryCore\TQuadricError)< RealType > BaseStruct


code: void Add &40; const FPlaneData & other &41;


description: Add scalar multiple of aFPlaneDatato thisFPlaneData

code: void Add &40; RealType w, const FPlaneData & other &41;


code: FPlaneData & operator&61; &40; const FPlaneData & other &41;


code: FPlaneData &40; const FPlaneData & other &41;


code: FPlaneData &40; const TVector< RealType > & Normal, const TVector< RealType > & Point &41;


code: FPlaneData &40; RealType w, const FPlaneData & other &41;


className: FPlaneData

code: struct FPlaneData


description: The optimal point minimizing the quadric error with respect to a volume conserving constraint

code: bool OptimalPoint ( [UE::Math::TVector](API\Runtime\Core\Math\TVector)< RealType > & OutResult, RealType minThresh ) const


code: TVolPresQuadricError ( const [TVolPresQuadricError](API\Runtime\GeometryCore\TVolPresQuadricError) & a, const [TVolPresQuadricError](API\Runtime\GeometryCore\TVolPresQuadricError) & b )


code: TVolPresQuadricError ( const [TVector](API\Runtime\Core\Math\TVector)< RealType > & Normal, const [TVector](API\Runtime\Core\Math\TVector)< RealType > & Point )


code: TVolPresQuadricError ( const [TVolPresQuadricError](API\Runtime\GeometryCore\TVolPresQuadricError) & a, const [TVolPresQuadricError](API\Runtime\GeometryCore\TVolPresQuadricError) & b, const [FPlaneData](API\Runtime\GeometryCore\TVolPresQuadricError\FPlaneData) & DuplicatePlaneData )


description: Angle in Degrees.

code: namespace UE { namespace Geometry { template<typename T> T UE::Geometry::AngleD ( const [UE::Math::TVector2](API\Runtime\Core\Math\TVector2)< T > & V1, const [UE::Math::TVector2](API\Runtime\Core\Math\TVector2)< T > & V2 ) } }


description:
Computes the Angle between V1 and V2, assuming they are already normalized
the (positive) angle between V1 and V2 in degrees

code: namespace UE { namespace Geometry { template<typename T> T UE::Geometry::AngleD ( const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< T > & V1, const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< T > & V2 ) } }


description: Angle in Radians.

code: namespace UE { namespace Geometry { template<typename T> T UE::Geometry::AngleR ( const [UE::Math::TVector2](API\Runtime\Core\Math\TVector2)< T > & V1, const [UE::Math::TVector2](API\Runtime\Core\Math\TVector2)< T > & V2 ) } }


description:
Computes the Angle between V1 and V2, assuming they are already normalized
the (positive) angle between V1 and V2 in radians

code: namespace UE { namespace Geometry { template<typename T> T UE::Geometry::AngleR ( const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< T > & V1, const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< T > & V2 ) } }


code: namespace UE { namespace Geometry { template<typename T> [UE::Math::TVector](API\Runtime\Core\Math\TVector)< T > UE::Geometry::Blend3 ( const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< T > & A, const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< T > & B, const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< T > & C, const T & WeightA, const T & WeightB, const T & WeightC ) } }


className: TVolPresQuadricError

description: See:http://hhoppe.com/newqem.pdforhttps://www.cc.gatech.edu/~turk/my_papers/memless_vis98.pdffor information about the volume preservation.

code: template<typename RealType> class TVolPresQuadricError : public [UE::Geometry::TQuadricError< RealType >](API\Runtime\GeometryCore\TQuadricError)

PlaneData

type: FPlaneData


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

code: namespace UE { namespace Geometry { bool UE::Geometry::ConvertLoopToTriOrderedEdgeLoop ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, const [TArray](API\Runtime\Core\Containers\TArray)< int32 > & VertexLoop, const [TArray](API\Runtime\Core\Containers\TArray)< int32 > & EdgeLoop, [TArray](API\Runtime\Core\Containers\TArray)< [FMeshTriOrderedEdgeID](API\Runtime\GeometryCore\DynamicMesh\FMeshTriOrderedEdgeID) > & TriOrderedEdgesLoopOut ) } }


description: Utility functions for converting/processing edge loops Convert the input Vertex/Edge loop into an edge loop representation that is independent of Vertex/Edge IDs. See description ofFMeshTriOrderedEdgeIDfor 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.

code: namespace UE { namespace Geometry { bool UE::Geometry::ConvertLoopToTriOrderedEdgeLoop ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, const [TArray](API\Runtime\Core\Containers\TArray)< int32 > & VertexLoop, const [TArray](API\Runtime\Core\Containers\TArray)< int32 > & EdgeLoop, [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< int(int EdgeID, int TriangleA, int TriangleB)> SelectEdgeTriangleFunc, [TArray](API\Runtime\Core\Containers\TArray)< [FMeshTriOrderedEdgeID](API\Runtime\GeometryCore\DynamicMesh\FMeshTriOrderedEdgeID) > & TriOrderedEdgesLoopOut ) } }


description: Recover the current Vertex and Edge loops given an encoded loop ofFMeshTriOrderedEdgeID. SeeFMeshTriOrderedEdgeIDfor details on this encoding, this function basically reversesConvertLoopToTriOrderedEdgeLoop()for the current mesh topology

code: namespace UE { namespace Geometry { bool UE::Geometry::ConvertTriOrderedEdgeLoopToLoop ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, const [TArray](API\Runtime\Core\Containers\TArray)< [FMeshTriOrderedEdgeID](API\Runtime\GeometryCore\DynamicMesh\FMeshTriOrderedEdgeID) > & TriOrderedEdgesLoopOut, [TArray](API\Runtime\Core\Containers\TArray)< int32 > & VertexLoop, [TArray](API\Runtime\Core\Containers\TArray)< int32 > * EdgeLoop ) } }


description: 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).

code: namespace UE { namespace Geometry { template<typename RealType> [TQuadricError](API\Runtime\GeometryCore\TQuadricError)< RealType > UE::Geometry::CreateSeamQuadric ( const [TVector](API\Runtime\Core\Math\TVector)< RealType > & p0, const [TVector](API\Runtime\Core\Math\TVector)< RealType > & p1, const [TVector](API\Runtime\Core\Math\TVector)< RealType > & AdjFaceNormal ) } }


code: namespace UE { namespace Geometry { template<typename T> [UE::Math::TVector](API\Runtime\Core\Math\TVector)< T > UE::Geometry::Cross ( const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< T > & V1, const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< T > & V2 ) } }


description: Skew-Symmetric matrix such that A X B = CrossProductMatrix(A) * B;.

code: namespace UE { namespace Geometry { template<typename RealType> static [TMatrix3](API\Runtime\GeometryCore\TMatrix3)< RealType > UE::Geometry::CrossProductMatrix ( const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< RealType > & A ) } }


code: namespace UE { namespace Geometry { template<typename T> T UE::Geometry::Distance ( const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< T > & V1, const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< T > & V2 ) } }


code: namespace UE { namespace Geometry { template<typename T> T UE::Geometry::Distance ( const [UE::Math::TVector2](API\Runtime\Core\Math\TVector2)< T > & V1, const [UE::Math::TVector2](API\Runtime\Core\Math\TVector2)< T > & V2 ) } }


code: namespace UE { namespace Geometry { template<typename T> T UE::Geometry::DistanceSquared ( const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< T > & V1, const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< T > & V2 ) } }


code: namespace UE { namespace Geometry { template<typename T> T UE::Geometry::DistanceSquared ( const [UE::Math::TVector2](API\Runtime\Core\Math\TVector2)< T > & V1, const [UE::Math::TVector2](API\Runtime\Core\Math\TVector2)< T > & V2 ) } }


code: namespace UE { namespace Geometry { template<typename T> T UE::Geometry::Dot ( const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< T > & V1, const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< T > & V2 ) } }


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

code: namespace UE { namespace Geometry { template<typename T> constexpr T UE::Geometry::DotPerp ( const [UE::Math::TVector2](API\Runtime\Core\Math\TVector2)< T > & V1, const [UE::Math::TVector2](API\Runtime\Core\Math\TVector2)< T > & V2 ) } }


description: 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.

code: namespace UE { namespace Geometry { enum EOperationValidationResult { Ok = 0, Failed_UnknownReason = 1, Failed_InvalidTopology = 2, } } }


description: 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).

code: namespace UE { namespace Geometry { enum 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_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, } } }


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

code: namespace UE { namespace Geometry { enum EValidityCheckFailMode { ReturnOnly = 0, Check = 1, Ensure = 2, } } }


description: Example function to generate a generic mesh adapter from arrays

code: namespace UE { namespace Geometry { [FTriangleMeshAdapterd](API\Runtime\GeometryCore\FTriangleMeshAdapterd) UE::Geometry::GetArrayMesh ( [TArray](API\Runtime\Core\Containers\TArray)< FVector > & Vertices, [TArray](API\Runtime\Core\Containers\TArray)< FIntVector > & Triangles ) } }


code: namespace UE { namespace Geometry { uint32 UE::Geometry::GetTypeHash ( const [FIndex2i](API\Runtime\GeometryCore\FIndex2i) & Index ) } }


code: namespace UE { namespace Geometry { uint32 UE::Geometry::GetTypeHash ( const [FVector2i](API\Runtime\GeometryCore\FVector2i) & Vector ) } }


code: namespace UE { namespace Geometry { uint32 UE::Geometry::GetTypeHash ( const [FIndex3i](API\Runtime\GeometryCore\FIndex3i) & Index ) } }


code: namespace UE { namespace Geometry { uint32 UE::Geometry::GetTypeHash ( const [FIndex4i](API\Runtime\GeometryCore\FIndex4i) & Index ) } }


code: namespace UE { namespace Geometry { uint32 UE::Geometry::GetTypeHash ( const [FVector3i](API\Runtime\GeometryCore\FVector3i) & Vector ) } }


code: namespace UE { namespace Geometry { template<typename T> constexpr [UE::Math::TVector2](API\Runtime\Core\Math\TVector2)< T > UE::Geometry::GetXY ( const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< T > & V ) } }


code: namespace UE { namespace Geometry { template<typename T> constexpr [UE::Math::TVector2](API\Runtime\Core\Math\TVector2)< T > UE::Geometry::GetXZ ( const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< T > & V ) } }


code: namespace UE { namespace Geometry { template<typename T> constexpr [UE::Math::TVector2](API\Runtime\Core\Math\TVector2)< T > UE::Geometry::GetYZ ( const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< T > & V ) } }


code: namespace UE { namespace Geometry { template<typename T> constexpr bool UE::Geometry::IsNormalized ( const [UE::Math::TVector2](API\Runtime\Core\Math\TVector2)< T > & Vector, const T Tolerance ) } }


code: namespace UE { namespace Geometry { template<typename T> constexpr bool UE::Geometry::IsNormalized ( const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< T > & Vector, const T Tolerance ) } }


code: namespace UE { namespace Geometry { template<typename T> T UE::Geometry::Length ( const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< T > & V ) } }


code: namespace UE { namespace Geometry { template<typename T> [TFrame3](API\Runtime\GeometryCore\TFrame3)< T > UE::Geometry::Lerp ( const [TFrame3](API\Runtime\GeometryCore\TFrame3)< T > & A, const [TFrame3](API\Runtime\GeometryCore\TFrame3)< T > & B, T Alpha ) } }


code: namespace UE { namespace Geometry { template<typename T> [UE::Math::TVector2](API\Runtime\Core\Math\TVector2)< T > UE::Geometry::Lerp ( const [UE::Math::TVector2](API\Runtime\Core\Math\TVector2)< T > & A, const [UE::Math::TVector2](API\Runtime\Core\Math\TVector2)< T > & B, T Alpha ) } }


code: namespace UE { namespace Geometry { template<typename T> [UE::Math::TVector](API\Runtime\Core\Math\TVector)< T > UE::Geometry::Lerp ( const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< T > & A, const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< T > & B, T Alpha ) } }


code: namespace UE { namespace Geometry { template<typename T> [UE::Math::TVector4](API\Runtime\Core\Math\TVector4)< T > UE::Geometry::Lerp ( const [UE::Math::TVector4](API\Runtime\Core\Math\TVector4)< T > & A, const [UE::Math::TVector4](API\Runtime\Core\Math\TVector4)< T > & B, T Alpha ) } }


code: namespace UE { namespace Geometry { [FVector3i](API\Runtime\GeometryCore\FVector3i) UE::Geometry::Max ( const [FVector3i](API\Runtime\GeometryCore\FVector3i) & V0, const [FVector3i](API\Runtime\GeometryCore\FVector3i) & V1 ) } }


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

code: namespace UE { namespace Geometry { template<typename T> constexpr [UE::Math::TVector](API\Runtime\Core\Math\TVector)< T > UE::Geometry::MakeUnitVector3 ( int32 Axis ) } }


code: namespace UE { namespace Geometry { template<typename T> constexpr [UE::Math::TVector](API\Runtime\Core\Math\TVector)< T > UE::Geometry::Max ( const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< T > & V0, const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< T > & V1 ) } }


code: namespace UE { namespace Geometry { template<typename T> constexpr T UE::Geometry::MaxAbsElement ( const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< T > & Vector ) } }


code: namespace UE { namespace Geometry { template<typename T> constexpr T UE::Geometry::MaxElement ( const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< T > & Vector ) } }


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

code: namespace UE { namespace Geometry { template<typename T> constexpr int32 UE::Geometry::MaxAbsElementIndex ( const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< T > & Vector ) } }


description: 0/1/2 index of maximum element

code: namespace UE { namespace Geometry { template<typename T> constexpr int32 UE::Geometry::MaxElementIndex ( const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< T > & Vector ) } }


code: namespace UE { namespace Geometry { [FVector3i](API\Runtime\GeometryCore\FVector3i) UE::Geometry::Min ( const [FVector3i](API\Runtime\GeometryCore\FVector3i) & V0, const [FVector3i](API\Runtime\GeometryCore\FVector3i) & V1 ) } }


code: namespace UE { namespace Geometry { template<typename T> constexpr [UE::Math::TVector](API\Runtime\Core\Math\TVector)< T > UE::Geometry::Min ( const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< T > & V0, const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< T > & V1 ) } }


code: namespace UE { namespace Geometry { template<typename T> constexpr T UE::Geometry::MinAbsElement ( const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< T > & Vector ) } }


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

code: namespace UE { namespace Geometry { template<typename T> constexpr int32 UE::Geometry::MinAbsElementIndex ( const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< T > & Vector ) } }


code: namespace UE { namespace Geometry { template<typename T> constexpr T UE::Geometry::MinElement ( const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< T > & Vector ) } }


description: 0/1/2 index of minimum element

code: namespace UE { namespace Geometry { template<typename T> constexpr int32 UE::Geometry::MinElementIndex ( const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< T > & Vector ) } }


code: namespace UE { namespace Geometry { template<typename T> T UE::Geometry::Normalize ( [UE::Math::TVector](API\Runtime\Core\Math\TVector)< T > & Vector, const T Epsilon ) } }


code: namespace UE { namespace Geometry { template<typename T> T UE::Geometry::Normalize ( [UE::Math::TVector2](API\Runtime\Core\Math\TVector2)< T > & Vector, const T Epsilon ) } }


code: namespace UE { namespace Geometry { template<typename T> [UE::Math::TVector2](API\Runtime\Core\Math\TVector2)< T > UE::Geometry::Normalized ( const [UE::Math::TVector2](API\Runtime\Core\Math\TVector2)< T > & Vector, const T Epsilon ) } }


code: namespace UE { namespace Geometry { template<typename T> constexpr [UE::Math::TVector](API\Runtime\Core\Math\TVector)< T > UE::Geometry::Normalized ( const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< T > & Vector, const T Epsilon ) } }


code: namespace UE { namespace Geometry { [FVector2i](API\Runtime\GeometryCore\FVector2i) UE::Geometry::operator* ( int32 Scalar, const [FVector2i](API\Runtime\GeometryCore\FVector2i) & V ) } }


code: namespace UE { namespace Geometry { [FVector3i](API\Runtime\GeometryCore\FVector3i) UE::Geometry::operator* ( int32 Scalar, const [FVector3i](API\Runtime\GeometryCore\FVector3i) & V ) } }


code: namespace UE { namespace Geometry { template<typename RealType> [TMatrix3](API\Runtime\GeometryCore\TMatrix3)< RealType > UE::Geometry::operator* ( RealType Scale, const [TMatrix3](API\Runtime\GeometryCore\TMatrix3)< RealType > & Mat ) } }


code: namespace UE { namespace Geometry { template<typename RealType> [TMatrix2](API\Runtime\GeometryCore\TMatrix2)< RealType > UE::Geometry::operator* ( RealType Scale, const [TMatrix2](API\Runtime\GeometryCore\TMatrix2)< RealType > & Mat ) } }


code: namespace UE { namespace Geometry { template<typename RealType> [TQuaternion](API\Runtime\GeometryCore\TQuaternion)< RealType > UE::Geometry::operator* ( const [TQuaternion](API\Runtime\GeometryCore\TQuaternion)< RealType > & A, const [TQuaternion](API\Runtime\GeometryCore\TQuaternion)< RealType > & B ) } }


code: namespace UE { namespace Geometry { template<typename RealType> [TQuaternion](API\Runtime\GeometryCore\TQuaternion)< RealType > UE::Geometry::operator* ( const [TQuaternion](API\Runtime\GeometryCore\TQuaternion)< RealType > & Q, RealType Scalar ) } }


code: namespace UE { namespace Geometry { template<typename RealType> [TVector](API\Runtime\Core\Math\TVector)< RealType > UE::Geometry::operator* ( const [TQuaternion](API\Runtime\GeometryCore\TQuaternion)< RealType > & Q, const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< RealType > & V ) } }


code: namespace UE { namespace Geometry { std::ostream & UE::Geometry::operator<< ( std::ostream & os, const [FVector2i](API\Runtime\GeometryCore\FVector2i) & Vec ) } }


code: namespace UE { namespace Geometry { template<typename RealType> std::ostream & UE::Geometry::operator<< ( std::ostream & os, const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< RealType > & Vec ) } }


code: namespace UE { namespace Geometry { template<typename RealType> [TQuaternion](API\Runtime\GeometryCore\TQuaternion)< RealType > UE::Geometry::operator* ( RealType Scalar, const [TQuaternion](API\Runtime\GeometryCore\TQuaternion)< RealType > & Q ) } }


code: namespace UE { namespace Geometry { std::ostream & UE::Geometry::operator<< ( std::ostream & os, const [FVector3i](API\Runtime\GeometryCore\FVector3i) & Vec ) } }


code: namespace UE { namespace Geometry { template<typename RealType> [TQuaternion](API\Runtime\GeometryCore\TQuaternion)< RealType > UE::Geometry::operator+ ( const [TQuaternion](API\Runtime\GeometryCore\TQuaternion)< RealType > & A, const [TQuaternion](API\Runtime\GeometryCore\TQuaternion)< RealType > & B ) } }


code: namespace UE { namespace Geometry { template<typename RealType> [TQuaternion](API\Runtime\GeometryCore\TQuaternion)< RealType > UE::Geometry::operator- ( const [TQuaternion](API\Runtime\GeometryCore\TQuaternion)< RealType > & A, const [TQuaternion](API\Runtime\GeometryCore\TQuaternion)< RealType > & B ) } }


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

code: namespace UE { namespace Geometry { template<typename T> T UE::Geometry::Orient ( const [UE::Math::TVector2](API\Runtime\Core\Math\TVector2)< T > & A, const [UE::Math::TVector2](API\Runtime\Core\Math\TVector2)< T > & B, const [UE::Math::TVector2](API\Runtime\Core\Math\TVector2)< T > & C ) } }


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

code: namespace UE { namespace Geometry { template<typename T> constexpr [UE::Math::TVector2](API\Runtime\Core\Math\TVector2)< T > UE::Geometry::PerpCW ( const [UE::Math::TVector2](API\Runtime\Core\Math\TVector2)< T > & V ) } }


description: Angle in Radians.

code: namespace UE { namespace Geometry { template<typename T> T UE::Geometry::SignedAngleR ( const [UE::Math::TVector2](API\Runtime\Core\Math\TVector2)< T > & V1, const [UE::Math::TVector2](API\Runtime\Core\Math\TVector2)< T > & V2 ) } }


description: 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.

code: namespace UE { namespace Geometry { template<typename RealType> RealType UE::Geometry::SnapToIncrement ( RealType Value, RealType Increment, RealType Offset ) } }


code: namespace UE { namespace Geometry { template<typename T> T UE::Geometry::SquaredLength ( const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< T > & V ) } }


description: Fill an array with the oriented triangle faces of the tet.

code: namespace UE { namespace Geometry { namespace TetUtil { template<bool bReverseOrientation> void UE::Geometry::TetUtil::GetTetFaces ( const [FIndex4i](API\Runtime\GeometryCore\FIndex4i) & Tet, [FIndex3i](API\Runtime\GeometryCore\FIndex3i) OutFaces ) } } }


description: a C array of vertex orderings for each of the 4 triangle faces of a tetrahedron

code: namespace UE { namespace Geometry { namespace TetUtil { template<bool bReverseOrientation> const [FIndex3i](API\Runtime\GeometryCore\FIndex3i) * UE::Geometry::TetUtil::GetTetFaceOrdering() } } }


code: namespace UE { namespace Geometry { template<typename T> constexpr [FColor](API\Runtime\Core\Math\FColor) UE::Geometry::ToFColor ( const [UE::Math::TVector4](API\Runtime\Core\Math\TVector4)< T > & Vector ) } }


code: namespace UE { namespace Geometry { template<typename T> constexpr [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::ToLinearColor ( const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< T > & Vector ) } }


description:
Test whether point Pt is inside or on a (non-degenerate) tetrahedron Tet. Note: Will always report 'outside' for a fully degenerate (flat) tetrahedron
0 if Pt is outside Tet (or Tet is degenerate), 1 if Pt is inside a positively-oriented Tet, -1 if Pt is inside and Tet is inverted

code: namespace UE { namespace Geometry { namespace TetUtil { template<typename RealType> int32 UE::Geometry::TetUtil::IsInsideExact ( const [TTetrahedron3](API\Runtime\GeometryCore\TTetrahedron3)< RealType > & Tet, [TVector](API\Runtime\Core\Math\TVector)< RealType > & Pt ) } } }


code: namespace UE { namespace Geometry { template<typename T> [FLinearColor](API\Runtime\Core\Math\FLinearColor) UE::Geometry::ToLinearColor ( const [UE::Math::TVector4](API\Runtime\Core\Math\TVector4)< T > & V ) } }


code: namespace UE { namespace Geometry { template<typename T> [UE::Math::TVector4](API\Runtime\Core\Math\TVector4)< T > UE::Geometry::ToVector4 ( const [FLinearColor](API\Runtime\Core\Math\FLinearColor) & Color ) } }


description: the edge length of an equilateral/regular triangle with the given area

code: namespace UE { namespace Geometry { namespace TriangleUtil { template<typename RealType> RealType UE::Geometry::TriangleUtil::EquilateralEdgeLengthForArea ( RealType TriArea ) } } }


code: namespace UE { namespace Geometry { template<typename T> [UE::Math::TVector](API\Runtime\Core\Math\TVector)< T > UE::Geometry::UnitCross ( const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< T > & V1, const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< T > & V2 ) } }


description: area of 3D triangle V0,V1,V2

code: namespace UE { namespace Geometry { namespace VectorUtil { template<typename RealType> RealType UE::Geometry::VectorUtil::Area ( const [TVector](API\Runtime\Core\Math\TVector)< RealType > & V0, const [TVector](API\Runtime\Core\Math\TVector)< RealType > & V1, const [TVector](API\Runtime\Core\Math\TVector)< RealType > & V2 ) } } }


description: area of 2D triangle V0,V1,V2

code: namespace UE { namespace Geometry { namespace VectorUtil { template<typename RealType> RealType UE::Geometry::VectorUtil::Area ( const [TVector2](API\Runtime\Core\Math\TVector2)< RealType > & V0, const [TVector2](API\Runtime\Core\Math\TVector2)< RealType > & V1, const [TVector2](API\Runtime\Core\Math\TVector2)< RealType > & V2 ) } } }


description: Aspect ratio of triangle

code: namespace UE { namespace Geometry { namespace VectorUtil { double UE::Geometry::VectorUtil::AspectRatio ( const FVector3d & v1, const FVector3d & v2, const FVector3d & v3 ) } } }


description: Compute barycentric coordinates/weights of vPoint inside 3D triangle (V0,V1,V2). If point is in triangle plane and inside triangle, coords will be positive and sum to 1. ie if result is a, then vPoint = a.x*V0 + a.y*V1 + a.z*V2. TODO: make robust to degenerate triangles?

code: namespace UE { namespace Geometry { namespace VectorUtil { template<typename RealType> [TVector](API\Runtime\Core\Math\TVector)< RealType > UE::Geometry::VectorUtil::BarycentricCoords ( const [TVector](API\Runtime\Core\Math\TVector)< RealType > & Point, const [TVector](API\Runtime\Core\Math\TVector)< RealType > & V0, const [TVector](API\Runtime\Core\Math\TVector)< RealType > & V1, const [TVector](API\Runtime\Core\Math\TVector)< RealType > & V2 ) } } }


description: Compute barycentric coordinates/weights of vPoint inside 2D triangle (V0,V1,V2). If point is inside triangle, coords will be positive and sum to 1. ie if result is a, then vPoint = a.x*V0 + a.y*V1 + a.z*V2. TODO: make robust to degenerate triangles?

code: namespace UE { namespace Geometry { namespace VectorUtil { template<typename RealType> [TVector](API\Runtime\Core\Math\TVector)< RealType > UE::Geometry::VectorUtil::BarycentricCoords ( const [TVector2](API\Runtime\Core\Math\TVector2)< RealType > & Point, const [TVector2](API\Runtime\Core\Math\TVector2)< RealType > & V0, const [TVector2](API\Runtime\Core\Math\TVector2)< RealType > & V1, const [TVector2](API\Runtime\Core\Math\TVector2)< RealType > & V2 ) } } }


description: sign of Bitangent relative to Normal and Tangent

code: namespace UE { namespace Geometry { namespace VectorUtil { template<typename RealType> RealType UE::Geometry::VectorUtil::BitangentSign ( const [TVector](API\Runtime\Core\Math\TVector)< RealType > & NormalIn, const [TVector](API\Runtime\Core\Math\TVector)< RealType > & TangentIn, const [TVector](API\Runtime\Core\Math\TVector)< RealType > & BitangentIn ) } } }


description: Bitangent vector based on given Normal, Tangent, and Sign value (+1/-1)

code: namespace UE { namespace Geometry { namespace VectorUtil { template<typename RealType> [TVector](API\Runtime\Core\Math\TVector)< RealType > UE::Geometry::VectorUtil::Bitangent ( const [TVector](API\Runtime\Core\Math\TVector)< RealType > & NormalIn, const [TVector](API\Runtime\Core\Math\TVector)< RealType > & TangentIn, RealType BitangentSign ) } } }


description: Bitangent vector based on given Normal and Tangent

code: namespace UE { namespace Geometry { namespace VectorUtil { template<typename RealType> [TVector](API\Runtime\Core\Math\TVector)< RealType > UE::Geometry::VectorUtil::BitangentFromTangent ( const [TVector](API\Runtime\Core\Math\TVector)< RealType > & NormalIn, const [TVector](API\Runtime\Core\Math\TVector)< RealType > & TangentIn ) } } }


description: circumcenter of triangle ABC

code: namespace UE { namespace Geometry { namespace VectorUtil { template<typename RealType> [TVector2](API\Runtime\Core\Math\TVector2)< RealType > UE::Geometry::VectorUtil::Circumcenter ( [TVector2](API\Runtime\Core\Math\TVector2)< RealType > A, [TVector2](API\Runtime\Core\Math\TVector2)< RealType > B, const [TVector2](API\Runtime\Core\Math\TVector2)< RealType > & C, RealType Epsilon ) } } }


description: input Value clamped to range [MinValue, MaxValue]

code: namespace UE { namespace Geometry { namespace VectorUtil { template<typename RealType> RealType UE::Geometry::VectorUtil::Clamp ( RealType Value, RealType MinValue, RealType MaxValue ) } } }


description: true if Abs(A-B) is less than Epsilon

code: namespace UE { namespace Geometry { namespace VectorUtil { template<typename RealType> bool UE::Geometry::VectorUtil::EpsilonEqual ( RealType A, RealType B, RealType Epsilon ) } } }


description: true if all coordinates of V0 and V1 are within Epsilon of eachother

code: namespace UE { namespace Geometry { namespace VectorUtil { template<typename RealType> bool UE::Geometry::VectorUtil::EpsilonEqual ( const [TVector2](API\Runtime\Core\Math\TVector2)< RealType > & V0, const [TVector2](API\Runtime\Core\Math\TVector2)< RealType > & V1, RealType Epsilon ) } } }


code: namespace UE { namespace Geometry { namespace VectorUtil { template<typename RealType> bool UE::Geometry::VectorUtil::EpsilonEqual ( const [TVector](API\Runtime\Core\Math\TVector)< RealType > & V0, const [TVector](API\Runtime\Core\Math\TVector)< RealType > & V1, RealType Epsilon ) } } }


description: true if all coordinates of V0 and V1 are within Epsilon of each other

code: namespace UE { namespace Geometry { namespace VectorUtil { template<typename RealType> bool UE::Geometry::VectorUtil::EpsilonEqual ( const [TVector4](API\Runtime\Core\Math\TVector4)< RealType > & V0, const [TVector4](API\Runtime\Core\Math\TVector4)< RealType > & V1, RealType Epsilon ) } } }


code: namespace UE { namespace Geometry { namespace VectorUtil { template<typename RealType> [TVector](API\Runtime\Core\Math\TVector)< RealType > UE::Geometry::VectorUtil::InverseTransformNormal ( const [TTransform](API\Runtime\Core\Math\TTransform)< RealType > & Transform, const [TVector](API\Runtime\Core\Math\TVector)< RealType > & Normal ) } } }


description: true if all components of V are finite

code: namespace UE { namespace Geometry { namespace VectorUtil { template<typename RealType> bool UE::Geometry::VectorUtil::IsFinite ( const [TVector2](API\Runtime\Core\Math\TVector2)< RealType > & V ) } } }


description: true if all components of V are finite

code: namespace UE { namespace Geometry { namespace VectorUtil { template<typename RealType> bool UE::Geometry::VectorUtil::IsFinite ( const [TVector](API\Runtime\Core\Math\TVector)< RealType > & V ) } } }


description: true if triangle V1,V2,V3 is obtuse

code: namespace UE { namespace Geometry { namespace VectorUtil { template<typename RealType> bool UE::Geometry::VectorUtil::IsObtuse ( const [TVector](API\Runtime\Core\Math\TVector)< RealType > & V1, const [TVector](API\Runtime\Core\Math\TVector)< RealType > & V2, const [TVector](API\Runtime\Core\Math\TVector)< RealType > & V3 ) } } }


description: Calculates one vector perpendicular to input Normal, as efficiently as possible.

code: namespace UE { namespace Geometry { namespace VectorUtil { template<typename RealType> [TVector](API\Runtime\Core\Math\TVector)< RealType > UE::Geometry::VectorUtil::MakePerpVector ( const [TVector](API\Runtime\Core\Math\TVector)< RealType > & Normal ) } } }


description: Calculates two vectors perpendicular to input Normal, as efficiently as possible.

code: namespace UE { namespace Geometry { namespace VectorUtil { template<typename RealType> void UE::Geometry::VectorUtil::MakePerpVectors ( const [TVector](API\Runtime\Core\Math\TVector)< RealType > & Normal, [TVector](API\Runtime\Core\Math\TVector)< RealType > & OutPerp1, [TVector](API\Runtime\Core\Math\TVector)< RealType > & OutPerp2 ) } } }


code: namespace UE { namespace Geometry { namespace VectorUtil { template<typename RealType> void UE::Geometry::VectorUtil::MakePerpVector ( const [TVector](API\Runtime\Core\Math\TVector)< RealType > & Normal, [TVector](API\Runtime\Core\Math\TVector)< RealType > & OutPerp1 ) } } }


description: 0/1/2 index of smallest value in Vector3

code: namespace UE { namespace Geometry { namespace VectorUtil { template<typename ValueVecType> int UE::Geometry::VectorUtil::Min3Index ( const ValueVecType & Vector3 ) } } }


description: un-normalized direction that is parallel to normal of triangle V0,V1,V2

code: namespace UE { namespace Geometry { namespace VectorUtil { template<typename RealType> [TVector](API\Runtime\Core\Math\TVector)< RealType > UE::Geometry::VectorUtil::NormalDirection ( const [TVector](API\Runtime\Core\Math\TVector)< RealType > & V0, const [TVector](API\Runtime\Core\Math\TVector)< RealType > & V1, const [TVector](API\Runtime\Core\Math\TVector)< RealType > & V2 ) } } }


description:
Calculate Normal and Area of triangle V0,V1,V2
triangle normal

code: namespace UE { namespace Geometry { namespace VectorUtil { template<typename RealType> [TVector](API\Runtime\Core\Math\TVector)< RealType > UE::Geometry::VectorUtil::NormalArea ( const [TVector](API\Runtime\Core\Math\TVector)< RealType > & V0, const [TVector](API\Runtime\Core\Math\TVector)< RealType > & V1, const [TVector](API\Runtime\Core\Math\TVector)< RealType > & V2, RealType & AreaOut ) } } }


description: normalized vector that is perpendicular to triangle V0,V1,V2 (triangle normal)

code: namespace UE { namespace Geometry { namespace VectorUtil { template<typename RealType> [TVector](API\Runtime\Core\Math\TVector)< RealType > UE::Geometry::VectorUtil::Normal ( const [TVector](API\Runtime\Core\Math\TVector)< RealType > & V0, const [TVector](API\Runtime\Core\Math\TVector)< RealType > & V1, const [TVector](API\Runtime\Core\Math\TVector)< RealType > & V2 ) } } }


description: angle between vectors (A-CornerPt) and (B-CornerPt)

code: namespace UE { namespace Geometry { namespace VectorUtil { template<typename RealType> RealType UE::Geometry::VectorUtil::OpeningAngleD ( [TVector](API\Runtime\Core\Math\TVector)< RealType > A, [TVector](API\Runtime\Core\Math\TVector)< RealType > B, const [TVector](API\Runtime\Core\Math\TVector)< RealType > & P ) } } }


description:
Calculates angle between VFrom and VTo after projection onto plane with normal defined by PlaneN
angle in degrees

code: namespace UE { namespace Geometry { namespace VectorUtil { template<typename RealType> RealType UE::Geometry::VectorUtil::PlaneAngleSignedD ( const [TVector](API\Runtime\Core\Math\TVector)< RealType > & VFrom, const [TVector](API\Runtime\Core\Math\TVector)< RealType > & VTo, const [TVector](API\Runtime\Core\Math\TVector)< RealType > & PlaneN ) } } }


description:
Calculates angle between VFrom and VTo after projection onto plane with normal defined by PlaneN
angle in radians

code: namespace UE { namespace Geometry { namespace VectorUtil { template<typename RealType> RealType UE::Geometry::VectorUtil::PlaneAngleSignedR ( const [TVector](API\Runtime\Core\Math\TVector)< RealType > & VFrom, const [TVector](API\Runtime\Core\Math\TVector)< RealType > & VTo, const [TVector](API\Runtime\Core\Math\TVector)< RealType > & PlaneN ) } } }


description: signed area of 2D triangle V0,V1,V2

code: namespace UE { namespace Geometry { namespace VectorUtil { template<typename RealType> RealType UE::Geometry::VectorUtil::SignedArea ( const [TVector2](API\Runtime\Core\Math\TVector2)< RealType > & V0, const [TVector2](API\Runtime\Core\Math\TVector2)< RealType > & V1, const [TVector2](API\Runtime\Core\Math\TVector2)< RealType > & V2 ) } } }


description: Tangent-Space vector based on given Normal and Bitangent

code: namespace UE { namespace Geometry { namespace VectorUtil { template<typename RealType> [TVector](API\Runtime\Core\Math\TVector)< RealType > UE::Geometry::VectorUtil::TangentFromBitangent ( const [TVector](API\Runtime\Core\Math\TVector)< RealType > & NormalIn, const [TVector](API\Runtime\Core\Math\TVector)< RealType > & BitangentIn ) } } }


code: namespace UE { namespace Geometry { namespace VectorUtil { template<typename RealType> [TVector](API\Runtime\Core\Math\TVector)< RealType > UE::Geometry::VectorUtil::TransformNormal ( const [TTransform](API\Runtime\Core\Math\TTransform)< RealType > & Transform, const [TVector](API\Runtime\Core\Math\TVector)< RealType > & Normal ) } } }


description:
Calculate gradient of scalar field values fi,fj,fk defined at corners of triangle Vi,Vj,Vk and interpolated across triangle using linear basis functions. This gradient is a 3D vector lying in the plane of the triangle (or zero if field is constant).
gradient (3D vector) lying in plane of triangle.

code: namespace UE { namespace Geometry { namespace VectorUtil { template<typename RealType> [TVector](API\Runtime\Core\Math\TVector)< RealType > UE::Geometry::VectorUtil::TriGradient ( [TVector](API\Runtime\Core\Math\TVector)< RealType > Vi, [TVector](API\Runtime\Core\Math\TVector)< RealType > Vj, [TVector](API\Runtime\Core\Math\TVector)< RealType > Vk, RealType fi, RealType fj, RealType fk ) } } }


description: solid angle at point P for triangle A,B,C

code: namespace UE { namespace Geometry { namespace VectorUtil { template<typename RealType> RealType UE::Geometry::VectorUtil::TriSolidAngle ( [TVector](API\Runtime\Core\Math\TVector)< RealType > A, [TVector](API\Runtime\Core\Math\TVector)< RealType > B, [TVector](API\Runtime\Core\Math\TVector)< RealType > C, const [TVector](API\Runtime\Core\Math\TVector)< RealType > & P ) } } }


description:
Tan(theta/2) = +/- sqrt( (1-cos(theta)) / (1+cos(theta)) )
positive value of tan(theta/2) where theta is angle between normalized vectors A and B

code: namespace UE { namespace Geometry { namespace VectorUtil { template<typename RealType> RealType UE::Geometry::VectorUtil::VectorTanHalfAngle ( const [TVector](API\Runtime\Core\Math\TVector)< RealType > & A, const [TVector](API\Runtime\Core\Math\TVector)< RealType > & B ) } } }


description:
Fast cotangent of angle between two vectors (do not have to be normalized unit vectors). cot = cos/sin, both of which can be computed from vector identities
cotangent of angle between V1 and V2, or zero if result would be unstable (eg infinity)

code: namespace UE { namespace Geometry { namespace VectorUtil { template<typename RealType> RealType UE::Geometry::VectorUtil::VectorCot ( const [TVector](API\Runtime\Core\Math\TVector)< RealType > & V1, const [TVector](API\Runtime\Core\Math\TVector)< RealType > & V2 ) } } }


code: namespace UE { namespace Math { template<typename RealType> std::ostream & UE::Math::operator<< ( std::ostream & os, const [TVector2](API\Runtime\Core\Math\TVector2)< RealType > & Vec ) } }


code: namespace UE { namespace Math { template<typename RealType> std::ostream & UE::Math::operator<< ( std::ostream & os, const [TVector4](API\Runtime\Core\Math\TVector4)< RealType > & Vec ) } }


description: Append enumerable elements to an array

code: namespace BufferUtil { template<typename T, typename EnumerableType> void BufferUtil::AppendElements ( [TArray](API\Runtime\Core\Containers\TArray)< T > & AppendTo, EnumerableType Enumerable ) }


description:
Count number of elements in array (or within requested range) that pass Predicate test
number of values in array that returned true for Predicate

code: namespace BufferUtil { template<typename T> int BufferUtil::CountValid ( const [TArray](API\Runtime\Core\Containers\TArray)< T > & Data, const [TFunction](API\Runtime\Core\GenericPlatform\TFunction)< bool(T)> & Predicate, int MaxIndex, int StartIndex ) }


description:
Removes elements of array (or within requested range) that do not pass Predicate, by shifting forward. Does not remove remaining elements
Number of valid elements in Data after filtering

code: namespace BufferUtil { template<typename T> int BufferUtil::FilterInPlace ( [TArray](API\Runtime\Core\Containers\TArray)< T > & Data, const [TFunction](API\Runtime\Core\GenericPlatform\TFunction)< bool(T)> & Predicate, int MaxIndex, int StartIndex ) }


className: ExpandFunctionT

code: typedef [TFunction](API\Runtime\Core\GenericPlatform\TFunction)< OutputType(InputType, int &)> ExpandFunctionT


className: ExpandIteratorT

code: typedef [ExpandIterator](API\Runtime\GeometryCore\Util\ExpandIterator)< OutputType, InputType, InputIteratorT > ExpandIteratorT


code: template<typename IteratorSource> ExpandEnumerable ( const IteratorSource & Source, [ExpandFunctionT](API\Runtime\Core\GenericPlatform\TFunction) ExpandFuncIn )


code: ExpandEnumerable ( const InputIteratorT & BeginIn, const InputIteratorT & EndIn, [ExpandFunctionT](API\Runtime\Core\GenericPlatform\TFunction) ExpandFuncIn )


className: ExpandEnumerable

description: Generic "enumerable" object that provides begin/end semantics for anExpandIteratorsuitable for use with range-based for. You can either provide begin/end iterators, or another "enumerable" object that hasbegin()/end() functions.

code: template<typename OutputType, typename InputType, typename InputIteratorT> class ExpandEnumerable

BeginItr

type: InputIteratorT

ExpandFunc

type: ExpandFunctionT


code: bool operator== ( const [ExpandIterator](API\Runtime\GeometryCore\Util\ExpandIterator) & Other ) const


code: OutputType operator*() const


code: bool operator!= ( const [ExpandIterator](API\Runtime\GeometryCore\Util\ExpandIterator) & Other ) const


code: const [ExpandIterator](API\Runtime\GeometryCore\Util\ExpandIterator) & operator++()


code: ExpandIterator ( const InputIteratorT & CurItr, const InputIteratorT & EndItr, const [ExpandFunctionT](API\Runtime\Core\GenericPlatform\TFunction) & ExpandFuncIn )


className: ExpandIterator

description: SeeFDynamicMesh3::VtxTrianglesItrfor an example

code: template<typename OutputType, typename InputType, typename InputIteratorT> class ExpandIterator

CurExpandI

type: int

CurValue

type: OutputType


description:
Create a new IndexSet for this Decomposition
ID of the new IndexSet

code: int32 CreateNewIndexSet()


className: FIndexSet

code: struct FIndexSet

IndexArray

type: TArray< int32 >


description: IndexSet for the given SetID

code: [TArray](API\Runtime\Core\Containers\TArray)< int32 > & GetIndexSetArray ( int32 SetID )


description: IndexSet for the given SetID

code: const [TArray](API\Runtime\Core\Containers\TArray)< int32 > & GetIndexSetArray ( int32 SetID ) const


description: list of ID integers which identify the IndexSets of this Decomposition

code: const [TArray](API\Runtime\Core\Containers\TArray)< int32 > & GetIndexSetIDs() const


className: FArrayIndexSetsDecomposition

description: FArrayIndexSetsDecompositionrepresents a decomposition of an integer index set into subsets, which are stored as arrays (ie this is just an array of arrays, where each sub-array has a unique integer identifier)

code: class FArrayIndexSetsDecomposition

SetIdentifierMap

type: TMap< int32,FI...

Sets

type: TIndirectArray<...


code: typedef [TBoundsGridIndexer3](API\Runtime\GeometryCore\Util\TBoundsGridIndexer3)< double > FBoundsGridIndexer3d


code: typedef [TBoundsGridIndexer3](API\Runtime\GeometryCore\Util\TBoundsGridIndexer3)< float > FBoundsGridIndexer3f


description: Get mapping for a triangle

code: int32 GetTriangleMapping ( int32 FromID ) const


description: Get mapping for a vertex

code: int32 GetVertexMapping ( int32 FromID ) const


description: Get mapping for three vertices, e.g. a triangle

code: [FIndex3i](API\Runtime\GeometryCore\FIndex3i) GetVertexMapping ( [FIndex3i](API\Runtime\GeometryCore\FIndex3i) FromIDs ) const


className: InvalidID

code: static constexpr int32 InvalidID = IndexConstants::InvalidID;


description: Get number of triangle mappings

code: int32 NumTriangleMappings() const


description: Get number of vertex mappings

code: int32 NumVertexMappings() const


description: Reset all maps, leaving them empty

code: void Reset()


description: Resize vertex and triangle maps, and initialize with InvalidID.

code: void Reset ( int32 NumVertMappings, int32 NumTriMappings, bool bInitializeWithInvalidID )


description: Resize triangle map, and optionally initialize with InvalidID.

code: void ResetTriangleMap ( int32 NumTriMappings, bool bInitializeWithInvalidID )


description: Resize vertex map, and optionally initialize with InvalidID.

code: void ResetVertexMap ( int32 NumVertMappings, bool bInitializeWithInvalidID )


description: Set up maps as identity maps.

code: void SetIdentity ( int32 NumVertMappings, int32 NumTriMappings )


description: Set up triangle map as identity map.

code: void SetIdentityTriangleMap ( int32 NumTriMappings )


description: Set up vertex map as identity map.

code: void SetIdentityVertexMap ( int32 NumVertMappings )


description: Set mapping for a triangle

code: void SetTriangleMapping ( int32 FromID, int32 ToID )


description: Set mapping for a vertex

code: void SetVertexMapping ( int32 FromID, int32 ToID )


description: Returns true if there are triangle mappings.

code: bool TriangleMapIsSet() const


description: Check data for validity; for testing

code: bool Validate() const


description: Returns true if there are vertex mappings.

code: bool VertexMapIsSet() const


className: FCompactMaps

description: Stores index remapping for vertices and triangles. Should only be used for compacting, and should maintain invariant that *Map[Idx] <= Idx for all maps

code: class FCompactMaps


description: Id for givenIndex

code: int32 GetId ( int32 Index ) const


description: Indexfor given Id

code: int32 GetIndex ( int32 Id ) const


description: true if Id is in valid range and maps to a valid index

code: bool IsValidId ( int32 Id ) const


description: true ifIndexis in valid range

code: bool IsValidIndex ( int32 Index ) const


description: Following theFDynamicMesh3convention this is really MaxId + 1.

code: int32 MaxId() const


description: maximum number of IDs in linearization (However not all IDs necessarily have a linear index)

code: int32 NumIds() const


code: template<typename IterableType> void Populate ( const int32 MaxId, const int32 Count, IterableType Iterable )


description: number of Indices in linearization

code: int32 NumIndices() const


description: Lookup ToVtxId(Index) = VtxId;.

code: const [TArray](API\Runtime\Core\Containers\TArray)< int32 > & ToId() const


description: Lookup ToIndex(VtxId) =Index; may return FDynamicMesh3::InvalidID.

code: const [TArray](API\Runtime\Core\Containers\TArray)< int32 > & ToIndex() const


code: FElementLinearization &40; const FElementLinearization & &41;


className: FElementLinearization

description: FElementLinearizationmaps a potentially-sparse index list into a linear array. Used linearize things like VtxIds of a mesh as a single array and allow bidirectional mapping between array offset and mesh VtxId. Linearized array offset can then be used for things like matrix row indexing when building a Laplacian matrix.

code: class FElementLinearization


code: FGeometryError ( int32 Code, const [FText](API\Runtime\Core\Internationalization\FText) & MessageIn )


className: FGeometryError

description: FGeometryErrorrepresents an error code/message emitted by a geometry operation. The intention of Errors is that they are fatal, IE if an operation emits Errors then it did not complete successfully. If that is not the case, use aFGeometryWarninginstead.

code: struct FGeometryError

CustomData

type: TArray< unsigne...

Message

type: FText

Timestamp

type: FDateTime


description: Append an Error to the result

code: void AddError ( [FGeometryError](API\Runtime\GeometryCore\Util\FGeometryError) Error )


description: Append a Warning to the result

code: void AddWarning ( [FGeometryWarning](API\Runtime\GeometryCore\Util\FGeometryWarning) Warning )


description:
Test if the given Progress has been cancelled, if so, set the Result to Cancelled
true if cancelled, false if not cancelled

code: bool CheckAndSetCancelled ( [FProgressCancel](API\Runtime\GeometryCore\Util\FProgressCancel) * Progress )


description: true if the geometry operation failed

code: bool HasFailed() const


description: true if the geometry operation has some result (ie was a Success or returned a PartialResult)

code: bool HasResult() const


description: Set state of the Result to Failure, and append aFGeometryErrorwith the given ErrorMessage and ResultCode

code: void SetFailed ( [FText](API\Runtime\Core\Internationalization\FText) ErrorMessage, int ResultCode )


description: Set to Success/Failure based on bSuccess, or Cancelled if the (optional)FProgressCancelindicates that it was Cancelled

code: void SetSuccess ( bool bSuccess, [FProgressCancel](API\Runtime\GeometryCore\Util\FProgressCancel) * Progress )


code: void UpdateResultType ( [EGeometryResultType](API\Runtime\GeometryCore\Util\UE__Geometry__EGeometryResultTyp-) NewType )


code: FGeometryResult ( [EGeometryResultType](API\Runtime\GeometryCore\Util\UE__Geometry__EGeometryResultTyp-) ResultType )


className: FGeometryResult

description: FGeometryResultrepresents a combined "success/failure/etc" state for a geometry operation along with a set of Error and Warning codes/messages.

code: struct FGeometryResult

Errors

type: TArray<FGeomet...

Result

type: EGeometryResult...


code: FGeometryWarning ( int32 Code, const [FText](API\Runtime\Core\Internationalization\FText) & MessageIn )


className: FGeometryWarning

description: FGeometryWarningrepresents a warning code/message emitted by a geometry operation. The intention of Warnings is that they are non-fatal, IE an operation might successfully complete but still emit Warnings

code: struct FGeometryWarning


code: bool operator== ( const [FilteredIterator](API\Runtime\GeometryCore\Util\FilteredIterator) & Other ) const


className: FilterFunctionT

code: typedef [TFunction](API\Runtime\Core\GenericPlatform\TFunction)< bool(ValueType)> FilterFunctionT


code: bool operator!= ( const [FilteredIterator](API\Runtime\GeometryCore\Util\FilteredIterator) & Other ) const


code: const [FilteredIterator](API\Runtime\GeometryCore\Util\FilteredIterator) & operator++()


code: FilteredIterator ( const IteratorT & CurItr, const IteratorT & EndItr, const [FilterFunctionT](API\Runtime\Core\GenericPlatform\TFunction) & FilterFuncIn )


className: FilteredIterator

description: Wrapper around an existing iterator that skips over values for which the filter_func returns false.

code: template<typename ValueType, typename IteratorT> class FilteredIterator

Cur

type: IteratorT

FilterFunc

type: FilterFunctionT


description: true ifIndexis in set

code: bool Contains ( int Index ) const


description: Initialize to either sparse or dense automatically, based on max index and estimated number of set indices

code: void InitAuto ( int MaxIndex, int SubsetCountEst )


description: Returns number of values in set

code: int Count() const


description: Initialize to sparse or dense based on the explicit caller choice

code: void InitManual ( bool bSetSparse, int MaxIndex )


code: FIndexFlagSet ( bool bSetSparse, int MaxIndex )


description: Array-style accessor that returns true ifIndexis in set, false otherwise

code: const bool operator[] ( unsigned int Index ) const


code: FIndexFlagSet ( int MaxIndex, int SubsetCountEst )


className: FIndexFlagSet

description: This class provides optionally sparse or dense boolean flags for a set of integer indices

code: class FIndexFlagSet


description: Check if node ordering is correct (for debugging/testing)

code: bool CheckIds()


description: Reset the queue to empty state. if bFreeMemory is false, we don't discard internal data structures, so there will be less allocation next time

code: void Clear ( bool bFreeMemory )


description: true if id is already in queue

code: bool Contains ( int NodeID ) const


description:
Remove node at head of queue, update queue, and return id for that node
ID of node at head of queue

code: int Dequeue()


className: FQueueNode

code: struct FQueueNode

priority

type: float


description: current size of queue

code: int GetCount() const


description: id of node at head of queue

code: int GetFirstNodeID() const


description: id of node at head of queue

code: float GetFirstNodePriority() const


description:
Query the priority at node id, assuming it exists in queue. Behavior is undefined if you call w/ id that is not in queue
priority for node

code: float GetPriority ( int id )


description: Initialize internal data structures. Internally a fixed-size array is used to track mapping from IDs to internal node indices, so maxID must be provided up-front. If this seems problematic or inefficient, this is not the Priority Queue for you.

code: void Initialize ( int MaxNodeID )


description: Add id to list w/ given priority. Do not call with same id twice!

code: void Insert ( int NodeID, float priority )


description: Remove node associated with given ID from queue. Behavior is undefined if you call w/ id that is not in queue

code: void Remove ( int NodeID )


code: bool IsValidQueue() const


description: Update priority at node id, and then move it to correct position in queue. Behavior is undefined if you call w/ id that is not in queue

code: void Update ( int NodeID, float Priority )


description: This constructor is provided for convenience, you must callInitialize()

code: FIndexPriorityQueue()


description: CallsInitialize()

code: FIndexPriorityQueue ( int maxID )


className: FIndexPriorityQueue

description: This is a min-heap priority queue class that does not use an object for each queue node. Integer IDs must be provided by the user to identify unique nodes. Internally an array is used to keep track of the mapping from ids to internal indices, so the max ID must also be provided.

code: class FIndexPriorityQueue

EnableDebugChecks

type: bool

description: Set this to true during development to catch issues

type: TArray< int >

description: Mapping from external ids to internal node indices

nodes

type: TDynamicVector<...

description: Tree of allocated nodes, stored linearly. active up to num_nodes (allocated may be larger)

description: Count of active nodes


code: template<class TriangleMeshType> static [FMeshTriInfoCache](API\Runtime\GeometryCore\Util\FMeshTriInfoCache) BuildTriInfoCache ( const TriangleMeshType & Mesh )


className: FMeshTriInfoCache

description: Basic cache of per-triangle information for a mesh

code: struct FMeshTriInfoCache


code: void GetTriInfo ( int TriangleID, FVector3d & NormalOut, double & AreaOut, FVector3d & CentroidOut ) const


code: bool GetNextIndex ( uint32 & NextIndexOut )


code: bool GetNextIndex ( int32 & NextIndexOut )


code: FModuloIteration ( uint32 MaxIndexIn, uint32 StartIndexIn, uint64 ModuloPrimeIn )


className: FModuloIteration

description: FModuloIterationIter(N); uint32Index; while (Iter.GetNextIndex(Index)) { ... }

code: struct FModuloIteration


description: true if a givenIndexis invalid (below zero or above MaxIndex if MaxIndex is valid)

code: bool BadIndex ( int Index ) const


description: a constant map

code: static [FOptionallySparseIndexMap](API\Runtime\GeometryCore\Util\FOptionallySparseIndexMap) ConstantMap ( int ConstantValue, int MaxIndex )


description: Dense variant: returns true unless you have set index to InvalidIndex (eg via SetToInvalid) sparse variant: returns true if index is in map or default index is >= 0 scaleandoffset variant: returns true if default index is >= 0 all return false if index is out-of-bounds

code: bool Contains ( int Index )


className: EMapType

description: Different kinds of storage that could be used for the map

code: enum EMapType { Dense, Sparse, ScaleAndOffset, }


description: an identity map

code: static [FOptionallySparseIndexMap](API\Runtime\GeometryCore\Util\FOptionallySparseIndexMap) IdentityMap ( int MaxIndex )


description: Initialize default values for dense map (sparse defaults are computed on the fly)

code: void InitDefaults()


description: Automatically choose sparse or dense storage based on use estimate

code: void Initialize ( int MaxIndexIn, int SubsetCountEst )


description: Array-style accessor to the map

code: const int operator[] ( int Index ) const


description: Sets the map at a given index. Do not call if MapType is ScaleAndOffset.

code: void Set ( int Index, int Value )


code: void SetInvalid ( int Index )


description: a sparsely-overriden an identity map; elements not explicitly set are identity

code: static [FOptionallySparseIndexMap](API\Runtime\GeometryCore\Util\FOptionallySparseIndexMap) SparseIdentityMap ( int MaxIndex )


description: Default constructor sets map to sparse, w/ constant -1 default value

code: FOptionallySparseIndexMap()


description: Construct map with explicit choice of storage type

code: FOptionallySparseIndexMap ( [EMapType](API\Runtime\GeometryCore\Util\FOptionallySparseIndexMap\EMapType) MapType, int MaxIndex )


description: Construct map with dense storage copied from an existing array

code: FOptionallySparseIndexMap ( [TArray](API\Runtime\Core\Containers\TArray)< int > Dense, int MaxIndex )


description: Construct map with automatically-chosen dense or sparse storage, based on max index and estimated element count

code: FOptionallySparseIndexMap ( int MaxIndex, int SubsetCountEst )


className: FOptionallySparseIndexMap

description: Indexmap that supports dense or sparse storage, or a simple formula-based map (e.g. constant, identity, shift) For dense and sparse, the formula can be used to set default values.

code: struct FOptionallySparseIndexMap

DefaultOffset

description: Mapping to assign defaults for indices that are not explicitly assigned; computed as Index*DefaultScale + DefaultOffset

Dense

description: Storage used when map is dense

MapType

type: EMapType

description: Choice of storage backing the map

MaxIndex

description: Max index in map; -1 will leave the map unbounded (invalid for Dense maps)

Sparse

type: TMap< int, int ...

description: Storage used when map is sparse


code: void AddWarning ( const [FText](API\Runtime\Core\Internationalization\FText) & MessageText, [EMessageLevel](API\Runtime\GeometryCore\Util\FProgressCancel\EMessageLevel) MessageLevel )


code: void AdvanceCurrentScopeProgressBy ( float Amount )


description: Advance current progress a fraction of the way toward a target value For example: if progress is .5, AdvanceProgressToward(1, .5) will take a half step to 1 and set progress to .75 As with all public progress function, progress is expressed relative to the current active progress range and cannot go backward.

code: void AdvanceCurrentScopeProgressToward ( float TargetProgressFrac, float FractionToward )


description: true if client would like to cancel operation

code: bool Cancelled()


description: A newFProgressScopethat covers work from the current progress to the target progress value (relative to the current scope)

code: static [FProgressScope](API\Runtime\GeometryCore\Util\FProgressCancel\FProgressScope) CreateScopeTo ( [FProgressCancel](API\Runtime\GeometryCore\Util\FProgressCancel) * ProgressCancel, float ProgressTo, const [FText](API\Runtime\Core\Internationalization\FText) & Message )


className: EMessageLevel

code: enum EMessageLevel { Internal = 0, UserMessage = 1, UserNotification = 2, UserWarning = 3, UserError = 4, }


className: FMessageInfo

code: struct FMessageInfo

MessageLevel

type: EMessageLevel


code: void AdvanceProgressBy &40; float Amount &41;


code: void AdvanceProgressToward &40; float TargetProgressFrac, float FractionToward &41;


description: Advance to the end of the scope's progress range and close the scope

code: void Done&40;&41;


description: Amount to progress in the current scope to reach the target (scope-relative) progress value

code: float GetDistanceTo &40; float TargetProgressFrac &41;


description: Progress in the current scope

code: float GetProgress&40;&41;


code: FProgressScope & operator&61; &40; const FProgressScope & Other &41;


code: FProgressScope & operator&61; &40; FProgressScope && Other &41;


description: Create a dummy/inactiveFProgressScope


description: Note: This function will leave the current progress unchanged if the target value is less than the current progress  it will not allow the progress value to go backward.

code: void SetProgressTo &40; float NewProgressFrac &41;


code: FProgressScope &40; const FProgressScope & Other &41;


code: FProgressScope &40; FProgressScope && Other &41;


code: FProgressScope &40; FProgressCancel &42; ProgressCancel, float ProgressAmount, const FText & Message &41;


className: FProgressScope

description: Simple helper to track progress in a local scope on an optionalFProgressCancelWill still work if the ProgressCancel is null (just does nothing in that case)

code: class FProgressScope


description: Amount to progress in the current scope to reach the target progress value

code: float GetCurrentScopeDistanceTo ( float TargetProgressFrac )


description: Progress as a fraction of the current scope's active progress range

code: float GetCurrentScopeProgress()


code: void SetCurrentScopeProgressTo ( float NewProgressFrac )


code: void SetMaxMessageDepth ( int32 ScopeDepth )


code: void SetProgressMessage ( const [FText](API\Runtime\Core\Internationalization\FText) & Message )


className: FProgressCancel

description: FProgressCancelis intended to be passed to long-running computes to do two things: 1) provide progress info back to caller 2) allow caller to cancel the computation

code: class FProgressCancel

CancelF

type: TFunction< bool...

Warnings

type: TArray<FMessag...


description: Allocate at specificIndex, which must either be larger than current maxIndex, or on the free list. If larger, all elements up to this one will be pushed onto free list. otherwise we have to do a linear search through free list. If you are doing many of these, it is likely faster to useAllocateAtUnsafe(), and thenRebuildFreeList()after you are done.

code: bool AllocateAt ( int Index )


description: Allocate at specificIndex, which must be free or larger than current maxIndex. However, we do not update free list. So, you probably need to doRebuildFreeList()after calling this.

code: bool AllocateAtUnsafe ( int Index )


code: bool operator&61;&61; &40; const BaseIterator & Other &41; const


code: bool operator&33;&61; &40; const BaseIterator & Other &41; const


code: BaseIterator &40; const FRefCountVector &42; VectorIn, int IndexIn, int LastIn &41;


className: BaseIterator

description: Iterators base iterator for indices with valid refcount (skips zero-refcount indices)

code: class BaseIterator

Index

type: int

Vector

type: constFRefCount...


code: void Decrement ( int Index, unsigned short DecrementCount )


code: FilteredIterator< int, IndexIterator > begin&40;&41;


code: FilteredIterator< int, IndexIterator > end&40;&41;


code: FilteredEnumerable &40; const IndexEnumerable & enumerable, TFunction< bool(int)> FilterFuncIn &41;


className: FilteredEnumerable

description: Iteration object that maps indices output by Index_iteration to a second type

code: class FilteredEnumerable

enumerable

type: IndexEnumerable


code: [FilteredEnumerable](API\Runtime\GeometryCore\Util\FRefCountVector\FilteredEnumerable) FilteredIndices ( [TFunction](API\Runtime\Core\GenericPlatform\TFunction)< bool(int)> FilterFunc ) const


code: int GetRawRefCount ( int Index ) const


code: const [TDynamicVector](API\Runtime\GeometryCore\Util\TDynamicVector)< unsigned short > & GetRawRefCounts() const


code: int GetRefCount ( int Index ) const


description: You should not use this!

code: [TDynamicVector](API\Runtime\GeometryCore\Util\TDynamicVector)< unsigned short > & GetRawRefCountsUnsafe()


code: int Increment ( int Index, unsigned short IncrementCount )


code: IndexEnumerable &40; const FRefCountVector &42; VectorIn &41;


className: IndexEnumerable

description: Enumerable object that providesbegin()/end() semantics, so you can iterate over valid indices using range-based for loop

code: class IndexEnumerable


code: int operator&42;&40;&41; const


code: IndexIterator operator&43;&43; &40; int &41;


code: IndexIterator &40; const FRefCountVector &42; VectorIn, int Index, int Last &41;


className: IndexIterator

description: Iterator over valid indices (ie non-zero refcount)

code: class IndexIterator : public [UE::Geometry::FRefCountVector::BaseIterator](API\Runtime\GeometryCore\Util\FRefCountVector\BaseIterator)


description: Returns iteration object over valid indices usage: for (int idx : indices()) { ... }


code: static constexpr unsigned short INVALID_REF_COUNT = ((uint16) 0xffff);


code: bool IsValid ( int Index ) const


code: bool IsValidUnsafe ( int Index ) const


code: MappedIterator< int, ToType, IndexIterator > begin&40;&41;


code: MappedIterator< int, ToType, IndexIterator > end&40;&41;


code: MappedEnumerable &40; const IndexEnumerable & enumerable, TFunction< ToType(int)> MapFunc &41;


className: MappedEnumerable

description: Enumerable object that maps indices output by Index_iteration to a second type

code: template<typename ToType> class MappedEnumerable

MapFunc

type: TFunction< ToTy...


description: Returns iteration object over mapping applied to valid indices eg usage: for (FVector3d v : mapped_indices(fn_that_looks_up_mesh_vtx_from_id)) { ... }

code: template<typename ToType> [MappedEnumerable](API\Runtime\GeometryCore\Util\FRefCountVector\MappedEnumerable)< ToType > MappedIndices ( [TFunction](API\Runtime\Core\GenericPlatform\TFunction)< ToType(int)> MapFunc ) const


code: [FRefCountVector](API\Runtime\GeometryCore\Util\FRefCountVector) & operator= ( const [FRefCountVector](API\Runtime\GeometryCore\Util\FRefCountVector) & )


code: [FRefCountVector](API\Runtime\GeometryCore\Util\FRefCountVector) & operator= ( [FRefCountVector](API\Runtime\GeometryCore\Util\FRefCountVector) && )


description: For example, we could rebuild ref counts for vertices by iterating over all triangles via the Iterate callable, and in the process any vertex we encounter for the first time gets a ref count of 1 via the AllocateRefCount callable, and any vertex we encounter repeatedly has its ref count incremented by one via the IncrementRefCount callable.

code: template<typename IterateFunc, typename AllocateRefCountFunc, typename IncrementRefCountFunc> void Rebuild ( unsigned int Num, IterateFunc && Iterate, AllocateRefCountFunc && AllocateRefCount, IncrementRefCountFunc && IncrementRefCount )


description: SerializeFRefCountVectorto an archive.

code: void Serialize ( [FArchive](API\Runtime\Core\Serialization\FArchive) & Ar, bool bCompactData, bool bUseCompression )


description: You should not use this!

code: void SetRefCountUnsafe ( int Index, unsigned short ToCount )


code: FRefCountVector ( [FRefCountVector](API\Runtime\GeometryCore\Util\FRefCountVector) && )


className: FRefCountVector

description: No overflow checking is done in release builds.

code: class FRefCountVector


code: typedef [TScaleGridIndexer2](API\Runtime\GeometryCore\Util\TScaleGridIndexer2)< float > FScaleGridIndexer2f


code: typedef [TScaleGridIndexer2](API\Runtime\GeometryCore\Util\TScaleGridIndexer2)< double > FScaleGridIndexer2d


code: typedef [TScaleGridIndexer3](API\Runtime\GeometryCore\Util\TScaleGridIndexer3)< double > FScaleGridIndexer3d


code: FRefCountVector ( const [FRefCountVector](API\Runtime\GeometryCore\Util\FRefCountVector) & )


code: typedef [TScaleGridIndexer3](API\Runtime\GeometryCore\Util\TScaleGridIndexer3)< float > FScaleGridIndexer3f


code: typedef [TShiftGridIndexer2](API\Runtime\GeometryCore\Util\TShiftGridIndexer2)< double > FShiftGridIndexer2d


code: typedef [TShiftGridIndexer2](API\Runtime\GeometryCore\Util\TShiftGridIndexer2)< float > FShiftGridIndexer2f


code: typedef [TShiftGridIndexer3](API\Runtime\GeometryCore\Util\TShiftGridIndexer3)< double > FShiftGridIndexer3d


code: typedef [TShiftGridIndexer3](API\Runtime\GeometryCore\Util\TShiftGridIndexer3)< float > FShiftGridIndexer3f


description: Create a list at the given ListIndex

code: void AllocateAt ( int32 ListIndex )


description: Grab a block from the free list, or allocate a new one

code: int32 AllocateBlock()


code: void GotoNextOverflow&40;&41;


description: Push a link-node onto the free list

code: void AddFreeLink ( int32 ptr )


code: bool operator&61;&61; &40; const BaseValueIterator & Other &41; const


code: bool operator&33;&61; &40; const BaseValueIterator & Other &41; const


code: BaseValueIterator &40; const FSmallListSet &42; ListSetIn, int32 ListIndex, bool is_end &41;


className: BaseValueIterator

description: BaseValueIteratoris a base class forValueIteratorandMappedValueIteratorbelow.

code: class BaseValueIterator

ListSet

type: constFSmallLis...


description: iterator for start of list at ListIndex, with given value mapping function

code: [MappedValueIterator](API\Runtime\GeometryCore\Util\FSmallListSet\MappedValueIterator) BeginMappedValues ( int32 ListIndex, const [TFunction](API\Runtime\Core\GenericPlatform\TFunction)< int32(int32)> & MapFunc ) const


className: BLOCKSIZE

description: Size of initial linear-memory portion of lists

code: static constexpr int32 BLOCKSIZE = 8;


description: iterator for start of list at ListIndex

code: [ValueIterator](API\Runtime\GeometryCore\Util\FSmallListSet\ValueIterator) BeginValues ( int32 ListIndex ) const


description: Remove all elements from the list at ListIndex

code: void Clear ( int32 ListIndex )


description: Offset from start of linear-memory portion of list that contains pointer to head of variable-length linked list

code: static constexpr int32 BLOCK_LIST_OFFSET = BLOCKSIZE + 1;


description:
Search for the given Value in list at ListIndex
true if found

code: bool Contains ( int32 ListIndex, int32 Value ) const


description: iterator for end of list at ListIndex, with given value mapping function

code: [MappedValueIterator](API\Runtime\GeometryCore\Util\FSmallListSet\MappedValueIterator) EndMappedValues ( int32 ListIndex, const [TFunction](API\Runtime\Core\GenericPlatform\TFunction)< int32(int32)> & MapFunc ) const


description: iterator for end of list at ListIndex

code: [ValueIterator](API\Runtime\GeometryCore\Util\FSmallListSet\ValueIterator) EndValues ( int32 ListIndex ) const


description: Call ApplyFunc on each element of the list at ListIndex

code: void Enumerate ( int32 ListIndex, [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< void(int32)> ApplyFunc ) const


description:
Search the list at ListIndex for a value where PredicateFunc(value) returns true
the found value, or the InvalidValue argument if not found

code: int32 Find ( int32 ListIndex, const [TFunction](API\Runtime\Core\GenericPlatform\TFunction)< bool(int32)> & PredicateFunc, int32 InvalidValue ) const


description:
Does not check for zero-size-list!
the first item in the list at ListIndex

code: int32 First ( int32 ListIndex ) const


description: the size of the list at ListIndex

code: int32 GetCount ( int32 ListIndex ) const


description: Insert Value into list at ListIndex

code: void Insert ( int32 ListIndex, int32 Value )