code: TExactIntrTriangle3Triangle3 ( [TTriangle3](API\Runtime\GeometryCore\TTriangle3)< Real > Triangle0, [TTriangle3](API\Runtime\GeometryCore\TTriangle3)< Real > Triangle1 )


description: An exact-math version ofTIntrTriangle3Triangle3, with less persistent state  results are returned per-function rather than kept on the struct.

module: GeometryCore

code: template<typename Real> class TExactIntrTriangle3Triangle3

type: TTriangle3< Rea...

description: Inputs.


description:
Calculate the intersection interval
true if the intervals intersect

code: bool Find()


description: first or second point of intersection interval

code: RealType GetIntersection ( int i )


description:
Fast check to see if intervals intersect, but does not calculate intersection interval
true if intervals intersect

code: bool Test() const


code: TIntersector1 ( const [TInterval1](API\Runtime\GeometryCore\TInterval1)< RealType > & u, const [TInterval1](API\Runtime\GeometryCore\TInterval1)< RealType > & v )


code: TIntersector1 ( RealType u0, RealType u1, RealType v0, RealType v1 )


description: TIntersector1computes the intersection of one-dimensional intervals [u0,u1] and [v0,v1]. The end points of the input intervals must be ordered u0 <= u1 and v0 <= v1. Infinite and degenerate intervals are allowed.

code: template<typename RealType> class TIntersector1

NumIntersections

type: int

description: Number of intersections found.

U

type: TInterval1< Rea...

description: First interval

V

description: Second interval


code: static EIntersectionType Classify ( const [TVector2](API\Runtime\Core\Math\TVector2)< RealType > & P0, const [TVector2](API\Runtime\Core\Math\TVector2)< RealType > & D0, const [TVector2](API\Runtime\Core\Math\TVector2)< RealType > & P1, const [TVector2](API\Runtime\Core\Math\TVector2)< RealType > & D1, RealType DotThreshold, RealType DistThreshold, [TVector2](API\Runtime\Core\Math\TVector2)< RealType > & s )


code: RealType GetDistThreshold() const


code: RealType GetDotThreshold() const


code: const [TLine2](API\Runtime\GeometryCore\TLine2)< RealType > & GetLine1() const


code: const [TLine2](API\Runtime\GeometryCore\TLine2)< RealType > & GetLine2() const


code: bool IsSimpleIntersection() const


code: void SetDistThreshold ( RealType Value )


code: void SetDotThreshold ( RealType Value )


code: void SetLine1 ( const [TLine2](API\Runtime\GeometryCore\TLine2)< RealType > & Value )


code: void SetLine2 ( [TLine2](API\Runtime\GeometryCore\TLine2)< RealType > & Value )


code: TIntrLine2Line2 ( const [TLine2](API\Runtime\GeometryCore\TLine2)< RealType > & Line1In, const [TLine2](API\Runtime\GeometryCore\TLine2)< RealType > & Line2In )


description: Compute intersection between two 2D lines

code: template<typename RealType> class TIntrLine2Line2

DistThresh

type: RealType

type: TLine2< RealTyp...

description: Input data

Point

type: TVector2< RealT...

description: Result data

Result

type: EIntersectionRe...

Type

type: EIntersectionTy...


code: static bool GetInterval ( const [TVector2](API\Runtime\Core\Math\TVector2)< Real > & Origin, const [TVector2](API\Runtime\Core\Math\TVector2)< Real > & Direction, const [TTriangle2](API\Runtime\GeometryCore\TTriangle2)< Real > & Tri, const [TVector](API\Runtime\Core\Math\TVector)< Real > & Dist, const [FVector3i](API\Runtime\GeometryCore\FVector3i) & Sign, [TVector2](API\Runtime\Core\Math\TVector2)< Real > & param )


code: [TLine2](API\Runtime\GeometryCore\TLine2)< Real > GetLine() const


code: [TTriangle2](API\Runtime\GeometryCore\TTriangle2)< Real > GetTriangle() const


code: void SetLine ( const [TLine2](API\Runtime\GeometryCore\TLine2)< Real > & LineIn )


code: void SetTriangle ( const [TTriangle2](API\Runtime\GeometryCore\TTriangle2)< Real > & TriangleIn )


code: static void TriangleLineRelations ( const [TVector2](API\Runtime\Core\Math\TVector2)< Real > & Origin, const [TVector2](API\Runtime\Core\Math\TVector2)< Real > & Direction, const [TTriangle2](API\Runtime\GeometryCore\TTriangle2)< Real > & Tri, [TVector](API\Runtime\Core\Math\TVector)< Real > & Dist, [FVector3i](API\Runtime\GeometryCore\FVector3i) & Sign, int & Positive, int & Negative, int & Zero, Real Tolerance )


code: TIntrLine2Triangle2 ( [TLine2](API\Runtime\GeometryCore\TLine2)< Real > l, [TTriangle2](API\Runtime\GeometryCore\TTriangle2)< Real > t )


description: Compute intersection between 2D Line and 2D Triangle

code: template<typename Real> class TIntrLine2Triangle2

Line

type: TLine2< Real >

description: Input.

type: double

type: TVector2< Real ...

Quantity

description: Output.

Triangle

type: TTriangle2< Rea...


code: static bool Clip ( RealType denom, RealType numer, RealType & t0, RealType & t1 )


code: static bool DoClipping ( RealType & t0, RealType & t1, const [TVector](API\Runtime\Core\Math\TVector)< RealType > & RayOrigin, const [TVector](API\Runtime\Core\Math\TVector)< RealType > & RayDirection, const [TAxisAlignedBox3](API\Runtime\GeometryCore\TAxisAlignedBox3)< RealType > & Box, bool solid, int & quantity, [TVector](API\Runtime\Core\Math\TVector)< RealType > & Point0, [TVector](API\Runtime\Core\Math\TVector)< RealType > & Point1, EIntersectionType & intrType )


description:
Find intersection of ray with AABB and returns ray T-value of intersection point (orTNumericLimits::Max()on miss)
true if ray intersects box

code: static bool FindIntersection ( const [TRay](API\Runtime\Core\Math\TRay)< RealType > & Ray, const [TAxisAlignedBox3](API\Runtime\GeometryCore\TAxisAlignedBox3)< RealType > & Box, RealType & RayParamOut )


description:
Test if ray intersects box
true if ray intersects box

code: static bool TestIntersection ( const [TRay](API\Runtime\Core\Math\TRay)< RealType > & Ray, const [TAxisAlignedBox3](API\Runtime\GeometryCore\TAxisAlignedBox3)< RealType > & Box, RealType ExpandExtents )


description: Compute intersection between 3D ray and 3D axis-aligned box

code: template<typename RealType> class TIntrRay3AxisAlignedBox3


description:
Find intersection of ray with oriented box
Based on GeometricTools Engine implementation:https://www.geometrictools.com/GTE/Mathematics/IntrRay3OrientedBox3.htrue if ray intersects box

code: static bool FindIntersection ( const [TRay](API\Runtime\Core\Math\TRay)< RealType > & Ray, const [TOrientedBox3](API\Runtime\GeometryCore\TOrientedBox3)< RealType > & Box, RealType & RayParamOut )


description: Compute intersection between 3D ray and 3D oriented box

code: template<typename RealType> class TIntrRay3OrientedBox3


description:
Find intersection point
true if ray intersects triangle

code: bool Find()


description: true if ray intersects triangle

code: bool Test()


code: TIntrRay3Triangle3 ( const [TRay](API\Runtime\Core\Math\TRay)< Real > & RayIn, const [TTriangle3](API\Runtime\GeometryCore\TTriangle3)< Real > & TriangleIn )


description: Compute intersection between 3D ray and 3D triangle

code: template<typename Real> class TIntrRay3Triangle3

Ray

type: TRay< Real >

description: Input.

RayParameter

type: Real

description: Output.


description: This is implemented inTSegment2::Intersectsbool Test()


code: RealType GetDotThreshold() const


code: RealType GetIntervalThreshold() const


code: const [TSegment2](API\Runtime\GeometryCore\TSegment2)< RealType > & GetSegment1() const


code: const [TSegment2](API\Runtime\GeometryCore\TSegment2)< RealType > & GetSegment2() const


code: bool IsSimpleIntersection() const


code: void SetDotThreshold ( RealType Value )


code: void SetIntervalThreshold ( RealType Value )


code: void SetSegment1 ( const [TSegment2](API\Runtime\GeometryCore\TSegment2)< RealType > & Value )


code: void SetSegment2 ( const [TSegment2](API\Runtime\GeometryCore\TSegment2)< RealType > & Value )


code: TIntrSegment2Segment2 ( const [TSegment2](API\Runtime\GeometryCore\TSegment2)< RealType > & Segment1In, const [TSegment2](API\Runtime\GeometryCore\TSegment2)< RealType > & Segment2In )


description: q = 2: The segments are collinear and intersect in a segment. Type is Segment. Points are Point0 and Point1 Calculate intersection between two 2D line segments

code: template<typename RealType> class TIntrSegment2Segment2

description: These values are all on segment 1, unlike many other tests!!

Quantity

description: Outputs

type: TSegment2< Real...

description: Inputs


code: [TIntrSegment2Triangle2](API\Runtime\GeometryCore\Intersection\TIntrSegment2Triangle2) * Compute ( Real Tolerance )


code: bool Find ( Real Tolerance )


code: [TSegment2](API\Runtime\GeometryCore\TSegment2)< Real > GetSegment() const


code: [TTriangle2](API\Runtime\GeometryCore\TTriangle2)< Real > GetTriangle() const


code: void SetSegment ( const [TSegment2](API\Runtime\GeometryCore\TSegment2)< Real > & SegmentIn )


code: void SetTriangle ( const [TTriangle2](API\Runtime\GeometryCore\TTriangle2)< Real > & TriangleIn )


code: TIntrSegment2Triangle2 ( [TSegment2](API\Runtime\GeometryCore\TSegment2)< Real > Seg, [TTriangle2](API\Runtime\GeometryCore\TTriangle2)< Real > Tri )


description: Compute intersection between 2D segment and 2D triangle. Note that if Segment.Extent is zero, this will test if the Segment Center is in the triangle.

code: template<typename Real> class TIntrSegment2Triangle2

description: Output.

Segment

description: Input.


code: [TTriangle2](API\Runtime\GeometryCore\TTriangle2)< Real > GetBox() const


code: bool IsTriangleOriented() const


code: void SetBox ( const [TAxisAlignedBox2](API\Runtime\GeometryCore\TAxisAlignedBox2)< Real > & BoxIn )


code: void SetTriangleOriented ( const bool bIsOrientedIn )


description: Output TODO: Unlike other TIntrPrim2Prim2 classes, this only computes the Boolean yes/noTest()But in the future we should add the option toCompute()the intersection polygon as well (e.g. refer to IntrTriangle2Triangle.h)


code: TIntrTriangle2AxisAlignedBox2 ( [TTriangle2](API\Runtime\GeometryCore\TTriangle2)< Real > Triangle, [TAxisAlignedBox2](API\Runtime\GeometryCore\TAxisAlignedBox2)< Real > Box, bool bTriangleIsOriented )


description: Compute intersection between a 2D triangle and a 2D axis-aligned box

code: template<typename Real> class TIntrTriangle2AxisAlignedBox2

Box

type: TAxisAlignedBox...

bTriangleIsOriented

type: bool

Triangle

description: Input.


code: [TTriangle2](API\Runtime\GeometryCore\TTriangle2)< Real > GetTriangle0() const


code: [TTriangle2](API\Runtime\GeometryCore\TTriangle2)< Real > GetTriangle1() const


code: void SetTriangle0 ( const [TTriangle2](API\Runtime\GeometryCore\TTriangle2)< Real > & Triangle0In )


code: static int WhichSide ( const [TTriangle2](API\Runtime\GeometryCore\TTriangle2)< Real > & V, const [TVector2](API\Runtime\Core\Math\TVector2)< Real > & P, const [TVector2](API\Runtime\Core\Math\TVector2)< Real > & D )


code: TIntrTriangle2Triangle2 ( [TTriangle2](API\Runtime\GeometryCore\TTriangle2)< Real > T0, [TTriangle2](API\Runtime\GeometryCore\TTriangle2)< Real > T1 )


