description: Calculate the Convex Hull of a 3D point set as a Triangle Mesh

code: template<typename RealType> class TConvexHull3

bSaveTriangleNeighbors

description: Whether neighbors for the hull triangles should be computed/saved.

HullNeighbors

description: We can optionally also return the hull triangle adjacencies.

Line

type: TLine3< RealTyp...

NumHullPoints

type: int

Plane

type: TPlane3< RealTy...

Progress

type: FProgressCancel...

description: Set this to be able to cancel running operation


module: GeometryCore

code: TExtremePoints3 ( int32 NumPoints, [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< [TVector](API\Runtime\Core\Math\TVector)< RealType >(int32)> GetPointFunc, [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< bool(int32)> FilterFunc, RealType Epsilon )


description: The extreme points are chosen to be far apart, and are used as the starting point for incremental convex hull construction.

code: template<typename RealType> struct TExtremePoints3

Basis

type: TVector< RealTy...

Origin

description: Coordinate frame spanned by input points.


code: void Build ( bool bForceRebuild )


description: Fast approximation of winding number using far-field approximations. On a closed mesh the winding number will be 1 or more inside (depending on number of "winds"). Outside a closed mesh the winding number will be zero. On an open mesh, the above holds near the mesh but in the "hole" areas the value will smoothly blend from 1 to 0 over a band of width dependent on the hole extent

code: double FastWindingNumber ( const FVector3d & P )


description: Const version does not auto-build on query

code: double FastWindingNumber ( const FVector3d & P ) const


code: [TMeshAABBTree3](API\Runtime\GeometryCore\Spatial\TMeshAABBTree3)< TriangleMeshType > * GetTree() const


description: true if fast winding number at point P is greater than winding threshold (default 0.5)

code: bool IsInside ( const FVector3d & P, double WindingIsoThreshold ) const


code: void SetTree ( [TMeshAABBTree3](API\Runtime\GeometryCore\Spatial\TMeshAABBTree3)< TriangleMeshType > * TreeToRef, bool bAutoBuild )


code: TFastWindingTree ( [TMeshAABBTree3](API\Runtime\GeometryCore\Spatial\TMeshAABBTree3)< TriangleMeshType > * TreeToRef, bool bAutoBuild )


code: bool AddHole ( [TPolygon2](API\Runtime\GeometryCore\TPolygon2)< T > Hole, bool bCheckContainment, bool bCheckOrientation )


className: TFastWindingTree

description: Fast Mesh Winding Number extension to aTMeshAABBTree3. This class is an "add-on" to the AABBTree, that can compute the Fast Mesh Winding Number. This calculation requires a precomputation pass where information is cached at each tree node.

code: template<class TriangleMeshType> class TFastWindingTree

FWNApproxOrder

description: FWN approximation order. Must be 1 or 2. 2 is more accurate, obviously.

FWNBeta

type: double

description: FWN beta parameter - is 2.0 in paper


code: [TAxisAlignedBox2](API\Runtime\GeometryCore\TAxisAlignedBox2)< T > Bounds() const


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


code: bool Contains ( [TPolygon2](API\Runtime\GeometryCore\TPolygon2)< T > Poly ) const


description: This should be more efficient when there are Holes...

code: double DistanceSquared ( [TVector2](API\Runtime\Core\Math\TVector2)< T > p, int & iHoleIndex, int & iNearSeg, double & fNearSegT ) const


description: Remove any Hole polygons for which RemoveHolePredicateFunc(Hole) returns true

code: void FilterHoles ( [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< bool(const [TPolygon2](API\Runtime\GeometryCore\TPolygon2)< T > &)> RemoveHolePredicateFunc )


code: const [TArray](API\Runtime\Core\Containers\TArray)< [TPolygon2](API\Runtime\GeometryCore\TPolygon2)< T > > & GetHoles() const


code: [TVector2](API\Runtime\Core\Math\TVector2)< T > GetNormal ( int iSegment, double segT, int iHoleIndex ) const


code: const [TPolygon2](API\Runtime\GeometryCore\TPolygon2)< T > & GetOuter() const


code: [TVector2](API\Runtime\Core\Math\TVector2)< T > GetSegmentPoint ( int iSegment, double fSegT, int iHoleIndex ) const


code: double HoleUnsignedArea() const


code: bool Intersects ( [TPolygon2](API\Runtime\GeometryCore\TPolygon2)< T > Poly ) const


code: bool OuterIsClockwise() const


code: void Scale ( [TVector2](API\Runtime\Core\Math\TVector2)< T > scale, [TVector2](API\Runtime\Core\Math\TVector2)< T > origin )


code: [TSegment2](API\Runtime\GeometryCore\TSegment2)< T > Segment ( int iSegment, int iHoleIndex ) const


code: void SetOuter ( const [TPolygon2](API\Runtime\GeometryCore\TPolygon2)< T > & ToSetOuter )


code: void SetOuterWithOrientation ( const [TPolygon2](API\Runtime\GeometryCore\TPolygon2)< T > & ToSetOuter, bool bToSetOuterIsCW )


code: void Simplify ( double ClusterTol, double LineDeviationTol )


code: void Transform ( const [TFunction](API\Runtime\Core\GenericPlatform\TFunction)< [TVector2](API\Runtime\Core\Math\TVector2)< T >(const [TVector2](API\Runtime\Core\Math\TVector2)< T > &)> & TransformFunc )


code: void Translate ( [TVector2](API\Runtime\Core\Math\TVector2)< T > translate )


description: Offset each polygon by the given Distance along vertex "normal" direction (ie for positive offset, outer polygon grows and holes shrink)

code: void VtxNormalOffset ( T OffsetDistance, bool bUseFaceAvg )


description: TGeneralPolygon2is a 2D polygon with holes

code: template<typename T> class TGeneralPolygon2

bOuterIsCW

type: bool

description: If true, Outer polygon winding is clockwise

Holes

type: TArray<TPolygo...

description: The list of Holes in the polygon

Outer

type: TPolygon2< T >

description: The Outer boundary of the polygon


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

code: namespace UE { namespace Geometry { template<typename RealType> [TOrientedBox3](API\Runtime\GeometryCore\TOrientedBox3)< RealType > UE::Geometry::ComputeOrientedBBox ( const [EDiTO](API\Runtime\GeometryCore\CompGeom\UE__Geometry__EDiTO) DiTO_K, const int32 NumPoints, [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< [UE::Math::TVector](API\Runtime\Core\Math\TVector)< RealType >(int32)> GetPointFunc ) } }


description:
The number of extreme vertices used by the method will be twice the number of sample directions.
OrientedBox3 that contains the points provided by the given GetPointFunc

code: namespace UE { namespace Geometry { template<typename RealType> [TOrientedBox3](API\Runtime\GeometryCore\TOrientedBox3)< RealType > UE::Geometry::ComputeOrientedBBox ( const [TArray](API\Runtime\Core\Containers\TArray)< [TVector](API\Runtime\Core\Math\TVector)< RealType >> & SampleDirections, const int32 NumPoints, [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< [UE::Math::TVector](API\Runtime\Core\Math\TVector)< RealType >(int32)> GetPointFunc ) } }


description: Forward declarations

code: namespace UE { namespace Geometry { enum EBox2FitCriteria { Area, Perimeter, } } }


description: Forward declarations

code: namespace UE { namespace Geometry { enum EBox3FitCriteria { Volume, SurfaceArea, } } }


description: TODO: To support meshes where volume is not well defined (e.g., open boundaries or many self-intersecting parts), we'll need alternative error metrics.

code: namespace UE { namespace Geometry { enum EConvexErrorMethod { RelativeVolume, } } }


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

code: namespace UE { namespace Geometry { enum EDiTO { DiTO_12 = 0, DiTO_14 = 1, DiTO_20 = 2, DiTO_26 = 3, } } }


description: value w/ sign indicating whether the normal of line AB is facing Direction (and 0 if parallel) (i.e. the sign of -PerpCW(B-A) dot Dir)

code: namespace UE { namespace Geometry { namespace ExactPredicates { template<typename RealType> RealType UE::Geometry::ExactPredicates::Facing2 ( const [TVector2](API\Runtime\Core\Math\TVector2)< RealType > & A, const [TVector2](API\Runtime\Core\Math\TVector2)< RealType > & B, const [TVector2](API\Runtime\Core\Math\TVector2)< RealType > & Direction ) } } }


description:
TVector-only version that can run in float or double
value w/ sign indicating whether triangle ABC is facing Direction, or 0 if it is parallel to Direction

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


description:
TVector2-only version that can run in float or double
value indicating whether point D is inside, outside, or exactly on the circle passing through ABC Note: Sign of the result depends on the orientation of triangle ABC  Counterclockwise: Inside is positive Clockwise: Inside is negative

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


description:
TVector-only version that can run in float or double
value indicating whether point E is inside, outside, or exactly on the sphere passing through ABCD Note: Sign of the result depends on the orientation of tetrahedron ABCD

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


description: Deprecated* Use Orient2instead.

code: namespace UE { namespace Geometry { namespace ExactPredicates { float *they have been expanded out the vector types they were used with *double UE::Geometry::ExactPredicates::Orient2D ( const FVector2d & A, const FVector2d & B, const FVector2d & C ) } } }


description: Deprecated* Use Orient2instead.

code: namespace UE { namespace Geometry { namespace ExactPredicates { double UE::Geometry::ExactPredicates::Orient2D ( const FVector2f & A, const FVector2f & B, const FVector2f & C ) } } }


description: Construct a general polygon with the given polygon as boundary

code: TGeneralPolygon2 ( const [TPolygon2](API\Runtime\GeometryCore\TPolygon2)< T > & ToSetOuter )


description: Deprecated* Use Orient3instead.

code: namespace UE { namespace Geometry { namespace ExactPredicates { double UE::Geometry::ExactPredicates::Orient3D ( const FVector3d & A, const FVector3d & B, const FVector3d & C, const FVector3d & D ) } } }


description: Deprecated* Use Orient3instead.

code: namespace UE { namespace Geometry { namespace ExactPredicates { double UE::Geometry::ExactPredicates::Orient3D ( const FVector3f & A, const FVector3f & B, const FVector3f & C, const FVector3f & D ) } } }


description:
TVector2-only version that can run in float or double
value indicating which side of line AB point C is on, or 0 if ABC are collinear

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


description:
TVector-only version that can run in float or double
value indicating which side of triangle ABC point D is on, or 0 if ABCD are coplanar

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


description:
Use the rotating calipers algorithm to find a best-fit oriented bounding box of a convex hull.
A best-fitTOrientedBox2that contains the points

code: namespace UE { namespace Geometry { template<typename RealType> [TOrientedBox2](API\Runtime\GeometryCore\TOrientedBox2)< RealType > UE::Geometry::FitOrientedBox2ConvexHull ( int32 NumPts, [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< [TVector2](API\Runtime\Core\Math\TVector2)< RealType >(int32)> GetHullPt, [EBox2FitCriteria](API\Runtime\GeometryCore\CompGeom\UE__Geometry__EBox2FitCriteria) FitMethod ) } }


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

code: namespace UE { namespace Geometry { template<typename RealType> [TOrientedBox2](API\Runtime\GeometryCore\TOrientedBox2)< RealType > UE::Geometry::FitOrientedBox2Points ( [TArrayView](API\Runtime\Core\Containers\TArrayView)< const [TVector2](API\Runtime\Core\Math\TVector2)< RealType >> Points, [EBox2FitCriteria](API\Runtime\GeometryCore\CompGeom\UE__Geometry__EBox2FitCriteria) FitMethod ) } }


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

code: namespace UE { namespace Geometry { template<typename RealType> [TOrientedBox2](API\Runtime\GeometryCore\TOrientedBox2)< RealType > UE::Geometry::FitOrientedBox2SimplePolygon ( [TArrayView](API\Runtime\Core\Containers\TArrayView)< const [TVector2](API\Runtime\Core\Math\TVector2)< RealType >> Polygon, [EBox2FitCriteria](API\Runtime\GeometryCore\CompGeom\UE__Geometry__EBox2FitCriteria) FitMethod ) } }


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

code: namespace UE { namespace Geometry { template<typename RealType> [TOrientedBox3](API\Runtime\GeometryCore\TOrientedBox3)< RealType > UE::Geometry::FitOrientedBox3Points ( [TArrayView](API\Runtime\Core\Containers\TArrayView)< const [TVector](API\Runtime\Core\Math\TVector)< RealType >> Points, [EBox3FitCriteria](API\Runtime\GeometryCore\CompGeom\UE__Geometry__EBox3FitCriteria) FitMethod, RealType SameNormalTolerance, [FProgressCancel](API\Runtime\GeometryCore\Util\FProgressCancel) * ProgressCancel ) } }


code: int add_edge ( int A, int B, int GID )


code: int AppendEdge ( const [FEdge](API\Runtime\GeometryCore\Curve\FDynamicGraph\FEdge) & E )


code: int AppendEdge ( const [FIndex2i](API\Runtime\GeometryCore\FIndex2i) & ev, int GID )


code: int AppendEdge ( int v0, int v1, int GID )


code: virtual int append_new_split_vertex ( int A, int B )


code: int append_vertex_internal()


description: This function checks that the graph is well-formed, ie all internal data structures are consistent

code: virtual bool CheckValidity ( [EValidityCheckFailMode](API\Runtime\GeometryCore\UE__Geometry__EValidityCheckFail-) FailMode ) const


code: [EMeshResult](API\Runtime\GeometryCore\UE__Geometry__EMeshResult) CollapseEdge ( int VKeep, int VRemove, [FEdgeCollapseInfo](API\Runtime\GeometryCore\Curve\FDynamicGraph\FEdgeCollapseInfo) & Collapse )


className: DuplicateEdgeID

code: static constexpr int DuplicateEdgeID = -2;


code: void debug_check_is_edge ( int E ) const


code: void debug_check_is_vertex ( int V ) const


code: bool edge_has_v ( int EID, int VID ) const


description: Enumerate edges.

code: [value_iteration](API\Runtime\GeometryCore\Curve\FDynamicGraph\value_iteration)< [FEdge](API\Runtime\GeometryCore\Curve\FDynamicGraph\FEdge) > Edges() const


className: FEdgeCollapseInfo

code: struct FEdgeCollapseInfo


code: int edge_other_v ( int EID, int VID ) const


className: FEdgeSplitInfo

code: struct FEdgeSplitInfo


code: [FIndex2i](API\Runtime\GeometryCore\FIndex2i) GetEdgeV ( int EID ) const


code: int GetEdgeGroup ( int EID ) const


code: int FindEdge ( int VA, int VB ) const


code: [FEdge](API\Runtime\GeometryCore\Curve\FDynamicGraph\FEdge) GetEdge ( int EID ) const


code: int GetVtxEdgeCount ( int VID ) const


code: int GetMaxVtxEdgeCount() const


code: bool insert_vertex_internal ( int32 Vid )


className: InvalidID

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


code: bool IsBoundaryVertex ( int VID ) const


code: bool IsEdge ( int EID ) const


code: bool IsJunctionVertex ( int VID ) const


code: bool IsRegularVertex ( int VID ) const


code: bool IsVertex ( int VID ) const


description: These values are (max_used+1), ie so an iteration should be < MaxVertexID, not <=

code: int MaxVertexID() const


code: [EMeshResult](API\Runtime\GeometryCore\UE__Geometry__EMeshResult) RemoveEdge ( int EID, bool bRemoveIsolatedVertices )


code: [EMeshResult](API\Runtime\GeometryCore\UE__Geometry__EMeshResult) RemoveVertex ( int VID, bool bRemoveIsolatedVertices )


code: void SetEdgeGroup ( int EID, int GroupID )


code: [EMeshResult](API\Runtime\GeometryCore\UE__Geometry__EMeshResult) SplitEdge ( int EAB, [FEdgeSplitInfo](API\Runtime\GeometryCore\Curve\FDynamicGraph\FEdgeSplitInfo) & Split )


code: [EMeshResult](API\Runtime\GeometryCore\UE__Geometry__EMeshResult) SplitEdge ( int VA, int VB, [FEdgeSplitInfo](API\Runtime\GeometryCore\Curve\FDynamicGraph\FEdgeSplitInfo) & Split )


code: [EMeshResult](API\Runtime\GeometryCore\UE__Geometry__EMeshResult) SplitEdgeWithExistingVertex ( int EAB, int ExistingMidVert, [FEdgeSplitInfo](API\Runtime\GeometryCore\Curve\FDynamicGraph\FEdgeSplitInfo) & Split )


code: virtual void subclass_validity_checks ( [TFunction](API\Runtime\Core\GenericPlatform\TFunction)< void(bool)> CheckOrFailF ) const


code: int replace_edge_vertex ( int EID, int VOld, int VNew )


code: void updateTimeStamp ( bool bShapeChange )


code: typedef [FRefCountVector::MappedEnumerable](API\Runtime\GeometryCore\Util\FRefCountVector\MappedEnumerable)< T > value_iteration


description: Iterators The functions vertices() / triangles() /edges()are provided so you can do: for ( int EID :edges()) { ... } and other relatedbegin()/end()idioms


description: Enumerate edge ids connected to vertex (i.e. edge one-ring)

code: [FSmallListSet::ValueEnumerable](API\Runtime\GeometryCore\Util\FSmallListSet\ValueEnumerable) VtxEdgesItr ( int VID ) const


description: Enumerate "other" vertices of edges connected to vertex (i.e. vertex one-ring)

code: [FSmallListSet::MappedValueEnumerable](API\Runtime\GeometryCore\Util\FSmallListSet\MappedValueEnumerable) VtxVerticesItr ( int VID ) const


className: FDynamicGraph

code: class FDynamicGraph

edges

type: TDynamicVector<...

type: FRefCountVector

type: FSmallListSet


code: int AppendVertex ( [TVector2](API\Runtime\Core\Math\TVector2)< T > V )


description: Internal used in SplitEdge

code: virtual int append_new_split_vertex ( int A, int B )


description: Cached bounding box, lazily re-computed on access if mesh has changed

code: [TAxisAlignedBox2](API\Runtime\GeometryCore\TAxisAlignedBox2)< T > CachedBounds()


description: Compute vertex bounding box


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


code: [TSegment2](API\Runtime\GeometryCore\TSegment2)< T > GetEdgeSegment ( int EID ) const


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


code: bool GetEdgeV ( int EID, [UE::Math::TVector2](API\Runtime\Core\Math\TVector2)< T > & A, [UE::Math::TVector2](API\Runtime\Core\Math\TVector2)< T > & B ) const


description: Compute opening angle at vertex VID. If not a vertex, or valence != 2, returns InvalidValue argument. If either edge is degenerate, returns InvalidValue argument.

code: double OpeningAngle ( int VID, double InvalidValue ) const


code: static [TVector2](API\Runtime\Core\Math\TVector2)< T > InvalidVertex()


code: void SetVertex ( int VID, [TVector2](API\Runtime\Core\Math\TVector2)< T > VNewPos )


description: Return edges around VID sorted by angle, in counter-clockwise order

code: bool SortedVtxEdges ( int VID, [TArray](API\Runtime\Core\Containers\TArray)< int > & Sorted ) const


code: virtual void subclass_validity_checks ( [TFunction](API\Runtime\Core\GenericPlatform\TFunction)< void(bool)> CheckOrFailF ) const


code: typedef [FDynamicGraph2](API\Runtime\GeometryCore\Curve\FDynamicGraph2)< double > FDynamicGraph2d


code: [value_iteration](API\Runtime\GeometryCore\Curve\FDynamicGraph\value_iteration)< [TVector2](API\Runtime\Core\Math\TVector2)< T > > Vertices() const


code: template<typename T> class FDynamicGraph2 : public [UE::Geometry::FDynamicGraph](API\Runtime\GeometryCore\Curve\FDynamicGraph)


code: int AppendVertex ( [TVector](API\Runtime\Core\Math\TVector)< T > V )


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


code: [TSegment3](API\Runtime\GeometryCore\TSegment3)< T > GetEdgeSegment ( int EID ) const


code: bool GetEdgeV ( int EID, [TVector](API\Runtime\Core\Math\TVector)< T > & A, [TVector](API\Runtime\Core\Math\TVector)< T > & B ) const


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


description: false If insertion failed (because a vertex with that ID already exists).

code: bool InsertVertex ( int32 Vid, [TVector](API\Runtime\Core\Math\TVector)< T > V )


code: static [TVector](API\Runtime\Core\Math\TVector)< T > InvalidVertex()


code: void SetVertex ( int VID, [TVector](API\Runtime\Core\Math\TVector)< T > VNewPos )


description: Enumerate positions of all Vertices in graph

code: [value_iteration](API\Runtime\GeometryCore\Curve\FDynamicGraph\value_iteration)< [TVector](API\Runtime\Core\Math\TVector)< T > > VerticesItr() const


code: typedef [FDynamicGraph3](API\Runtime\GeometryCore\Curve\FDynamicGraph3)< double > FDynamicGraph3d


code: template<typename T> class FDynamicGraph3 : public [UE::Geometry::FDynamicGraph](API\Runtime\GeometryCore\Curve\FDynamicGraph)


description: Internal used in SplitEdge

code: virtual int append_new_split_vertex ( int A, int B )


className: FDynamicGraphN

description: Implementation of DGraph that has no dimensionality, ie no data stored for vertices besides indices.

code: class FDynamicGraphN : public [UE::Geometry::FDynamicGraph](API\Runtime\GeometryCore\Curve\FDynamicGraph)


code: typedef [TGeneralPolygon2](API\Runtime\GeometryCore\CompGeom\TGeneralPolygon2)< double > FGeneralPolygon2d


className: FPlanarComplexd

code: typedef [TPlanarComplex](API\Runtime\GeometryCore\Curve\TPlanarComplex)< double > FPlanarComplexd


code: typedef [TGeneralPolygon2](API\Runtime\GeometryCore\CompGeom\TGeneralPolygon2)< float > FGeneralPolygon2f


className: FPlanarComplexf

code: typedef [TPlanarComplex](API\Runtime\GeometryCore\Curve\TPlanarComplex)< float > FPlanarComplexf


code: [TGeneralPolygon2](API\Runtime\GeometryCore\CompGeom\TGeneralPolygon2)< RealType > ConvertNestToGeneralPolygon ( const [FPolygonNesting](API\Runtime\GeometryCore\Curve\TPlanarComplex\FPolygonNesting) & Nest ) const


code: [TArray](API\Runtime\Core\Containers\TArray)< [TGeneralPolygon2](API\Runtime\GeometryCore\CompGeom\TGeneralPolygon2)< RealType > > ConvertOutputToGeneralPolygons() const


description: Finds set of "solid" regions  e.g. boundary loops with interior holes. Result has outer loops being clockwise, and holes counter-clockwise

code: void FindSolidRegions()


className: FPolygonNesting

description: Outputs

code: struct FPolygonNesting

HoleIndices

type: TArray< int >


className: TPlanarComplex

code: template<typename RealType> struct TPlanarComplex

Polygons

description: Inputs

Solids

type: TArray<FPolygo...


code: namespace UE { namespace Geometry { namespace CurveUtil { template<typename RealType, typename VectorType> static RealType UE::Geometry::CurveUtil::ArcLength ( const [TArrayView](API\Runtime\Core\Containers\TArrayView)< const VectorType > & Vertices, bool bLoop ) } } }


description: Use the Sutherland–Hodgman algorithm to clip the vertices to the given bounds Note if the path/polygon is concave, this may leave overlapping edges at the boundary. Note this modifies and re-sizes the input array, so is written forTArrayinstead ofTArrayView

code: namespace UE { namespace Geometry { namespace CurveUtil { template<typename RealType, typename VectorType, bool bLoop, int ClipDims> static void UE::Geometry::CurveUtil::ClipConvexToBounds ( [TArray](API\Runtime\Core\Containers\TArray)< VectorType > & Vertices, VectorType Min, VectorType Max ) } } }


description: true if the given query point is inside the closed curve (in the XY plane), based on the winding integral Note: Negative and positive windings are both considered 'inside'

code: namespace UE { namespace Geometry { namespace CurveUtil { template<typename RealType, typename VectorType> bool UE::Geometry::CurveUtil::Contains2 ( const [TArrayView](API\Runtime\Core\Containers\TArrayView)< const VectorType > & Vertices, const VectorType & QueryPoint ) } } }


code: namespace UE { namespace Geometry { namespace CurveUtil { template<typename RealType, typename VectorType> int UE::Geometry::CurveUtil::FindNearestIndex ( const [TArrayView](API\Runtime\Core\Containers\TArrayView)< const VectorType > & Vertices, const VectorType & V ) } } }


description: Construct a normal at a vertex of the Polygon by averaging the adjacent face normals. This vector is independent of the lengths of the adjacent segments. Points "inward" for a Clockwise Polygon, and outward for CounterClockwise Note: Specific to 2D curves; normals computed by rotating tangents in the XY plane

code: namespace UE { namespace Geometry { namespace CurveUtil { template<typename RealType, typename VectorType, bool bLoop> VectorType UE::Geometry::CurveUtil::GetNormal_FaceAvg2 ( const [TArrayView](API\Runtime\Core\Containers\TArrayView)< const VectorType > & Vertices, int VertexIndex ) } } }


description: Curve utility functions Get (by reference) the vertices surrounding the given vertex index If bLoop is false and the Prev or Next vertex would be out of bounds, the vertex at Idx is used instead.

code: namespace UE { namespace Geometry { namespace CurveUtil { template<typename RealType, typename VectorType, bool bLoop> void UE::Geometry::CurveUtil::GetPrevNext ( const [TArrayView](API\Runtime\Core\Containers\TArrayView)< const VectorType > & Vertices, int32 Idx, VectorType & OutPrev, VectorType & OutNext ) } } }


description: Get (by reference) vectors pointing toward the given vertex index, from its surrounding vertices If bLoop is false and the Prev or Next vertex would be out of bounds, a zero vector is used instead

code: namespace UE { namespace Geometry { namespace CurveUtil { template<typename RealType, typename VectorType, bool bLoop> void UE::Geometry::CurveUtil::GetVectorsToPrevNext ( const [TArrayView](API\Runtime\Core\Containers\TArrayView)< const VectorType > & Vertices, int32 VertexIndex, VectorType & OutToPrev, VectorType & OutToNext, bool bNormalize ) } } }


description: Smooth vertices in-place (will not produce a symmetric result, but does not require extra buffer)

code: namespace UE { namespace Geometry { namespace CurveUtil { template<typename RealType, typename VectorType> void UE::Geometry::CurveUtil::InPlaceSmooth ( [TArrayView](API\Runtime\Core\Containers\TArrayView)< VectorType > Vertices, int StartIdx, int EndIdx, double Alpha, int NumIterations, bool bClosed ) } } }


description:
Tests closed, 2D curve for convexity, with an optional tolerance allowing for approximately-collinear points Note that tolerance is per vertex angle, so a very-finely-sampled smooth concavity could be reported as convex
true if polygon is convex

code: namespace UE { namespace Geometry { namespace CurveUtil { template<typename RealType, typename VectorType> bool UE::Geometry::CurveUtil::IsConvex2 ( const [TArrayView](API\Runtime\Core\Containers\TArrayView)< const VectorType > Vertices, RealType Tolerance, bool bDegenerateIsConvex ) } } }


description: Smooth set of vertices using extra buffer

code: namespace UE { namespace Geometry { namespace CurveUtil { template<typename RealType, typename VectorType> void UE::Geometry::CurveUtil::IterativeSmooth ( [TArrayView](API\Runtime\Core\Containers\TArrayView)< VectorType > Vertices, int StartIdx, int EndIdx, double Alpha, int NumIterations, bool bClosed ) } } }


description: Compute the signed area of a closed curve, assuming vertices in the XY plane

code: namespace UE { namespace Geometry { namespace CurveUtil { template<typename RealType, typename VectorType> RealType UE::Geometry::CurveUtil::SignedArea2 ( const [TArrayView](API\Runtime\Core\Containers\TArrayView)< const VectorType > & Vertices ) } } }


description: the tangent direction (normalized) of the path at Idx, using the surrounding vertices (as found byGetPrevNext())

code: namespace UE { namespace Geometry { namespace CurveUtil { template<typename RealType, typename VectorType, bool bLoop> VectorType UE::Geometry::CurveUtil::Tangent ( const [TArrayView](API\Runtime\Core\Containers\TArrayView)< const VectorType > & Vertices, int32 Idx ) } } }


code: namespace UE { namespace Geometry { namespace CurveUtil { template<typename RealType, typename VectorType> VectorType UE::Geometry::CurveUtil::Tangent ( const [TArrayView](API\Runtime\Core\Containers\TArrayView)< const VectorType > & Vertices, int32 Idx, bool bLoop ) } } }


description: Compute the winding of a point relative to a closed curve, assuming vertices in the XY plane

code: namespace UE { namespace Geometry { namespace CurveUtil { template<typename RealType, typename VectorType> RealType UE::Geometry::CurveUtil::WindingIntegral2 ( const [TArrayView](API\Runtime\Core\Containers\TArrayView)< const VectorType > & Vertices, const VectorType & QueryPoint ) } } }


code: FVector3d Evaluate ( const FVector3d & Pos ) const


className: MyBase

code: typedef [TBaseKelvinlet](API\Runtime\GeometryCore\Deformers\TBaseKelvinlet)< [FAffineKelvinlet](API\Runtime\GeometryCore\Deformers\FAffineKelvinlet) > MyBase


code: void UpdateForce ( const [FMatrix3d](API\Runtime\GeometryCore\FMatrix3d) & NF )


code: FAffineKelvinlet ( const [FMatrix3d](API\Runtime\GeometryCore\FMatrix3d) & ForceMatrix, const double Size, const double ShearModulus, const double PoissonRatio )


code: double Divergence ( const FVector3d & Pos ) const


className: FAffineKelvinlet

description: Implement the "Locally affine regularized Kelvinlet" from "Regularized Kelvinlets: Sculpting Brushes based on Fundamental Solutions of Elasticity" - de Goes and James 2017

code: class FAffineKelvinlet : public [UE::Geometry::TBaseKelvinlet< FAffineKelvinlet >](API\Runtime\GeometryCore\Deformers\TBaseKelvinlet)

F

description: Force Matrix.

SymF

description: 2 * symmetric part of F + trace.. : F + F^T + I Trace(F)


code: FBiLaplacianPullKelvinlet ( const FVector3d & Force, const double Size, const double ShearModulus, const double PoissonRatio )


className: FBiLaplacianPullKelvinlet

description: Note: this is independent of "a" the shear modulus term.

code: class FBiLaplacianPullKelvinlet : public [UE::Geometry::TBaseKelvinlet< FBiLaplacianPullKelvinlet >](API\Runtime\GeometryCore\Deformers\TBaseKelvinlet)


className: FBiLaplacianTwistPullKelvinlet


code: FLaplacianPullKelvinlet ( const FVector3d & Force, const double Size, const double ShearModulus, const double PoissonRatio )


className: FLaplacianPullKelvinlet

description: Note: this is independent of "a" the shear moduls term.

code: class FLaplacianPullKelvinlet : public [UE::Geometry::TBaseKelvinlet< FLaplacianPullKelvinlet >](API\Runtime\GeometryCore\Deformers\TBaseKelvinlet)


className: FLaplacianTwistPullKelvinlet


description: Specialized override that should give the same result, but be faster.


code: typedef [TBaseKelvinlet](API\Runtime\GeometryCore\Deformers\TBaseKelvinlet)< [FPinchKelvinlet](API\Runtime\GeometryCore\Deformers\FPinchKelvinlet) > MyBase


code: FPinchKelvinlet ( const [FMatrix3d](API\Runtime\GeometryCore\FMatrix3d) & ForceMatrix, const double Size, const double ShearModulus, const double PoissonRatio )


className: FPinchKelvinlet

code: class FPinchKelvinlet : public [UE::Geometry::TBaseKelvinlet< FPinchKelvinlet >](API\Runtime\GeometryCore\Deformers\TBaseKelvinlet)


description: The canonical Kelvinlet for a regularized force. u(r) = [A_e(r) I + B_e(r) r r^t] f; where A_e(r) = (a-b)/r_e + a e^2 / (2 r_e^3) B_e(r) = b / (r_e^3)


code: typedef [TBaseKelvinlet](API\Runtime\GeometryCore\Deformers\TBaseKelvinlet)< [FPullKelvinlet](API\Runtime\GeometryCore\Deformers\FPullKelvinlet) > MyBase


code: FPullKelvinlet ( const FVector3d & Force, const double Size, const double ShearModulus, const double PoissonRatio )


className: FPullKelvinlet

code: class FPullKelvinlet : public [UE::Geometry::TBaseKelvinlet< FPullKelvinlet >](API\Runtime\GeometryCore\Deformers\TBaseKelvinlet)


description: Specialized override that should give the same result, but be faster. note:= 0 andF.Trace()= 0 for the skewsymmetric cross product matrix.


code: typedef [TBaseKelvinlet](API\Runtime\GeometryCore\Deformers\TBaseKelvinlet)< [FScaleKelvinlet](API\Runtime\GeometryCore\Deformers\FScaleKelvinlet) > MyBase


code: FScaleKelvinlet ( const double Scale, const double Size, const double ShearModulus, const double PoissonRatio )


className: FScaleKelvinlet

description: Note: this one doesn't care about a, b since we have scaled the divergence.

code: class FScaleKelvinlet : public [UE::Geometry::TBaseKelvinlet< FScaleKelvinlet >](API\Runtime\GeometryCore\Deformers\TBaseKelvinlet)

S

description: Scale.


code: FVector3d Evaluate ( const FVector3d & Pos ) const


code: FSharpBiLaplacianPullKelvinlet ( const FVector3d & Force, const double Size, const double ShearModulus, const double PoissonRatio )


className: FSharpBiLaplacianPullKelvinlet

code: class FSharpBiLaplacianPullKelvinlet : public [UE::Geometry::TBaseKelvinlet< FSharpBiLaplacianPullKelvinlet >](API\Runtime\GeometryCore\Deformers\TBaseKelvinlet)


code: double Divergence ( const FVector3d & Pos ) const


code: FSharpLaplacianPullKelvinlet ( const FVector3d & Force, const double Size, const double ShearModulus, const double PoissonRatio )


className: FSharpLaplacianPullKelvinlet

code: class FSharpLaplacianPullKelvinlet : public [UE::Geometry::TBaseKelvinlet< FSharpLaplacianPullKelvinlet >](API\Runtime\GeometryCore\Deformers\TBaseKelvinlet)


code: typedef [TBaseKelvinlet](API\Runtime\GeometryCore\Deformers\TBaseKelvinlet)< [FTwistKelvinlet](API\Runtime\GeometryCore\Deformers\FTwistKelvinlet) > MyBase


code: FTwistKelvinlet ( const [FTwistKelvinlet](API\Runtime\GeometryCore\Deformers\FTwistKelvinlet) & Other )


code: FTwistKelvinlet ( const FVector3d & Twist, const double Size, const double ShearModulus, const double PoissonRatio )


className: FTwistKelvinlet

description: Independent of shear modulus and is volume preserving.

code: class FTwistKelvinlet : public [UE::Geometry::TBaseKelvinlet< FTwistKelvinlet >](API\Runtime\GeometryCore\Deformers\TBaseKelvinlet)

F

description: Force Matrix.


description: ShearModuls and Poisson Ratio - both => 0. Poisson Ratio should be in the interval [0, 1/2)

code: void SetMaterialParameters ( const double ShearModulus, const double PoissonRatio )


code: void UpdateRegularization ( const double R )


code: TBaseKelvinlet ( const double Size, const double ShearModulus, const double PoissonRatio )


className: TBaseKelvinlet

code: template<typename KelvinletModelType> class TBaseKelvinlet : public [UE::Geometry::TKelvinletIntegrator< KelvinletModelType >](API\Runtime\GeometryCore\Deformers\TKelvinletIntegrator)

a

description: Using lowercase to be consistent with standard notation (cf "Sharp Kelvinlets: Elastic Deformations with Cusps and Localized Falloffs" 2019 de Goes)

bhat

description: Note: to translate to the notation of F.de Goes, b = a * bhat.

E

description: Epsilon and powers of epsilon.


code: TBlendPairedKelvinlet ( const BrushTypeA & BrushA, const BrushTypeB & BrushB, double StrengthA )


className: TBlendPairedKelvinlet

code: template<typename BrushTypeA, typename BrushTypeB> class TBlendPairedKelvinlet : public [UE::Geometry::TKelvinletIntegrator< TBlendPairedKelvinlet< BrushTypeA, BrushTypeB > >](API\Runtime\GeometryCore\Deformers\TKelvinletIntegrator)

ABrush

type: BrushTypeA

BBrush

type: BrushTypeB


description: A single step of RK3

code: FVector3d IntegrateRK3 ( const FVector3d & Pos, double dt ) const


className: TKelvinletIntegrator

code: template<typename KelvinletModelType> class TKelvinletIntegrator


code: typedef [TDistLine3Line3](API\Runtime\GeometryCore\Distance\TDistLine3Line3)< double > FDistLine3Line3d


code: typedef [TDistLine3Line3](API\Runtime\GeometryCore\Distance\TDistLine3Line3)< float > FDistLine3Line3f


code: typedef [TDistLine3Ray3](API\Runtime\GeometryCore\Distance\TDistLine3Ray3)< double > FDistLine3Ray3d


code: typedef [TDistLine3Ray3](API\Runtime\GeometryCore\Distance\TDistLine3Ray3)< float > FDistLine3Ray3f


code: typedef [TDistLine3Segment3](API\Runtime\GeometryCore\Distance\TDistLine3Segment3)< double > FDistLine3Segment3d


code: typedef [TDistLine3Segment3](API\Runtime\GeometryCore\Distance\TDistLine3Segment3)< float > FDistLine3Segment3f


code: typedef [TDistLine3Triangle3](API\Runtime\GeometryCore\Distance\TDistLine3Triangle3)< double > FDistLine3Triangle3d


code: typedef [TDistLine3Triangle3](API\Runtime\GeometryCore\Distance\TDistLine3Triangle3)< float > FDistLine3Triangle3f


code: typedef [TDistPoint3Triangle3](API\Runtime\GeometryCore\Distance\TDistPoint3Triangle3)< double > FDistPoint3Triangle3d


code: typedef [TDistPoint3Triangle3](API\Runtime\GeometryCore\Distance\TDistPoint3Triangle3)< float > FDistPoint3Triangle3f


code: typedef [TDistRay3Segment3](API\Runtime\GeometryCore\Distance\TDistRay3Segment3)< double > FDistRay3Segment3d


code: typedef [TDistRay3Segment3](API\Runtime\GeometryCore\Distance\TDistRay3Segment3)< float > FDistRay3Segment3f


code: typedef [TDistSegment3Triangle3](API\Runtime\GeometryCore\Distance\TDistSegment3Triangle3)< double > FDistSegment3Triangle3d


code: typedef [TDistSegment3Triangle3](API\Runtime\GeometryCore\Distance\TDistSegment3Triangle3)< float > FDistSegment3Triangle3f


code: typedef [TDistTriangle3Triangle3](API\Runtime\GeometryCore\Distance\TDistTriangle3Triangle3)< float > FDistTriangle3Triangle3f


code: typedef [TDistTriangle3Triangle3](API\Runtime\GeometryCore\Distance\TDistTriangle3Triangle3)< double > FDistTriangle3Triangle3d


code: TDistLine3Line3 ( const [TLine3](API\Runtime\GeometryCore\TLine3)< Real > & Line1In, const [TLine3](API\Runtime\GeometryCore\TLine3)< Real > & Line2In )


description: Compute distance between two 3D lines

code: template<typename Real> class TDistLine3Line3

DistanceSquared

type: Real

description: Results.

type: TLine3< Real >

description: Input.

type: TVector< Real >


code: TDistLine3Ray3 ( const [TLine3](API\Runtime\GeometryCore\TLine3)< Real > & LineIn, const [TRay](API\Runtime\Core\Math\TRay)< Real > & RayIn )


description: Compute distance between 3D line and 3D ray

code: template<typename Real> class TDistLine3Ray3

description: Results.

Line

description: Input.

Ray

type: TRay< Real >


code: TDistLine3Segment3 ( const [TLine3](API\Runtime\GeometryCore\TLine3)< Real > & LineIn, const [TSegment3](API\Runtime\GeometryCore\TSegment3)< Real > & SegmentIn )


description: Compute unsigned distance between 3D line and 3D segment

code: template<typename Real> class TDistLine3Segment3

DistanceSquared

description: Output.

Line

description: Input.

Segment

type: TSegment3< Real...


code: TDistLine3Triangle3 ( const [TLine3](API\Runtime\GeometryCore\TLine3)< Real > & LineIn, const [TTriangle3](API\Runtime\GeometryCore\TTriangle3)< Real > & TriangleIn )


description: Compute unsigned distance between 3D line and 3D triangle

code: template<typename Real> class TDistLine3Triangle3

DistanceSquared

description: Output.

Line

description: Input.

Triangle

type: TTriangle3< Rea...


code: TDistPoint3Triangle3 ( const [TVector](API\Runtime\Core\Math\TVector)< Real > & PointIn, const [TTriangle3](API\Runtime\GeometryCore\TTriangle3)< Real > & TriangleIn )


description: Compute unsigned distance between 3D Point and 3D Triangle

code: template<typename Real> class TDistPoint3Triangle3

Point

description: Input.

TriangleBaryCoords

description: Results.


code: static double SquaredDistance ( const [TRay](API\Runtime\Core\Math\TRay)< Real > & Ray, const [TSegment3](API\Runtime\GeometryCore\TSegment3)< Real > & Segment, Real & RayParam, Real & SegParam )


code: TDistRay3Segment3 ( const [TRay](API\Runtime\Core\Math\TRay)< Real > & RayIn, const [TSegment3](API\Runtime\GeometryCore\TSegment3)< Real > & SegmentIn )


description: Compute distance between 3D ray and 3D segment

code: template<typename Real> class TDistRay3Segment3

DistanceSquared

description: Results.

Ray

description: Input.


code: TDistSegment3Triangle3 ( const [TSegment3](API\Runtime\GeometryCore\TSegment3)< Real > & SegmentIn, const [TTriangle3](API\Runtime\GeometryCore\TTriangle3)< Real > & TriangleIn )


description: Compute unsigned distance between 3D segment and 3D triangle

code: template<typename Real> class TDistSegment3Triangle3

DistanceSquared

description: Output.

Segment

description: Input.


code: void SetTriangle ( int WhichTriangle, const [TTriangle3](API\Runtime\GeometryCore\TTriangle3)< Real > & TriangleIn )


code: TDistTriangle3Triangle3 ( const [TTriangle3](API\Runtime\GeometryCore\TTriangle3)< Real > & TriangleA, const [TTriangle3](API\Runtime\GeometryCore\TTriangle3)< Real > & TriangleB )


code: template<typename Real> class TDistTriangle3Triangle3

DistanceSquared

description: Output.

TriangleBaryCoords

type: TVector< Real >...


className: FBuildOptions

code: struct FBuildOptions

bBuildAABBTree

type: bool

description: If true, AABBTree is automatically built for the mesh on construction

bBuildTriangleMap

description: If true andSourceWasCompactT()== false, mapping fromFColliderMeshto source mesh triangle IDs is constructed

bBuildVertexMap

description: If true andSourceWasCompactV()== false, mapping fromFColliderMeshto source mesh vertex IDs is constructed


description: true if a triangle was hit and Out parameters are initialized

code: bool FindNearestHitTriangle ( const FRay3d & Ray, double & RayParameterOut, int & HitTriangleIDOut, FVector3d & BaryCoordsOut ) const


description: Find the TriangleID closest to P on the collider mesh, and distance to it, within distance MaxDist, or return InvalidID. UseGetSourceTriangleID()to map the TriangleID back to the source mesh. Use MeshQueries.TriangleDistance() to get more information.

code: int FindNearestTriangle ( const FVector3d & Point, double & NearestDistSqrOut, const [IMeshSpatial::FQueryOptions](API\Runtime\GeometryCore\Spatial\IMeshSpatial\FQueryOptions) & Options ) const


code: uint64 GetChangeStamp() const


description: this function should be avoided if possible, and may be removed in the future.


code: int32 GetSourceTriangleID ( int32 TriangleID ) const


code: int32 GetSourceVertexID ( int32 VertexID ) const


code: [FIndex3i](API\Runtime\GeometryCore\FIndex3i) GetTriangle ( int32 TriangleID ) const


code: FVector3d GetTriNormal ( int32 TriangleID ) const


code: void GetTriVertices ( int32 TriangleID, FVector3d & V0, FVector3d & V1, FVector3d & V2 ) const


code: FVector3d GetVertex ( int32 VertexID ) const


code: bool HasTriangleIDMap() const


code: void Initialize ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & SourceMesh, const [FBuildOptions](API\Runtime\GeometryCore\DynamicMesh\FColliderMesh\FBuildOptions) & BuildOptions )


description: Mesh API required forTMeshAABBTree3

code: bool IsTriangle ( int32 TriangleID ) const


code: bool IsVertex ( int32 VertexID ) const


code: void Reset ( bool bReleaseMemory )


code: bool SourceWasCompactT() const


code: bool SourceWasCompactV() const


code: FColliderMesh ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & SourceMesh, const [FBuildOptions](API\Runtime\GeometryCore\DynamicMesh\FColliderMesh\FBuildOptions) & BuildOptions )


className: FColliderMesh

description: FColliderMesh(effectively) implements theTTriangleMeshAdapterinterface, and so can be used anywhere aTTriangleMeshAdaptercould be used (eg withTMeshQueriesfunctions).

code: class FColliderMesh

SourceTriangleIDs

type: TArray< int32 >

Vertices

type: TArray< FVector...

description: For large meshes it might be better to optionally useTDynamicVectorhere (but keeping theTArrayfor small meshes is still also desirable due to minimum-size).


description: position of Point projected onto the target

code: virtual FVector3d Project ( const FVector3d & Point, int Identifier )


code: virtual FVector3d Project ( const FVector3d & Point, FVector3d & ProjectNormalOut, int Identifier )


code: FColliderMeshProjectionTarget()


code: FColliderMeshProjectionTarget ( [FColliderMesh](API\Runtime\GeometryCore\DynamicMesh\FColliderMesh) * ColliderMeshIn )


className: FColliderMeshProjectionTarget

description: Projection target API wrapper for anFColliderMesh

code: class FColliderMeshProjectionTarget : public [UE::Geometry::IOrientedProjectionTarget](API\Runtime\GeometryCore\Spatial\IOrientedProjectionTarget)

ColliderMesh

type: FColliderMesh&...


className: FComputeTangentsOptions

description: Options used byTMeshTangentsfor tangents computation

code: struct FComputeTangentsOptions

bAngleWeighted

description: If true, per-face tangents are weighted by opening angle at triangle-vertices when blending

bAveraged

description: If true, per-face tangents are blended to create triange-vertex tangents


code: int AddEdgeInternal ( int vA, int vB, int tA, int tB )


code: void AddTriangleEdge ( int TriangleID, int v0, int v1, int j, int EdgeID )


code: int AddTriangleInternal ( int a, int b, int c, int e0, int e1, int e2 )


code: void AllocateEdgesList ( int VertexID )


description: TriVertices must be distinct and refer to existing, valid vertices

code: int AppendTriangle ( const [FIndex3i](API\Runtime\GeometryCore\FIndex3i) & TriVertices, int GroupID )


description: Vertex0, Vertex1, and Vertex2 must be distinct and refer to existing, valid vertices

code: int AppendTriangle ( int Vertex0, int Vertex1, int Vertex2, int GroupID )


description: Mesh ConstructionAppend vertex at position and other fields, returns vid

code: int AppendVertex ( const [FVertexInfo](API\Runtime\GeometryCore\DynamicMesh\FVertexInfo) & VertInfo )


description: Append vertex at position, returns vid

code: int AppendVertex ( const FVector3d & Position )


description: Copy vertex SourceVertexID from existing SourceMesh, returns new vertex id

code: int AppendVertex ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & SourceMesh, int SourceVertexID )


code: const [FDynamicMeshAttributeSet](API\Runtime\GeometryCore\DynamicMesh\FDynamicMeshAttributeSet) * Attributes() const


description: Call this before a set of unsafeInsertTriangle()calls


description: enumerable object for boundary edge indices suitable for use with range-based for, ie for ( int i :BoundaryEdgeIndicesItr())


description: Support for inserting vertex and triangle at specific IDs. This is a bit tricky because we likely will need to update the free lists in the RefCountVectors, which can be expensive. If you are going to do many inserts (eg inside a loop), wrap in BeginUnsafe / EndUnsafe calls, and pass bUnsafe = true to the InsertX() calls, to the defer free list rebuild until you are done.Call this before a set of unsafeInsertVertex()calls


description: Checks that the mesh is well-formed, ie all internal data structures are consistent

code: virtual bool CheckValidity ( [FValidityOptions](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3\FValidityOptions) ValidityOptions, [EValidityCheckFailMode](API\Runtime\GeometryCore\UE__Geometry__EValidityCheckFail-) FailMode ) const


description: "times" the point inside the mesh (like in 2D polygon winding)

code: double CalculateWindingNumber ( const FVector3d & QueryPoint ) const


description: Discard all data

code: void Clear()


code: virtual [EMeshResult](API\Runtime\GeometryCore\UE__Geometry__EMeshResult) CollapseEdge ( int KeepVertID, int RemoveVertID, [FEdgeCollapseInfo](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3\FEdgeCollapseInfo) & CollapseInfo )


description:
Collapse the edge between the two vertices, if topologically possible.
Ok on success, or enum value indicates why operation cannot be applied. Mesh remains unmodified on error.

code: virtual [EMeshResult](API\Runtime\GeometryCore\UE__Geometry__EMeshResult) CollapseEdge ( int KeepVertID, int RemoveVertID, double EdgeParameterT, [FEdgeCollapseInfo](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3\FEdgeCollapseInfo) & CollapseInfo )


description: Copy input mesh while compacting, i.e. removing unused vertices/triangles/edges. Note that it is currently unsafe to hold on to the attribute set pointer (returned fromAttributes()) across the CompactCopy call, as the latter may rebuild an entirely new attribute set.

code: void CompactCopy ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & CopyMesh, bool bNormals, bool bColors, bool bUVs, bool bAttributes, [FCompactMaps](API\Runtime\GeometryCore\Util\FCompactMaps) * CompactInfo )


description: Mesh Edit operations Compact mesh in-place, by moving vertices around and rewriting indices. Should be faster if the amount of compacting is not too significant, and is useful in some places.

code: void CompactInPlace ( [FCompactMaps](API\Runtime\GeometryCore\Util\FCompactMaps) * CompactInfo )


description: Returns measure of compactness in range [0,1], where 1 is fully compacted

code: double CompactMetric() const


description:
Initialize mesh from the output of a MeshShapeGenerator (assumesGenerate()was already called)
false if any triangles defined in Generator were skipped due to invalid topology

code: bool Copy ( const [FMeshShapeGenerator](API\Runtime\GeometryCore\Generators\FMeshShapeGenerator) * Generator )


description: Set internal data structures to be a copy of input mesh using the specified attributes

code: void Copy ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & CopyMesh, bool bNormals, bool bColors, bool bUVs, bool bAttributes )


code: void DiscardTriangleGroups()


className: DuplicateTriangleID

description: DuplicateTriangleID is returned byAppendTriangle()to indicate that the added triangle already exists in the mesh, and was ignored because we do not support duplicate triangles

code: static constexpr int DuplicateTriangleID = -3;


description: number of edges in the mesh

code: int EdgeCount() const


code: bool EdgeHasTriangle ( int EdgeID, int TriangleID ) const


description: enumerable object for valid edge indices suitable for use with range-based for, ie for ( int i :EdgeIndicesItr())


code: bool EdgeHasVertex ( int EdgeID, int VertexID ) const


description: Enumerate edges. Each returned element is [v0,v1,t0,t1], where t1 will be InvalidID if this is a boundary edge


description: Ensure that all the same extended attributes available in ToMatch are also enabled.Bydefault, clears existing attributes, so that there will be an exact match If bClearExisting is passed as false, existing attributes are not removed/cleared. If bDiscardExtraAttributes=true and bClearExisting=false, extra attributes not in ToMatch are discarded, but existing attributes are not cleared/reset

code: void EnableMatchingAttributes ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & ToMatch, bool bClearExisting, bool bDiscardExtraAttributes )


