description: Set the value at an Attribute to be a linear interpolation of two other Attributes

code: virtual void SetAttributeFromLerp ( int SetAttribute, int AttributeA, int AttributeB, double Alpha )


description: Set the element at a given index

module: GeometryCore

code: void SetValue ( int VertexID, const AttribValueType * Data )


description: Set the element at a given index

code: template<typename AsType> void SetValue ( int VertexID, const AsType & Data )


className: Super

code: typedef [TDynamicAttributeBase](API\Runtime\GeometryCore\DynamicMesh\TDynamicAttributeBase)< ParentType > Super


description: Create an empty overlay

code: TDynamicVertexAttribute()


description: Create an attribute for the given parent

code: TDynamicVertexAttribute ( ParentType * ParentIn, bool bAutoInit )


code: virtual ~TDynamicVertexAttribute()


className: TDynamicVertexAttribute

description: TDynamicVertexAttributeprovides per-vertex storage of an attribute value

code: template<typename AttribValueType, int AttribDimension, typename ParentType> class TDynamicVertexAttribute : public [UE::Geometry::TDynamicAttributeBase< ParentType >](API\Runtime\GeometryCore\DynamicMesh\TDynamicAttributeBase)

AttribValues

type: TDynamicVector<...

description: List of per-vertex attribute values

Parent

type: ParentType *...

description: The parent object (e.g. mesh, point set) this attribute belongs to


code: virtual bool Apply ( [TDynamicAttributeBase](API\Runtime\GeometryCore\DynamicMesh\TDynamicAttributeBase)< ParentType > * Attribute, bool bRevert ) const


code: virtual void SaveInitialVertex ( const [TDynamicAttributeBase](API\Runtime\GeometryCore\DynamicMesh\TDynamicAttributeBase)< ParentType > * Attribute, int VertexID )


code: TDynamicVertexAttributeChange()


code: virtual void StoreAllFinalVertices ( const [TDynamicAttributeBase](API\Runtime\GeometryCore\DynamicMesh\TDynamicAttributeBase)< ParentType > * Attribute, const [TArray](API\Runtime\Core\Containers\TArray)< int > & VertexIDs )


className: TDynamicVertexAttributeChange

code: template<typename AttribValueType, int AttribDimension, typename ParentType> class TDynamicVertexAttributeChange : public [UE::Geometry::TDynamicAttributeChangeBase< ParentType >](API\Runtime\GeometryCore\DynamicMesh\TDynamicAttributeChangeBase)


description: Check validity of attribute

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


description: Compact the attribute in place

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


code: void CompactCopy ( const [FCompactMaps](API\Runtime\GeometryCore\Util\FCompactMaps) & CompactMaps, const [TDynamicVertexSkinWeightsAttribute](API\Runtime\GeometryCore\DynamicMesh\TDynamicVertexSkinWeightsAttribu-)< ParentType > & ToCopy )


description: Set this overlay to contain the same arrays as the copy overlay

code: void Copy ( const [TDynamicVertexSkinWeightsAttribute](API\Runtime\GeometryCore\DynamicMesh\TDynamicVertexSkinWeightsAttribu-)< ParentType > & Copy )


description: Generic function to copy data in to an attribute; it's up to the derived class to map RawID to chunks of attribute data

code: virtual bool CopyIn ( int RawID, void * Buffer, int BufferSize )


description: Generic function to copy data out of an attribute; it's up to the derived class to map RawID to chunks of attribute data

code: virtual bool CopyOut ( int RawID, void * Buffer, int BufferSize ) const


description: Accessors/Queries

code: virtual bool CopyThroughMapping ( const [TDynamicAttributeBase](API\Runtime\GeometryCore\DynamicMesh\TDynamicAttributeBase)< ParentType > * Source, const [FMeshIndexMappings](API\Runtime\GeometryCore\DynamicMesh\FMeshIndexMappings) & Mapping )


description: Copy the attribute value at FromVertexID to ToVertexID

code: void CopyValue ( int FromVertexID, int ToVertexID )


description: the parent for this attribute

code: const ParentType * GetParent() const


description: the parent for this attribute

code: ParentType * GetParent()


description: Get the element at a given index

code: void GetValue ( int VertexID, [FBoneWeights](API\Runtime\GeometryCore\DynamicMesh\TDynamicVertexSkinWeightsAttribu-\FBoneWeights) & Data ) const


description: Get the element at a given index

code: template<typename AsType> void GetValue ( int VertexID, AsType & Data ) const


description: Get the element at a given index via a pair of bone index and weight arrays. The number of influences is equal to the array size.

code: template<typename BoneIndexType, typename BoneFloatWeightType> void GetValue ( int VertexID, [TArray](API\Runtime\Core\Containers\TArray)< BoneIndexType > & OutBones, [TArray](API\Runtime\Core\Containers\TArray)< BoneFloatWeightType > & OutWeights ) const


description: Initialize the attribute values to the given max vertex ID

code: void Initialize ( const [FBoneWeights](API\Runtime\GeometryCore\DynamicMesh\TDynamicVertexSkinWeightsAttribu-\FBoneWeights) InitialValue )


description: Allocate a new compact copy of the attribute layer, optionally with a different parent. Default implementation does a full copy and then compacts it, usually derived class will want to override this with a more efficient direct compact copy implementation

code: virtual [TDynamicAttributeBase](API\Runtime\GeometryCore\DynamicMesh\TDynamicAttributeBase)< ParentType > * MakeCompactCopy ( const [FCompactMaps](API\Runtime\GeometryCore\Util\FCompactMaps) & CompactMaps, ParentType * ParentIn ) const


description: Allocate a new copy of the attribute layer, optionally with a different parent

code: virtual [TDynamicAttributeBase](API\Runtime\GeometryCore\DynamicMesh\TDynamicAttributeBase)< ParentType > * MakeCopy ( ParentType * ParentIn ) const


description: Allocate a new empty instance of the same type of attribute layer

code: virtual [TDynamicAttributeBase](API\Runtime\GeometryCore\DynamicMesh\TDynamicAttributeBase)< ParentType > * MakeNew ( ParentType * ParentIn ) const


code: virtual [TUniquePtr](API\Runtime\Core\Templates\TUniquePtr)< [TDynamicAttributeChangeBase](API\Runtime\GeometryCore\DynamicMesh\TDynamicAttributeChangeBase)< ParentType > > NewBlankChange() const


description: Update the overlay to reflect an edge collapse in the parent

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


description: Update the overlay to reflect an edge merge in the parent

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


description: Update the overlay to reflect an edge flip in the parent

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


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


description: Update the overlay to reflect a face poke in the parent

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


description: Update the overlay to reflect an edge split in the parent

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


description: Update the overlay to reflect a vertex split in the parent

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


description:
FromRefSkeleton can contain bones that are not present in ToRefSkeleton as long as those bones are not referenced by any of the weights.
true on success, false otherwise

code: bool ReindexBoneIndicesToSkeleton ( const [TArray](API\Runtime\Core\Containers\TArray)< [FName](API\Runtime\Core\UObject\FName) > & FromRefSkeleton, const [TArray](API\Runtime\Core\Containers\TArray)< [FName](API\Runtime\Core\UObject\FName) > & ToRefSkeleton )


code: void ResizeAttribStoreIfNeeded ( int VertexID )


code: void Serialize ( [FArchive](API\Runtime\Core\Serialization\FArchive) & Ar, const [FCompactMaps](API\Runtime\GeometryCore\Util\FCompactMaps) * CompactMaps, bool bUseCompression )


description: Set the value at an Attribute to be a linear interpolation of two other Attributes

code: void SetBoneWeightsFromLerp ( int SetAttribute, int AttributeA, int AttributeB, double Alpha )


description: Set the value at an Attribute to be a barycentric interpolation of three other Attributes. If one of the barycentric coordinates is nearly one (within UE_SMALL_NUMBER tolerance) then simply copy over the value of the corresponding Attribute.

code: void SetBoneWeightsFromBary ( int SetAttribute, int AttributeA, int AttributeB, int AttributeC, const FVector3d & BaryCoords )


code: void SetNewValue ( int32 InNewVertexID, const [FBoneWeights](API\Runtime\GeometryCore\DynamicMesh\TDynamicVertexSkinWeightsAttribu-\FBoneWeights) InBoneWeights )


description: Set the element at a given index

code: template<typename ContainerAdapter> void SetValue ( int VertexID, const [UE::AnimationCore::TBoneWeights](API\Runtime\AnimationCore\TBoneWeights)< ContainerAdapter > & Data )


description: Set the element at a given index

code: void SetValue ( int VertexID, const [FBoneWeights](API\Runtime\GeometryCore\DynamicMesh\TDynamicVertexSkinWeightsAttribu-\FBoneWeights) & Data )


description: Set the element at a given index

code: template<typename BoneIndexType, typename BoneFloatWeightType> void SetValue ( int VertexID, const [TArray](API\Runtime\Core\Containers\TArray)< BoneIndexType > & InBones, const [TArray](API\Runtime\Core\Containers\TArray)< BoneFloatWeightType > & InWeights, int32 InNumEntries )


description: Create an empty overlay

code: TDynamicVertexSkinWeightsAttribute()


description: Create an attribute for the given parent

code: TDynamicVertexSkinWeightsAttribute ( ParentType * ParentIn, bool bAutoInit )


code: virtual bool Apply ( [TDynamicAttributeBase](API\Runtime\GeometryCore\DynamicMesh\TDynamicAttributeBase)< ParentType > * Attribute, bool bRevert ) const


className: TDynamicVertexSkinWeightsAttribute

description: TDynamicVertexAttributeprovides per-vertex storage of bone weights (skin weights)

code: template<typename ParentType> class TDynamicVertexSkinWeightsAttribute : public [UE::Geometry::TDynamicAttributeBase< ParentType >](API\Runtime\GeometryCore\DynamicMesh\TDynamicAttributeBase)

description: The parent object (e.g. mesh, point set) this attribute belongs to

VertexBoneWeights

description: FIXME: Replace with a local slab allocator storage to avoid per-item TInlineAllocator.


code: virtual void SaveInitialVertex ( const [TDynamicAttributeBase](API\Runtime\GeometryCore\DynamicMesh\TDynamicAttributeBase)< ParentType > * Attribute, int VertexID )


code: virtual void StoreAllFinalVertices ( const [TDynamicAttributeBase](API\Runtime\GeometryCore\DynamicMesh\TDynamicAttributeBase)< ParentType > * Attribute, const [TArray](API\Runtime\Core\Containers\TArray)< int > & VertexIDs )


code: template<typename ParentType> class TDynamicVertexSkinWeightsAttributeChange : public [UE::Geometry::TDynamicAttributeChangeBase< ParentType >](API\Runtime\GeometryCore\DynamicMesh\TDynamicAttributeChangeBase)


description: Check that the Octree is internally valid

code: void CheckValidity ( [EValidityCheckFailMode](API\Runtime\GeometryCore\UE__Geometry__EValidityCheckFail-) FailMode, bool bVerbose, bool bFailOnMissingPoints ) const


description: Find the nearest triangle of the VertexSource that is hit by the ray

code: int32 FindNearestHitVertex ( const FRay3d & Ray, double MaxDistance ) const


description: Add all vertices of MeshIn to the octree

code: void Initialize ( const SourceType * VertexSourceIn, bool bDynamicExpand )


description: Insert a triangle into the tree

code: void InsertVertex ( int32 VertexID )


description: Insert a list of vertices into the tree

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


description: Insert a set of vertices into the tree

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


description: Include the current bounds of a triangle in the ModifiedBounds box

code: void NotifyPendingModification ( int VertexID )


description: Include the current bounds of a set of vertices in the ModifiedBounds box

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


description: Reinsert a set of vertices into the tree

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


description: Remove a triangle from the tree

code: bool RemovePoint ( int32 VertexID )


description: Remove a list of vertices from the tree

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