code: void SetTriangle1 ( const [TTriangle2](API\Runtime\GeometryCore\TTriangle2)< Real > & Triangle1In )


description: Compute intersection between 2D triangles

code: template<typename Real> class TIntrTriangle2Triangle2

Points

description: Intersection polygon - this array will always be 6 elements long, however only the first Quantity vertices will be valid

Quantity

description: Output.

description: Input.


code: bool ContainsPoint ( const [TTriangle3](API\Runtime\GeometryCore\TTriangle3)< Real > & triangle, const [TPlane3](API\Runtime\GeometryCore\TPlane3)< Real > & plane, const [TVector](API\Runtime\Core\Math\TVector)< Real > & point )


code: bool GetCoplanarIntersection ( const [TPlane3](API\Runtime\GeometryCore\TPlane3)< Real > & plane, const [TTriangle3](API\Runtime\GeometryCore\TTriangle3)< Real > & tri0, const [TTriangle3](API\Runtime\GeometryCore\TTriangle3)< Real > & tri1 )


code: [TTriangle3](API\Runtime\GeometryCore\TTriangle3)< Real > GetTriangle0() const


code: [TTriangle3](API\Runtime\GeometryCore\TTriangle3)< Real > GetTriangle1() const


code: static bool Intersects ( const [TTriangle3](API\Runtime\GeometryCore\TTriangle3)< Real > & Triangle0, const [TTriangle3](API\Runtime\GeometryCore\TTriangle3)< Real > & Triangle1, Real Tolerance )


code: bool IntersectsSegment ( const [TPlane3](API\Runtime\GeometryCore\TPlane3)< Real > & plane, const [TTriangle3](API\Runtime\GeometryCore\TTriangle3)< Real > & triangle, const [TVector](API\Runtime\Core\Math\TVector)< Real > & end0, const [TVector](API\Runtime\Core\Math\TVector)< Real > & end1 )


description:
Solve a common sub-problem for triangle-triangle intersection  find the sub-segment (or point) where a triangle intersects a coplanar segment
Number of points representing the intersection result (0 for none, 1 for point, 2 for segment)

code: static int IntersectTriangleWithCoplanarSegment ( const [TPlane3](API\Runtime\GeometryCore\TPlane3)< Real > & plane, const [TTriangle3](API\Runtime\GeometryCore\TTriangle3)< Real > & triangle, const [TVector](API\Runtime\Core\Math\TVector)< Real > & end0, const [TVector](API\Runtime\Core\Math\TVector)< Real > & end1, [TVector](API\Runtime\Core\Math\TVector)< Real > & OutA, [TVector](API\Runtime\Core\Math\TVector)< Real > & OutB, Real Tolerance )


code: static void ProjectOntoAxis ( const [TTriangle3](API\Runtime\GeometryCore\TTriangle3)< Real > & triangle, const [TVector](API\Runtime\Core\Math\TVector)< Real > & axis, Real & fmin, Real & fmax )


code: void SetReportCoplanarIntersection ( bool bReportCoplanarIntersectionIn )


description: Store an externally-computed binary yes/no result

code: void SetResult ( bool IsIntersecting )


description: Store an externally-computed segment intersection result

code: void SetResult ( const [TVector](API\Runtime\Core\Math\TVector)< Real > & A, const [TVector](API\Runtime\Core\Math\TVector)< Real > & B )


description: Store an externally-computed no-intersection result

code: void SetResultNone()


code: void SetTolerance ( Real ToleranceIn )


code: void SetTriangle0 ( const [TTriangle3](API\Runtime\GeometryCore\TTriangle3)< Real > & Triangle0In )


code: void SetTriangle1 ( const [TTriangle3](API\Runtime\GeometryCore\TTriangle3)< Real > & Triangle1In )


code: static void TrianglePlaneRelations ( const [TTriangle3](API\Runtime\GeometryCore\TTriangle3)< Real > & triangle, const [TPlane3](API\Runtime\GeometryCore\TPlane3)< Real > & plane, [TVector](API\Runtime\Core\Math\TVector)< Real > & distance, [FIndex3i](API\Runtime\GeometryCore\FIndex3i) & sign, int & positive, int & negative, int & zero, Real Tolerance )


code: TIntrTriangle3Triangle3 ( const [TTriangle3](API\Runtime\GeometryCore\TTriangle3)< Real > & T0, const [TTriangle3](API\Runtime\GeometryCore\TTriangle3)< Real > & T1 )


description: Compute intersection between 3D triangles useTest()for fast boolean query, does not compute intersection info useFind()to compute full informationBydefault fully-contained co-planar triangles are not reported as intersecting. Call SetReportCoplanarIntersection(true) to handle this case (more expensive)

code: template<typename Real> class TIntrTriangle3Triangle3

bReportCoplanarIntersection

description: If true, will return intersection polygons for co-planar triangles.

Points

type: TVector< Real >...

description: Intersection points (for point, line, polygon) only first Quantity elements are relevant

Result

description: Result flags

type: TTriangle3< Rea...

description: Input.


description:
Sphere Containment Queries
true if InnerSphere is fully contained within OuterSphere

code: namespace UE { namespace Geometry { template<typename RealType> bool UE::Geometry::IsInside ( const [TSphere3](API\Runtime\GeometryCore\TSphere3)< RealType > & OuterSphere, const [TSphere3](API\Runtime\GeometryCore\TSphere3)< RealType > & InnerSphere ) } }


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

code: namespace UE { namespace Geometry { template<typename RealType, typename GridType> bool UE::Geometry::IsInside ( const [TCapsule3](API\Runtime\GeometryCore\TCapsule3)< RealType > & OuterCapsule, const [TTriLinearGridInterpolant](API\Runtime\GeometryCore\Implicit\TTriLinearGridInterpolant)< GridType > & InnerGrid ) } }


description:
OrientedBox Containment Queries
true if InnerBox is fully contained within OuterBox

code: namespace UE { namespace Geometry { template<typename RealType> bool UE::Geometry::IsInside ( const [TOrientedBox3](API\Runtime\GeometryCore\TOrientedBox3)< RealType > & OuterBox, const [TOrientedBox3](API\Runtime\GeometryCore\TOrientedBox3)< RealType > & InnerBox ) } }


description: true if InnerCapsule is fully contained within OuterBox

code: namespace UE { namespace Geometry { template<typename RealType> bool UE::Geometry::IsInside ( const [TOrientedBox3](API\Runtime\GeometryCore\TOrientedBox3)< RealType > & OuterBox, const [TCapsule3](API\Runtime\GeometryCore\TCapsule3)< RealType > & InnerCapsule ) } }


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

code: namespace UE { namespace Geometry { template<typename RealType, typename EnumerablePointsType, typename E> bool UE::Geometry::IsInside ( const [TOrientedBox3](API\Runtime\GeometryCore\TOrientedBox3)< RealType > & OuterBox, EnumerablePointsType EnumerablePts ) } }


description: true if InnerSphere is fully contained within OuterBox

code: namespace UE { namespace Geometry { template<typename RealType> bool UE::Geometry::IsInside ( const [TOrientedBox3](API\Runtime\GeometryCore\TOrientedBox3)< RealType > & OuterBox, const [TSphere3](API\Runtime\GeometryCore\TSphere3)< RealType > & InnerSphere ) } }


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

code: namespace UE { namespace Geometry { template<typename RealType, typename GridType> bool UE::Geometry::IsInside ( const [TOrientedBox3](API\Runtime\GeometryCore\TOrientedBox3)< RealType > & OuterBox, const [TTriLinearGridInterpolant](API\Runtime\GeometryCore\Implicit\TTriLinearGridInterpolant)< GridType > & InnerGrid ) } }


description: To test if an object is inside an SDF, we first rasterize the object's AABB onto the SDF grid. If all of the AABB cells have negative SDF values, we report that the object is inside. Note this is conservative, not exact  so an object may actually be inside the implicit surface defined by the SDF, but if its AABB is not fully inside then we will report "not inside."

code: namespace UE { namespace Geometry { template<typename RealType, typename GridType> bool UE::Geometry::IsInside ( const [TTriLinearGridInterpolant](API\Runtime\GeometryCore\Implicit\TTriLinearGridInterpolant)< GridType > & OuterGrid, const [UE::Geometry::TAxisAlignedBox3](API\Runtime\GeometryCore\TAxisAlignedBox3)< RealType > & InnerAABB ) } }


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

code: namespace UE { namespace Geometry { template<typename RealType, typename GridType> bool UE::Geometry::IsInside ( const [TTriLinearGridInterpolant](API\Runtime\GeometryCore\Implicit\TTriLinearGridInterpolant)< GridType > & OuterGrid, const [TTransform](API\Runtime\Core\Math\TTransform)< RealType > & OuterGridTransform, const [TCapsule3](API\Runtime\GeometryCore\TCapsule3)< RealType > & InnerCapsule ) } }


description: Signed Distance Field containment queries Test if the axis-aligned bounding box of InnerSphere is completely inside the negative region of the signed distance field discretized on OuterGrid

code: namespace UE { namespace Geometry { template<typename RealType, typename GridType> bool UE::Geometry::IsInside ( const [TTriLinearGridInterpolant](API\Runtime\GeometryCore\Implicit\TTriLinearGridInterpolant)< GridType > & OuterGrid, const [TTransform](API\Runtime\Core\Math\TTransform)< RealType > & OuterGridTransform, const [TSphere3](API\Runtime\GeometryCore\TSphere3)< RealType > & InnerSphere ) } }


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

code: namespace UE { namespace Geometry { template<typename RealType, typename GridType> bool UE::Geometry::IsInside ( const [TTriLinearGridInterpolant](API\Runtime\GeometryCore\Implicit\TTriLinearGridInterpolant)< GridType > & OuterGrid, const [TTransform](API\Runtime\Core\Math\TTransform)< RealType > & OuterGridTransform, const [TOrientedBox3](API\Runtime\GeometryCore\TOrientedBox3)< RealType > & InnerBox ) } }


description: true if InnerCapsule is fully contained within OuterSphere

code: namespace UE { namespace Geometry { template<typename RealType> bool UE::Geometry::IsInside ( const [TSphere3](API\Runtime\GeometryCore\TSphere3)< RealType > & OuterSphere, const [TCapsule3](API\Runtime\GeometryCore\TCapsule3)< RealType > & InnerCapsule ) } }


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

code: namespace UE { namespace Geometry { template<typename RealType, typename GridType, typename EnumerablePointsType, typename E> bool UE::Geometry::IsInside ( const [TTriLinearGridInterpolant](API\Runtime\GeometryCore\Implicit\TTriLinearGridInterpolant)< GridType > & OuterGrid, const [TTransform](API\Runtime\Core\Math\TTransform)< RealType > & OuterGridTransform, EnumerablePointsType EnumerablePts ) } }


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

code: namespace UE { namespace Geometry { template<typename RealType, typename GridType1, typename GridType2> bool UE::Geometry::IsInside ( const [TTriLinearGridInterpolant](API\Runtime\GeometryCore\Implicit\TTriLinearGridInterpolant)< GridType1 > & OuterGrid, const [TTransform](API\Runtime\Core\Math\TTransform)< RealType > & OuterGridTransform, const [TTriLinearGridInterpolant](API\Runtime\GeometryCore\Implicit\TTriLinearGridInterpolant)< GridType2 > & InnerGrid, const [TTransform](API\Runtime\Core\Math\TTransform)< RealType > & InnerGridTransform ) } }


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

code: namespace UE { namespace Geometry { template<typename RealType, typename EnumerablePointsType, typename E> bool UE::Geometry::IsInside ( const [TSphere3](API\Runtime\GeometryCore\TSphere3)< RealType > & OuterSphere, EnumerablePointsType EnumerablePts ) } }


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

code: namespace UE { namespace Geometry { template<typename RealType, typename GridType> bool UE::Geometry::IsInside ( const [TSphere3](API\Runtime\GeometryCore\TSphere3)< RealType > & OuterSphere, const [TTriLinearGridInterpolant](API\Runtime\GeometryCore\Implicit\TTriLinearGridInterpolant)< GridType > & InnerGrid ) } }


description: true if InnerBox is fully contained within OuterSphere