description: Vertex and Triangle attribute arrays Enable requested set of mesh components (triangle groups and vertex normals/colors/UVs) and discard any that are not requested

code: void EnableMeshComponents ( int MeshComponentsFlags )


code: void EnableTriangleGroups ( int InitialGroupID )


code: void EnableVertexColors ( const FVector3f & InitialColor )


code: void EnableVertexNormals ( const FVector3f & InitialNormal )


code: void EnableVertexUVs ( const FVector2f & InitialUV )


description: Call after a set of unsafeInsertTriangle()calls to rebuild free list

code: virtual void EndUnsafeTrianglesInsert()


description: Call after a set of unsafeInsertVertex()calls to rebuild free list

code: virtual void EndUnsafeVerticesInsert()


description: Call ApplyFunc for each triangle connected to an Edge (1 or 2 triangles)

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


description: Call VertexFunc for each one-ring vertex neighbour of a vertex. Currently this is more efficient thanVtxVerticesItr()due to overhead in the Values() enumerable

code: void EnumerateVertexVertices ( int32 VertexID, [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< void(int32)> VertexFunc ) const


description: Call ApplyFunc for each one-ring triangle of a vertex. Currently this is significantly more efficient thanVtxTrianglesItr()in many use cases.

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


description: Call EdgeFunc for each one-ring edge of a vertex. Currently this is more efficient thanVtxEdgesItr()due to overhead in the Values() enumerable

code: void EnumerateVertexEdges ( int32 VertexID, [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< void(int32)> EdgeFunc ) const


description: SerializeFEdgeto an archive.

code: void Serialize &40; FArchive & Ar &41;


className: FEdgeFlipInfo

description: TODO:


description: Find id of edge connecting A and B

code: int FindEdge ( int VertexA, int VertexB ) const


description: Find edgeid for edge [a,b] from triangle that contains the edge. Faster thanFindEdge()because it is constant-time.

code: int FindEdgeFromTri ( int VertexA, int VertexB, int TriangleID ) const


code: int32 FindEdgeInternal ( int32 vA, int32 vB, bool & bIsBoundary ) const


description: Find edgeid for edge connecting two triangles

code: int FindEdgeFromTriPair ( int TriangleA, int TriangleB ) const


description: Returns edge ID

code: int FindTriangleEdge ( int TriangleID, int vA, int vB ) const


description: Find triangle made up of any permutation of vertices [a,b,c]

code: int FindTriangle ( int A, int B, int C ) const


description:
Flip/Rotate an edge of the mesh. This does not change the number of edges, vertices, or triangles. Boundary edges of the mesh cannot be flipped.
Ok on success, or enum value indicates why operation cannot be applied. Mesh remains unmodified on error.

code: virtual [EMeshResult](API\Runtime\GeometryCore\UE__Geometry__EMeshResult) FlipEdge ( int EdgeAB, [FEdgeFlipInfo](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3\FEdgeFlipInfo) & FlipInfo )


description:
CallsFlipEdge()on the edge between two vertices, if it exists
Ok on success, or enum value indicates why operation cannot be applied. Mesh remains unmodified on error.

code: virtual [EMeshResult](API\Runtime\GeometryCore\UE__Geometry__EMeshResult) FlipEdge ( int EdgeVertA, int EdgeVertB, [FEdgeFlipInfo](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3\FEdgeFlipInfo) & FlipInfo )


className: FSameAsOptions

description: Options for the IsSameAs check

code: struct FSameAsOptions

bIgnoreDataLayout

description: Ignore gaps and padding in the data layout, i.e. the exact index is irrelevant as long as valid entries are equal in value and in the same order.

Epsilon

type: float


description: Construct with most-permissive options that we still consider valid for processing


description: Construct validity checking options

code: FValidityOptions &40; bool bAllowNonManifoldVertices, bool bAllowAdjacentFacesReverseOrientation &41;


className: FValidityOptions

description: Options for what the validity check will permit

code: struct FValidityOptions


description: Returns all group IDs at vertex

code: bool GetAllVertexGroups ( int VertexID, [TArray](API\Runtime\Core\Containers\TArray)< int > & GroupsOut ) const


description:
Find edge ids of boundary edges connected to vertex.
count of number of elements of e that were filled

code: int GetAllVtxBoundaryEdges ( int VertexID, [TArray](API\Runtime\Core\Containers\TArray)< int > & EdgeListOut ) const


description: Computes bounding box of all vertices.

code: [FAxisAlignedBox3d](API\Runtime\GeometryCore\FAxisAlignedBox3d) GetBounds ( bool bParallel ) const


description: ChangeStamp is a combination of the Shape and Topology ChangeStamps

code: uint64 GetChangeStamp() const


description: bitwise-or of EMeshComponents flags specifying which extra data this mesh has

code: int GetComponentsFlags() const


description: Get the vertices and triangles of an edge, returned as [v0,v1,t0,t1], where t1 may be InvalidID

code: [FEdge](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3\FEdge) GetEdge ( int EdgeID ) const


code: const [TDynamicVector](API\Runtime\GeometryCore\Util\TDynamicVector)< FVector3f > * GetColorsBuffer() const


description: Returns average normal of connected face normals

code: FVector3d GetEdgeNormal ( int EdgeID ) const


description: If edge has vertices [a,b], and is connected two triangles [a,b,c] and [a,b,d], this returns [c,d], or [c,InvalidID] for a boundary edge

code: [FIndex2i](API\Runtime\GeometryCore\FIndex2i) GetEdgeOpposingV ( int EdgeID ) const


description: Get point along edge, t clamped to range [0,1]

code: FVector3d GetEdgePoint ( int EdgeID, double ParameterT ) const


code: const [FEdge](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3\FEdge) & GetEdgeRef ( int EdgeID ) const


code: const [TDynamicVector](API\Runtime\GeometryCore\Util\TDynamicVector)< [FEdge](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3\FEdge) > & GetEdgesBuffer() const


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


description: Get the triangle pair for an edge. The second triangle may be InvalidID

code: [FIndex2i](API\Runtime\GeometryCore\FIndex2i) GetEdgeT ( int EdgeID ) const


description: Get the vertex pair for an edge

code: [FIndex2i](API\Runtime\GeometryCore\FIndex2i) GetEdgeV ( int EdgeID ) const


description: Get the vertex positions of an edge

code: bool GetEdgeV ( int EdgeID, FVector3d & a, FVector3d & b ) const


description: the max valence of all vertices in the mesh

code: int GetMaxVtxEdgeCount() const


description: Utility function that returns one or two triangles of edge, used to enumerate vertex one-ring triangles The logic is a bit tricky to follow without drawing it out on paper, but this will only return each triangle once, for the 'outgoing' edge from the vertex, and each triangle only has one such edge at any vertex (including boundary triangles)

code: [FIndex2i](API\Runtime\GeometryCore\FIndex2i) GetOrderedOneRingEdgeTris ( int VertexID, int EdgeID ) const


code: const [TDynamicVector](API\Runtime\GeometryCore\Util\TDynamicVector)< FVector3f > * GetNormalsBuffer() const


description: Return edge vertex indices, but oriented based on attached triangle (rather than min-sorted)

code: [FIndex2i](API\Runtime\GeometryCore\FIndex2i) GetOrientedBoundaryEdgeV ( int EdgeID ) const


code: int GetOtherEdgeTriangle ( int EdgeID, int TriangleID ) const


code: int GetOtherEdgeVertex ( int EdgeID, int VertexID ) const


description: ShapeChangeStamp is incremented any time a mesh vertex position is changed or the mesh topology is modified, if bEnableShapeChangeStamp=true

code: uint32 GetShapeChangeStamp() const


description: TopologyChangeStamp is incremented when the mesh topology is modified

code: uint32 GetTopologyChangeStamp() const


description: Get triangle vertices

code: [FIndex3i](API\Runtime\GeometryCore\FIndex3i) GetTriangle ( int TriangleID ) const


code: const [TDynamicVector](API\Runtime\GeometryCore\Util\TDynamicVector)< [FIndex3i](API\Runtime\GeometryCore\FIndex3i) > & GetTriangleEdges() const


code: int GetTriangleGroup ( int tID ) const


description: Get triangle vertices

code: const [FIndex3i](API\Runtime\GeometryCore\FIndex3i) & GetTriangleRef ( int TriangleID ) const


code: const [TDynamicVector](API\Runtime\GeometryCore\Util\TDynamicVector)< int > * GetTriangleGroupsBuffer() const


code: const [TDynamicVector](API\Runtime\GeometryCore\Util\TDynamicVector)< [FIndex3i](API\Runtime\GeometryCore\FIndex3i) > & GetTrianglesBuffer() const


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


description: Calculate area triangle

code: double GetTriArea ( int TriangleID ) const


description: Interpolate vertex normals of triangle using barycentric coordinates

code: FVector3d GetTriBaryNormal ( int TriangleID, double Bary0, double Bary1, double Bary2 ) const


description: Interpolate vertex positions of triangle using barycentric coordinates

code: FVector3d GetTriBaryPoint ( int TriangleID, double Bary0, double Bary1, double Bary2 ) const


description: Compute interpolated vertex attributes at point of triangle

code: void GetTriBaryPoint ( int TriangleID, double Bary0, double Bary1, double Bary2, [FVertexInfo](API\Runtime\GeometryCore\DynamicMesh\FVertexInfo) & VertInfo ) const


description: Construct bounding box of triangle as efficiently as possible

code: [FAxisAlignedBox3d](API\Runtime\GeometryCore\FAxisAlignedBox3d) GetTriBounds ( int TriangleID ) const


description: Compute centroid of triangle

code: FVector3d GetTriCentroid ( int TriangleID ) const


description: Get one of the edges of a triangle

code: int GetTriEdge ( int TriangleID, int j ) const


description: Return (triangle, edge_index) representation for given Edge ID

code: [FMeshTriEdgeID](API\Runtime\GeometryCore\DynamicMesh\FMeshTriEdgeID) GetTriEdgeIDFromEdgeID ( int EdgeID ) const


description: Get triangle edges

code: [FIndex3i](API\Runtime\GeometryCore\FIndex3i) GetTriEdges ( int TriangleID ) const


description: Get triangle edges

code: const [FIndex3i](API\Runtime\GeometryCore\FIndex3i) & GetTriEdgesRef ( int TriangleID ) const


description: Construct stable frame at triangle centroid, where frame.Z is face normal, and frame.X is aligned with edge nEdge of triangle.

code: [FFrame3d](API\Runtime\GeometryCore\FFrame3d_1) GetTriFrame ( int TriangleID, int Edge ) const


description: Compute internal angle at vertex i of triangle (where i is 0,1,2);

code: double GetTriInternalAngleR ( int TriangleID, int i ) const


description: Compute internal angles at all vertices of triangle

code: FVector3d GetTriInternalAnglesR ( int TriangleID ) const


description: Compute triangle normal, area, and centroid all at once. Re-uses vertex lookups and computes normal & area simultaneously.Howeverdoes not produce the same normal/area as separate calls, because of this.

code: void GetTriInfo ( int TriangleID, FVector3d & Normal, double & Area, FVector3d & Centroid ) const


description: Find the neighbour triangles of a triangle (any of them might be InvalidID)

code: [FIndex3i](API\Runtime\GeometryCore\FIndex3i) GetTriNeighbourTris ( int TriangleID ) const


description: Compute solid angle of oriented triangle tID relative to point p - see WindingNumber()

code: double GetTriSolidAngle ( int TriangleID, const FVector3d & p ) const


description: Get the position of one of the vertices of a triangle

code: FVector3d GetTriVertex ( int TriangleID, int j ) const


description: Get the three vertex positions of a triangle

code: template<typename VecType> void GetTriVertices ( int TriangleID, VecType & v0, VecType & v1, VecType & v2 ) const


code: const [TDynamicVector](API\Runtime\GeometryCore\Util\TDynamicVector)< FVector2f > * GetUVBuffer() const


description: Get extended vertex information

code: bool GetVertex ( int VertexID, [FVertexInfo](API\Runtime\GeometryCore\DynamicMesh\FVertexInfo) & VertInfo, bool bWantNormals, bool bWantColors, bool bWantUVs ) const


description: Calculate face normal of triangle

code: FVector3d GetTriNormal ( int TriangleID ) const


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


description:
Vertex/Tri/Edge accessors
the vertex position

code: FVector3d GetVertex ( int VertexID ) const


description: Compute a normal/tangent frame at vertex that is "stable" as long as the mesh topology doesn't change, meaning that one axis of the frame will be computed from projection of outgoing edge.Bydefault, frame.Z is normal, and .X points along mesh edge. Requires that VertexNormals are available, or UseNormal != nullptr, otherwise returns default Frame3d

code: [FFrame3d](API\Runtime\GeometryCore\FFrame3d_1) GetVertexFrame ( int VertexID, bool bFrameNormalY, FVector3d * UseNormal ) const


code: void GetVertexEdgesList ( int VertexID, [TArray](API\Runtime\Core\Containers\TArray)< int > & EdgesOut ) const


code: bool GetVertexGroups ( int VertexID, [FIndex4i](API\Runtime\GeometryCore\FIndex4i) & GroupsOut ) const


description: Get all vertex information available

code: [FVertexInfo](API\Runtime\GeometryCore\DynamicMesh\FVertexInfo) GetVertexInfo ( int VertexID ) const


code: FVector3f GetVertexNormal ( int vID ) const


description: the vertex position

code: const FVector3d & GetVertexRef ( int VertexID ) const


code: FVector3f GetVertexColor ( int vID ) const


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


description: Direct buffer access

code: const [TDynamicVector](API\Runtime\GeometryCore\Util\TDynamicVector)< FVector3d > & GetVerticesBuffer() const


code: FVector2f GetVertexUV ( int vID ) const


description: Get triangles connected to vertex in contiguous order, with multiple groups if vertex is a bowtie.

code: [EMeshResult](API\Runtime\GeometryCore\UE__Geometry__EMeshResult) GetVtxContiguousTriangles ( int VertexID, [TArray](API\Runtime\Core\Containers\TArray)< int > & TrianglesOut, [TArray](API\Runtime\Core\Containers\TArray)< int > & ContiguousGroupLengths, [TArray](API\Runtime\Core\Containers\TArray)< bool > & GroupIsLoop ) const


description: the valence of a vertex (the number of connected edges)

code: int GetVtxEdgeCount ( int VertexID ) const


description: Given an edge and vertex on that edge, returns other vertex of edge, the two opposing verts, and the two connected triangles (OppVert2Out and Tri2Out are be InvalidID for boundary edge)

code: void GetVtxNbrhood ( int EdgeID, int VertexID, int & OtherVertOut, int & OppVert1Out, int & OppVert2Out, int & Tri1Out, int & Tri2Out ) const


description: Fastest possible one-ring centroid. This is used inside many other algorithms so it helps to have it be maximally efficient

code: void GetVtxOneRingCentroid ( int VertexID, FVector3d & CentroidOut ) const


code: int GetVtxBoundaryEdges ( int VertexID, int & Edge0Out, int & Edge1Out ) const


description: Get triangle one-ring at vertex.

code: [EMeshResult](API\Runtime\GeometryCore\UE__Geometry__EMeshResult) GetVtxTriangles ( int VertexID, [TArray](API\Runtime\Core\Containers\TArray)< int > & TrianglesOut ) const


description: Triangle ID for a single triangle connected to VertexID, or InvalidID if VertexID does not exist or has no attached triangles

code: int GetVtxSingleTriangle ( int VertexID ) const


description: true if Shape ChangeStamp is enabled (disabled by default)

code: bool HasShapeChangeStampEnabled() const


description: true if this mesh has attribute layers

code: bool HasAttributes() const


description: true if this mesh has per-triangle groups

code: bool HasTriangleGroups() const


description: true if this mesh has per-vertex normals

code: bool HasVertexNormals() const


description: true if this mesh has per-vertex UVs

code: bool HasVertexUVs() const


description: true if this mesh has per-vertex colors

code: bool HasVertexColors() const


description: Return # of triangles attached to vID, or -1 if invalid vertex

code: int GetVtxTriangleCount ( int VertexID ) const


description: Insert triangle at given index, assuming it is unused. If bUnsafe, we use fast id allocation that does not update free list. You should only be using this betweenBeginUnsafeTrianglesInsert()/EndUnsafeTrianglesInsert()calls

code: [EMeshResult](API\Runtime\GeometryCore\UE__Geometry__EMeshResult) InsertTriangle ( int TriangleID, const [FIndex3i](API\Runtime\GeometryCore\FIndex3i) & TriVertices, int GroupID, bool bUnsafe )


description: Insert vertex at given index, assuming it is unused. If bUnsafe, we use fast id allocation that does not update free list. You should only be using this betweenBeginUnsafeVerticesInsert()/EndUnsafeVerticesInsert()calls

code: [EMeshResult](API\Runtime\GeometryCore\UE__Geometry__EMeshResult) InsertVertex ( int VertexID, const [FVertexInfo](API\Runtime\GeometryCore\DynamicMesh\FVertexInfo) & VertInfo, bool bUnsafe )


className: InvalidEdge

code: static constexpr [FIndex2i](API\Runtime\GeometryCore\FIndex2i) InvalidEdge {InvalidID, InvalidID};


className: InvalidID

description: InvalidID indicates that a vertex/edge/triangle ID is invalid

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


className: InvalidVertex

code: static const FVector3d InvalidVertex = FVector3d(TNumericLimits<double>::Max(), 0.0, 0.0);


className: InvalidTriangle

code: static constexpr [FIndex3i](API\Runtime\GeometryCore\FIndex3i) InvalidTriangle {InvalidID, InvalidID, InvalidID};


description: Topological queriesReturns true if edge is on the mesh boundary, ie only connected to one triangle

code: bool IsBoundaryEdge ( int EdgeID ) const


description: Returns true if any edge of triangle is a boundary edge

code: bool IsBoundaryTriangle ( int TriangleID ) const


description: Returns true if vID is a "bowtie" vertex, ie multiple disjoint triangle sets in one-ring

code: bool IsBowtieVertex ( int VertexID ) const


description: true if mesh has no boundary edges

code: bool IsClosed() const


description: Returns true if vertices, edges, and triangles are all dense (Count == MaxID)

code: bool IsCompact() const


description: true if triangle count == max triangle id

code: bool IsCompactT() const


description: true if vertex count == max vertex id

code: bool IsCompactV() const


description: true if EdgeID is a valid edge in this mesh

code: bool IsEdge ( int EdgeID ) const


description: Returns true if the vertex is part of any boundary edges

code: bool IsBoundaryVertex ( int VertexID ) const


description: Returns true if the two triangles connected to edge have different group IDs

code: bool IsGroupBoundaryEdge ( int EdgeID ) const


description: Returns true if vertex has more than one tri group in its tri nbrhood

code: bool IsGroupBoundaryVertex ( int VertexID ) const


description: Returns true if more than two group boundary edges meet at vertex (ie 3+ groups meet at this vertex)

code: bool IsGroupJunctionVertex ( int VertexID ) const


description: true if VertexID is a valid vertex in this mesh AND is used by at least one triangle

code: bool IsReferencedVertex ( int VertexID ) const


description: Check if another mesh is the same as this mesh.Bydefault only checks vertices and triangles, turn on other parameters w/ flags

code: virtual bool IsSameAs ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & OtherMesh, const [FSameAsOptions](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3\FSameAsOptions) & Options ) const


description: true if TriangleID is a valid triangle in this mesh

code: bool IsTriangle ( int TriangleID ) const


description: true if VertexID is a valid vertex in this mesh

code: bool IsVertex ( int VertexID ) const


description: upper bound on edge IDs used in the mesh, i.e. all edge IDs in use are < MaxEdgeID

code: int MaxEdgeID() const


description: upper bound on group IDs used in the mesh, i.e. all group IDs in use are < MaxGroupID

code: int MaxGroupID() const


description: upper bound on triangle IDs used in the mesh, i.e. all triangle IDs in use are < MaxTriangleID

code: int MaxTriangleID() const


description: upper bound on vertex IDs used in the mesh, i.e. all vertex IDs in use are < MaxVertexID

code: int MaxVertexID() const


description:
.... (dots are vertices) ../
Ok on success, or enum value indicates why operation cannot be applied. Mesh remains unmodified on error.

code: virtual [EMeshResult](API\Runtime\GeometryCore\UE__Geometry__EMeshResult) MergeEdges ( int KeepEdgeID, int DiscardEdgeID, [FMergeEdgesInfo](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3\FMergeEdgesInfo) & MergeInfo, bool bCheckValidOrientation )


description: Debug utility functions Returns a debug string that contains mesh statistics and other information

code: virtual [FString](API\Runtime\Core\Containers\FString) MeshInfoString() const


className: NonManifoldID

description: NonManifoldID is returned byAppendTriangle()to indicate that the added triangle would result in nonmanifold geometry and hence was ignored

code: static constexpr int NonManifoldID = -2;


description: Copy and move assignment

code: const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & operator= ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & CopyMesh )