description: Remove a set of vertices from the tree

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


description: Reset the internal ModifiedBounds box that tracks modified triangle bounds

code: void ResetModifiedBounds()


description: The template expansion requires that FDynamicXYZ3 has the following API: 1) a function int MaxVertexID() that returns the maximum vertex ID/index 2) a function bool IsVertex(int) that returns true if the index is valid 3) a function FVector3d GetVertex(int index) that returns the position of a vertex 4) a function FAxisAlignedBox3d GetBounds() that returns a bounding-box of the point set

code: template<typename SourceType> class TDynamicVerticesOctree3 : public [UE::Geometry::FSparseDynamicPointOctree3](API\Runtime\GeometryCore\Spatial\FSparseDynamicPointOctree3)

HitSphereRadius

type: double

ModifiedBounds

type: FAxisAlignedBox...

description: Bounding box of vertices that have been inserted/removed since last clear

VertexSource

type: const SourceTyp...

description: Potential optimizations:


description:
Convenience function to compute tangents from the mesh attribute set's primary UVs and normals
true if tangents were computed, false otherwise

code: static bool ComputeDefaultOverlayTangents ( [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh )


description: Calculate MikkT-space-style tangents.

code: void ComputeMikkTStyleTangents ( const [FDynamicMeshNormalOverlay](API\Runtime\GeometryCore\DynamicMesh\FDynamicMeshNormalOverlay) * NormalOverlay, const [FDynamicMeshUVOverlay](API\Runtime\GeometryCore\DynamicMesh\FDynamicMeshUVOverlay) * UVOverlay, const [FComputeTangentsOptions](API\Runtime\GeometryCore\DynamicMesh\FComputeTangentsOptions) & Options )


description: Compute per-triangle tangents for the given UV Overlay

code: void ComputeTriangleTangents ( const [FDynamicMeshUVOverlay](API\Runtime\GeometryCore\DynamicMesh\FDynamicMeshUVOverlay) * UVOverlay, bool bOrthogonalize )


description: Calculate per-triangle tangent spaces based on the given per-triangle normal and UV overlays. In this mode there is no averaging of tangents across triangles. So if we have N triangles in the mesh, then 3*N tangents are generated. These tangents are computed in parallel.

code: void ComputeTriVertexTangents ( const [FDynamicMeshNormalOverlay](API\Runtime\GeometryCore\DynamicMesh\FDynamicMeshNormalOverlay) * NormalOverlay, const [FDynamicMeshUVOverlay](API\Runtime\GeometryCore\DynamicMesh\FDynamicMeshUVOverlay) * UVOverlay, const [FComputeTangentsOptions](API\Runtime\GeometryCore\DynamicMesh\FComputeTangentsOptions) & Options )


description: Set Tangents on mesh overlays

code: bool CopyToOverlays ( [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & MeshToSet ) const


description: Initialize Tangents from other Tangents set

code: template<typename OtherRealType> void CopyTriVertexTangents ( const [TMeshTangents](API\Runtime\GeometryCore\DynamicMesh\TMeshTangents)< OtherRealType > & OtherTangents )


description:
Initialize Tangents from theFDynamicMeshAttributeSetof SourceMesh
false if tangent attributes do not exist

code: bool CopyTriVertexTangents ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & SourceMesh )


description: Calculate per-triangle tangents and then projected to overlay normals at each triangle-vertex

code: void ComputeSeparatePerTriangleTangents ( const [FDynamicMeshNormalOverlay](API\Runtime\GeometryCore\DynamicMesh\FDynamicMeshNormalOverlay) * NormalOverlay, const [FDynamicMeshUVOverlay](API\Runtime\GeometryCore\DynamicMesh\FDynamicMeshUVOverlay) * UVOverlay, const [FComputeTangentsOptions](API\Runtime\GeometryCore\DynamicMesh\FComputeTangentsOptions) & Options )


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


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


description: Interpolated tangent and bitangent at barycentric coordinates inside a triangle, for per-triangle computed tangents

code: void GetInterpolatedTriangleTangent ( int32 TriangleID, const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< RealType > & BaryCoords, [UE::Math::TVector](API\Runtime\Core\Math\TVector)< RealType > & TangentOut, [UE::Math::TVector](API\Runtime\Core\Math\TVector)< RealType > & BitangentOut ) const


description: Return tangent and bitangent at a vertex of triangle for per-triangle computed tangents

code: void GetPerTriangleTangent ( int32 TriangleID, int32 TriVertIdx, [UE::Math::TVector](API\Runtime\Core\Math\TVector)< RealType > & TangentOut, [UE::Math::TVector](API\Runtime\Core\Math\TVector)< RealType > & BitangentOut ) const


code: template<typename VectorType, typename OtherRealType> void GetPerTriangleTangent ( int32 TriangleID, int32 TriVertIdx, VectorType & TangentOut, VectorType & BitangentOut ) const


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


description: Get tangent and bitangent at a vertex of a triangle for per-triangle computed tangents

code: template<typename OtherVectorType> void GetTriangleVertexTangentVectors ( int32 TriangleID, int32 TriVertexIndex, OtherVectorType & TangentOut, OtherVectorType & BitangentOut ) const


description: Per-Triangle Tangents Number of Tangents is NumTrianglesInitialize buffer sizes to one tangent/bitangent per mesh triangle

code: void InitializeTriangleTangents ( bool bClearToZero )


description: Per-Triangle-Vertex Tangents Number of Tangents is NumTriangles * 3 Set internal buffer sizes suitable for calculating per-triangle tangents. This is intended to be used if you wish to calculate your own tangents and useSetPerTriangleTangent()

code: void InitializeTriVertexTangents ( bool bClearToZero )


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


description: Set tangent and bitangent at a vertex of triangle for per-triangle computed tangents.

code: void SetPerTriangleTangent ( int TriangleID, int TriVertIdx, const [TVector](API\Runtime\Core\Math\TVector)< RealType > & Tangent, const [TVector](API\Runtime\Core\Math\TVector)< RealType > & Bitangent )


description: Set the size of the Tangents array to Count, and optionally clear all values to (0,0,0)

code: void SetTangentCount ( int Count, bool bClearToZero )


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


className: TMeshTangents

description: TMeshTangentsis a utility class that can calculate and store various types of tangent vectors for a FDynamicMesh.

code: template<typename RealType> class TMeshTangents

AllDegenerateTris

type: TArray< int32 >

description: Indices of degenerate triangles.

Bitangents

type: TArray<TVector...

description: Set of computed bitangents

Mesh

type: constFDynamicM...

description: Target Mesh

Tangents

description: Set of computed tangents


description: CallSetType.Add(VertexPosition)for all valid vertex indices in for_each(Enumeration)

code: namespace UE { namespace Geometry { template<typename EnumeratorType, typename SetType> void UE::Geometry::CollectVertexPositions ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, EnumeratorType Enumeration, SetType & Output ) } }


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

code: namespace UE { namespace Geometry { bool UE::Geometry::CompactAttributeValues ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, [TDynamicMeshScalarTriangleAttribute](API\Runtime\GeometryCore\DynamicMesh\TDynamicMeshScalarTriangleAttrib-)< int32 > & TriangleAttrib, [FInterval1i](API\Runtime\GeometryCore\FInterval1i) & OldMaxAttributeRangeOut, int & NewMaxAttributeValueOut, [TArray](API\Runtime\Core\Containers\TArray)< int32 > & OldToNewMapOut, [TArray](API\Runtime\Core\Containers\TArray)< int32 > & NewToOldMapOut, bool & bWasCompactOut ) } }


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

code: namespace UE { namespace Geometry { bool UE::Geometry::CopyVertexNormalsToOverlay ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, [FDynamicMeshNormalOverlay](API\Runtime\GeometryCore\DynamicMesh\FDynamicMeshNormalOverlay) & NormalOverlayOut, bool bCompactElements ) } }


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

code: namespace UE { namespace Geometry { bool UE::Geometry::CopyVertexUVsToOverlay ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, [FDynamicMeshUVOverlay](API\Runtime\GeometryCore\DynamicMesh\FDynamicMeshUVOverlay) & UVOverlayOut, bool bCompactElements ) } }


description: Discard all debug meshes stored in the global Debug Meshes map

code: namespace UE { namespace Geometry { namespace Debug { void UE::Geometry::Debug::ClearAllDebugMeshes() } } }


description: If a mesh was previously stored via StashDebugMesh with the given DebugMeshName, copy it to MeshOut, and optionally remove it from the Debug Meshes map

code: namespace UE { namespace Geometry { namespace Debug { bool UE::Geometry::Debug::FetchDebugMesh ( [FString](API\Runtime\Core\Containers\FString) DebugMeshName, [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & MeshOut, bool bClear ) } } }


description: Store a copy of Mesh in a global Debug Meshes TMap. The mesh will exist until the Engine exits, unless FetchDebugMesh or ClearAllDebugMeshes removes it

code: namespace UE { namespace Geometry { namespace Debug { void UE::Geometry::Debug::StashDebugMesh ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, [FString](API\Runtime\Core\Containers\FString) DebugMeshName ) } } }


description: Forward declarations

code: namespace UE { namespace Geometry { enum EMeshComponents { None = 0, VertexNormals = 1, VertexColors = 2, VertexUVs = 4, FaceGroups = 8, All = 15, } } }


description:
Walk around VertexID from FromTriangleID to next connected triangle if it exists, walking "away" from PrevTriangleID.
triplet of values (FoundTriangleID, SharedEdgeID, IndexOfEdgeInFromTri), or allIndexConstants::InvalidIDif not found

code: namespace UE { namespace Geometry { template<typename TrisConnectedPredicate> [FIndex3i](API\Runtime\GeometryCore\FIndex3i) UE::Geometry::FindNextAdjacentTriangleAroundVtx ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * Mesh, int32 VertexID, int32 FromTriangleID, int32 PrevTriangleID, TrisConnectedPredicate TrisConnectedTest ) } }


description: the ID of the shared edge betwen two given triangles, orIndexConstants::InvalidIDif not found / invalid input

code: namespace UE { namespace Geometry { int32 UE::Geometry::FindSharedEdgeInTriangles ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, int32 Triangle0, int32 Triangle1 ) } }


description:
Find the two edges in a Triangle that are connected to a given Vertex of the triangle
edge pair, or (IndexConstants::InvalidID,IndexConstants::InvalidID) on error

code: namespace UE { namespace Geometry { [FIndex2i](API\Runtime\GeometryCore\FIndex2i) UE::Geometry::FindVertexEdgesInTriangle ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, int32 TriangleID, int32 VertexID ) } }


description: Transformed adapter of a FDynamicMesh

code: namespace UE { namespace Geometry { [FTriangleMeshAdapterd](API\Runtime\GeometryCore\FTriangleMeshAdapterd) UE::Geometry::MakeTransformedDynamicMeshAdapter ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * Mesh, FTransform3d Transform ) } }


description: Mesh boundary edge midpoints as a point set

code: namespace UE { namespace Geometry { [FPointSetAdapterd](API\Runtime\GeometryCore\FPointSetAdapterd) UE::Geometry::MakeBoundaryEdgeMidpointsAdapter ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * Mesh ) } }


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

code: namespace UE { namespace Geometry { [FTriangleMeshAdapterd](API\Runtime\GeometryCore\FTriangleMeshAdapterd) UE::Geometry::MakeDynamicMeshAdapter ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * Mesh ) } }


description: mesh edge midpoints as a point set

code: namespace UE { namespace Geometry { [FPointSetAdapterd](API\Runtime\GeometryCore\FPointSetAdapterd) UE::Geometry::MakeEdgeMidpointsAdapter ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * Mesh ) } }


description: PointSet points as a point set

code: namespace UE { namespace Geometry { [FPointSetAdapterd](API\Runtime\GeometryCore\FPointSetAdapterd) UE::Geometry::MakePointsAdapter ( const [FDynamicPointSet3d](API\Runtime\GeometryCore\DynamicMesh\FDynamicPointSet3d) * PointSet ) } }