code: namespace UE { namespace Geometry { template<typename RealType> bool UE::Geometry::IsInside ( const [TSphere3](API\Runtime\GeometryCore\TSphere3)< RealType > & OuterSphere, const [TOrientedBox3](API\Runtime\GeometryCore\TOrientedBox3)< RealType > & InnerBox ) } }


description: true if InnerSphere is fully contained within OuterCapsule

code: namespace UE { namespace Geometry { template<typename RealType> bool UE::Geometry::IsInside ( const [TCapsule3](API\Runtime\GeometryCore\TCapsule3)< RealType > & OuterCapsule, const [TSphere3](API\Runtime\GeometryCore\TSphere3)< RealType > & InnerSphere ) } }


description:
Capsule Containment Queries
true if InnerCapsule is fully contained within OuterCapsule

code: namespace UE { namespace Geometry { template<typename RealType> bool UE::Geometry::IsInside ( const [TCapsule3](API\Runtime\GeometryCore\TCapsule3)< RealType > & OuterCapsule, const [TCapsule3](API\Runtime\GeometryCore\TCapsule3)< RealType > & InnerCapsule ) } }


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

code: namespace UE { namespace Geometry { template<typename RealType, typename EnumerablePointsType, typename E> bool UE::Geometry::IsInside ( const [TCapsule3](API\Runtime\GeometryCore\TCapsule3)< RealType > & OuterCapsule, EnumerablePointsType EnumerablePts ) } }


description:
Convex Hull/Volume containment queries Test if the convex volume defined by a set of Halfspaces contains InnerSphere. Each Halfspace normal should point "outwards", ie it defines the outer halfspace that is not inside the Convex Volume.
false if InnerSphere intersects any of the Halfspaces

code: namespace UE { namespace Geometry { template<typename RealType> bool UE::Geometry::IsInsideHull ( [TArrayView](API\Runtime\Core\Containers\TArrayView)< [THalfspace3](API\Runtime\GeometryCore\THalfspace3)< RealType >> Halfspaces, const [TSphere3](API\Runtime\GeometryCore\TSphere3)< RealType > & InnerSphere ) } }


description: true if InnerBox is fully contained within OuterCapsule

code: namespace UE { namespace Geometry { template<typename RealType> bool UE::Geometry::IsInside ( const [TCapsule3](API\Runtime\GeometryCore\TCapsule3)< RealType > & OuterCapsule, const [TOrientedBox3](API\Runtime\GeometryCore\TOrientedBox3)< RealType > & InnerBox ) } }


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

code: namespace UE { namespace Geometry { template<typename RealType, typename EnumerablePointsType, typename E> bool UE::Geometry::IsInsideHull ( [TArrayView](API\Runtime\Core\Containers\TArrayView)< [THalfspace3](API\Runtime\GeometryCore\THalfspace3)< RealType >> Halfspaces, EnumerablePointsType EnumerablePts ) } }


code: namespace UE { namespace Geometry { template<typename RealType, typename GridType> bool UE::Geometry::IsInsideHull ( [TArrayView](API\Runtime\Core\Containers\TArrayView)< [THalfspace3](API\Runtime\GeometryCore\THalfspace3)< RealType >> Halfspaces, const [TTriLinearGridInterpolant](API\Runtime\GeometryCore\Implicit\TTriLinearGridInterpolant)< GridType > & InnerGrid ) } }


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

code: namespace UE { namespace Geometry { template<typename RealType> bool UE::Geometry::IsInsideHull ( [TArrayView](API\Runtime\Core\Containers\TArrayView)< [THalfspace3](API\Runtime\GeometryCore\THalfspace3)< RealType >> Halfspaces, const [TCapsule3](API\Runtime\GeometryCore\TCapsule3)< RealType > & InnerCapsule ) } }


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

code: namespace UE { namespace Geometry { template<typename RealType> bool UE::Geometry::IsInsideHull ( [TArrayView](API\Runtime\Core\Containers\TArrayView)< [THalfspace3](API\Runtime\GeometryCore\THalfspace3)< RealType >> Halfspaces, const [TOrientedBox3](API\Runtime\GeometryCore\TOrientedBox3)< RealType > & InnerBox ) } }


description:
Halfspace Intersection Queries
true if Halfspace and Sphere intersect

code: namespace UE { namespace Geometry { template<typename RealType> bool UE::Geometry::TestIntersection ( const [THalfspace3](API\Runtime\GeometryCore\THalfspace3)< RealType > & Halfspace, const [TSphere3](API\Runtime\GeometryCore\TSphere3)< RealType > & Sphere ) } }


description: true if Halfspace and Capsule intersect

code: namespace UE { namespace Geometry { template<typename RealType> bool UE::Geometry::TestIntersection ( const [THalfspace3](API\Runtime\GeometryCore\THalfspace3)< RealType > & Halfspace, const [TCapsule3](API\Runtime\GeometryCore\TCapsule3)< RealType > & Capsule ) } }


description: Return true if Segment and Box intersect and false otherwise.

code: namespace UE { namespace Geometry { template<typename Real> bool UE::Geometry::TestIntersection ( const [TSegment2](API\Runtime\GeometryCore\TSegment2)< Real > & Segment, const [TAxisAlignedBox2](API\Runtime\GeometryCore\TAxisAlignedBox2)< Real > & Box ) } }


description: true if Halfspace and Box intersect

code: namespace UE { namespace Geometry { template<typename RealType> bool UE::Geometry::TestIntersection ( const [THalfspace3](API\Runtime\GeometryCore\THalfspace3)< RealType > & Halfspace, const [TOrientedBox3](API\Runtime\GeometryCore\TOrientedBox3)< RealType > & Box ) } }


description: Apply given Transform to a Mesh. Modifies Vertex Positions and Normals, and any Per-Triangle Normal Overlays

code: namespace MeshAdapterTransforms { template<class TriangleMeshType> void MeshAdapterTransforms::ApplyTransform ( TriangleMeshType & Mesh, const [FTransformSRT3d](API\Runtime\GeometryCore\FTransformSRT3d) & Transform ) }


description: Apply inverse of given Transform to a Mesh. Modifies Vertex Positions and Normals, and any Per-Triangle Normal Overlays

code: namespace MeshAdapterTransforms { template<class TriangleMeshType> void MeshAdapterTransforms::ApplyTransformInverse ( TriangleMeshType & Mesh, const [FTransformSRT3d](API\Runtime\GeometryCore\FTransformSRT3d) & Transform ) }


code: namespace MeshAdapterTransforms { template<class TriangleMeshType> void MeshAdapterTransforms::ApplyTransform ( TriangleMeshType & Mesh, [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< FVector3d(const FVector3d &)> PositionTransform, [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< FVector3f(const FVector3f &)> NormalTransform ) }


description: Transform Mesh out of local coordinates of Frame

code: namespace MeshAdapterTransforms { template<class TriangleMeshType> void MeshAdapterTransforms::FrameCoordsToWorld ( TriangleMeshType & Mesh, const [FFrame3d](API\Runtime\GeometryCore\FFrame3d_1) & Frame ) }


description: Apply Translation to vertex positions of Mesh. Does not modify any other attributes.

code: namespace MeshAdapterTransforms { template<class TriangleMeshType> void MeshAdapterTransforms::Translate ( TriangleMeshType & Mesh, const FVector3d & Translation ) }


description: Transform Mesh into local coordinates of Frame

code: namespace MeshAdapterTransforms { template<class TriangleMeshType> void MeshAdapterTransforms::WorldToFrameCoords ( TriangleMeshType & Mesh, const [FFrame3d](API\Runtime\GeometryCore\FFrame3d_1) & Frame ) }


description: Test if a given edge collapse would change the mesh shape or UVs unacceptably

code: static bool CollapseWouldChangeShapeOrUVs ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, const [TSet](API\Runtime\Core\Containers\TSet)< int > & PathEdgeSet, double DotTolerance, int SourceEID, int32 RemoveV, const FVector3d & RemoveVPos, int32 KeepV, const FVector3d & KeepVPos, const FVector3d & EdgeDir, bool bPreserveTriangleGroups, bool bPreserveUVsForMesh, bool bPreserveVertexUVs, bool bPreserveOverlayUVs, float UVToleranceSq, bool bPreserveVertexNormals, float NormalEqualCosThreshold )


description: Test if a given edge collapse would cause a triangle flip or other unacceptable decrease in mesh quality Specialized for collapsing at flat triangles Test if a given edge collapse would cause a triangle flip or other unacceptable decrease in mesh quality

code: static bool CollapseWouldHurtTriangleQuality ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, const FVector3d & RemoveVNormal, int32 RemoveV, const FVector3d & RemoveVPos, int32 KeepV, const FVector3d & KeepVPos, double TryToImproveTriQualityThreshold, bool bHasMultipleNormals )


description:
The below helper functions are used by SimplifyAlongEdges, but also the similar customized versions of the same algorithm inFMeshBooleanandFMeshSelfUnionas well Test if the triangles connected to a vertex are all coplanar
Whether all the triangles were coplanar

code: static bool IsFlat ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, int VID, double DotTolerance, FVector3d & OutFirstNormal )


description: Simplify Mesh along the given edges, and update the edge set accordingly

code: void SimplifyAlongEdges ( [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, [TSet](API\Runtime\Core\Containers\TSet)< int32 > & InOutEdges, [TUniqueFunction](API\Runtime\Core\Templates\TUniqueFunction)< void(const [DynamicMeshInfo::FEdgeCollapseInfo](API\Runtime\GeometryCore\DynamicMesh\FEdgeCollapseInfo) &)> ProcessCollapse ) const


description:
Test if the triangles connected to a vertex could be flattened by folding along the given edge
Whether all the triangles were coplanar

code: static bool IsDevelopableAlongEdge ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, int EID, int VID, double DotTolerance, FVector3d & NormalA, bool & bIsFlat )


description:
Compute the Boolean operation
true if operation succeeds

code: bool Compute()


className: FLocalPlanarSimplify

description: Class to support local planar simplification, to reduce excess edges created by plane cuts, edge loop insertions, and similar operations (Note a custom version of this logic also exists on theFMeshBooleanclass)

code: class FLocalPlanarSimplify

bPreserveOverlayUVs

description: Prevent simplification from distorting overlay UVs

bPreserveTriangleGroups

description: Prevent simplification from distorting triangle groups

bPreserveVertexNormals

description: Prevent simplification from distorting vertex normals

bPreserveVertexUVs

description: Prevent simplification from distorting vertex UVs

NormalDistortTolerance

type: float

description: When preserving normals, sets maximum allowed change in normals from collapsing an edge, measured at the removed vertex in degrees

SimplificationAngleTolerance

description: Degrees of deviation from coplanar that we will still simplify

TryToImproveTriQualityThreshold

description: If triangle quality (aspect ratio) is worse than this threshold, only simplify in ways that improve quality.

UVDistortTolerance

description: When preserving UVs, sets maximum allowed change in UV coordinates from collapsing an edge, measured at the removed vertex


description: If this returns true, abort computation.

code: virtual bool Cancelled()


className: EBooleanOp

code: enum EBooleanOp { Union, Difference, Intersect, TrimInside, TrimOutside, NewGroupInside, NewGroupOutside, }


description: EOperationValidationResult::Okif we can apply operation, or error code if we cannot


code: FMeshBoolean ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * MeshA, const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * MeshB, [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * OutputMesh, [EBooleanOp](API\Runtime\GeometryCore\Operations\FMeshBoolean\EBooleanOp) Operation )


description: Perform a boolean operation to combine two meshes into a provided output mesh.

code: FMeshBoolean ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * MeshA, const [FTransformSRT3d](API\Runtime\GeometryCore\FTransformSRT3d) & TransformA, const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * MeshB, const [FTransformSRT3d](API\Runtime\GeometryCore\FTransformSRT3d) & TransformB, [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * OutputMesh, [EBooleanOp](API\Runtime\GeometryCore\Operations\FMeshBoolean\EBooleanOp) Operation )


description: Split mesh(es) along the provided intersections

code: bool Cut ( const [MeshIntersection::FIntersectionsQueryResult](API\Runtime\GeometryCore\Spatial\FIntersectionsQueryResult) & Intersections )


className: FMeshBoolean

description: MeshBoolean  perform a boolean operation on two input meshes.

code: class FMeshBoolean

AllNewEdges

type: TSet< int32 >