code: const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & operator= ( [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) && MoveMesh )


description: Call PokeTriangle at the centroid of the triangle

code: virtual [EMeshResult](API\Runtime\GeometryCore\UE__Geometry__EMeshResult) PokeTriangle ( int TriangleID, [FPokeTriangleInfo](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3\FPokeTriangleInfo) & PokeInfo )


description:
Insert a new vertex inside a triangle, ie do a 1 to 3 triangle split
Ok on success, or enum value indicates why operation cannot be applied. Mesh remains unmodified on error.

code: virtual [EMeshResult](API\Runtime\GeometryCore\UE__Geometry__EMeshResult) PokeTriangle ( int TriangleID, const FVector3d & BaryCoordinates, [FPokeTriangleInfo](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3\FPokeTriangleInfo) & PokeInfo )


description: Remove vertex VertexID and all connected triangles. Returns Failed_VertexStillReferenced if VertexID is still referenced by any triangles. If bPreserveManifold is true, checks that we will not create a bowtie vertex first. In this case, returns Failed_WouldCreateBowtie if removing the triangles would create a bowtie.

code: [EMeshResult](API\Runtime\GeometryCore\UE__Geometry__EMeshResult) RemoveVertex ( int VertexID, bool bPreserveManifold )


description: Remove a triangle from the mesh. Also removes any unreferenced edges after tri is removed. If bRemoveIsolatedVertices is true, then if you remove all tris from a vert, that vert is also removed. If bPreserveManifold, we check that you will not create a bow tie vertex (and return false). If this check is not done, you have to make sure you don't create a bow tie, because other code assumes we don't have bow ties, and will not handle it properly