description: Mesh triangle centroids as a point set

code: namespace UE { namespace Geometry { [FPointSetAdapterd](API\Runtime\GeometryCore\FPointSetAdapterd) UE::Geometry::MakeTriCentroidsAdapter ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * Mesh ) } }


description:
Split the triangle one-ring at VertexID into two triangle sets by "cutting" it with edge SplitEdgeID that is connected to VertexID. VertexID must be a boundary-vertex of the mesh, otherwise one edge is not enough to "split" it. Bowtie vertices are not supported.
false if the split failed, ie the inputs are invalid or one of the output sets is empty

code: namespace UE { namespace Geometry { bool UE::Geometry::SplitBoundaryVertexTrianglesIntoSubsets ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * Mesh, int32 VertexID, int32 SplitEdgeID, [TArray](API\Runtime\Core\Containers\TArray)< int32 > & TriangleSet0, [TArray](API\Runtime\Core\Containers\TArray)< int32 > & TriangleSet1 ) } }


description: Mesh vertices as a point set

code: namespace UE { namespace Geometry { [FPointSetAdapterd](API\Runtime\GeometryCore\FPointSetAdapterd) UE::Geometry::MakeVerticesAdapter ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * Mesh ) } }


description:
Split the triangle one-ring at VertexID into two triangle sets by "cutting" it with two edges SplitEdgeID0 and SplitEdgeID1 that are both connected to VertexID. VertexID must be an "interior" vertex of the mesh (ie not on boundary). Bowtie vertices are not supported.
false if the split failed, ie the inputs are invalid or one of the output sets is empty

code: namespace UE { namespace Geometry { bool UE::Geometry::SplitInteriorVertexTrianglesIntoSubsets ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * Mesh, int32 VertexID, int32 SplitEdgeID0, int32 SplitEdgeID1, [TArray](API\Runtime\Core\Containers\TArray)< int32 > & TriangleSet0, [TArray](API\Runtime\Core\Containers\TArray)< int32 > & TriangleSet1 ) } }


description: Find list of unique vertices that are contained in one or more triangles

code: namespace UE { namespace Geometry { void UE::Geometry::TriangleToVertexIDs ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * Mesh, const [TArray](API\Runtime\Core\Containers\TArray)< int > & TriangleIDs, [TArray](API\Runtime\Core\Containers\TArray)< int > & VertexIDsOut ) } }


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

code: namespace UE { namespace Geometry { template<typename OverlayType, typename EnumeratorType, typename OutputSetType> void UE::Geometry::TrianglesToOverlayElements ( const OverlayType * Overlay, EnumeratorType TriangleEnumeration, OutputSetType & ElementsOut ) } }


description: Find all the triangles in all the one rings of a set of vertices

code: namespace UE { namespace Geometry { void UE::Geometry::VertexToTriangleOneRing ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * Mesh, const [TArray](API\Runtime\Core\Containers\TArray)< int > & VertexIDs, [TSet](API\Runtime\Core\Containers\TSet)< int > & TriangleIDsOut ) } }


className: FAttrBasedQuadricErrord

code: typedef [TAttrBasedQuadricError](API\Runtime\GeometryCore\TAttrBasedQuadricError)< double > FAttrBasedQuadricErrord


className: FAttrBasedQuadricErrorf

code: typedef [TAttrBasedQuadricError](API\Runtime\GeometryCore\TAttrBasedQuadricError)< float > FAttrBasedQuadricErrorf


code: typedef [TAxisAlignedBox2](API\Runtime\GeometryCore\TAxisAlignedBox2)< double > FAxisAlignedBox2d


code: typedef [TAxisAlignedBox2](API\Runtime\GeometryCore\TAxisAlignedBox2)< float > FAxisAlignedBox2f


code: void Expand ( int32 Radius )


description:
Corners are ordered to follow the perimeter of the bounding rectangle, starting from the (Min.X, Min.Y) corner and ending at (Min.X, Max.Y)
Corner of the bounding rectangle

code: [FVector2i](API\Runtime\GeometryCore\FVector2i) GetCorner ( int Index ) const


code: FAxisAlignedBox2i ( int32 SquareSize )


code: FAxisAlignedBox2i ( const [FVector2i](API\Runtime\GeometryCore\FVector2i) & Min, const [FVector2i](API\Runtime\GeometryCore\FVector2i) & Max )


code: FAxisAlignedBox2i ( int32 Width, int32 Height )


code: typedef [TAxisAlignedBox3](API\Runtime\GeometryCore\TAxisAlignedBox3)< float > FAxisAlignedBox3f


code: typedef [TAxisAlignedBox3](API\Runtime\GeometryCore\TAxisAlignedBox3)< double > FAxisAlignedBox3d


code: void Contain ( const [FVector3i](API\Runtime\GeometryCore\FVector3i) & V )


code: bool Contains ( const [FVector3i](API\Runtime\GeometryCore\FVector3i) & V ) const


description: Corner point on the box identified by the given index. See diagram in OrientedBoxTypes.h for index/corner mapping.

code: [FVector3i](API\Runtime\GeometryCore\FVector3i) GetCorner ( int Index ) const


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


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


code: FAxisAlignedBox3i ( const [FVector3i](API\Runtime\GeometryCore\FVector3i) & Min, const [FVector3i](API\Runtime\GeometryCore\FVector3i) & Max )


code: typedef [TCapsule3](API\Runtime\GeometryCore\TCapsule3)< double > FCapsule3d


code: typedef [TCapsule3](API\Runtime\GeometryCore\TCapsule3)< float > FCapsule3f


code: typedef [TCircle2](API\Runtime\GeometryCore\TCircle2)< double > FCircle2d


code: typedef [TCircle2](API\Runtime\GeometryCore\TCircle2)< float > FCircle2f


code: typedef [TCircle3](API\Runtime\GeometryCore\TCircle3)< double > FCircle3d


code: typedef [TCircle3](API\Runtime\GeometryCore\TCircle3)< float > FCircle3f


description:
Fill hole with a triangle fan given an existing (unconnected) center vertex and an ordered loop of boundary vertices on the hole border.
true if operation succeeded. If a failure occurs, any added triangles are removed via RemoveTriangles.

code: bool AddTriangleFan_OrderedVertexLoop ( int CenterVertex, const [TArray](API\Runtime\Core\Containers\TArray)< int > & VertexLoop, int GroupID, [FDynamicMeshEditResult](API\Runtime\GeometryCore\FDynamicMeshEditResult) & ResultOut )


description: Append Colors from one attribute overlay to another. Assumes that AppendMesh has already been appended to Mesh. Note that this function has no dependency on .Mesh, it could be static

code: void AppendColors ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * AppendMesh, const [FDynamicMeshColorOverlay](API\Runtime\GeometryCore\DynamicMesh\FDynamicMeshColorOverlay) * FromOverlay, [FDynamicMeshColorOverlay](API\Runtime\GeometryCore\DynamicMesh\FDynamicMeshColorOverlay) * ToOverlay, const [FIndexMapi](API\Runtime\GeometryCore\FIndexMapi) & VertexMap, const [FIndexMapi](API\Runtime\GeometryCore\FIndexMapi) & TriangleMap, [FIndexMapi](API\Runtime\GeometryCore\FIndexMapi) & ColorMapOut )


description: Append input mesh to our internal Mesh. If the internal Mesh has attributes enabled, per-triangle normals will be computed and set. No other attributes are initialized.

code: void AppendMesh ( const [TTriangleMeshAdapter](API\Runtime\GeometryCore\TTriangleMeshAdapter)< double > * AppendMesh, [FMeshIndexMappings](API\Runtime\GeometryCore\DynamicMesh\FMeshIndexMappings) & IndexMapsOut, [TFunction](API\Runtime\Core\GenericPlatform\TFunction)< FVector3d(int, const FVector3d &)> PositionTransform )


description: Append input mesh to our internal mesh

code: void AppendMesh ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * AppendMesh, [FMeshIndexMappings](API\Runtime\GeometryCore\DynamicMesh\FMeshIndexMappings) & IndexMapsOut, [TFunction](API\Runtime\Core\GenericPlatform\TFunction)< FVector3d(int, const FVector3d &)> PositionTransform, [TFunction](API\Runtime\Core\GenericPlatform\TFunction)< FVector3d(int, const FVector3d &)> NormalTransform )


description: Append normals from one attribute overlay to another. Assumes that AppendMesh has already been appended to Mesh. Note that this function has no dependency on .Mesh, it could be static

code: void AppendNormals ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * AppendMesh, const [FDynamicMeshNormalOverlay](API\Runtime\GeometryCore\DynamicMesh\FDynamicMeshNormalOverlay) * FromNormals, [FDynamicMeshNormalOverlay](API\Runtime\GeometryCore\DynamicMesh\FDynamicMeshNormalOverlay) * ToNormals, const [FIndexMapi](API\Runtime\GeometryCore\FIndexMapi) & VertexMap, const [FIndexMapi](API\Runtime\GeometryCore\FIndexMapi) & TriangleMap, [TFunction](API\Runtime\Core\GenericPlatform\TFunction)< FVector3d(int, const FVector3d &)> NormalTransform, [FIndexMapi](API\Runtime\GeometryCore\FIndexMapi) & NormalMapOut )


description: Append triangles of an existing mesh. This duplicates the current groups and also any attributes existing on the triangles.

code: void AppendTriangles ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * SourceMesh, const [TArrayView](API\Runtime\Core\Containers\TArrayView)< const int > & SourceTriangles, [FMeshIndexMappings](API\Runtime\GeometryCore\DynamicMesh\FMeshIndexMappings) & IndexMaps, [FDynamicMeshEditResult](API\Runtime\GeometryCore\FDynamicMeshEditResult) & ResultOut, bool bComputeTriangleMap )


description: Append UVs from one attribute overlay to another. Assumes that AppendMesh has already been appended to Mesh. Note that this function has no dependency on .Mesh, it could be static

code: void AppendUVs ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * AppendMesh, const [FDynamicMeshUVOverlay](API\Runtime\GeometryCore\DynamicMesh\FDynamicMeshUVOverlay) * FromUVs, [FDynamicMeshUVOverlay](API\Runtime\GeometryCore\DynamicMesh\FDynamicMeshUVOverlay) * ToUVs, const [FIndexMapi](API\Runtime\GeometryCore\FIndexMapi) & VertexMap, const [FIndexMapi](API\Runtime\GeometryCore\FIndexMapi) & TriangleMap, [FIndexMapi](API\Runtime\GeometryCore\FIndexMapi) & UVMapOut )


description:
Calculate and set the per-triangle normals of the two input quads. Average of the two face normals is used unless the quad is planar
the normal vector that was set

code: FVector3f ComputeAndSetQuadNormal ( const [FIndex2i](API\Runtime\GeometryCore\FIndex2i) & QuadTris, bool bIsPlanar )


description:
Converts a loop to a sequence of edge identifiers that are both Vid and Eid independent. The identifiers are of the form (TriangleID, ([0,2] vert sub index, [0,2] vert sub index)), and they are used in some cases (extrude, inset) where we want to perform vertex splits along a region boundary (to remove bowties) but need to maintain a record of the original loop path. We don't use (TriangleID, Eid sub index) because that makes it harder to keep track of individual edge directionality.
false if not successful (usually due to a mismatch between VidLoop and EdgeLoop).

code: static bool ConvertLoopToTriVidPairSequence ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, const [TArray](API\Runtime\Core\Containers\TArray)< int32 > & VidLoop, const [TArray](API\Runtime\Core\Containers\TArray)< int32 > & EdgeLoop, [TArray](API\Runtime\Core\Containers\TArray)< TPair< int32, TPair< int8, int8 >>> & TriVertPairsOut )