description: All edges created by mesh boolean algorithm. Only populated if bTrackAllNewEdges = true

bCollapseDegenerateEdgesOnCut

description: Whether to do additional processing to try to remove degenerate edges

bPopulateSecondMeshGroupMap

description: When doing an operation that merges two meshes (Union, Difference, Intersect) and bPopulateSecondMeshGroupMap is true, we populate a map from group ID's in the second mesh to group ID's in the result.

bPutResultInInputSpace

description: Put the Result mesh in the same space as the input.

bSimplifyAlongNewEdges

description: Control whether we attempt to auto-simplify the small planar triangles that the boolean operation tends to generate

bTrackAllNewEdges

description: Control whether new edges should be tracked

bWeldSharedEdges

description: Weld newly-created cut edges where the input meshes meet.

CreatedBoundaryEdges

type: TArray< int >

description: Boundary edges created by the mesh boolean algorithm failing to cleanly weld (doesn't include boundaries that already existed in source meshes)

DegenerateEdgeTolFactor

description: Tolerance factor (multiplied by SnapTolerance) for removing short edges created by the cutting process; should be no more than 2

Meshes

type: constFDynamicM...

description: Inputs

Operation

type: EBooleanOp

PreserveUVsOnlyForMesh

type: int

description: If > -1, then only preserve the UVs of one of the input meshes.

Progress

type: FProgressCancel...

description: Set this to be able to cancel running operation

Result

description: An existing mesh, to be filled with the boolean result.

ResultTransform

description: OutputTransform taking the result mesh back to the original space of the inputs

SecondMeshGroupMap

type: FIndexMapi

SimplificationAngleTolerance

description: Simplification-specific settings (only relevant if bSimplifyAlongNewEdges==true):Degrees of deviation from coplanar that we will still simplify

SnapTolerance

description: Tolerance distance for considering a point to be on a vertex or edge, especially during mesh-mesh cutting

Transforms

type: constFTransfor...

WindingThreshold

description: Threshold to determine whether triangle in one mesh is inside or outside of the other


code: FMeshMeshCut ( [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * MeshA, [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * MeshB )


className: FMeshMeshCut

description: Cut a mesh where it crosses a second mesh  resolving all intersections, but not deleting geometry. Optionally resolve intersections mutually for both meshes.

code: class FMeshMeshCut

bCutCoplanar

description: If true, detect coplanar faces and re-triangulate so that the triangulations match 1:1 (TODO: not implemented!)

bMutuallyCut

description: If true, modify both meshes to split at crossing points; otherwise only modify MeshA

bTrackInsertedVertices

description: If true, record vertex insertions

Mesh

description: InputsMeshes to cut  note thatFMeshMeshCut::Cutis destructive, so these are also outputs

SegmentToChain

type: TArray< int >[2...

description: For each intersection segment, where the corresponding elements start in VertexChains.

SnapTolerance

type: double

description: Tolerance distance for considering a point to be on a vertex, edge or plane

VertexChains

description: Outputs Packed chains of vertex IDs, representing the vertices for each segment in the mesh Packed as the number of vertices in that chain, followed by that many vertex ids, per segment NOT 1:1 w/ segments; some segments may have failed to insert


code: FMeshSelfCut ( [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * Mesh )


description: Split mesh along the provided intersections


className: FMeshSelfCut

code: class FMeshSelfCut

bTrackInsertedVertices

description: If true, record vertex insertions

Mesh

description: InputsMesh to cut  note thatFMeshSelfCut::Cutis destructive, so this are an output


description:
Compute the plane cut by splitting mesh edges that cross the cut plane, and then deleting any triangles on the positive side of the cutting plane.
true if operation succeeds


code: FMeshSelfUnion ( [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * MeshIn )


code: bool AddViaPlanarWalk ( int StartTri, int StartVID, FVector3d StartPt, int EndTri, int EndVertID, FVector3d EndPt, FVector3d WalkPlaneNormal, [TFunction](API\Runtime\Core\GenericPlatform\TFunction)< FVector3d(const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) *, int)> VertexToPosnFn, bool bAllowBackwardsSearch, double AcceptEndPtOutsideDist, double PtOnPlaneThresholdSq, double BackwardsTolerance )


className: FMeshSelfUnion

description: MeshSelfUnion  perform a "Mesh Boolean" style union of a mesh on itself, resolving any self intersections and welding the new boundaries as needed

code: class FMeshSelfUnion

AllNewEdges

description: All edges created by mesh boolean algorithm. Only populated if bTrackAllNewEdges = true

bCollapseDegenerateEdgesOnCut

description: InputsWhether to do additional processing to try to remove degenerate edges

bPreserveOverlayUVs

description: Prevent simplification from distorting overlay UVs

bPreserveTriangleGroups

description: Prevent simplification from distorting triangle groups

bPreserveVertexNormals

description: Prevent simplification from distorting vertex normals

bPreserveVertexUVs

description: Prevent simplification from distorting vertex UVs

bSimplifyAlongNewEdges

description: Control whether we attempt to auto-simplify the small planar triangles that the boolean operation tends to generate

bTrackAllNewEdges

description: Control whether new edges should be tracked

bTrimFlaps

description: Whether to remove visible "open" geometry

bWeldSharedEdges

description: Weld newly-created cut edges where the mesh is unioned with itself.

CreatedBoundaryEdges

description: OutputBoundary edges created by the mesh boolean algorithm failing to cleanly weld (doesn't include boundaries that already existed in source mesh)

DegenerateEdgeTolFactor

description: Tolerance factor (multiplied by SnapTolerance) for removing short edges created by the cutting process; should be no more than 2

description: The input mesh, to be modified.

NormalDistortTolerance

description: When preserving normals, sets maximum allowed change in normals from collapsing an edge, measured at the removed vertex in degrees

NormalOffset

description: Amount we nudge samples off the surface when evaluating winding number, to avoid numerical issues

TryToImproveTriQualityThreshold

description: If triangle quality (aspect ratio) is worse than this threshold, only simplify in ways that improve quality.

UVDistortTolerance

description: When preserving UVs, sets maximum allowed change in UV coordinates from collapsing an edge, measured at the removed vertex


description:
Make the embedded path into a closed loop. Only succeeds if path start and end already share a triangle!
true if succeeded

code: bool ClosePath()


description:
TODO: not clear if we need this  helper to find the shared triangle (if it exists) that we could traverse to connect two surface points. this gets a bit hairy and it's easier to keep track of the traversed triangles during the mesh walk that creates any path in the first place static int FindSharedTriangle(const FDynamicMesh3* Mesh, const FMeshSurfacePoint& A, const FMeshSurfacePoint& B);
True if the Path exactly sticks to the mesh surface, and never jumps to disconnected elements

code: bool IsConnected() const


description: TODO: support for embedding arbitrary paths in mesh using a graph remesher **

code: *bool EmbedPath ( bool bUpdatePath, [TArray](API\Runtime\Core\Containers\TArray)< int > & PathVertices, [TFunction](API\Runtime\Core\GenericPlatform\TFunction)< bool(const [TArray](API\Runtime\Core\Containers\TArray)< FVector2d > &[Vertices](API\Plugins\DynamicMesh\Operations\UE__Geometry__EOcclusionTriangle-), const [TArray](API\Runtime\Core\Containers\TArray)< [FIndex3i](API\Runtime\GeometryCore\FIndex3i) > &LabelledEdges, [TArray](API\Runtime\Core\Containers\TArray)< FVector2d > &OutVertices, [TArray](API\Runtime\Core\Containers\TArray)< int32 > &OutVertexMap, [TArray](API\Runtime\Core\Containers\TArray)< [FIndex3i](API\Runtime\GeometryCore\FIndex3i) > &OutTriangles)> MeshGraphFn )


description:
Embed a surface path in mesh provided that the path only crosses vertices and edges except at the start and end, so we can add the path easily with local edge splits and possibly two triangle pokes (rather than needing general remeshing machinery) Also assumes triangles are only crossed over once (except possibly to loop around to the start triangle on the end triangle) Planar walks naturally create simple paths, so this function can be used on any paths created by single planar walks.
true if embedding succeeded.

code: *bool EmbedSimplePath ( bool bUpdatePath, [TArray](API\Runtime\Core\Containers\TArray)< int > & PathVertices, bool bDoNotDuplicateFirstVertexID, double SnapElementThresholdSq )


description: EOperationValidationResult::Okif we can apply operation, or error code if we cannot


description: Cut mesh with plane. Assumption is that plane normal is Z value.

code: FMeshSurfacePath ( [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * Mesh )


className: FMeshSurfacePath

description: Walk the surface of an FDynamicMesh to try find a planar path connecting two points. Paths include every vertex and edge they need to cross. Greedy algorithm will only return one path if there are multiple.bool WalkMeshPlanar( const FDynamicMesh3* Mesh, int StartTri, int EndVertID, FVector3d StartPt, int EndTri, FVector3d EndPt, FVector3d WalkPlaneNormal, TFunctionVertexToPosnFn, bool bAllowBackwardsSearch, double AcceptEndPtOutsideDist, double PtOnPlaneThreshold,TArray>& WalkedPath, double BackwardsTolerance = FMathd::ZeroTolerance * 10); Represent a path on the surface of a mesh via barycentric coordinates and triangle references

code: class FMeshSurfacePath

Path

type: TArray< TPair< ...


code: FVector3d Pos ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * Mesh ) const


code: FMeshSurfacePoint ( int VertexID )


code: FMeshSurfacePoint ( int TriangleID, const FVector3d & BaryCoord )


code: FMeshSurfacePoint ( int EdgeID, double FirstCoordWt )


className: FMeshSurfacePoint

code: struct FMeshSurfacePoint

PointType

type: ESurfacePointTy...


description: Forward declarations

code: namespace UE { namespace Geometry { enum ESurfacePointType { Vertex = 0, Edge = 1, Triangle = 2, } } }


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

code: namespace UE { namespace Geometry { bool UE::Geometry::EmbedProjectedPath ( [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * Mesh, int StartTriID, [FFrame3d](API\Runtime\GeometryCore\FFrame3d_1) Frame, const [TArray](API\Runtime\Core\Containers\TArray)< FVector2d > & Path2D, [TArray](API\Runtime\Core\Containers\TArray)< int > & OutPathVertices, [TArray](API\Runtime\Core\Containers\TArray)< int > & OutVertexCorrespondence, bool bClosePath, [FMeshFaceSelection](API\Runtime\GeometryCore\Selections\FMeshFaceSelection) * EnclosedFaces, double PtSnapVertexOrEdgeThresholdSq ) } }


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

code: namespace UE { namespace Geometry { bool UE::Geometry::EmbedProjectedPaths ( [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * Mesh, const [TArrayView](API\Runtime\Core\Containers\TArrayView)< const int > StartTriIDs, [FFrame3d](API\Runtime\GeometryCore\FFrame3d_1) Frame, const [TArrayView](API\Runtime\Core\Containers\TArrayView)< const [TArray](API\Runtime\Core\Containers\TArray)< FVector2d >> AllPaths, [TArray](API\Runtime\Core\Containers\TArray)< [TArray](API\Runtime\Core\Containers\TArray)< int >> & OutAllPathVertices, [TArray](API\Runtime\Core\Containers\TArray)< [TArray](API\Runtime\Core\Containers\TArray)< int >> & OutAllVertexCorrespondence, bool bClosePaths, [FMeshFaceSelection](API\Runtime\GeometryCore\Selections\FMeshFaceSelection) * EnclosedFaces, double PtSnapVertexOrEdgeThresholdSq ) } }


description: Compute common stats used by the packing algorithms to transform UV islands

code: void GetIslandStats ( [IUVMeshView](API\Runtime\GeometryCore\Parameterization\FUVPacker\IUVMeshView) * Mesh, const [TArray](API\Runtime\Core\Containers\TArray)< int32 > & Island, [FAxisAlignedBox2d](API\Runtime\GeometryCore\FAxisAlignedBox2d) & IslandBoundsOut, double & IslandScaleFactorOut, double & UVAreaOut )


code: FIndex3i GetTriangle &40; int32 TID &41; const


code: FIndex3i GetUVTriangle &40; int32 TID &41; const


code: FVector2f GetUV &40; int32 EID &41; const


code: FVector3d GetVertex &40; int32 VID &41; const


code: void SetUV &40; int32 EID, FVector2f UV &41;


code: virtual &126;IUVMeshView&40;&41;


className: IUVMeshView

description: Abstract interface to apply UV packer a mesh

code: struct IUVMeshView


description: Version of StackPack that takes an array of arrays instead of aTFunctionRef, for convenience.

code: bool StackPack ( [IUVMeshView](API\Runtime\GeometryCore\Parameterization\FUVPacker\IUVMeshView) * Mesh, const [TArray](API\Runtime\Core\Containers\TArray)< [TArray](API\Runtime\Core\Containers\TArray)< int >> & UVIslands )


description: Version of StandardPack that takes an array of arrays instead of aTFunctionRef, for convenience.

code: bool StandardPack ( [IUVMeshView](API\Runtime\GeometryCore\Parameterization\FUVPacker\IUVMeshView) * Mesh, const [TArray](API\Runtime\Core\Containers\TArray)< [TArray](API\Runtime\Core\Containers\TArray)< int >> & UVIslands )


description: Uniformly scale all UV islands so that the largest fits in positive-unit-square, and translate each islands separately so that it's bbox-min is at the origin. So the islands are "stacked" and all fit in the unit box.

code: bool StackPack ( [IUVMeshView](API\Runtime\GeometryCore\Parameterization\FUVPacker\IUVMeshView) * Mesh, int NumIslands, [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< void(int, [TArray](API\Runtime\Core\Containers\TArray)< int32 > &)> CopyIsland )


description: Standard UE UV layout, similar to that used for Lightmap UVs. All UV islands are packed into standard positive-unit-square. Only supports single-pixel border size.

code: bool StandardPack ( [IUVMeshView](API\Runtime\GeometryCore\Parameterization\FUVPacker\IUVMeshView) * Mesh, int NumIslands, [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< void(int, [TArray](API\Runtime\Core\Containers\TArray)< int32 > &)> CopyIsland )


className: FUVPacker

description: FUVPackerimplements various strategies for packing UV islands in a generic mesh class. The UV islands must already be identified, this class simply scales/rotates/translates the islands to fit.

code: class FUVPacker

bAllowFlips

description: If true, islands can be flipped in addition to rotate/translate/scale

bScaleIslandsByWorldSpaceTexelRatio

description: Attempt to rescale islands to match texel-to-world-space ratio across islands, based on ratio of World- and UV-space edge lengths

GutterSize

description: Thickness of gutter/border in pixel dimensions. Not supported by all packing methods

TextureResolution

description: Resolution of the target texture. This is used to convert pixel gutter/border thickness to UV space


description: vertex id associated with the maximum graph distance returned by GetMaxGraphDistance()


description: Add new SeedPoints to the current solution, and then propagate updated graph distances to any points closer to these new seed points than to existing seed points.

code: void AddSeedPoints ( const [TArray](API\Runtime\Core\Containers\TArray)< [FSeedPoint](API\Runtime\GeometryCore\Parameterization\TIncrementalMeshDijkstra\FSeedPoint) > & SeedPointsIn )


description:
Find path from a point to the nearest seed point
true if valid path was found

code: bool FindPathToNearestSeed ( int32 PointID, [TArray](API\Runtime\Core\Containers\TArray)< int32 > & PathToSeedOut, int32 MaxLength )


className: FSeedPoint

description: FSeedPointdefines a seed point passed to the various compute methods below

code: struct FSeedPoint

ExternalID

description: Client-defined integer ID for this seed point (not used internally)

PointID

description: Point ID for this seed point, must be a valid point ID in the input PointSet

StartDistance

description: Initial distance for this seed point


description: the distance calculated for index PointID

code: double GetDistance ( int32 PointID ) const


description: the ExternalID of the SeedPoint that is closest to PointID, or -1 if PointID does not have a valid graph distance

code: int32 GetSeedExternalIDForPointSetID ( int32 PointID )


code: static double InvalidDistance()


description: true if the distance for index PointID was calculated

code: bool HasDistance ( int32 PointID ) const


description: ConstructTMeshDijkstrafor the given PointSet. We will hold a reference to this PointSet for the lifetime of the class.

code: TIncrementalMeshDijkstra ( const PointSetType * PointSetIn )


className: TIncrementalMeshDijkstra

description: TIncrementalMeshDijkstracomputes graph distances on a mesh from seed point(s) using Dijkstra's algorithm. Derived fromTMeshDijkstra. This Incremental variant allows adding new Seed points to an already-computed solution.

code: template<class PointSetType> class TIncrementalMeshDijkstra

GetPositionFunc

type: TUniqueFunction...

description: Return the 3D Position of a given Point in the PointSet.

PointSet

type: const PointSetT...

description: PointSet we are calculating on


description: Computes graph distances outwards from seed points to all points that are less/equal to ComputeToMaxDistance from the seed.

code: void ComputeToMaxDistance ( const [TArray](API\Runtime\Core\Containers\TArray)< [FSeedPoint](API\Runtime\GeometryCore\Parameterization\TMeshDijkstra\FSeedPoint) > & SeedPointsIn, double ComputeToMaxDistanceIn )


code: void ComputeToMaxDistance ( const [TArray](API\Runtime\Core\Containers\TArray)< FVector2d > & SeedPointsIn, double ComputeToMaxDistanceIn )


description: Computes graph distances outwards from seed points to all points that are less/equal to ComputeToMaxDistance from the seed, or until TargetPointID is reached. This is useful for finding shortest paths between two points

code: bool ComputeToTargetPoint ( const [TArray](API\Runtime\Core\Containers\TArray)< [FSeedPoint](API\Runtime\GeometryCore\Parameterization\TMeshDijkstra\FSeedPoint) > & SeedPointsIn, int32 TargetPointID, double ComputeToMaxDistanceIn )


StartDistance

description: Initial distance for this seed point


description: the maximum graph distance encountered during the computation


code: double GetMaxGraphDistance() const


description: Reset internal data structures but keep allocated memory

code: void Reset()


description: distance value that indicates invalid or uncomputed distance


code: FVector2d ComputeLocalUV ( const [FFrame3d](API\Runtime\GeometryCore\FFrame3d_1) & Frame, FVector3d Position ) const


description: Apply a function to each calculated UV

code: void ApplyUVs ( [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< void(int32 PointID, const FVector2d &UV)> ApplyFunc ) const


code: TMeshDijkstra ( const PointSetType * PointSetIn )


description: Computes UVs outwards from seed frame/nbrs to all points that are less/equal to ComputeToMaxDistance from the seed.

code: void ComputeToMaxDistance ( const [FFrame3d](API\Runtime\GeometryCore\FFrame3d_1) & SeedFrameIn, const [FIndex3i](API\Runtime\GeometryCore\FIndex3i) & SeedNbrs, double ComputeToMaxDistanceIn )


description: Computes UVs outwards from seed vertex to all points that are less/equal to ComputeToMaxDistance from the seed.

code: void ComputeToMaxDistance ( int32 CenterPointVtxID, const [FFrame3d](API\Runtime\GeometryCore\FFrame3d_1) & CenterPointFrame, double ComputeToMaxDistanceIn )


className: TMeshDijkstra

description: Templated on the point set type, which must provide positions, normals, and neighbours. Currently will only work forFDynamicMesh3and FDynamicPointSet3 because of call to PointSetType->VtxVerticesItr()

code: template<class PointSetType> class TMeshDijkstra

bEnableDistanceWeighting

type: bool

description: If enabled, when computing local point-pair distances,GetWeightedDistanceFunc()will be called with the Euclidean distance to allow for alternative metrics

GetWeightedDistanceFunc

description: Called when computing pairwise point distances between neighbours FromVID and ToVID, to allow for alternative distance metrics.

PointSet

description: PointSet we are calculating on


className: FGraphNode

description: Information about each active/computed point

code: struct FGraphNode


description: Find all computed UVs within the specified distances

code: void GetAllComputedUVs ( [TArray](API\Runtime\Core\Containers\TArray)< int32 > & PointIDsOut, [TArray](API\Runtime\Core\Containers\TArray)< FVector2d > & PointUVsOut, double MaxUVMagnitude, double MaxGraphDist ) const


code: [FFrame3d](API\Runtime\GeometryCore\FFrame3d_1) GetFrame ( const [FGraphNode](API\Runtime\GeometryCore\Parameterization\TMeshLocalParam\FGraphNode) & Node ) const


description: the maximum graph distance/radius encountered during the computation


description: the maximum UV distance/radius encountered during the computation

code: double GetMaxUVDistance() const


code: const [FGraphNode](API\Runtime\GeometryCore\Parameterization\TMeshLocalParam\FGraphNode) * GetNodeForPointSetID ( int32 PointSetID ) const


code: [FGraphNode](API\Runtime\GeometryCore\Parameterization\TMeshLocalParam\FGraphNode) * GetNodeForPointSetID ( int32 PointSetID, bool bCreateIfMissing )


code: FVector3d GetPosition ( const int32 PointID ) const


code: FVector3d GetNormal ( const int32 PointID ) const


description: Array of points with set UVs.

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


description: 2D Axis-Aligned Bounding Box of the calculated UVs


description: the UV calculated for index PointID

code: FVector2d GetUV ( int32 PointID ) const


description: true if the UV for index PointID was calculated

code: bool HasUV ( int32 PointID ) const


code: static FVector2d InvalidUV()


code: void ProcessQueueUntilTermination ( double MaxDistance )


description: Calculate the UV value at Position based on the existing NbrUV, using the frame at NbrFrame, and the original SeedFrame

code: FVector2d PropagateUV ( const FVector3d & Position, const FVector2d & NbrUV, const [FFrame3d](API\Runtime\GeometryCore\FFrame3d_1) & NbrFrame, const [FFrame3d](API\Runtime\GeometryCore\FFrame3d_1) & SeedFrameIn ) const


code: void Reset()


description: Scale and then Translate all calculated UV values

code: void TransformUV ( double Scale, FVector2d Translate )


description: Given new Distance/UV at Parent, check if any of its neighbours are in the queue, and if they are, and the new graph distance is shorter, update their queue position (this is basically the update step of Disjktras algorithm)

code: void UpdateNeighboursSparse ( [FGraphNode](API\Runtime\GeometryCore\Parameterization\TMeshLocalParam\FGraphNode) * Parent )


code: void UpdateUVExpmap ( [FGraphNode](API\Runtime\GeometryCore\Parameterization\TMeshLocalParam\FGraphNode) & Node )


code: void UpdateUVExpmapUpwind ( [FGraphNode](API\Runtime\GeometryCore\Parameterization\TMeshLocalParam\FGraphNode) & Node )


code: void UpdateUVPlanar ( [FGraphNode](API\Runtime\GeometryCore\Parameterization\TMeshLocalParam\FGraphNode) & Node )


code: TMeshLocalParam ( const PointSetType * PointSetIn )


className: TMeshLocalParam

code: template<class PointSetType> class TMeshLocalParam

AllocatedNodes

type: TDynamicVector<...

bEnableExternalNormals

description: If true, ExternalNormalFunc will be used to fetch normals instead of requesting from PointSet->GetVertexNormal.

ExternalNormalFunc

type: TFunction< FVec...

description: Normals will be requested from this function if bEnableExternalNormals == true

IDToNodeIndexMap

type: TMap< int32, in...

description: To avoid constructingFGraphNodefor all input points (because we are computing a "local" param), we only allocate on demand, and then store a sparse mapping in IDToNodeIndexMap

MaxGraphDistance

description: Max distances encountered during last compute

ParamMode

type: ELocalParamType...

description: Type of local parameterization to compute

Queue

type: FIndexPriorityQ...

description: Queue of nodes to process (for dijkstra front propagation)

SeedFrame

description: Seed frame, unwrap is centered around this position/axes


description: Type of local parameterization

code: namespace UE { namespace Geometry { enum ELocalParamTypes { PlanarProjection = 1, ExponentialMap = 2, ExponentialMapUpwindAvg = 3, } } }


description: The strategy used is to compute a much higher density sampling than needed (based on .SubSampleDensity), then iteratively select from that point set and decimate it within the radius of selected samples. The implementation also introduces various biases to increase performance. Generally increasing SubSampleDensity will result in more tightly-packed results, but at increasingly expensive computation time.

code: void ComputePoissonSampling ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, [FProgressCancel](API\Runtime\GeometryCore\Util\FProgressCancel) * Progress )


className: EInterpretWeightMode

description: Control how active Weights are used to affect point radius

code: enum EInterpretWeightMode { RadiusInterp = 0, RadiusInterpWithFill = 1, WeightedRandom = 2, }


className: ESizeDistribution

description: Controls the distribution of sample radii

code: enum ESizeDistribution { Uniform = 0, Smaller = 1, Larger = 2, }


className: FSampleSetStatisticsd

code: typedef [TSampleSetStatistics](API\Runtime\GeometryCore\Sampling\TSampleSetStatistics)< double > FSampleSetStatisticsd


className: FSampleSetStatisticsf

code: typedef [TSampleSetStatistics](API\Runtime\GeometryCore\Sampling\TSampleSetStatistics)< float > FSampleSetStatisticsf


className: FMeshSurfacePointSampling

description: FMeshSurfacePointSamplingcomputes oriented point samples on the surface of a Mesh using various sampling strategies.

code: class FMeshSurfacePointSampling

BarycentricCoords

type: TArray< FVector...

description: Barycentric Coordinates of each Sample Point in it's respective Triangle.

bComputeBarycentrics

description: If true, barycentric coordinates output array will be populated

bInvertWeights

description: If true, weights are inverted

bUseVertexWeights

description: Control whether VertexWeights (if valid) will be interpolated to modulate sampling

InterpretWeightMode

type: EInterpretWeigh...

description: Active weight interpretation mode

MaxSampleRadius

description: Parameters for non-uniform / variable-radius sampling.

MaxSamples

description: Maximum number of samples requested. If 0 or default value, mesh will be maximally sampled

MaxSubSamplePoints

description: Safety threshold for maximum number of points in subsampling.

Radii

type: TArray< double ...

description: Radius of each Sample Point, length is the same as Samples array

RandomSeed

description: Random Seed used to initialize sampling strategies

Result

type: FGeometryResult

description: TODO: when MaxSamples is set, it would be useful to be able to use Weight to modulate positional distribution instead of radius, (or both!) OutputsResult of last computation

SampleRadius

description: Basic sampling parametersDesired "radius" of sample points.

Samples

description: Oriented Sample Points on the mesh surface.

SizeDistribution

type: ESizeDistributi...

description: Active Size Distribution mode

SizeDistributionPower

description: Used to define how extreme the Size Distribution shift is. Valid range is [1,10]

SubSampleDensity

description: Density of subsampling used in Poisson strategy.

TriangleIDs

type: TArray< int32 >

description: Triangle that contains each Sample Point, length is the same as Samples array

VertexWeights

description: Per-vertex weights, size must be == Max VertexIndexof input Mesh


code: RealType EvaluateFromOffset ( const [FVector2i](API\Runtime\GeometryCore\FVector2i) & Offset ) const


description: 2D Discretized Kernel (ie 2D grid/matrix of values)

code: template<typename RealType> class TDiscreteKernel2

Kernel

type: TArray< RealTyp...


code: typedef [TVectorSetAnalysis3](API\Runtime\GeometryCore\Sampling\TVectorSetAnalysis3)< float > FVectorSetAnalysis3f


code: typedef [TVectorSetAnalysis3](API\Runtime\GeometryCore\Sampling\TVectorSetAnalysis3)< double > FVectorSetAnalysis3d


code: typedef [TDiscreteKernel2](API\Runtime\GeometryCore\Sampling\TDiscreteKernel2)< double > TDiscreteKernel2d


code: typedef [TDiscreteKernel2](API\Runtime\GeometryCore\Sampling\TDiscreteKernel2)< float > TDiscreteKernel2f


className: EType

code: enum EType { Square, Disc, }


description: sphere point for givenIndex

code: [TVector2](API\Runtime\Core\Math\TVector2)< RealType > operator[] ( int32 Index ) const


description: sphere point for givenIndex

code: [TVector2](API\Runtime\Core\Math\TVector2)< RealType > Point ( int32 Index ) const


className: TFibonacciLattice

description: Reference: Spherical Fibonacci Point Sets for Illumination Integralshttps://repositori.upf.edu/bitstream/handle/10230/35552/marques_CGForum32_sphe.pdf?sequence=1&isAllowed=y

code: template<typename RealType> class TFibonacciLattice

Type

type: EType


code: TFibonacciLattice ( int32 NumPoints, [EType](API\Runtime\GeometryCore\Sampling\TFibonacciLattice\EType) InType )


code: RealType Evaluate ( RealType X ) const


code: RealType EvaluateSqr ( RealType XSquared ) const


code: RealType EvaluateUnscaled ( RealType X ) const


code: RealType EvaluateSqrUnscaled ( RealType XSquared ) const


description: 1D Gaussian

code: template<typename RealType> class TGaussian1

Sigma

type: RealType


code: TGaussian1 ( RealType SigmaIn )


code: typedef [TGaussian1](API\Runtime\GeometryCore\Sampling\TGaussian1)< double > TGaussian1d


code: RealType Evaluate ( const [UE::Math::TVector2](API\Runtime\Core\Math\TVector2)< RealType > & XY ) const


code: typedef [TGaussian1](API\Runtime\GeometryCore\Sampling\TGaussian1)< float > TGaussian1f


code: RealType EvaluateSqrUnscaled ( const [UE::Math::TVector2](API\Runtime\Core\Math\TVector2)< RealType > & XY ) const


code: static void MakeKernelFromRadius ( RealType Radius, [TDiscreteKernel2](API\Runtime\GeometryCore\Sampling\TDiscreteKernel2)< RealType > & KernelOut, bool bNormalized )


code: static void MakeKernelFromRadius ( RealType Radius, [TArray](API\Runtime\Core\Containers\TArray)< RealType > & KernelOut, int32 & IntRadiusOut, bool bNormalized )


code: static void MakeKernelFromWidth ( int32 IntRadius, RealType Sigma, [TArray](API\Runtime\Core\Containers\TArray)< RealType > & KernelOut, bool bNormalized )


description: 2D Gaussian

code: template<typename RealType> class TGaussian2


code: TGaussian2 ( RealType SigmaIn )


code: typedef [TGaussian2](API\Runtime\GeometryCore\Sampling\TGaussian2)< double > TGaussian2d


code: typedef [TGaussian2](API\Runtime\GeometryCore\Sampling\TGaussian2)< float > TGaussian2f


code: TGaussian3 ( RealType SigmaIn )


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


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


code: typedef [TGaussian3](API\Runtime\GeometryCore\Sampling\TGaussian3)< double > TGaussian3d


description: 3D Gaussian

code: template<typename RealType> class TGaussian3


description: total number of grid points.

code: int32 Num() const


code: typedef [TGaussian3](API\Runtime\GeometryCore\Sampling\TGaussian3)< float > TGaussian3f


description: grid sample for given linear index

code: [UE::Math::TVector2](API\Runtime\Core\Math\TVector2)< RealType > Sample ( int32 Index ) const


code: TGridSampler ( int32 SizeIn )


className: TGridSampler

description: Given a linear index into a square grid of given size, gives back the [0,1) XY coordinate of the grid cell center (assuming linear index increases first in X and then in Y).

code: template<typename RealType> class TGridSampler


className: EDistribution

code: enum EDistribution { Uniform, Cosine, }


description: sphere point for givenIndex

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


code: THemisphericalFibonacci ( int32 NumPoints, [EDistribution](API\Runtime\GeometryCore\Sampling\THemisphericalFibonacci\EDistribution) Dist )


description: sphere point for givenIndex

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


className: THemisphericalFibonacci

description: Z is "up" in the hemisphere.

code: template<typename RealType> class THemisphericalFibonacci

Distribution

type: EDistribution


description: Count a Normal in the histogram, ie find the Bin it should be included in and add the Weight to that Bin (The Normal does not strictly need to be normalized)

code: void Count ( const [TVector](API\Runtime\Core\Math\TVector)< RealType > & Normal, RealType Weight )


description: Attempt to compute a measure of the range of variation in normals across the occupied bins

code: RealType WeightedSpreadMetric() const


description: the normal direction for the Histogram bin that contains the most points / largest mass

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


description: Initialize a normal histogram with the given number of bins

code: TNormalHistogram ( int32 NumBins )


className: TNormalHistogram

description: One current limitation of this implementation is that the unit +/- X/Y/Z axes are not bin center points.

code: template<typename RealType> class TNormalHistogram

BinPoints

type: TSphericalFibon...


code: void AccumulateValue_FixedCount ( int32 StatisticIndex, const RealType Value )


code: void Begin_FixedCount ( int64 Count )


code: void CompleteSecondPass_FixedCount()


code: void StartSecondPass_FixedCount()


code: template<typename EnumerableType> void ComputeMultiPass ( int64 Count, const EnumerableType & MultiEnumerableType )


code: TSampleSetStatisticBuilder ( int32 NumStatisticsIn )


code: void AccumulateValue_FixedCount ( const RealType Value, [FFixedCountData](API\Runtime\GeometryCore\Sampling\TSampleSetStatistics\FFixedCountData) & DataInOut )


code: [FFixedCountData](API\Runtime\GeometryCore\Sampling\TSampleSetStatistics\FFixedCountData) Begin_FixedCount ( int64 CountIn )


className: TSampleSetStatisticBuilder

description: Helper class for reducing the amount of boilerplace code when building a set ofTSampleSetStatisticsvalues.

code: template<typename RealType> struct TSampleSetStatisticBuilder

FixedCountBuildData

type: TArray< typenam...

Statistics

type: TArray<TSample...


code: const [TSampleSetStatistics](API\Runtime\GeometryCore\Sampling\TSampleSetStatistics)< RealType > & operator[] ( int32 Index ) const


code: void CompleteSecondPass_FixedCount ( [FFixedCountData](API\Runtime\GeometryCore\Sampling\TSampleSetStatistics\FFixedCountData) & DataInOut )


className: FFixedCountData

description: Usage:FFixedCountDataData = Stat.Begin_FixedCount(N); for ( Value in Values ) Stat.AccumulateValue_FixedCount(Value); Stat.StartSecondPass_FixedCount(Data); for ( Value in Values ) Stat.AccumulateValue_FixedCount(Value); Stat.CompleteSecondPass_FixedCount(Data);

code: struct FFixedCountData


code: void StartSecondPass_FixedCount ( [FFixedCountData](API\Runtime\GeometryCore\Sampling\TSampleSetStatistics\FFixedCountData) & DataInOut )


className: TSampleSetStatistics

description: TSampleSetStatisticsstores and calculates statistics for a scalar sample set, such as the range of values, mean, variance, etc.

code: template<typename RealType> struct TSampleSetStatistics

Count

description: Number of values used to compute statistics

Mean

description: Mean / Average of values

Range

type: TInterval1< Rea...

description: Range of values

StandardDeviation

description: Standard Deviation of values


description: Indexof the sphere point closest to the given point P

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


description: MultiplyAddFrac(A,B) = multiply_add( A ,B, -floor(A*B) )

code: static RealType MultiplyAddFrac ( RealType a, RealType b )


description: sphere point for givenIndex

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


code: TSphericalFibonacci ( int32 NumPoints )


className: TSphericalFibonacci

description: Z is "up" in the sphere.

code: template<typename RealType> class TSphericalFibonacci


description: sphere point for givenIndex

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


description: Run simple greedy clustering algorithm on input ClusterVectors. Done in a single pass over vectors, each successive Vector is either grouped with one of the existing clusters if it's direction is within AngleToleranceDeg, or creates a new cluster.

code: void GreedyClusterVectors ( RealType AngleToleranceDeg )


description: Initialize the internal set of Vectors and IDs using an external integer-Enumerable and associated GetVector(ID) function

code: template<typename EnumerableIDType> void Initialize ( EnumerableIDType EnumerableIDs, [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< [TVector](API\Runtime\Core\Math\TVector)< RealType >(int32)> GetVectorFunc, int32 NumVectorsHint, bool bIsNormalizedHint )


description: number of input vectors

code: int32 NumVectors() const


description: TVectorSetAnalysis3computes various analyses of a set of input Vectors (currently mainly clustering.

code: template<typename RealType> class TVectorSetAnalysis3

bNormalized

type: bool

ClusterVectors

type: TArray<TVector...

description: Calculated valuesSet of vectors that represent centers of clusters

Vectors

description: Input data

VectorToClusterMap

description: Mapping from Vector index to ClusterVectors index


description: number of clusters found by last clustering algorithm (may be zero if not initialized)

code: int32 NumClusters() const


description: DO NOT USE DIRECTLY STL-like iterators to enable ranged-based for loop support (forwardingTIndirectArraydeclarations)

code: auto begin()


description: Calculation functions. Call these to calculate different types of Components. Find all connected triangle components of the Mesh and store in Components array. Triangle connectivity is based on edge connectivity, ie bowtie-vertices are not connections between triangles.

code: void FindConnectedTriangles ( [TFunction](API\Runtime\Core\GenericPlatform\TFunction)< bool(int32, int32)> TrisConnectedPredicate )


className: FComponent

description: Connected Component found by one of the calculation functions

code: struct FComponent

Indices

type: TArray< int >

description: List of indices contained in component


description: Find all connected triangle components of a subset of triangles of the Mesh and store in Components array. Triangle connectivity is based on edge connectivity, ie bowtie-vertices are not connections between triangles.

code: void FindConnectedTriangles ( const [TArray](API\Runtime\Core\Containers\TArray)< int > & TriangleROI, [TFunction](API\Runtime\Core\GenericPlatform\TFunction)< bool(int32, int32)> TrisConnectedPredicate )


code: void FindConnectedTriangles ( [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< bool(int)> IndexFilterFunc, [TFunction](API\Runtime\Core\GenericPlatform\TFunction)< bool(int32, int32)> TrisConnectedPredicate )


description: Find all connected vertex components of a subset of vertices of the Mesh and store in Components array.

code: void FindConnectedVertices ( const [TArray](API\Runtime\Core\Containers\TArray)< int > & VertexROI, [TFunction](API\Runtime\Core\GenericPlatform\TFunction)< bool(int32, int32)> VertsConnectedPredicate )


description: Find all connected vertex components of the Mesh and store in Components array.

code: void FindConnectedVertices ( [TFunction](API\Runtime\Core\GenericPlatform\TFunction)< bool(int32, int32)> VertsConnectedPredicate )


description: Find all connected triangle components that contain one or more Seed Triangles and store in Components array. Search only starts from Seed Triangles. Triangle connectivity is based on edge connectivity, ie bowtie-vertices are not connections between triangles.

code: void FindTrianglesConnectedToSeeds ( const [TArray](API\Runtime\Core\Containers\TArray)< int > & SeedTriangles, [TFunction](API\Runtime\Core\GenericPlatform\TFunction)< bool(int32, int32)> TrisConnectedPredicate )


code: void FindConnectedVertices ( [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< bool(int)> IndexFilterFunc, [TFunction](API\Runtime\Core\GenericPlatform\TFunction)< bool(int32, int32)> VertsConnectedPredicate )


description: Internal functions to calculate ROI

code: void FindTriComponent ( [FComponent](API\Runtime\GeometryCore\Selections\FMeshConnectedComponents\FComponent) * Component, [TArray](API\Runtime\Core\Containers\TArray)< int32 > & ComponentQueue, [TArray](API\Runtime\Core\Containers\TArray)< uint8 > & ActiveSet )


description: Internal functions to calculate ROI

code: void FindTriComponent ( [FComponent](API\Runtime\GeometryCore\Selections\FMeshConnectedComponents\FComponent) * Component, [TArray](API\Runtime\Core\Containers\TArray)< int32 > & ComponentQueue, [TArray](API\Runtime\Core\Containers\TArray)< uint8 > & ActiveSet, [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< bool(int32, int32)> TriConnectedPredicate )


description: Internal functions to calculate ROI

code: void FindTriComponents ( [FInterval1i](API\Runtime\GeometryCore\FInterval1i) ActiveRange, [TArray](API\Runtime\Core\Containers\TArray)< uint8 > & ActiveSet, [TFunction](API\Runtime\Core\GenericPlatform\TFunction)< bool(int32, int32)> TriConnectedPredicate )


code: void FindVertComponent ( [FComponent](API\Runtime\GeometryCore\Selections\FMeshConnectedComponents\FComponent) * Component, [TArray](API\Runtime\Core\Containers\TArray)< int32 > & ComponentQueue, [TArray](API\Runtime\Core\Containers\TArray)< uint8 > & ActiveSet, [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< bool(int32, int32)> VertsConnectedPredicate )


description: Internal functions to calculate ROI

code: void FindTriComponents ( const [TArray](API\Runtime\Core\Containers\TArray)< int32 > & SeedList, [TArray](API\Runtime\Core\Containers\TArray)< uint8 > & ActiveSet, [TFunction](API\Runtime\Core\GenericPlatform\TFunction)< bool(int32, int32)> TriConnectedPredicate )


code: void FindVertComponents ( [FInterval1i](API\Runtime\GeometryCore\FInterval1i) ActiveRange, [TArray](API\Runtime\Core\Containers\TArray)< uint8 > & ActiveSet, [TFunction](API\Runtime\Core\GenericPlatform\TFunction)< bool(int32, int32)> VertsConnectedPredicate )


code: void FindVertComponent ( [FComponent](API\Runtime\GeometryCore\Selections\FMeshConnectedComponents\FComponent) * Component, [TArray](API\Runtime\Core\Containers\TArray)< int32 > & ComponentQueue, [TArray](API\Runtime\Core\Containers\TArray)< uint8 > & ActiveSet )


description: element of Components array at givenIndex

code: const [FComponent](API\Runtime\GeometryCore\Selections\FMeshConnectedComponents\FComponent) & GetComponent ( int32 Index ) const


code: void FindVertComponents ( const [TArray](API\Runtime\Core\Containers\TArray)< int32 > & SeedList, [TArray](API\Runtime\Core\Containers\TArray)< uint8 > & ActiveSet, [TFunction](API\Runtime\Core\GenericPlatform\TFunction)< bool(int32, int32)> VertsConnectedPredicate )


description: Find all connected vertex components that contain one or more Seed Vertices and store in Components array. Search only starts from Seed Vertices.

code: void FindVerticesConnectedToSeeds ( const [TArray](API\Runtime\Core\Containers\TArray)< int > & SeedVertices, [TFunction](API\Runtime\Core\GenericPlatform\TFunction)< bool(int32, int32)> VertsConnectedPredicate )


code: [FComponent](API\Runtime\GeometryCore\Selections\FMeshConnectedComponents\FComponent) & GetComponent ( int32 Index )


description: index of largest component by element count

code: int32 GetLargestIndexByCount() const


description: Utility function to expand an edge selection to all edges considered "connected".

code: static void GrowToConnectedEdges ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, const [TArray](API\Runtime\Core\Containers\TArray)< int > & InputROI, [TSet](API\Runtime\Core\Containers\TSet)< int > & ResultROI, [TArray](API\Runtime\Core\Containers\TArray)< int32 > * QueueBuffer, [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< bool(int32, int32)> CanGrowPredicate )


description: Utility function to expand a triangle selection to all triangles considered "connected". More efficient than using fullFMeshConnectedComponentsinstance if ROI is small relative to Mesh size (or if temp buffers can be re-used)

code: static void GrowToConnectedTriangles ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * Mesh, const [TArray](API\Runtime\Core\Containers\TArray)< int > & InputROI, [TArray](API\Runtime\Core\Containers\TArray)< int > & ResultROI, [TArray](API\Runtime\Core\Containers\TArray)< int32 > * QueueBuffer, [TSet](API\Runtime\Core\Containers\TSet)< int32 > * DoneBuffer, [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< bool(int32, int32)> CanGrowPredicate )


description: Utility function to expand a triangle selection to all triangles considered "connected". More efficient than using fullFMeshConnectedComponentsinstance if ROI is small relative to Mesh size (or if temp buffers can be re-used) This version computes an outputTSetinstead of outputTArray, which is preferable in some cases.

code: static void GrowToConnectedTriangles ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * Mesh, const [TArray](API\Runtime\Core\Containers\TArray)< int > & InputROI, [TSet](API\Runtime\Core\Containers\TSet)< int > & ResultROI, [TArray](API\Runtime\Core\Containers\TArray)< int32 > * QueueBuffer, [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< bool(int32, int32)> CanGrowPredicate )


description: Utility function to expand a vertex selection to all vertices considered "connected".

code: static void GrowToConnectedVertices ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, const [TArray](API\Runtime\Core\Containers\TArray)< int > & InputROI, [TSet](API\Runtime\Core\Containers\TSet)< int > & ResultROI, [TArray](API\Runtime\Core\Containers\TArray)< int32 > * QueueBuffer, [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< bool(int32, int32)> CanGrowPredicate )


description:
Initialize the internalFComponentlist from the input ComponentLists, skipping any empty input lists
true if all IDs are valid, or if check was skipped

code: bool InitializeFromTriangleComponents ( const [TArray](API\Runtime\Core\Containers\TArray)< [TArray](API\Runtime\Core\Containers\TArray)< int32 >> & ComponentLists, bool bValidateIDs )


code: bool InitializeFromTriangleComponents ( [TArray](API\Runtime\Core\Containers\TArray)< [TArray](API\Runtime\Core\Containers\TArray)< int32 >> & ComponentLists, bool bMoveSubLists, bool bValidateIDs )


code: bool InitializeFromVertexComponents ( [TArray](API\Runtime\Core\Containers\TArray)< [TArray](API\Runtime\Core\Containers\TArray)< int32 >> & ComponentLists, bool bMoveSubLists, bool bValidateIDs )


code: bool InitializeFromVertexComponents ( const [TArray](API\Runtime\Core\Containers\TArray)< [TArray](API\Runtime\Core\Containers\TArray)< int32 >> & ComponentLists, bool bValidateIDs )


description:
Query functions. Only valid to call after a Calculation function has been called.
Number of Components that were found

code: int32 Num() const


code: const [FComponent](API\Runtime\GeometryCore\Selections\FMeshConnectedComponents\FComponent) & operator[] ( int32 Index ) const


code: [FComponent](API\Runtime\GeometryCore\Selections\FMeshConnectedComponents\FComponent) & operator[] ( int32 Index )


code: void RemoveFromActiveSet ( const [FComponent](API\Runtime\GeometryCore\Selections\FMeshConnectedComponents\FComponent) * Component, [TArray](API\Runtime\Core\Containers\TArray)< uint8 > & ActiveSet )


code: FMeshConnectedComponents ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * MeshIn )


description: Sort the Components array by component element count

code: void SortByCount ( bool bLargestFirst )


className: FMeshConnectedComponents

description: FMeshConnectedComponentscalculates Connected Components of a Mesh, or sub-regions of a Mesh.Bydefault the actual mesh connectivity is used, but an optional connectivity predicate can be provided to specify when two elements should be considered connected.

code: class FMeshConnectedComponents

Components

type: TIndirectArray<...

description: List of Connected Components that have been found by one of the calculation functions

Mesh

type: constFDynamicM...


code: [TBitArray](API\Runtime\Core\Containers\TBitArray)< [FDefaultBitArrayAllocator](API\Runtime\Core\Containers\FDefaultBitArrayAllocator) > AsBitArray() const


code: [TArray](API\Runtime\Core\Containers\TArray)< int > AsArray() const


code: [TSet](API\Runtime\Core\Containers\TSet)< int > AsSet() const


description: DO NOT USE DIRECTLY STL-like iterators to enable range-based for loop support.

code: [TSet](API\Runtime\Core\Containers\TSet)< int >::TRangedForIterator begin()


code: [TSet](API\Runtime\Core\Containers\TSet)< int >::TRangedForConstIterator begin() const


code: void Deselect ( [TArrayView](API\Runtime\Core\Containers\TArrayView)< const int > edges )


code: [TSet](API\Runtime\Core\Containers\TSet)< int >::TRangedForIterator end()


code: [TSet](API\Runtime\Core\Containers\TSet)< int >::TRangedForConstIterator end() const


code: void Select ( const [TArray](API\Runtime\Core\Containers\TArray)< int > & edges )


code: void Select ( [TArrayView](API\Runtime\Core\Containers\TArrayView)< const int > edges )


code: void Select ( [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< bool(int)> SelectF )


code: void SelectBoundaryTriEdges ( const [FMeshFaceSelection](API\Runtime\GeometryCore\Selections\FMeshFaceSelection) & Triangles )


code: void SelectTriangleEdges ( [TArrayView](API\Runtime\Core\Containers\TArrayView)< const int > Triangles )


code: void SelectVertexEdges ( [TArrayView](API\Runtime\Core\Containers\TArrayView)< const int > vertices )


code: FMeshEdgeSelection ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * mesh )


description: Convert vertex selection to edge selection. Require at least minCount verts of edge to be selected

code: FMeshEdgeSelection ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * mesh, const [FMeshVertexSelection](API\Runtime\GeometryCore\Selections\FMeshVertexSelection) & convertV, int minCount )


description: Convert face selection to edge selection. Require at least minCount tris of edge to be selected

code: FMeshEdgeSelection ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * mesh, const [FMeshFaceSelection](API\Runtime\GeometryCore\Selections\FMeshFaceSelection) & convertT, int minCount )


className: FMeshEdgeSelection

description: Currently a thin wrapper of aTSetof Edge IDs paired with a Mesh; the backing storage will likely change as we need to optimize in the future

code: class FMeshEdgeSelection


code: [TBitArray](API\Runtime\Core\Containers\TBitArray)< [FDefaultBitArrayAllocator](API\Runtime\Core\Containers\FDefaultBitArrayAllocator) > AsBitArray() const


code: [TArray](API\Runtime\Core\Containers\TArray)< int > AsArray() const


code: const [TSet](API\Runtime\Core\Containers\TSet)< int > & AsSet() const


code: [TSet](API\Runtime\Core\Containers\TSet)< int >::TRangedForIterator begin()


code: [TSet](API\Runtime\Core\Containers\TSet)< int >::TRangedForConstIterator begin() const


description: Return true if we clipped something

code: bool ClipFins ( bool bClipLoners )


code: bool Contains ( int tid ) const


description: Return false from FilterF to prevent triangles from being deselected.

code: void ContractBorderByOneRingNeighbours ( int NumRings, bool bContractFromMeshBoundary, const [TUniqueFunction](API\Runtime\Core\Templates\TUniqueFunction)< bool(int)> & FilterF )


code: void Deselect ( [TArrayView](API\Runtime\Core\Containers\TArrayView)< const int > Triangles )


code: template<typename EnumerableType> void Deselect ( const EnumerableType & Enumerable )


code: [TSet](API\Runtime\Core\Containers\TSet)< int >::TRangedForIterator end()


code: void DeselectGroup ( int gid )


code: [TSet](API\Runtime\Core\Containers\TSet)< int >::TRangedForConstIterator end() const


code: void ExpandToFaceNeighbours ( const [TUniqueFunction](API\Runtime\Core\Templates\TUniqueFunction)< bool(int)> & FilterF )


description: Return false from FilterF to prevent triangles from being included.

code: void ExpandToOneRingNeighbours ( const [TUniqueFunction](API\Runtime\Core\Templates\TUniqueFunction)< bool(int)> & FilterF )


code: void ExpandToOneRingNeighbours ( int nRings, const [TUniqueFunction](API\Runtime\Core\Templates\TUniqueFunction)< bool(int)> & FilterF )


description: Return true if we filled any ears.

code: bool FillEars ( bool bFillTinyHoles )


description: Find set of tris just inside border of selection

code: [TArray](API\Runtime\Core\Containers\TArray)< int > FindBorderTris() const


description: Find set of tris just outside border of selection

code: [TArray](API\Runtime\Core\Containers\TArray)< int > FindNeighbourTris() const


code: void ExpandToFaceNeighbours ( int rounds, const [TUniqueFunction](API\Runtime\Core\Templates\TUniqueFunction)< bool(int)> & FilterF )


description: Grow selection outwards from seed triangles, until it hits boundaries defined by triangle and edge filters. Edge filter is not effective unless it (possibly combined w/ triangle filter) defines closed loops.

code: void FloodFill ( const [TArray](API\Runtime\Core\Containers\TArray)< int > & Seeds, const [TUniqueFunction](API\Runtime\Core\Templates\TUniqueFunction)< bool(int)> & TriFilterF, const [TUniqueFunction](API\Runtime\Core\Templates\TUniqueFunction)< bool(int)> & EdgeFilterF )


description: Grow selection outwards from seed triangle, until it hits boundaries defined by triangle and edge filters. Edge filter is not effective unless it (possibly combined w/ triangle filter) defines closed loops.

code: void FloodFill ( int tSeed, const [TUniqueFunction](API\Runtime\Core\Templates\TUniqueFunction)< bool(int)> & TriFilterF, const [TUniqueFunction](API\Runtime\Core\Templates\TUniqueFunction)< bool(int)> & EdgeFilterF )


description: pair (bIsSelectionBoundaryEdge, bIsMeshBoundaryEdge) for a given edge

code: TPair< bool, bool > IsSelectionBoundaryEdge ( int32 eid ) const


code: bool LocalOptimize ( bool bRemoveBowties )


code: bool IsSelected ( int tid ) const


description: Returns true if selection was modified

code: bool LocalOptimize ( bool bClipFins, bool bFillEars, bool bFillTinyHoles, bool bClipLoners, bool bRemoveBowties )


description: Find any "bowtie" vertices - ie vertex v such taht there is multiple spans of triangles selected in v's triangle one-ring - and deselect those one-rings. Returns true if selection was modified.

code: bool RemoveBowties()


code: void Select ( [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< bool(int)> SelectF )


code: template<typename EnumerableType, typename E> void Select ( const EnumerableType & Enumerable )


code: void SelectEdgeTris ( int eid )


code: void SelectGroup ( int gid )


code: void SelectVertexOneRing ( int vid )


code: void SelectGroupInverse ( int gid )


code: void SelectVertexOneRings ( [TArrayView](API\Runtime\Core\Containers\TArrayView)< const int > Vertices )


description: Find the elements in current selection that are not in SubtractSet, and store in DifferenceStorage

code: template<typename EnumerableType, typename StorageType> void SetDifference ( const EnumerableType & SubtractSet, StorageType & DifferenceStorage ) const


description: Find the elements in current selection that are also in IntersectSet, and store in IntersectionStorage

code: template<typename EnumerableType, typename StorageType> void SetIntersection ( const EnumerableType & IntersectSet, StorageType & IntersectionStorage ) const


code: FMeshFaceSelection ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * mesh )


description: Select a group

code: FMeshFaceSelection ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * mesh, int group_id )


description: Convert vertex selection to face selection. Require at least minCount verts of tri to be selected (valid values are 1,2,3)

code: FMeshFaceSelection ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * mesh, const [FMeshVertexSelection](API\Runtime\GeometryCore\Selections\FMeshVertexSelection) & convertV, int minCount )


code: [TArray](API\Runtime\Core\Containers\TArray)< int > AsArray() const


code: [TBitArray](API\Runtime\Core\Containers\TBitArray)< [FDefaultBitArrayAllocator](API\Runtime\Core\Containers\FDefaultBitArrayAllocator) > AsBitArray() const


className: FMeshFaceSelection

code: class FMeshFaceSelection


code: [TSet](API\Runtime\Core\Containers\TSet)< int >::TRangedForIterator begin()


code: [TSet](API\Runtime\Core\Containers\TSet)< int >::TRangedForConstIterator begin() const


code: [TSet](API\Runtime\Core\Containers\TSet)< int > AsSet() const


description: Remove all vertices in current selection set that have at least one neighbour vertex that is not selected (ie vertices are on border of selection)

code: void ContractByBorderVertices ( int32 nRings )


code: void Deselect ( [TArrayView](API\Runtime\Core\Containers\TArrayView)< const int > Vertices )


code: void DeselectEdge ( int eid )


code: void DeselectEdges ( [TArrayView](API\Runtime\Core\Containers\TArrayView)< const int > Edges )


code: [TSet](API\Runtime\Core\Containers\TSet)< int >::TRangedForIterator end()


description: Return false from FilterF to prevent vertices from being included.

code: void ExpandToOneRingNeighbours ( const [TUniqueFunction](API\Runtime\Core\Templates\TUniqueFunction)< bool(int)> & FilterF )


code: [TSet](API\Runtime\Core\Containers\TSet)< int >::TRangedForConstIterator end() const


description: [TODO] should do this more efficiently, likeFMeshFaceSelection

code: void ExpandToOneRingNeighbours ( int nRings, const [TUniqueFunction](API\Runtime\Core\Templates\TUniqueFunction)< bool(int)> & FilterF )


description: Grow selection outwards from seed vertex, until it hits boundaries defined by vertex filter.

code: void FloodFill ( const [TArray](API\Runtime\Core\Containers\TArray)< int > & Seeds, const [TUniqueFunction](API\Runtime\Core\Templates\TUniqueFunction)< bool(int)> & VertIncludedF )


code: void FloodFill ( int vSeed, const [TUniqueFunction](API\Runtime\Core\Templates\TUniqueFunction)< bool(int)> & VertIncludedF )


code: bool IsSelected ( int vID ) const


description: Select vertices where PredicteFunc(VertexPosition) == bSelectTrue

code: template<typename PredicateFuncType> void SelectByPosition ( PredicateFuncType PredicateFunc, bool bSelectTrue )


description: Select vertices where PredicteFunc(VertexID) == bSelectTrue

code: template<typename PredicateFuncType> void SelectByVertexID ( PredicateFuncType PredicateFunc, bool bSelectTrue )


code: void Select ( [TArrayView](API\Runtime\Core\Containers\TArrayView)< const int > Vertices )


code: void SelectEdgeVertices ( [TArrayView](API\Runtime\Core\Containers\TArrayView)< const int > Edges )


description: Select set of boundary vertices connected to vSeed.

code: void SelectConnectedBoundaryV ( int vSeed )


description: For each vertex of input triangle set, select vertex if all one-ring triangles are contained in triangle set (ie vertex is not on boundary of triangle set).

code: void SelectInteriorVertices ( const [FMeshFaceSelection](API\Runtime\GeometryCore\Selections\FMeshFaceSelection) & triangles )


code: void SelectTriangleVertices ( [TArrayView](API\Runtime\Core\Containers\TArrayView)< const int > Triangles )


code: void SelectTriangleVertices ( const [FMeshFaceSelection](API\Runtime\GeometryCore\Selections\FMeshFaceSelection) & Triangles )


description: Convert face selection to vertex selection.

code: FMeshVertexSelection ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * mesh, const [FMeshFaceSelection](API\Runtime\GeometryCore\Selections\FMeshFaceSelection) & convertT )


description: Convert edge selection to vertex selection.

code: FMeshVertexSelection ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * mesh, const [FMeshEdgeSelection](API\Runtime\GeometryCore\Selections\FMeshEdgeSelection) & convertE )


code: FMeshVertexSelection ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * mesh )


className: FSparseMatrixAssemblerd

code: typedef [TSparseMatrixAssembler](API\Runtime\GeometryCore\Solvers\TSparseMatrixAssembler)< double > FSparseMatrixAssemblerd


className: FMeshVertexSelection

code: class FMeshVertexSelection


className: FPositionConstraint

description: Basic position constraint

code: struct FPositionConstraint

bPostFix

description: If bPostFix is true, this position constraint should be explicitly enforced after a solve

ConstraintIndex

description: Index/Identifier of constraint, defined by usage

ElementID

description: ID of constrained UV element

Position

description: Constraint position

Weight

type: double

description: Arbitrary weight


className: FSparseMatrixAssemblerf

code: typedef [TSparseMatrixAssembler](API\Runtime\GeometryCore\Solvers\TSparseMatrixAssembler)< float > FSparseMatrixAssemblerf


className: TSparseMatrixAssembler

description: Generic adapter for building a Sparse Matrix. Generally sparse-matrix assembly code emits matrix entries as tuples of form (i,j,Value).

code: template<typename RealType> class TSparseMatrixAssembler

AddEntryFunc

type: TUniqueFunction...

description: Add matrix entry tuple (i,j,Value)

ReserveEntriesFunc

description: Hint to reserve space for at least this many entries


className: FUVConstraint

description: Basic UV constraint

code: struct FUVConstraint

ElementID

description: ID of constrained UV element

Position

description: Constraint position

Weight

description: Arbitrary weight