code: [EMeshResult](API\Runtime\GeometryCore\UE__Geometry__EMeshResult) RemoveTriangle ( int TriangleID, bool bRemoveIsolatedVertices, bool bPreserveManifold )


code: int ReplaceEdgeTriangle ( int EdgeID, int tOld, int tNew )


code: int ReplaceEdgeVertex ( int EdgeID, int vOld, int vNew )


code: int ReplaceTriangleEdge ( int EdgeID, int eOld, int eNew )


code: int ReplaceTriangleVertex ( int TriangleID, int vOld, int vNew )


description: Reverse the ccw/cw orientation of all triangles in the mesh, and optionally flip the vertex normals if they exist

code: void ReverseOrientation ( bool bFlipNormals )


description: Reverse the ccw/cw orientation of a triangle

code: [EMeshResult](API\Runtime\GeometryCore\UE__Geometry__EMeshResult) ReverseTriOrientation ( int TriangleID )


code: void ReverseTriOrientationInternal ( int TriangleID )


description: Serialize the mesh to an archive.

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


description: Internal implementations for serialization to allow for better code separation between different versions and other implementation details.

code: template<int Variant> void SerializeInternal ( [FArchive](API\Runtime\Core\Serialization\FArchive) & Ar, void * Ptr )


code: template<> void SerializeInternal ( [FArchive](API\Runtime\Core\Serialization\FArchive) &, void * )