description: Copy all attribute-layer values from one triangle to another, using the IndexMaps to track and re-use shared attribute values.

code: void CopyAttributes ( int FromTriangleID, int ToTriangleID, [FMeshIndexMappings](API\Runtime\GeometryCore\DynamicMesh\FMeshIndexMappings) & IndexMaps, [FDynamicMeshEditResult](API\Runtime\GeometryCore\FDynamicMeshEditResult) & ResultOut )


description: Disconnects triangles (without constructing boundary loops) such that the input Triangles are not connected to any other triangles in the mesh

code: void DisconnectTriangles ( const [TArray](API\Runtime\Core\Containers\TArray)< int > & Triangles, bool bPreventBowties )


description: If the BoundaryLoops are not correct for the provided TriangleSet, this version will likely crash.

code: bool DisconnectTriangles ( const [TSet](API\Runtime\Core\Containers\TSet)< int > & TriangleSet, const [TArray](API\Runtime\Core\Containers\TArray)< [FEdgeLoop](API\Runtime\GeometryCore\FEdgeLoop) > & BoundaryLoops, [TArray](API\Runtime\Core\Containers\TArray)< [FLoopPairSet](API\Runtime\GeometryCore\FDynamicMeshEditor\FLoopPairSet) > & LoopSetOut, bool bAllowBoundaryVertices )


description:
Finds boundary loops of connected components of a set of triangles, and duplicates the vertices along the boundary, such that the triangles become disconnected. If the triangle set includes boundary vertices, they cannot be disconnected as they will become unreferenced. The function returns false if boundary vertices are found, unless bHandleBoundaryVertices = true. In that case, the boundary vertex is duplicated, and the original vertex is kept with the "Inner" loop. The new unreferenced vertex is left on the "Outer" loop, and the attached edges do not exist so are set as InvalidID. TheFLoopPairSet.bOuterIncludesIsolatedVerticesflag is set to true if boundary vertices are encountered. Note: This function can create a mesh with bowties if you pass in a subset of triangles that would have bowtie connectivity. (it is impossible to create the paired LoopSetOut with 1:1 vertex pairs without leaving in the bowties?)
true on success

code: bool DisconnectTriangles ( const [TArray](API\Runtime\Core\Containers\TArray)< int > & Triangles, [TArray](API\Runtime\Core\Containers\TArray)< [FLoopPairSet](API\Runtime\GeometryCore\FDynamicMeshEditor\FLoopPairSet) > & LoopSetOut, bool bHandleBoundaryVertices )


description:
Duplicate triangles of a mesh. This duplicates the current groups and also any attributes existing on the triangles.
Make a copy of provided triangles, with new vertices. You provide IndexMaps because you know if you are doing a small subset or a full-mesh-copy.

code: void DuplicateTriangles ( const [TArray](API\Runtime\Core\Containers\TArray)< int > & Triangles, [FMeshIndexMappings](API\Runtime\GeometryCore\DynamicMesh\FMeshIndexMappings) & IndexMaps, [FDynamicMeshEditResult](API\Runtime\GeometryCore\FDynamicMeshEditResult) & ResultOut )


className: EDuplicateTriBehavior

description: This enum/argument controls the behavior. However, fundamentally this kind of problem should be handled upstream!! For example by not trying to remesh areas that contain nonmanifold geometry...

code: enum EDuplicateTriBehavior { EnsureContinue, EnsureAbort, UseExisting, Replace, }


description:
Find "new" color for input color element underIndexmapping, or create new if missing
index of duplicate color in given color layer

code: int FindOrCreateDuplicateColor ( int ElementID, [FMeshIndexMappings](API\Runtime\GeometryCore\DynamicMesh\FMeshIndexMappings) & IndexMaps, [FDynamicMeshEditResult](API\Runtime\GeometryCore\FDynamicMeshEditResult) * ResultOut )


description:
Find "new" group for input group underIndexmapping, or create new if missing
index of duplicate group

code: int FindOrCreateDuplicateGroup ( int TriangleID, [FMeshIndexMappings](API\Runtime\GeometryCore\DynamicMesh\FMeshIndexMappings) & IndexMaps, [FDynamicMeshEditResult](API\Runtime\GeometryCore\FDynamicMeshEditResult) & ResultOut )


description:
Find "new" normal for input normal element underIndexmapping, or create new if missing
index of duplicate normal in given normal layer

code: int FindOrCreateDuplicateNormal ( int ElementID, int NormalLayerIndex, [FMeshIndexMappings](API\Runtime\GeometryCore\DynamicMesh\FMeshIndexMappings) & IndexMaps, [FDynamicMeshEditResult](API\Runtime\GeometryCore\FDynamicMeshEditResult) * ResultOut )


description:
Find "new" UV for input UV element underIndexmapping, or create new if missing
index of duplicate UV in given UV layer

code: int FindOrCreateDuplicateUV ( int ElementID, int UVLayerIndex, [FMeshIndexMappings](API\Runtime\GeometryCore\DynamicMesh\FMeshIndexMappings) & IndexMaps )


description:
Find "new" vertex for input vertex underIndexmapping, or create new if missing
index of duplicate vertex

code: int FindOrCreateDuplicateVertex ( int VertexID, [FMeshIndexMappings](API\Runtime\GeometryCore\DynamicMesh\FMeshIndexMappings) & IndexMaps, [FDynamicMeshEditResult](API\Runtime\GeometryCore\FDynamicMeshEditResult) & ResultOut )


className: FLoopPairSet

description: Pair of associated vertex and edge loops. Assumption is that loop sizes are the same and have a 1-1 correspondence. OuterVertices may include unreferenced vertices, and OuterEdges may include InvalidID edges in that case.

code: struct FLoopPairSet

bOuterIncludesIsolatedVertices

type: bool

description: If true, some OuterVertices are not referenced by any triangles, and the pair of OuterEdges that would touch that vertex are InvalidID


description: Flip the normals of the given triangles. This includes their vertex normals, if they exist, as well as any per-triangle attribute normals.

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


description:
Assumes that Submesh has been modified, but boundary loop has been preserved, and that old submesh has already been removed from this mesh. Just appends new vertices and rewrites triangles.
true if submesh successfully inserted, false if any triangles failed (which happens if triangle would result in non-manifold mesh)

code: bool ReinsertSubmesh ( const [FDynamicSubmesh3](API\Runtime\GeometryCore\FDynamicSubmesh3) & Submesh, [FOptionallySparseIndexMap](API\Runtime\GeometryCore\Util\FOptionallySparseIndexMap) & SubToNewV, [TArray](API\Runtime\Core\Containers\TArray)< int > * NewTris, [EDuplicateTriBehavior](API\Runtime\GeometryCore\FDynamicMeshEditor\EDuplicateTriBehavior) DuplicateBehavior )


description: Remove any vertices that are not used by any triangles

code: bool RemoveIsolatedVertices()


description:
Remove any connected components with volume or area below the given thresholds
number of components removed

code: int RemoveSmallComponents ( double MinVolume, double MinArea, int MinTriangleCount )


description:
Remove a list of triangles from the mesh, and optionally any vertices that are now orphaned
true if all removes succeeded

code: bool RemoveTriangles ( const [TArray](API\Runtime\Core\Containers\TArray)< int > & Triangles, bool bRemoveIsolatedVerts )