code: template<> void SerializeInternal ( [FArchive](API\Runtime\Core\Serialization\FArchive) & Ar, void * OptionsPtr )


code: template<> void SerializeInternal ( [FArchive](API\Runtime\Core\Serialization\FArchive) & Ar, void * )


code: void SetEdgeTrianglesInternal ( int EdgeID, int t0, int t1 )


code: void SetEdgeVerticesInternal ( int EdgeID, int a, int b )


description: NOTE: Both change stamps are unreliable in many contexts, and may someday get removed. Specifically, they get reset onClear(), copied to the destination rather than incremented in copies and moves, and do not track any changes via access to the buffers directly (throughGetVerticesBuffer(), etc).

code: void SetShapeChangeStampEnabled ( bool bEnabled )


description: Rewrite the triangle to reference the new tuple of vertices.

code: virtual [EMeshResult](API\Runtime\GeometryCore\UE__Geometry__EMeshResult) SetTriangle ( int TriangleID, const [FIndex3i](API\Runtime\GeometryCore\FIndex3i) & NewVertices, bool bRemoveIsolatedVertices )


code: void SetTriangleEdgesInternal ( int TriangleID, int e0, int e1, int e2 )


code: void SetTriangleGroup ( int tid, int group_id )


description: Internal functions

code: void SetTriangleInternal ( int TriangleID, int v0, int v1, int v2 )