code: bool RemoveTriangles ( const [TArray](API\Runtime\Core\Containers\TArray)< int > & Triangles, bool bRemoveIsolatedVerts, [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< void(int)> OnRemoveTriFunc )


description: Rescale UVs for the whole mesh, for the given UV attribute layer

code: void RescaleAttributeUVs ( float UVScale, bool bWorldSpace, int UVLayerIndex, [TOptional](API\Runtime\Core\IO\TOptional)< [FTransformSRT3d](API\Runtime\GeometryCore\FTransformSRT3d) > ToWorld )


description: Reverse the orientation of the given triangles, and optionally flip relevant normals

code: void ReverseTriangleOrientations ( const [TArray](API\Runtime\Core\Containers\TArray)< int > & Triangles, bool bInvertNormals )


description: For triangles connecting loops of corresponded vertices, set UVs in a cylindrical pattern so that the U coordinate starts at 0 for the first corresponded pair of vertices, and cycles around to 1 Assumes Triangles array stores indices of triangles in progressively filling the tube, starting with VertexIDs*[0]. (This is used to set the UVs correctly at the seam joining the start & end of the loop)

code: void SetGeneralTubeUVs ( const [TArray](API\Runtime\Core\Containers\TArray)< int > & Triangles, const [TArray](API\Runtime\Core\Containers\TArray)< int > & VertexIDs1, const [TArray](API\Runtime\Core\Containers\TArray)< int > & MatchedIndices1, const [TArray](API\Runtime\Core\Containers\TArray)< int > & VertexIDs2, const [TArray](API\Runtime\Core\Containers\TArray)< int > & MatchedIndices2, const [TArray](API\Runtime\Core\Containers\TArray)< float > & UValues, const FVector3f & VDir, float UVScaleFactor, const FVector2f & UVTranslation, int UVLayerIndex )


description: Create and set new shared per-triangle normals for a pair of triangles that share one edge (ie a quad)

code: void SetQuadNormals ( const [FIndex2i](API\Runtime\GeometryCore\FIndex2i) & QuadTris, const FVector3f & Normal )


description: Project the two triangles of the quad onto a plane defined by the ProjectionFrame and use that to create/set new shared per-triangle UVs. UVs are translated so that their bbox min-corner is at origin, and scaled by given scale factor

code: void SetQuadUVsFromProjection ( const [FIndex2i](API\Runtime\GeometryCore\FIndex2i) & QuadTris, const [FFrame3d](API\Runtime\GeometryCore\FFrame3d_1) & ProjectionFrame, float UVScaleFactor, const FVector2f & UVTranslation, int UVLayerIndex )


description: Create and set new shared per-triangle normals for a list of triangles. Normal at each vertex is calculated based only on average of triangles in set

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


description: Create and set new shared per-triangle normals for a list of triangles

code: void SetTriangleNormals ( const [TArray](API\Runtime\Core\Containers\TArray)< int > & Triangles, const FVector3f & Normal )


description: Project triangles onto a plane defined by the ProjectionFrame and use that to create/set new shared per-triangle UVs. UVs can be translated so that their bbox min-corner is at origin, and scaled by given scale factor This is an older function signature that forwards to the more specific one.

code: void SetTriangleUVsFromProjection ( const [TArray](API\Runtime\Core\Containers\TArray)< int32 > & Triangles, const [FFrame3d](API\Runtime\GeometryCore\FFrame3d_1) & ProjectionFrame, float UVScaleFactor, const FVector2f & UVTranslation, bool bShiftToOrigin, int32 UVLayerIndex )


description: Project triangles onto a plane defined by the ProjectionFrame and use that to create/set new shared per-triangle UVs.

code: void SetTriangleUVsFromProjection ( const [TArray](API\Runtime\Core\Containers\TArray)< int > & Triangles, const [FFrame3d](API\Runtime\GeometryCore\FFrame3d_1) & ProjectionFrame, const FVector2f & UVScale, const FVector2f & UVTranslation, int UVLayerIndex, bool bShiftToOrigin, bool bNormalizeBeforeScaling )


description: For a 'tube' of triangles connecting loops of corresponded vertices, set smooth normals such that corresponding vertices have corresponding normals

code: void SetTubeNormals ( const [TArray](API\Runtime\Core\Containers\TArray)< int > & Triangles, const [TArray](API\Runtime\Core\Containers\TArray)< int > & VertexIDs1, const [TArray](API\Runtime\Core\Containers\TArray)< int > & MatchedIndices1, const [TArray](API\Runtime\Core\Containers\TArray)< int > & VertexIDs2, const [TArray](API\Runtime\Core\Containers\TArray)< int > & MatchedIndices2 )


description: Splits all bowties across the whole mesh

code: void SplitBowties ( [FDynamicMeshEditResult](API\Runtime\GeometryCore\FDynamicMeshEditResult) & ResultOut )


description: Splits any bowties specifically on the given vertex, and updates (does not reset!) ResultOut with any added vertices

code: void SplitBowties ( int VertexID, [FDynamicMeshEditResult](API\Runtime\GeometryCore\FDynamicMeshEditResult) & ResultOut )


description: Splits bowties attached to any of the given triangles, and updates (does not reset!) ResultOut with any added vertices

code: void SplitBowtiesAtTriangles ( const [TArray](API\Runtime\Core\Containers\TArray)< int32 > & TriangleIDs, [FDynamicMeshEditResult](API\Runtime\GeometryCore\FDynamicMeshEditResult) & ResultOut )


description:
Create multiple meshes out of the source mesh by splitting triangles out. Static because it creates multiple output meshes, so doesn't quite fit in theFDynamicMeshEditormodel of operating on a single mesh
true if needed split, false if there were not multiple mesh ids so no split was needed

code: static bool SplitMesh ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * SourceMesh, [TArray](API\Runtime\Core\Containers\TArray)< [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) > & SplitMeshes, [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< int(int)> TriIDToMeshID, int DeleteMeshID )


description:
Stitch together two loops of vertices where vertices are only sparsely corresponded
true if operation succeeded. If a failure occurs, any added triangles are removed via RemoveTriangles

code: bool StitchSparselyCorrespondedVertexLoops ( const [TArray](API\Runtime\Core\Containers\TArray)< int > & VertexIDs1, const [TArray](API\Runtime\Core\Containers\TArray)< int > & MatchedIndices1, const [TArray](API\Runtime\Core\Containers\TArray)< int > & VertexIDs2, const [TArray](API\Runtime\Core\Containers\TArray)< int > & MatchedIndices2, [FDynamicMeshEditResult](API\Runtime\GeometryCore\FDynamicMeshEditResult) & ResultOut, bool bReverseOrientation )


description:
Stitch together two loops of vertices with a quad-strip of triangles. Loops must be oriented (ordered) correctly for your use case. If loop edges are [a,b] and [c,d], then tris added are [b,a,d] and [a,c,d]
true if operation succeeded. If a failure occurs, any added triangles are removed via RemoveTriangles

code: bool StitchVertexLoopsMinimal ( const [TArray](API\Runtime\Core\Containers\TArray)< int > & VertexLoop1, const [TArray](API\Runtime\Core\Containers\TArray)< int > & VertexLoop2, [FDynamicMeshEditResult](API\Runtime\GeometryCore\FDynamicMeshEditResult) & ResultOut )


description:
Weld together two loops of vertices. Loops must be oriented (ordered) correctly for your use case.
true if operation succeeded, false if any errors ocurred

code: bool WeldVertexLoops ( const [TArray](API\Runtime\Core\Containers\TArray)< int32 > & VertexLoop1, const [TArray](API\Runtime\Core\Containers\TArray)< int32 > & VertexLoop2 )


description:
If an entry of TriVidPairs1 resolves to verts [a,b] and the corresponding pair of verts in VertexLoop2 are [c,d], then tris added are [b,a,d] and [a,c,d].
true if operation succeeded. If a failure occurs, any added triangles are removed via RemoveTriangles

code: bool StitchVertexLoopToTriVidPairSequence ( const [TArray](API\Runtime\Core\Containers\TArray)< TPair< int32, TPair< int8, int8 >>> & TriVidPairs1, const [TArray](API\Runtime\Core\Containers\TArray)< int > & VertexLoop2, [FDynamicMeshEditResult](API\Runtime\GeometryCore\FDynamicMeshEditResult) & ResultOut )


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


className: FDynamicMeshEditor

description: FDynamicMeshEditorimplements low-level mesh editing operations. These operations can be used to construct higher-level operations. For example an Extrude operation could be implemented viaDuplicateTriangles()and StitchLoopMinimal().

code: class FDynamicMeshEditor

Mesh

description: The mesh we will be editing


description: Flatten the triangle/quad/polygon lists into a single list of all triangles

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


description: Clear this data structure

code: void Reset()


className: FDynamicMeshEditResult

description: FDynamicMeshEditResultis used to return information about new mesh elements created by mesh changes, primarily inFDynamicMeshEditor

code: struct FDynamicMeshEditResult

NewColorOverlayElements

description: New color overlay elements

NewGroups

type: TArray< int >

description: New triangle groups created by an edit

NewNormalOverlayElements

type: TArray<TArray<...

description: New normal overlay elements

NewPolygons

description: New polygons created by an edit, where each polygon is a list of triangle IDs

NewQuads

description: New quads created by an edit, where each quad is a pair of triangle IDs

NewTriangles

description: New triangles created by an edit.

NewVertices

description: New vertices created by an edit


description: Computes the Submesh object, index mappings corresponding sub to base mesh, and boundary between sub and base mesh

code: void Compute ( const [TArrayView](API\Runtime\Core\Containers\TArrayView)< const int > & SubTriangles, int WantComponents, bool bAttributes )


description: Computes submesh object, setting a new BaseMesh first

code: void Compute ( [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * Base, const [TArrayView](API\Runtime\Core\Containers\TArrayView)< const int > & Triangles, int WantComponents, bool bAttributes )


description: Compute boundary vertices and edges between the SubTriangles and the rest of the mesh Called by Compute after the Submesh is computed.

code: void ComputeBoundaryInfo ( const [TArrayView](API\Runtime\Core\Containers\TArrayView)< const int > & SubTriangles )


description: set of border vertex indices on base mesh (ie verts of BaseBorderE - does not include mesh boundary vertices)

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


description: set of internal border edge indices on base mesh. Does not include mesh boundary edges.

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


description: set of mesh-boundary edges on base mesh that are in submesh

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


description: Const accessor for base mesh

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


description: Accessor for submesh


description: Const accessor for submesh

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


description: true if edge ID is in base border edge ID set

code: bool InBaseBorderEdges ( int BaseEID ) const


description: true if vertex ID is in base border vertex ID set

code: bool InBaseBorderVertices ( int BaseVID ) const


description: true if edge ID is in base boundary edge ID set

code: bool InBaseBoundaryEdges ( int BaseEID ) const


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


description: Edge ID in base mesh, mapped from submesh

code: int MapEdgeToBaseMesh ( int SubEID ) const


code: void MapGroupsToSubmesh ( [TArrayView](API\Runtime\Core\Containers\TArrayView)< int32 > GroupIDs ) const


description: Group ID in the base mesh, mapped from submesh

code: int MapGroupToBaseMesh ( int SubGID ) const


description: Group ID in the submesh, mapped from base mesh

code: int MapGroupToSubmesh ( int BaseGID ) const


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


description: Triangle ID in the base mesh, mapped from submesh

code: int MapTriangleToBaseMesh ( int SubTID ) const


description: Triangle ID in the submesh, mapped from base mesh

code: int MapTriangleToSubmesh ( int BaseTID ) const


description: Vertex ID in base mesh, mapped from submesh

code: int MapVertexToBaseMesh ( int SubVID ) const


description: Vertex ID in submesh, mapped from base mesh

code: int MapVertexToSubmesh ( int BaseVID ) const


description: Pair of vertex IDs in base mesh, mapped from submesh

code: [FIndex2i](API\Runtime\GeometryCore\FIndex2i) MapVerticesToBaseMesh ( [FIndex2i](API\Runtime\GeometryCore\FIndex2i) VIDs ) const


description: Pair of vertex IDs in submesh, mapped from base mesh

code: [FIndex2i](API\Runtime\GeometryCore\FIndex2i) MapVerticesToSubmesh ( [FIndex2i](API\Runtime\GeometryCore\FIndex2i) VIDs ) const


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


description: Default constructor


description: Edge ID in submesh, mapped from base mesh

code: int MapEdgeToSubmesh ( int BaseEID ) const


description: Base mesh-only constructor; does not build submesh

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


description: Constructor sets the base mesh and computes the submesh

code: FDynamicSubmesh3 ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * BaseMesh, const [TArray](API\Runtime\Core\Containers\TArray)< int > & Triangles, int WantComponents, bool bAttributes )


code: struct FDynamicSubmesh3

BaseBorderE

type: TSet< int >

bComputeTriMaps

description: Whether to compute triangle maps (adds additional cost). True by default.

Mappings

type: FMeshIndexMappi...

description: TODO: this is a fully generic mapping backed by TMaps both ways we could instead back the reverse mapping by aTArraysince it's dense for submeshes


description: Populate the BowtieVertices member

code: void CalculateBowtieVertices()


description:
Exhaustively check that verts and edges of this EdgeLoop are consistent. This is quite expensive.
true if loop is consistent/valid

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


description: index of vertex in the Vertices list that is closest to QueryPoint

code: int FindNearestVertexIndex ( const FVector3d & QueryPoint ) const


description: index of VertexID in the Vertices list, or -1 if not found

code: int FindVertexIndex ( int VertexID ) const


description: number of edges in the loop

code: int GetEdgeCount() const


description: bounding box of the vertices of the EdgeLoop


description: vertex position in loop at the vertex after LoopIndex

code: FVector3d GetNextVertex ( int32 LoopIndex ) const


description: vertex position in loop at the vertex previous to LoopIndex

code: FVector3d GetPrevVertex ( int32 LoopIndex ) const


description: vertex position in loop at the given LoopIndex

code: FVector3d GetVertex ( int LoopIndex ) const


description: number of vertices in the loop

code: int GetVertexCount() const


description: Add the vertices of the loop to the Vertices array

code: template<typename VecType> void GetVertices ( [TArray](API\Runtime\Core\Containers\TArray)< VecType > & VerticesOut ) const


description: Initialize the loop data

code: void Initialize ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * mesh, const [TArray](API\Runtime\Core\Containers\TArray)< int > & vertices, const [TArray](API\Runtime\Core\Containers\TArray)< int > & edges, const [TArray](API\Runtime\Core\Containers\TArray)< int > * BowtieVerticesIn )


description: Construct anFEdgeLoopfrom a list of edges of the mesh

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


code: void InitializeFromEdges ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * MeshIn, const [TArray](API\Runtime\Core\Containers\TArray)< int > & EdgesIn )


description:
Construct EdgeLoop from list of vertices of mesh
false if we found any parts of vertices that are not connected by an edge

code: bool InitializeFromVertices ( const [TArray](API\Runtime\Core\Containers\TArray)< int > & VerticesIn, bool bAutoOrient )


code: bool InitializeFromVertices ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * MeshIn, const [TArray](API\Runtime\Core\Containers\TArray)< int > & VerticesIn, bool bAutoOrient )


description: true if all edges of this loop are internal edges, ie not on the mesh boundary

code: bool IsInternalLoop() const


description: Reverse order of vertices and edges in loop

code: void Reverse()


description: Set the bowtie vertices

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


description:
If any edges if the loop are on a mesh boundary, we can check that the loop is oriented such that it corresponds with the boundary edges, and if not, reverse it.
true if the loop was reversed

code: bool SetCorrectOrientation()


description: Utility function to convert a vertex loop to an edge loop

code: static void VertexLoopToEdgeLoop ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * Mesh, const [TArray](API\Runtime\Core\Containers\TArray)< int > & VertexLoop, [TArray](API\Runtime\Core\Containers\TArray)< int > & OutEdgeLoop )


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


description: Initialize EdgeLoop with the given vertices and edges

code: FEdgeLoop ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * mesh, const [TArray](API\Runtime\Core\Containers\TArray)< int > & vertices, const [TArray](API\Runtime\Core\Containers\TArray)< int > & edges )


description: true if all edges of this loop are boundary edges

code: bool IsBoundaryLoop ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * TestMesh ) const


className: FEdgeLoop

description: Sequential lists of vertices/edges in a mesh that form a closed loop

code: class FEdgeLoop

bBowtiesCalculated

description: If true, then BowtieVertices list is valid

BowtieVertices

description: List of bowtie vertices. This list is only valid if bBowtiesCalculated = true.

Edges

description: Ordered list of edges forming the EdgeLoop

Mesh

description: The Mesh that contains this EdgeLoop

Vertices

description: Ordered list of vertices forming the EdgeLoop


description: Populate the BowtieVertices member

code: void CalculateBowtieVertices()


description: index of vertex in the Vertices list that is closest to QueryPoint

code: int FindNearestVertexIndex ( const FVector3d & QueryPoint ) const


description:
Exhaustively check that verts and edges of this EdgeSpan are consistent. This is quite expensive.
true if span is consistent/valid

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


description: index of VertexID in the Vertices list, or -1 if not found

code: int FindVertexIndex ( int VertexID ) const


description: bounding box of the vertices of the EdgeSpan


description: number of edges in the span

code: int GetEdgeCount() const


description: Extract Polyline from Mesh based on vertex list

code: void GetPolyline ( [FPolyline3d](API\Runtime\GeometryCore\FPolyline3d) & PolylineOut ) const


description: vertex position in span at the given SpanIndex

code: FVector3d GetVertex ( int SpanIndex ) const


description: number of vertices in the span

code: int GetVertexCount() const


description: Construct anFEdgeSpanfrom a list of edges of the mesh

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


description: Initialize the loop data

code: void Initialize ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * mesh, const [TArray](API\Runtime\Core\Containers\TArray)< int > & vertices, const [TArray](API\Runtime\Core\Containers\TArray)< int > & edges, const [TArray](API\Runtime\Core\Containers\TArray)< int > * BowtieVerticesIn )


code: void InitializeFromEdges ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * MeshIn, const [TArray](API\Runtime\Core\Containers\TArray)< int > & EdgesIn )


description:
Construct EdgeSpan from list of vertices of mesh
false if we found any parts of VerticesIn that are not connected by an edge

code: bool InitializeFromVertices ( const [TArray](API\Runtime\Core\Containers\TArray)< int > & VerticesIn, bool bAutoOrient )


code: bool InitializeFromVertices ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * MeshIn, const [TArray](API\Runtime\Core\Containers\TArray)< int > & VerticesIn, bool bAutoOrient )


description: true if all edges of this span are boundary edges

code: bool IsBoundaryspan ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * TestMesh ) const


description: true if all edges of this span are internal edges, ie not on the mesh boundary

code: bool IsInternalspan() const


description: Set the bowtie vertices

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


description: Reverse order of vertices and edges in span

code: void Reverse()


description:
If any edges if the span are on a mesh boundary, we can check that the span is oriented such that it corresponds with the boundary edges, and if not, reverse it.
true if the span was reversed

code: bool SetCorrectOrientation()


description: Utility function to convert a vertex span to an edge span

code: static void VertexSpanToEdgeSpan ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * Mesh, const [TArray](API\Runtime\Core\Containers\TArray)< int > & VertexSpan, [TArray](API\Runtime\Core\Containers\TArray)< int > & OutEdgeSpan )


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


description: Initialize EdgeSpan with the given vertices and edges

code: FEdgeSpan ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * mesh, const [TArray](API\Runtime\Core\Containers\TArray)< int > & vertices, const [TArray](API\Runtime\Core\Containers\TArray)< int > & edges )


className: FEdgeSpan

description: Sequential lists of vertices/edges in a mesh that isnotclosed. If the list is closed it should be anFEdgeLoop

code: class FEdgeSpan

bBowtiesCalculated

description: If true, then BowtieVertices list is valid

BowtieVertices

description: List of bowtie vertices. This list is only valid if bBowtiesCalculated = true.

Edges

description: Ordered list of edges forming the EdgeSpan

Mesh

description: The Mesh that contains this EdgeSpan

description: Ordered list of vertices forming the EdgeSpan


className: FForceGeometryNamespaceToExist

code: struct FForceGeometryNamespaceToExist

a

type: int


code: typedef [TFrame3](API\Runtime\GeometryCore\TFrame3)< double > FFrame3d


code: typedef [TFrame3](API\Runtime\GeometryCore\TFrame3)< float > FFrame3f


description: Called before the module is unloaded, right before the module object is destroyed. During normal shutdown, this is called in reverse order that modules finishStartupModule(). This means that, as long as a module references dependent modules in it'sStartupModule(), it can safely reference those dependencies inShutdownModule()as well.

code: virtual void ShutdownModule()


description: IModuleInterfaceimplementation

code: virtual void StartupModule()


className: FGeometryCoreModule

code: class FGeometryCoreModule : public [IModuleInterface](API\Runtime\Core\Modules\IModuleInterface)


code: typedef [THalfspace3](API\Runtime\GeometryCore\THalfspace3)< double > FHalfspace3d


code: typedef [THalfspace3](API\Runtime\GeometryCore\THalfspace3)< float > FHalfspace3f


code: bool Contains ( int Value ) const


code: int IndexOf ( int Value ) const


code: static constexpr [FIndex2i](API\Runtime\GeometryCore\FIndex2i) Invalid()


code: static constexpr [FIndex2i](API\Runtime\GeometryCore\FIndex2i) Max()


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


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


code: int & operator[] ( int Idx )


code: const int & operator[] ( int Idx ) const


description: whichever of A or B is not Value, orIndexConstants::InvalidIDif neither is Value

code: int OtherElement ( int Value ) const


description: SerializeFIndex2ito an archive.

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


code: static constexpr [FIndex2i](API\Runtime\GeometryCore\FIndex2i) Zero()


code: constexpr FIndex2i ( int ValA, int ValB )


description: 2-index tuple. Ported from g3Sharp library, with the intention of maintaining compatibility with existing g3Sharp code. Has an API similar to WildMagic, GTEngine, Eigen, etc.

code: struct FIndex2i

type: union UE::Geome...


description: shifted triplet such that A=WantIndex0Value, and B,C values maintain the same relative ordering

code: [FIndex3i](API\Runtime\GeometryCore\FIndex3i) GetCycled ( int32 WantIndex0Value ) const


code: static constexpr [FIndex3i](API\Runtime\GeometryCore\FIndex3i) Invalid()


code: static constexpr [FIndex3i](API\Runtime\GeometryCore\FIndex3i) Max()


className: FIndex3i::operator FIntVector

code: operator FIntVector() const


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


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


description: SerializeFIndex3ito an archive


code: static constexpr [FIndex3i](API\Runtime\GeometryCore\FIndex3i) Zero()


code: FIndex3i ( const FIntVector & Vec )


code: constexpr FIndex3i ( int ValA, int ValB, int ValC )


description: Implicit casts to/from FIntVector are defined.

code: struct FIndex3i


code: bool Contains ( int Idx ) const


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


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


code: int IndexOf ( int Value ) const


code: int & operator[] ( int Idx )


code: const int & operator[] ( int Idx ) const


code: FIndex4i ( int ValA, int ValB, int ValC, int ValD )


description: 4-index tuple. Ported from g3Sharp library, with the intention of maintaining compatibility with existing g3Sharp code. Has an API similar to WildMagic, GTEngine, Eigen, etc.

code: struct FIndex4i


className: FIndexedWeightMap

code: typedef [TIndexedWeightMap](API\Runtime\GeometryCore\TIndexedWeightMap)< float > FIndexedWeightMap


code: typedef [TIndexedWeightMap](API\Runtime\GeometryCore\TIndexedWeightMap)< double > FIndexedWeightMap1d


code: typedef [TIndexedWeightMap](API\Runtime\GeometryCore\TIndexedWeightMap)< float > FIndexedWeightMap1f


className: FIndexMapi

code: typedef [TIndexMap](API\Runtime\GeometryCore\TIndexMap)< int > FIndexMapi


className: FIndexMeshArrayAdapterd

code: typedef [TIndexMeshArrayAdapter](API\Runtime\GeometryCore\TIndexMeshArrayAdapter)< uint32, double > FIndexMeshArrayAdapterd


code: typedef [TInterval1](API\Runtime\GeometryCore\TInterval1)< double > FInterval1d


code: typedef [TInterval1](API\Runtime\GeometryCore\TInterval1)< float > FInterval1f


code: void Expand ( int32 Radius )


code: FInterval1i ( const int32 & Min, const int32 & Max )


code: typedef [TLine2](API\Runtime\GeometryCore\TLine2)< double > FLine2d


code: typedef [TLine2](API\Runtime\GeometryCore\TLine2)< float > FLine2f


code: typedef [TLine3](API\Runtime\GeometryCore\TLine3)< double > FLine3d


code: typedef [TLine3](API\Runtime\GeometryCore\TLine3)< float > FLine3f


code: typedef [TMatrix2](API\Runtime\GeometryCore\TMatrix2)< double > FMatrix2d


code: typedef [TMatrix2](API\Runtime\GeometryCore\TMatrix2)< float > FMatrix2f


code: typedef [TMatrix3](API\Runtime\GeometryCore\TMatrix3)< double > FMatrix3d


code: typedef [TMatrix3](API\Runtime\GeometryCore\TMatrix3)< float > FMatrix3f


description:
Find the set of boundary EdgeLoops and EdgeSpans. .SpanBehavior and .FailureBehavior control what happens if we run into problem cases
false if errors occurred, in this case output set is incomplete

code: bool Compute()


description: Count number of times item appears in loop

code: static int CountInList ( const [TArray](API\Runtime\Core\Containers\TArray)< int > & Loop, int Item )


description: Count number of valid vertices in l between loop[i0] and loop[i1-1]

code: static int CountSpan ( const [TArray](API\Runtime\Core\Containers\TArray)< int > & Loop, int i0, int i1 )


className: EFailureBehaviors

code: enum EFailureBehaviors { Abort, ConvertToOpenSpan, }


className: ESpanBehaviors

code: enum ESpanBehaviors { Ignore, Abort, Compute, }


description: Read out the span from loop[i0] to loop [i1-1] into an array. If bMarkInvalid, then these values are set to -1 in loop

code: static void ExtractSpan ( [TArray](API\Runtime\Core\Containers\TArray)< int > & Loop, int i0, int i1, bool bMarkInvalid, [TArray](API\Runtime\Core\Containers\TArray)< int > & OutSpan )


description: Find the index of item in loop, starting at start index

code: static int FindIndex ( const [TArray](API\Runtime\Core\Containers\TArray)< int > & Loop, int Start, int Item )


description: This is called when loopV contains one or more "bowtie" vertices. These verticesmightbe duplicated in loopV (but not necessarily) If they are, we have to break loopV into subloops that don't contain duplicates.

code: bool ExtractSubloops ( [TArray](API\Runtime\Core\Containers\TArray)< int > & loopV, [TArray](API\Runtime\Core\Containers\TArray)< int > & loopE, [TArray](API\Runtime\Core\Containers\TArray)< int > & bowties, [Subloops](API\Runtime\GeometryCore\FMeshBoundaryLoops\Subloops) & SubloopsOut )


description: Ok, bdry_edges[0...bdry_edges_count] contains the boundary edges coming out of bowtie_v. We want to pick the best one to continue the loop that came in to bowtie_v on incoming_e. If the loops are all sane, then we will get the smallest loops by "turning left" at bowtie_v.

code: int FindLeftTurnEdge ( int incoming_e, int bowtie_v, [TArray](API\Runtime\Core\Containers\TArray)< int > & bdry_edges, int bdry_edges_count, [TArray](API\Runtime\Core\Containers\TArray)< bool > & used_edges )


description: index of loop that contains edge, or -1 if not found

code: int FindLoopContainingEdge ( int EdgeID ) const


description: index of loop that contains vertex, or -1 if not found

code: int FindLoopContainingVertex ( int VertexID ) const


description: index of loop that best matches input edges, or -1 if not found

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


description: index of loop that best matches input triangles, or -1 if not found

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