description: Set vertex position

code: void SetVertex ( int VertexID, const FVector3d & vNewPos, bool bTrackChange )


code: void SetVertexColor ( int vID, const FVector3f & vNewColor )


code: void SetVertexNormal ( int vID, const FVector3f & vNewNormal )


code: void SetVertexUV ( int vID, const FVector2f & vNewUV )


description:
Split an edge of the mesh by inserting a vertex. This creates a new triangle on either side of the edge (ie a 2-4 split). If the original edge had vertices [a,b], with triangles t0=[a,b,c] and t1=[b,a,d], then the split inserts new vertex f. After the split t0=[a,f,c] and t1=[f,a,d], and we have t2=[f,b,c] and t3=[f,d,b] (it's best to draw it out on paper...)
Ok on success, or enum value indicates why operation cannot be applied. Mesh remains unmodified on error.

code: virtual [EMeshResult](API\Runtime\GeometryCore\UE__Geometry__EMeshResult) SplitEdge ( int EdgeAB, [FEdgeSplitInfo](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3\FEdgeSplitInfo) & SplitInfo, double SplitParameterT )


description:
Splits the edge between two vertices at the midpoint, if this edge exists
Ok on success, or enum value indicates why operation cannot be applied. Mesh remains unmodified on error.

code: [EMeshResult](API\Runtime\GeometryCore\UE__Geometry__EMeshResult) SplitEdge ( int EdgeVertA, int EdgeVertB, [FEdgeSplitInfo](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3\FEdgeSplitInfo) & SplitInfo )


description:
Clones the given vertex and updates any provided triangles to use the new vertex if/where they used the old one.
Ok on success, or enum value indicates why operation cannot be applied. Mesh remains unmodified on error.

code: virtual [EMeshResult](API\Runtime\GeometryCore\UE__Geometry__EMeshResult) SplitVertex ( int VertexID, const [TArrayView](API\Runtime\Core\Containers\TArrayView)< const int > & TrianglesToUpdate, [FVertexSplitInfo](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3\FVertexSplitInfo) & SplitInfo )


description:
Tests whether splitting the given vertex with the given triangles would leave no triangles attached to the original vertex (creating an isolated vertex)
true if calling SplitVertex with these arguments would leave an isolated vertex at the original VertexID

code: virtual bool SplitVertexWouldLeaveIsolated ( int VertexID, const [TArrayView](API\Runtime\Core\Containers\TArrayView)< const int > & TrianglesToUpdate )


description: number of triangles in the mesh

code: int TriangleCount() const


code: bool TriangleHasVertex ( int TriangleID, int VertexID ) const


description: enumerable object for valid triangle indices suitable for use with range-based for, ie for ( int i :TriangleIndicesItr())


description: Enumerate all triangles in the mesh

code: [value_iteration](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3\value_iteration)< [FIndex3i](API\Runtime\GeometryCore\FIndex3i) > TrianglesItr() const


code: bool TriHasNeighbourTri ( int CheckTriID, int NbrTriID ) const


code: bool TriHasSequentialVertices ( int TriangleID, int vA, int vB ) const


description: Increment the specified ChangeStamps, if they are enabled. Thread-safe.

code: void UpdateChangeStamps ( bool bShapeChange, bool bTopologyChange )


code: typedef [FRefCountVector::MappedEnumerable](API\Runtime\GeometryCore\Util\FRefCountVector\MappedEnumerable)< T > value_iteration


description: number of vertices in the mesh

code: int VertexCount() const


description: enumerable object for valid vertex indices suitable for use with range-based for, ie for ( int i :VertexIndicesItr())


description: Mesh Element Iterators The functionsVertexIndicesItr()/TriangleIndicesItr()/EdgeIndicesItr()allow you to do: for ( int eid :EdgeIndicesItr()) { ... } and other relatedbegin()/end()idioms


description: Enumerate positions of all vertices in mesh

code: [value_iteration](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3\value_iteration)< FVector3d > VerticesItr() const


description: enumerable object for one-ring edges of a vertex, suitable for use with range-based for, ie for ( int i : VtxEdgesItr(VertexID) )

code: [FSmallListSet::ValueEnumerable](API\Runtime\GeometryCore\Util\FSmallListSet\ValueEnumerable) VtxEdgesItr ( int VertexID ) const


description: enumerable object for one-ring vertex neighbours of a vertex, suitable for use with range-based for, ie for ( int i : VtxVerticesItr(VertexID) )

code: [FSmallListSet::MappedValueEnumerable](API\Runtime\GeometryCore\Util\FSmallListSet\MappedValueEnumerable) VtxVerticesItr ( int VertexID ) const


description: enumerable object for one-ring triangles of a vertex, suitable for use with range-based for, ie for ( int i : VtxTrianglesItr(VertexID) )

code: [vtx_triangles_enumerable](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3\vtx_triangles_enumerable) VtxTrianglesItr ( int VertexID ) const


description: Default constructor


description: Copy/Move construction

code: FDynamicMesh3 ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & CopyMesh )