description: pair (LoopIndex,VertexIndexInLoop) of VertexID in EdgeLoops, orFIndex2i::Invalidif not found

code: [FIndex2i](API\Runtime\GeometryCore\FIndex2i) FindVertexInLoop ( int VertexID ) const


description: number of loops found byCompute()

code: int GetLoopCount() const


description: index of loop with longest arc length, or -1 if no loops

code: int GetLongestLoopIndex() const


description: index of loop with maximum number of vertices

code: int GetMaxVerticesLoopIndex() const


description: number of spans found byCompute()

code: int GetSpanCount() const


description: Static Utility functions that can be re-used in MeshRegionBoundaryLoops In all the functions below, the list loopV is assumed to possibly contain "removed" vertices indicated by -1. These areignored.Checkif the loop from bowtieV to bowtieV inside loopV contains any other bowtie verts. Also returns start and end indices in loopV of "clean" loop Note that start may be < end, if the "clean" loop wraps around the end

code: static bool IsSimpleBowtieLoop ( const [TArray](API\Runtime\Core\Containers\TArray)< int > & LoopVerts, const [TArray](API\Runtime\Core\Containers\TArray)< int > & BowtieVerts, int BowtieVertex, int & start_i, int & end_i )


description: [TODO] cache this : a dictionary? we will not need very many, but we will need each multiple times!

code: FVector3d GetVertexNormal ( int vid )


description: Check if forward path from loopV[i1] to loopV[i2] contains any bowtie verts other than bowtieV

code: static bool IsSimplePath ( const [TArray](API\Runtime\Core\Containers\TArray)< int > & LoopVerts, const [TArray](API\Runtime\Core\Containers\TArray)< int > & BowtieVerts, int BowtieVertex, int i1, int i2 )


description: Loop at the given index

code: const [FEdgeLoop](API\Runtime\GeometryCore\FEdgeLoop) & operator[] ( int Index ) const


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


className: Subloops

code: struct Subloops

Loops

type: TArray<FEdgeLo...

Spans

type: TArray<FEdgeSp...


code: FMeshBoundaryLoops ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * MeshIn, bool bAutoCompute )


className: FMeshBoundaryLoops

code: class FMeshBoundaryLoops

bAborted

description: If true, we aborted computation due to unrecoverable errors

bFellBackToSpansOnFailure

description: If true, we had to call back to spans because of failures duringCompute().

bSawOpenSpans

description: If true, we found at least one open span duringCompute().

EdgeFilterFunc

type: TFunction< bool...

description: If non-null, then only edges that pass this filter are considered. This may result in open spans.

FailureBehavior

type: EFailureBehavio...

description: WhatCompute()will do if it encounters unrecoverable errors while walking around a loop

FailureBowties

description: If we encountered unrecoverable errors, it is generally due to bowtie vertices.

Loops

description: Resulting set of loops filled byCompute()

Mesh

description: Mesh we are finding loops on

SpanBehavior

type: ESpanBehaviors

description: WhatCompute()will do if it encounter open spans

description: Resulting set of spans filled byCompute(), if SpanBehavior == Compute


description:
Find set of FEdgeLoops on the border of the input triangle set
false if errors occurred, in this case output set is incomplete

code: bool Compute()


className: ElementIDAndValue

code: typedef TPair< int32, ElementType > ElementIDAndValue


description: Ok, bdry_edges[0...bdry_edges_count] contains the boundary edges coming out of bowtie_v. We want to pick the best one to continue the loop that came : to bowtie_v on incoming_e. If the loops are all sane, then we will get the smallest loops by "turning left" at bowtie_v.

code: int FindLeftTurnEdge ( int incoming_e, int bowtie_v, [TArray](API\Runtime\Core\Containers\TArray)< int > & bdry_edges, int bdry_edges_count, const [FIndexFlagSet](API\Runtime\GeometryCore\Util\FIndexFlagSet) & used_edges )


description: E needs to be large enough (ie call GetVtxBoundaryEdges, or as large as max one-ring) returns count, ie number of elements of e that were filled

code: int GetAllVertexBoundaryEdges ( int vID, [TArray](API\Runtime\Core\Containers\TArray)< int > & e )


description: number of loops found byCompute()

code: int32 GetLoopCount() const


description:
Generates a map from vertex ID's of the loop vertices to corresponding overlay element ID's and values. The elements chosen are those associated with the internal triangle whose edge goes out of that vertex in the loop direction. The function is useful in cases where the triangles inside the loop will be deleted and replaced, and we want to keep the same UV's on the border vertices. Does not clear LoopVidsToOverlayElementsOut before use (simply adds to it), so could be used for multiple loops.
false if there is an error (if the overlay does not have an element for one of the vids)

code: template<typename StorageType, int ElementSize, typename ElementType> bool GetLoopOverlayMap ( const [FEdgeLoop](API\Runtime\GeometryCore\FEdgeLoop) & LoopIn, const [TDynamicMeshOverlay](API\Runtime\GeometryCore\DynamicMesh\TDynamicMeshOverlay)< StorageType, ElementSize > & Overlay, [VidOverlayMap](API\Runtime\GeometryCore\FMeshRegionBoundaryLoops\VidOverlayMap)< ElementType > & LoopVidsToOverlayElementsOut )


code: const [TArray](API\Runtime\Core\Containers\TArray)< [FEdgeLoop](API\Runtime\GeometryCore\FEdgeLoop) > & GetLoops() const


description: index of loop with maximum number of vertices

code: int GetMaxVerticesLoopIndex() const


description: Return same indices as GetEdgeV, but oriented based on attached triangle

code: [FIndex2i](API\Runtime\GeometryCore\FIndex2i) GetOrientedEdgeVerts ( int eID, int tid_in )


description:
Find the edge loop border around a set of triangles of a Mesh. This is computed via local walk and so does not create any full-mesh data structures. However current implementation may not be efficient for large triangle sets. Algorithm terminates if a non-manifold boundary is detected, and returns false if some triangles are unused.
true if a single well-formed loop was found, false if non-manifold or failure case encountered

code: static bool GetTriangleSetBoundaryLoop ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, const [TArray](API\Runtime\Core\Containers\TArray)< int32 > & Tris, [FEdgeLoop](API\Runtime\GeometryCore\FEdgeLoop) & Loop )


description: Returns first two boundary edges, and count of total boundary edges

code: int GetVertexBoundaryEdges ( int vID, int & e0, int & e1 )


description: [TODO] cache this : a dictionary? we will not need very many, but we will need each multiple times!

code: FVector3d GetVertexNormal ( int vid )


code: bool IsEdgeOnBoundary ( int eid ) const


description: Returns true for both internal and mesh boundary edges tid_in and tid_out are triangles 'in' and 'out' of set, respectively

code: bool IsEdgeOnBoundary ( int eid, int & tid_in, int & tid_out ) const


description: number of loops found byCompute()

code: int32 Num() const


description: Loop at the given index

code: const [FEdgeLoop](API\Runtime\GeometryCore\FEdgeLoop) & operator[] ( int Index ) const


code: void SetMesh ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * MeshIn, const [TArray](API\Runtime\Core\Containers\TArray)< int > & RegionTris )


description: This is called when loopV contains one or more "bowtie" vertices. These verticesmightbe duplicated : loopV (but not necessarily) If they are, we have to break loopV into subloops that don't contain duplicates.

code: bool TryExtractSubloops ( [TArray](API\Runtime\Core\Containers\TArray)< int > & loopV, const [TArray](API\Runtime\Core\Containers\TArray)< int > & loopE, const [TArray](API\Runtime\Core\Containers\TArray)< int > & bowties, [TArray](API\Runtime\Core\Containers\TArray)< [FEdgeLoop](API\Runtime\GeometryCore\FEdgeLoop) > & SubLoopsOut )


description: Given a map generated byGetLoopOverlayMap(), checks that the overlay elements pointed to by the map still exist in the overlay, and sets the ID to be invalid if not. This can be called after deleting the triangles inside a loop to update the generated map and remove any UV elements that no longer exist (because the vertex was on a UV seam).

code: template<typename StorageType, int ElementSize, typename ElementType> void UpdateLoopOverlayMapValidity ( [VidOverlayMap](API\Runtime\GeometryCore\FMeshRegionBoundaryLoops\VidOverlayMap)< ElementType > & LoopVidsToOverlayElements, const [TDynamicMeshOverlay](API\Runtime\GeometryCore\DynamicMesh\TDynamicMeshOverlay)< StorageType, ElementSize > & Overlay )


className: VidOverlayMap

code: typedef [TMap](API\Runtime\Core\Containers\TMap)< int32, [ElementIDAndValue](API\Runtime\GeometryCore\FMeshRegionBoundaryLoops\ElementIDAndValue)< ElementType >> VidOverlayMap


code: FMeshRegionBoundaryLoops ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * MeshIn, const [TArray](API\Runtime\Core\Containers\TArray)< int > & RegionTris, bool bAutoCompute )


className: FMeshRegionBoundaryLoops

description: Extract FEdgeLoops on the boundary of a set of triangles of a mesh.

code: class FMeshRegionBoundaryLoops

bFailed

description: If true, we did not completely succeed in extracting all loops

Edges

type: FIndexFlagSet

Mesh

description: Mesh we are finding loops on

Triangles

description: Sets of included triangles and edges


code: typedef [TOrientedBox2](API\Runtime\GeometryCore\TOrientedBox2)< double > FOrientedBox2d


code: typedef [TOrientedBox2](API\Runtime\GeometryCore\TOrientedBox2)< float > FOrientedBox2f


code: typedef [TOrientedBox3](API\Runtime\GeometryCore\TOrientedBox3)< double > FOrientedBox3d


code: typedef [TPlane3](API\Runtime\GeometryCore\TPlane3)< double > FPlane3d


code: typedef [TOrientedBox3](API\Runtime\GeometryCore\TOrientedBox3)< float > FOrientedBox3f


code: typedef [TPlane3](API\Runtime\GeometryCore\TPlane3)< float > FPlane3f


className: FPointSetAdapterd

code: typedef [TPointSetAdapter](API\Runtime\GeometryCore\TPointSetAdapter)< double > FPointSetAdapterd


code: typedef [TPolygon2](API\Runtime\GeometryCore\TPolygon2)< float > FPolygon2f


className: FPointSetAdapterf

code: typedef [TPointSetAdapter](API\Runtime\GeometryCore\TPointSetAdapter)< float > FPointSetAdapterf


code: typedef [TPolyline3](API\Runtime\GeometryCore\TPolyline3)< double > FPolyline3d


code: typedef [TPolyline3](API\Runtime\GeometryCore\TPolyline3)< float > FPolyline3f


className: FQuadricErrord

code: typedef [TQuadricError](API\Runtime\GeometryCore\TQuadricError)< double > FQuadricErrord


className: FQuadricErrorf

code: typedef [TQuadricError](API\Runtime\GeometryCore\TQuadricError)< float > FQuadricErrorf


className: FQuaterniond

code: typedef [TQuaternion](API\Runtime\GeometryCore\TQuaternion)< double > FQuaterniond


className: FQuaternionf

code: typedef [TQuaternion](API\Runtime\GeometryCore\TQuaternion)< float > FQuaternionf


code: typedef [TSegment2](API\Runtime\GeometryCore\TSegment2)< double > FSegment2d


code: typedef [TSegment2](API\Runtime\GeometryCore\TSegment2)< float > FSegment2f


code: typedef [TSegment3](API\Runtime\GeometryCore\TSegment3)< double > FSegment3d


code: typedef [TPolygon2](API\Runtime\GeometryCore\TPolygon2)< double > FPolygon2d


code: typedef [TSegment3](API\Runtime\GeometryCore\TSegment3)< float > FSegment3f


description: IsElement(Index) returns false ifIndexis not valid. Find, Union and GetSize should never be called on an invalid index.