code: FDynamicMesh3 ( [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) && MoveMesh )


description: Default constructor

code: FDynamicMesh3 ( [EMeshComponents](API\Runtime\GeometryCore\DynamicMesh\UE__Geometry__EMeshComponents) flags )


description: Construct an empty mesh with specified attributes

code: FDynamicMesh3 ( bool bWantNormals, bool bWantColors, bool bWantUVs, bool bWantTriGroups )


description: Destructor

code: virtual ~FDynamicMesh3()


description: The functionCheckValidity()does extensive sanity checking on the mesh data structure. Use this to test your code, both for mesh construction and editing!!

code: class FDynamicMesh3

AttributeSet

type: TUniquePtr<FDy...

description: Extended Attributes for the Mesh (UV layers, Hard Normals, additional Polygroup Layers, etc)

bEnableShapeChangeStamp

description: Enable/Disable updating of ShapeChangeStamp.

EdgeRefCounts

type: FRefCountVector

description: Reference counts of edge indices.

Edges

type: TDynamicVector<...

description: List of edge elements.

GroupIDCounter

type: int

description: Upper bound on the triangle group IDs used in the mesh (may be larger than the actual maximum if triangles have been deleted)

ShapeChangeStamp

type: std::atomic< ui...

description: If bEnableShapeChangeStamp=true, The shape change stamp is incremented any time a function that modifies the mesh shape or topology is called

TopologyChangeStamp

description: The topology change stamp is incremented any time a function that modifies the mesh topology is called

TriangleEdges

description: List of triangle edge triplets [Edge0 Edge1 Edge2]

TriangleGroups

type: TOptional<TDyn...

description: (optional) List of per-triangle group identifiers

TriangleRefCounts

description: Reference counts of triangle indices.

Triangles

description: List of triangle vertex-index triplets [Vert0 Vert1 Vert2]

VertexColors

description: (optional) List of per-vertex colors

VertexEdgeLists

type: FSmallListSet

description: List of per-vertex edge one-rings

VertexNormals

description: (optional) List of per-vertex normals

VertexRefCounts

description: Reference counts of vertex indices.

VertexUVs

description: (optional) List of per-vertex uv's

Vertices

description: List of vertex positions


description: Construction from Mesh Generator

code: FDynamicMesh3 ( const [FMeshShapeGenerator](API\Runtime\GeometryCore\Generators\FMeshShapeGenerator) * Generator )


className: FDynamicMeshAttributeChangeBase


description: Call ::Apply() on all the UV and Normal changes

code: bool Apply ( [FDynamicMeshAttributeSet](API\Runtime\GeometryCore\DynamicMesh\FDynamicMeshAttributeSet) * Attributes, bool bRevert ) const


code: [FDynamicMeshAttributeChangeSet](API\Runtime\GeometryCore\DynamicMesh\FDynamicMeshAttributeChangeSet) & operator= ( const [FDynamicMeshAttributeChangeSet](API\Runtime\GeometryCore\DynamicMesh\FDynamicMeshAttributeChangeSet) & )


code: [FDynamicMeshAttributeChangeSet](API\Runtime\GeometryCore\DynamicMesh\FDynamicMeshAttributeChangeSet) & operator= ( [FDynamicMeshAttributeChangeSet](API\Runtime\GeometryCore\DynamicMesh\FDynamicMeshAttributeChangeSet) && )


code: FDynamicMeshAttributeChangeSet()


code: FDynamicMeshAttributeChangeSet ( [FDynamicMeshAttributeChangeSet](API\Runtime\GeometryCore\DynamicMesh\FDynamicMeshAttributeChangeSet) && )


code: FDynamicMeshAttributeChangeSet ( const [FDynamicMeshAttributeChangeSet](API\Runtime\GeometryCore\DynamicMesh\FDynamicMeshAttributeChangeSet) & )


className: FDynamicMeshAttributeChangeSet

description: FDynamicMeshAttributeChangeSetstores a set of UV and Normal changes for aFDynamicMesh3

code: class FDynamicMeshAttributeChangeSet

ColorChange

type: TOptional<FDyn...

NormalChanges

type: TArray<FDynami...

RegisteredAttributeChanges

type: TArray<TUnique...


description:
Append bone attributes from another set. When appending, the bone attributes in the Other set will only be appended if a bone with the same name does not exist in the current bone name attribute. Hence, the order of the bones in this set is preserved.
true, if append was successful

code: bool AppendBonesUnique ( const [FDynamicMeshAttributeSet](API\Runtime\GeometryCore\DynamicMesh\FDynamicMeshAttributeSet) & Other )


description: Attach a new attribute (and transfer ownership of it to the attribute set)

code: void AttachAttribute ( [FName](API\Runtime\Core\UObject\FName) AttribName, [FDynamicMeshAttributeBase](API\Runtime\GeometryCore\DynamicMesh\FDynamicMeshAttributeBase) * Attribute )


description: Skin weights Create a new skin weights attribute with a given skin weights profile name. If an attribute already exists with that name, that existing attribute will be deleted.

code: void AttachSkinWeightsAttribute ( [FName](API\Runtime\Core\UObject\FName) InProfileName, [FDynamicMeshVertexSkinWeightsAttribute](API\Runtime\GeometryCore\DynamicMesh\FDynamicMeshVertexSkinWeightsAtt-) * InAttribute )


description: Check validity of attributes

code: virtual bool CheckValidity ( bool bAllowNonmanifold, [EValidityCheckFailMode](API\Runtime\GeometryCore\UE__Geometry__EValidityCheckFail-) FailMode ) const


description: Performs a CompactCopy of the attached overlays/attributes. Called by the parent mesh CompactCopy function.

code: void CompactCopy ( const [FCompactMaps](API\Runtime\GeometryCore\Util\FCompactMaps) & CompactMaps, const [FDynamicMeshAttributeSet](API\Runtime\GeometryCore\DynamicMesh\FDynamicMeshAttributeSet) & Copy )


description: Compacts the attribute set in place Called by the parent mesh CompactInPlace function

code: void CompactInPlace ( const [FCompactMaps](API\Runtime\GeometryCore\Util\FCompactMaps) & CompactMaps )


code: void Copy ( const [FDynamicMeshAttributeSet](API\Runtime\GeometryCore\DynamicMesh\FDynamicMeshAttributeSet) & Copy )


description: Bone Attributes

code: void CopyBoneAttributes ( const [FDynamicMeshAttributeSet](API\Runtime\GeometryCore\DynamicMesh\FDynamicMeshAttributeSet) & Copy )


description: Disable all bone attributes.

code: void DisableBones()


description: The attribute is valid if either all attributes are empty or if the bone name attribute is not empty then all the other attributes must be either empty or their size is equal to the bone name attribute size.

code: bool CheckBoneValidity ( [EValidityCheckFailMode](API\Runtime\GeometryCore\UE__Geometry__EValidityCheckFail-) FailMode ) const


description: Disable Tangents overlays

code: void DisableTangents()


description: Enable all bone attributes and intialize their size to the given bone number.

code: void EnableBones ( const int InBonesNum )


description: Enable the matching attributes and overlay layers as the ToMatch set, but do not copy any data across. If bClearExisting=true, all existing attributes are cleared, so after the function there is an exact match but any existing attribute data is lost (!) If bClearExisting=false, new attributes are added, but existing attributes and data are preserved If bDiscardExtraAttributes=true and bClearExisting=false, then attributes in the current set but not in ToMatch are discarded, but existing attributes are not cleared/reset

code: void EnableMatchingAttributes ( const [FDynamicMeshAttributeSet](API\Runtime\GeometryCore\DynamicMesh\FDynamicMeshAttributeSet) & ToMatch, bool bClearExisting, bool bDiscardExtraAttributes )


code: void EnableMatchingBoneAttributes ( const [FDynamicMeshAttributeSet](API\Runtime\GeometryCore\DynamicMesh\FDynamicMeshAttributeSet) & ToMatch, bool bClearExisting, bool bDiscardExtraAttributes )


description: Enable Tangents overlays (Tangent = Normal layer 1, Bitangent = Normal layer 2)

code: void EnableTangents()


code: const [FDynamicMeshAttributeBase](API\Runtime\GeometryCore\DynamicMesh\FDynamicMeshAttributeBase) * GetAttachedAttribute ( [FName](API\Runtime\Core\UObject\FName) AttribName ) const


code: [FDynamicMeshAttributeBase](API\Runtime\GeometryCore\DynamicMesh\FDynamicMeshAttributeBase) * GetAttachedAttribute ( [FName](API\Runtime\Core\UObject\FName) AttribName )


code: const [TMap](API\Runtime\Core\Containers\TMap)< [FName](API\Runtime\Core\UObject\FName), [TUniquePtr](API\Runtime\Core\Templates\TUniquePtr)< [FDynamicMeshAttributeBase](API\Runtime\GeometryCore\DynamicMesh\FDynamicMeshAttributeBase) > > & GetAttachedAttributes() const


code: const [FDynamicMeshBoneColorAttribute](API\Runtime\GeometryCore\DynamicMesh\FDynamicMeshBoneColorAttribute) * GetBoneColors() const


code: const [FDynamicMeshBoneNameAttribute](API\Runtime\GeometryCore\DynamicMesh\FDynamicMeshBoneNameAttribute) * GetBoneNames() const


code: const [FDynamicMeshBoneParentIndexAttribute](API\Runtime\GeometryCore\DynamicMesh\FDynamicMeshBoneParentIndexAttri-) * GetBoneParentIndices() const


code: const [FDynamicMeshBonePoseAttribute](API\Runtime\GeometryCore\DynamicMesh\FDynamicMeshBonePoseAttribute) * GetBonePoses() const


code: const [FDynamicMeshMaterialAttribute](API\Runtime\GeometryCore\DynamicMesh\FDynamicMeshMaterialAttribute) * GetMaterialID() const


description: the Normal layer at the givenIndexif exists, else nullptr

code: [FDynamicMeshNormalOverlay](API\Runtime\GeometryCore\DynamicMesh\FDynamicMeshNormalOverlay) * GetNormalLayer ( int Index )


code: const [FDynamicMeshNormalOverlay](API\Runtime\GeometryCore\DynamicMesh\FDynamicMeshNormalOverlay) * GetNormalLayer ( int Index ) const


description: Get number of bones.

code: int32 GetNumBones() const


description: the parent mesh for this overlay

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


description: the parent mesh for this overlay


description: the Polygroup layer at the givenIndex

code: [FDynamicMeshPolygroupAttribute](API\Runtime\GeometryCore\DynamicMesh\FDynamicMeshPolygroupAttribute) * GetPolygroupLayer ( int Index )


description: the Polygroup layer at the givenIndex

code: const [FDynamicMeshPolygroupAttribute](API\Runtime\GeometryCore\DynamicMesh\FDynamicMeshPolygroupAttribute) * GetPolygroupLayer ( int Index ) const


description: Returns a pointer to a skin weight attribute of the given profile name. If the attribute does not exist, a nullptr is returned.

code: [FDynamicMeshVertexSkinWeightsAttribute](API\Runtime\GeometryCore\DynamicMesh\FDynamicMeshVertexSkinWeightsAtt-) * GetSkinWeightsAttribute ( [FName](API\Runtime\Core\UObject\FName) InProfileName ) const


description: Returns a map of all skin weight attributes.

code: const [TMap](API\Runtime\Core\Containers\TMap)< [FName](API\Runtime\Core\UObject\FName), [TUniquePtr](API\Runtime\Core\Templates\TUniquePtr)< [FDynamicMeshVertexSkinWeightsAttribute](API\Runtime\GeometryCore\DynamicMesh\FDynamicMeshVertexSkinWeightsAtt-) > > & GetSkinWeightsAttributes() const


description: the UV layer at the givenIndexif exists, else nullptr

code: [FDynamicMeshUVOverlay](API\Runtime\GeometryCore\DynamicMesh\FDynamicMeshUVOverlay) * GetUVLayer ( int Index )


code: const [FDynamicMeshUVOverlay](API\Runtime\GeometryCore\DynamicMesh\FDynamicMeshUVOverlay) * GetUVLayer ( int Index ) const


description: the weight layer at the givenIndex

code: [FDynamicMeshWeightAttribute](API\Runtime\GeometryCore\DynamicMesh\FDynamicMeshWeightAttribute) * GetWeightLayer ( int Index )


description: the weight layer at the givenIndex

code: const [FDynamicMeshWeightAttribute](API\Runtime\GeometryCore\DynamicMesh\FDynamicMeshWeightAttribute) * GetWeightLayer ( int Index ) const


code: bool HasAttachedAttribute ( [FName](API\Runtime\Core\UObject\FName) AttribName ) const


description: Per-Triangle Material ID

code: bool HasMaterialID() const


code: bool HasPrimaryColors() const


description: Returns true if the list of skin weight attributes includes the given profile name.

code: bool HasSkinWeightsAttribute ( [FName](API\Runtime\Core\UObject\FName) InProfileName ) const


description: true if normal layers exist for the normal, tangent, and bitangent

code: bool HasTangentSpace() const


description: Initialize the existing attribute layers with the given vertex and triangle sizes

code: void Initialize ( int MaxVertexID, int MaxTriangleID )


description: Returns true if the attached overlays/attributes are compact

code: bool IsCompact()


description: true if the given edge is a material ID boundary

code: virtual bool IsMaterialBoundaryEdge ( int EdgeID ) const


description: Returns true if this AttributeSet is the same as Other.

code: bool IsSameAs ( const [FDynamicMeshAttributeSet](API\Runtime\GeometryCore\DynamicMesh\FDynamicMeshAttributeSet) & Other, bool bIgnoreDataLayout ) const


description: Only compares bone names and parent indices.

code: bool IsSameBoneAttributesAs ( const [FDynamicMeshAttributeSet](API\Runtime\GeometryCore\DynamicMesh\FDynamicMeshAttributeSet) & Other ) const


description: true if the given edge is a seam edge in any overlay

code: virtual bool IsSeamEdge ( int EdgeID ) const


description: true if the given edge is a seam edge in any overlay. This version considers tangent seams as a type of normal seam; to consider tangent seams separately, call the 4-argument IsSeamEdge instead.

code: virtual bool IsSeamEdge ( int EdgeID, bool & bIsUVSeamOut, bool & bIsNormalSeamOut, bool & bIsColorSeamOut ) const


code: virtual bool IsSeamEdge ( int EdgeID, bool & bIsUVSeamOut, bool & bIsNormalSeamOut, bool & bIsColorSeamOut, bool & bIsTangentSeamOut ) const


description: true if the given edge is the termination of a seam in any overlay

code: virtual bool IsSeamEndEdge ( int EdgeID ) const


description: true if the given vertex is a seam vertex in any overlay

code: virtual bool IsSeamVertex ( int VertexID, bool bBoundaryIsSeam ) const


description:
Normal Layers
number of Normals layers

code: virtual int NumNormalLayers() const


code: int NumAttachedAttributes() const


description:
Polygroup layers
number of Polygroup layers

code: virtual int32 NumPolygroupLayers() const


description:
UV Layers
number of UV layers

code: virtual int NumUVLayers() const


description:
Weight layers
number of weight layers

code: virtual int32 NumWeightLayers() const


code: virtual void OnCollapseEdge ( const [DynamicMeshInfo::FEdgeCollapseInfo](API\Runtime\GeometryCore\DynamicMesh\FEdgeCollapseInfo) & collapseInfo )


code: virtual void OnFlipEdge ( const [DynamicMeshInfo::FEdgeFlipInfo](API\Runtime\GeometryCore\DynamicMesh\FEdgeFlipInfo) & flipInfo )


code: virtual void OnMergeEdges ( const [DynamicMeshInfo::FMergeEdgesInfo](API\Runtime\GeometryCore\DynamicMesh\FMergeEdgesInfo) & mergeInfo )


description: These functions are called by theFDynamicMesh3to update the various attributes when the parent mesh topology has been modified. TODO: would it be better to register all the overlays and attributes with the base set and not overload these? maybe!

code: virtual void OnNewTriangle ( int TriangleID, bool bInserted )


code: virtual void OnPokeTriangle ( const [DynamicMeshInfo::FPokeTriangleInfo](API\Runtime\GeometryCore\DynamicMesh\FPokeTriangleInfo) & pokeInfo )


code: virtual void OnNewVertex ( int VertexID, bool bInserted )


code: virtual void OnRemoveTriangle ( int TriangleID )


code: virtual void OnRemoveVertex ( int VertexID )


code: virtual void OnReverseTriOrientation ( int TriangleID )


description: Mesh-specific on* functions; may be split out

code: virtual void OnSplitEdge ( const [DynamicMeshInfo::FEdgeSplitInfo](API\Runtime\GeometryCore\DynamicMesh\FEdgeSplitInfo) & SplitInfo )