code: template<typename IsElementFunction> void Init ( int32 NumIDs, IsElementFunction IsElement )


code: void Union ( int32 A, int32 B )


className: FSizedDisjointSet

description: Disjoint set with additional storage to track the size of each set.

code: struct FSizedDisjointSet


code: typedef [TSphere3](API\Runtime\GeometryCore\TSphere3)< double > FSphere3d


code: typedef [TSphere3](API\Runtime\GeometryCore\TSphere3)< float > FSphere3f


code: typedef [TTetrahedron3](API\Runtime\GeometryCore\TTetrahedron3)< double > FTetrahedron3d


code: typedef [TTetrahedron3](API\Runtime\GeometryCore\TTetrahedron3)< float > FTetrahedron3f


code: typedef [TTransformSequence3](API\Runtime\GeometryCore\TTransformSequence3)< double > FTransformSequence3d


code: typedef [TTransformSequence3](API\Runtime\GeometryCore\TTransformSequence3)< float > FTransformSequence3f


code: typedef [TTransformSRT3](API\Runtime\GeometryCore\TTransformSRT3)< float > FTransformSRT3f


code: typedef [TTriangle2](API\Runtime\GeometryCore\TTriangle2)< double > FTriangle2d


code: typedef [TTriangle2](API\Runtime\GeometryCore\TTriangle2)< float > FTriangle2f


code: typedef [TTransformSRT3](API\Runtime\GeometryCore\TTransformSRT3)< double > FTransformSRT3d


code: typedef [TTriangle3](API\Runtime\GeometryCore\TTriangle3)< double > FTriangle3d


code: typedef [TTriangle3](API\Runtime\GeometryCore\TTriangle3)< float > FTriangle3f


code: typedef [TTriangle3](API\Runtime\GeometryCore\TTriangle3)< int > FTriangle3i


className: FTriangleMeshAdapterd

code: typedef [TTriangleMeshAdapter](API\Runtime\GeometryCore\TTriangleMeshAdapter)< double > FTriangleMeshAdapterd


className: FTriangleMeshAdapterf

code: typedef [TTriangleMeshAdapter](API\Runtime\GeometryCore\TTriangleMeshAdapter)< float > FTriangleMeshAdapterf


code: constexpr int32 DistanceSquared ( const [FVector2i](API\Runtime\GeometryCore\FVector2i) & V2 ) const


code: constexpr int32 Dot ( const [FVector2i](API\Runtime\GeometryCore\FVector2i) & V2 ) const


code: static constexpr [FVector2i](API\Runtime\GeometryCore\FVector2i) One()


className: FVector2i::operator const int32 *

code: constexpr operator const int32 *() const


className: FVector2i::operator FVector2d

code: operator FVector2d() const


className: FVector2i::operator FVector2f

code: operator FVector2f() const


className: FVector2i::operator int32 *

code: constexpr operator int32 *()


code: constexpr [FVector2i](API\Runtime\GeometryCore\FVector2i) operator+ ( const [FVector2i](API\Runtime\GeometryCore\FVector2i) & V2 ) const


code: constexpr [FVector2i](API\Runtime\GeometryCore\FVector2i) operator+ ( const int32 & Scalar ) const


code: constexpr [FVector2i](API\Runtime\GeometryCore\FVector2i) & operator+= ( const [FVector2i](API\Runtime\GeometryCore\FVector2i) & V2 )


code: constexpr [FVector2i](API\Runtime\GeometryCore\FVector2i) & operator= ( const [FVector2i](API\Runtime\GeometryCore\FVector2i) & V2 )


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


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


code: constexpr [FVector2i](API\Runtime\GeometryCore\FVector2i) operator/ ( const int32 & Scalar ) const


code: constexpr [FVector2i](API\Runtime\GeometryCore\FVector2i) operator/ ( const [FVector2i](API\Runtime\GeometryCore\FVector2i) & V2 ) const


code: constexpr [FVector2i](API\Runtime\GeometryCore\FVector2i) & operator/= ( const int32 & Scalar )


code: constexpr [FVector2i](API\Runtime\GeometryCore\FVector2i) operator* ( const int32 & Scalar ) const


code: constexpr [FVector2i](API\Runtime\GeometryCore\FVector2i) operator* ( const [FVector2i](API\Runtime\GeometryCore\FVector2i) & V2 ) const


code: constexpr [FVector2i](API\Runtime\GeometryCore\FVector2i) & operator*= ( const int32 & Scalar )


code: constexpr [FVector2i](API\Runtime\GeometryCore\FVector2i) operator- ( const [FVector2i](API\Runtime\GeometryCore\FVector2i) & V2 ) const


code: constexpr [FVector2i](API\Runtime\GeometryCore\FVector2i) operator-() const


code: constexpr [FVector2i](API\Runtime\GeometryCore\FVector2i) operator- ( const int32 & Scalar ) const


code: constexpr int32 & operator[] ( int Idx )


code: constexpr const int32 & operator[] ( int Idx ) const


code: constexpr [FVector2i](API\Runtime\GeometryCore\FVector2i) & operator-= ( const [FVector2i](API\Runtime\GeometryCore\FVector2i) & V2 )


code: constexpr int32 SquaredLength() const


code: static constexpr [FVector2i](API\Runtime\GeometryCore\FVector2i) UnitY()


code: static constexpr [FVector2i](API\Runtime\GeometryCore\FVector2i) UnitX()


code: static constexpr [FVector2i](API\Runtime\GeometryCore\FVector2i) Zero()


code: constexpr FVector2i ( const int32 * Data )


code: [PRAGMA_DISABLE_DEPRECATION_WARNINGS](API\Plugins\ModelingComponents\Baking\PRAGMA_DISABLE_DEPRECATION_WARNI-) constexpr FVector2i ( const [FVector2i](API\Runtime\GeometryCore\FVector2i) & Vec )


code: FVector2i ( const FVector & Vec )


code: FVector2i ( const FVector2f & Vec )


code: FVector2i ( const FVector2d & Vec )


code: constexpr FVector2i ( int32 ValX, int32 ValY )


description: 2D 32-bit integer Vector

code: struct FVector2i


code: constexpr int32 DistanceSquared ( const [FVector3i](API\Runtime\GeometryCore\FVector3i) & V2 ) const


code: constexpr int32 Dot ( const [FVector3i](API\Runtime\GeometryCore\FVector3i) & V2 ) const


className: FVector3i::operator const int32 *

code: constexpr operator const int32 *() const


className: FVector3i::operator FVector3d

code: operator FVector3d() const


className: FVector3i::operator FVector3f

code: operator FVector3f() const


className: FVector3i::operator int32 *

code: constexpr operator int32 *()


code: constexpr [FVector3i](API\Runtime\GeometryCore\FVector3i) operator+ ( const [FVector3i](API\Runtime\GeometryCore\FVector3i) & V2 ) const


code: constexpr [FVector3i](API\Runtime\GeometryCore\FVector3i) operator+ ( const int32 & Scalar ) const


code: constexpr [FVector3i](API\Runtime\GeometryCore\FVector3i) & operator+= ( const [FVector3i](API\Runtime\GeometryCore\FVector3i) & V2 )


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


code: [FVector3i](API\Runtime\GeometryCore\FVector3i) & operator= ( const [FVector3i](API\Runtime\GeometryCore\FVector3i) & V2 )


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


code: constexpr bool operator< ( const [FVector3i](API\Runtime\GeometryCore\FVector3i) & Other ) const


code: constexpr [FVector3i](API\Runtime\GeometryCore\FVector3i) operator/ ( const int32 & Scalar ) const


code: constexpr [FVector3i](API\Runtime\GeometryCore\FVector3i) operator/ ( const [FVector3i](API\Runtime\GeometryCore\FVector3i) & V2 ) const


code: constexpr [FVector3i](API\Runtime\GeometryCore\FVector3i) & operator/= ( const int32 & Scalar )


code: constexpr [FVector3i](API\Runtime\GeometryCore\FVector3i) operator* ( const int32 & Scalar ) const


code: constexpr [FVector3i](API\Runtime\GeometryCore\FVector3i) operator* ( const [FVector3i](API\Runtime\GeometryCore\FVector3i) & V2 ) const


code: constexpr [FVector3i](API\Runtime\GeometryCore\FVector3i) & operator*= ( const int32 & Scalar )


code: constexpr [FVector3i](API\Runtime\GeometryCore\FVector3i) operator-() const


code: constexpr [FVector3i](API\Runtime\GeometryCore\FVector3i) operator- ( const [FVector3i](API\Runtime\GeometryCore\FVector3i) & V2 ) const


code: constexpr [FVector3i](API\Runtime\GeometryCore\FVector3i) operator- ( const int32 & Scalar ) const


code: int32 & operator[] ( int Idx )


code: const int32 & operator[] ( int Idx ) const


code: constexpr [FVector3i](API\Runtime\GeometryCore\FVector3i) & operator-= ( const [FVector3i](API\Runtime\GeometryCore\FVector3i) & V2 )


code: constexpr int32 SquaredLength() const


code: constexpr FVector3i ( const int32 * Data )


code: [PRAGMA_DISABLE_DEPRECATION_WARNINGS](API\Plugins\ModelingComponents\Baking\PRAGMA_DISABLE_DEPRECATION_WARNI-) constexpr FVector3i ( const [FVector3i](API\Runtime\GeometryCore\FVector3i) & Vec )


code: FVector3i ( const FVector3f & Vec )


code: FVector3i ( const FVector3d & Vec )


code: constexpr FVector3i ( int32 ValX, int32 ValY, int32 ValZ )


description: 3D 32-bit integer Vector

code: struct FVector3i


code: template<typename TriangleMeshType> void ConnectCloseVertices ( const TriangleMeshType & Mesh, double CloseVertexThreshold, int32 KeepSizeThreshold )


description: TODO: support more overlap strategies, currently just uses AABB Note this merges components based on overlap of their bounding boxes as computedbeforeany merges; multiple passes may merge additional components

code: template<typename TriangleMeshType> void ConnectOverlappingComponents ( const TriangleMeshType & Mesh, int32 KeepSizeThreshold )


code: template<typename TriangleMeshType> void ConnectTriangles ( const TriangleMeshType & Mesh )


code: template<typename TriangleType> void ConnectTriangles ( [TArrayView](API\Runtime\Core\Containers\TArrayView)< const TriangleType > Triangles )


description:
Apply ProcessComponentFn() to each connected component, or until the function returns false
True if every component was processed, false if ProcessComponentFn returned false and the enumeration returned early.

code: bool EnumerateContiguousComponentsFromArray ( const [TArray](API\Runtime\Core\Containers\TArray)< int32 > & ContiguousComponentsArray, [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< bool(int32, [TArrayView](API\Runtime\Core\Containers\TArrayView)< const int32 >)> ProcessComponentFn )


code: void ConnectVertices ( int32 VertexID0, int32 VertexID1 )


code: int32 GetComponent ( int32 VertexID )


code: template<typename TriangleType> int32 GetComponent ( const TriangleType & Triangle )


code: int32 GetComponentSize ( int32 VertexID )


code: template<typename TriangleMeshType> bool HasMultipleComponents ( const TriangleMeshType & Mesh, int32 KeepSizeThreshold )


code: bool HasMultipleComponents ( int32 MaxVID, int32 KeepSizeThreshold )


code: void Init ( int32 MaxVertexID )


code: template<typename TriangleMeshType> void Init ( const TriangleMeshType & Mesh )


description: Map arbitrary set IDs to indices from 0 to k-1 (if there are k components)

code: template<typename TriangleMeshType> [TMap](API\Runtime\Core\Containers\TMap)< int32, int32 > MakeComponentMap ( const TriangleMeshType & Mesh, int32 KeepSizeThreshold )


code: [TMap](API\Runtime\Core\Containers\TMap)< int32, int32 > MakeComponentMap ( int32 MaxVID, int32 KeepSizeThreshold )