className: FOffsetInfo

description: Outputs Offset information for a single connected component

code: struct FOffsetInfo

BaseLoops

type: TArray<FEdgeLo...

description: Initial loops on the mesh

bIsSolid

description: If true, full region was thickened into a solid

OffsetGroups

description: Groups on offset faces. These IDs will be the same as the original groups in the region.

OffsetLoops

description: Offset loops on the mesh.

OffsetTids

description: Set of triangles for this region. These will be the same Tids that were originally in the region.

StitchPolygonIDs

description: List of group ids / polygon ids on each triangle-strip "tube"

StitchTriangles

description: Lists of triangle-strip "tubes" that connect each loop-pair


className: EVertexExtrusionVectorType

description: Method used to determine the per-vertex offset direction vector

module: DynamicMesh

code: enum EVertexExtrusionVectorType { Zero, VertexNormal, SelectionTriNormalsAngleWeightedAverage, SelectionTriNormalsAngleWeightedAdjusted, }


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


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


className: FOffsetMeshRegion

description: Each quad of the border loop is assigned it's own normal and UVs (ie each is a separate UV-island)

code: class FOffsetMeshRegion

AllModifiedAndNewTriangles

type: TArray< int32 >

description: List of all triangles created/modified by this operation

bGroupPerSubdivision

type: bool

description: If true, each subdivision level gets a new group This parameter is only supported inEVersion::Version1and later

bInferMaterialID

description: If true, Material IDs around the border of the extrude area are propagated "down" the extrusion tube This parameter is only supported inEVersion::Version1and later

bIsPositiveOffset

description: When bOffsetFullComponentsAsSolids is true and the extrusion applied by OffsetPositionFunc is negative, then fully-connected components need to be turned inside-out.

bOffsetFullComponentsAsSolids

description: If a sub-region of Triangles is a full connected component, offset into a solid instead of leaving a shell

bSingleGroupPerArea

description: If true, each extruded area gets a single new group, instead of remapping the input groups This parameter is only supported inEVersion::Version1and later

bUVIslandPerGroup

description: If true, new UV island is assigned for each group in stitch region.

CreaseAngleThresholdDeg

type: double

description: Split the extrude "tube" into separate groups based on the opening angle between quads.

DefaultOffsetDistance

description: Used in the default OffsetPositionFunc.

ExtrusionVectorType

type: EVertexExtrusio...

description: Determines the type of vector passed in per-vertex to OffsetPositionFunc

LoopEdgesShouldHaveSameGroup

type: TFunction< bool...

description: When stitching the extruded portion to the source loop, this determines the grouping of the side quads by passing in successive Eids in the original loop.

MaxScaleForAdjustingTriNormalsOffset

description: When using SelectionTriNormalsAngleWeightedAdjusted to keep triangles parallel, clamp the offset scale to at most this factor

Mesh

description: InputsThe mesh that we are modifying

NumSubdivisions

description: Number of subdivisions along the length of the "tubes" used to stitch the offset regions.

OffsetPositionFunc

type: TFunction< FVec...

description: OffsetPositionFunc function is called to generate the offset vertex position.

OffsetRegions

type: TArray<FOffset...

description: List of offset regions/components

SetMaterialID

type: int

description: Constant Material ID to set along the extrusion tubes This parameter is only supported inEVersion::Version1and later

Triangles

description: The triangle region we are modifying

UseVersion

type: EVersion

description: Version of Offset operation being used. Defaults to Current, ie most recent version

UVScaleFactor

type: float

description: Quads on the stitch loop are planar-projected and scaled by this amount


description: Apply the operation to the mesh.

code: void Apply()


code: FPlanarFlipsOptimization ( [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * MeshIn, int32 NumPassesIn, double PlanarDotThreshIn )


className: FPlanarFlipsOptimization

description: If both triangles on an edge are coplanar, we can arbitrarily flip the interior edge to improve triangle quality. Similarly if one triangle on an edge is degenerate, we can flip the edge without affecting the shape to try to remove it. This code does one or more passes of such an optimization.

code: class FPlanarFlipsOptimization


description: Construct planar hole filler (projects the hole edges to a plane and fills the hole w/ a general 2D polygon triangulation)

code: FPlanarHoleFiller ( [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * Mesh, const [TArray](API\Runtime\Core\Containers\TArray)< [TArray](API\Runtime\Core\Containers\TArray)< int >> * VertexLoops, [TFunction](API\Runtime\Core\GenericPlatform\TFunction)< [TArray](API\Runtime\Core\Containers\TArray)< [FIndex3i](API\Runtime\GeometryCore\FIndex3i) >(const [FGeneralPolygon2d](API\Runtime\GeometryCore\Curve\FGeneralPolygon2d) &)> PlanarTriangulationFunc, FVector3d PlaneOrigin, FVector3d PlaneNormal )


className: FPlanarHoleFiller

description: Fill a set of boundary loops with planar surfaces. User must provide the triangulation function.

code: class FPlanarHoleFiller : public [UE::Geometry::IHoleFiller](API\Plugins\DynamicMesh\Operations\IHoleFiller)

Mesh

description: Inputs

PlanarTriangulationFunc

type: TFunction<TArr...

VertexLoops

type: constTArray<T...


description:
Generate PN Triangles geometry and optionally compute quadratically varying normals.
true if the algorithm succeeds, false if it failed or was canceled by the user.

code: virtual bool Compute()


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


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


className: FPNTriangles

description: FPNTrianglesimplements curved PN (Point-Normal) Triangles (Curved PN Triangles, Vlachos, 2001). Each PN triangle replaces one original flat triangle by a curved shape that is retriangulated into a number of small subtriangles. The geometry of a PN triangle is defined as one cubic Bezier patch using control points. The patch matches the point and normal information at the vertices of the original flat triangle.

code: class FPNTriangles

bRecalculateNormals

description: If true and the mesh has the normal overlay then recalculate it.

Mesh

description: Input & OutputThe mesh that we are modifying.

Progress

type: FProgressCancel...

description: InputSet this to be able to cancel running operation.

TessellationLevel

description: How many times we are recursively subdividing triangles (loop style subdivision).


description: If this returns true, abort computation.

code: virtual bool Cancelled()


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

code: bool Compute()


code: FPolygroupRemesh ( [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * Mesh, const [FGroupTopology](API\Plugins\DynamicMesh\FGroupTopology) * Topology, [TFunction](API\Runtime\Core\GenericPlatform\TFunction)< [TArray](API\Runtime\Core\Containers\TArray)< [FIndex3i](API\Runtime\GeometryCore\FIndex3i) >(const [FGeneralPolygon2d](API\Runtime\GeometryCore\Curve\FGeneralPolygon2d) &)> PlanarTriangulationFunc )


className: FPolygroupRemesh

description: PolygroupRemesh  remesh only considering polygroup features (topological corners and bends on polygroup edges) This can help clean up low poly meshes that have extra vertices along straight edges e.g. after mesh Boolean operations

code: class FPolygroupRemesh

Mesh

description: InputsThe mesh to remesh  will be updated in place

PlanarTriangulationFunc

description: Planar triangulation function (e.g. ConstrainedDelaunayTriangulatein GeometryAlgorithms)

Progress

description: Set this to be able to cancel running operation

SimplificationAngleTolerance

description: Units are degrees.

Topology

type: constFGroupTop...

description: Topology of polygroups in the mesh, before the remesh has been computed


description: true if we need to abort the computation.


description: Tessellate the whole mesh such that all the edge and inner tessellation levels are equal to InTessellationLevel.

code: static [TUniquePtr](API\Runtime\Core\Templates\TUniquePtr)< [FTessellationPattern](API\Plugins\DynamicMesh\Operations\FTessellationPattern) > CreateConcentricRingsTessellationPattern ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * InMesh, const int InTessellationLevel )


description:
Generate tessellated geometry.
true if the algorithm succeeds, false if it failed or was cancelled by the user.


description: not yet implemented

code: static [TUniquePtr](API\Runtime\Core\Templates\TUniquePtr)< [FTessellationPattern](API\Plugins\DynamicMesh\Operations\FTessellationPattern) > CreateConcentricRingsTessellationPattern ( const [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< int(const int EdgeID)> InEdgeFunc, const [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< int(const int TriangleID)> InTriFunc )


description:
O
           / \
          O. .O
         /  O  \
        O. / \ .O
       /  O. .O  \
      /  /  O  \  \
     /  /  / \  \  \
    O. /  /   \  \ .O
   /  O. /     \ .O  \
  /  /  O-------O  \  \
 O. /   .       .   \ .O
/  O----O-------O----O  \
 / . . . . \ O-O-O----O-O-O

code: static [TUniquePtr](API\Runtime\Core\Templates\TUniquePtr)< [FTessellationPattern](API\Plugins\DynamicMesh\Operations\FTessellationPattern) > CreateConcentricRingsTessellationPattern ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * InMesh, const [TArray](API\Runtime\Core\Containers\TArray)< int > & InEdgeTessLevels, const [TArray](API\Runtime\Core\Containers\TArray)< int > & InInnerTessLevels )


description: Tessellate only selected triangles such that the edge and inner tessellation levels of those triangles are set to InTessellationLevel.

code: static [TUniquePtr](API\Runtime\Core\Templates\TUniquePtr)< [FTessellationPattern](API\Plugins\DynamicMesh\Operations\FTessellationPattern) > CreateConcentricRingsTessellationPattern ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * InMesh, const int InTessellationLevel, const [TArray](API\Runtime\Core\Containers\TArray)< int > & InTriangleList )


description:
Tessellate only triangles that belong to a given polygroup id within the polygroup layer attribute (FDynamicMeshPolygroupAttribute) specified by its name.
nullptr if InMesh has no attributes or if no polygroup layer attribute with the given name or id exists.

code: static [TUniquePtr](API\Runtime\Core\Templates\TUniquePtr)< [FTessellationPattern](API\Plugins\DynamicMesh\Operations\FTessellationPattern) > CreateConcentricRingsPatternFromPolyGroup ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * InMesh, const int InTessellationLevel, const [FString](API\Runtime\Core\Containers\FString) & InLayerName, const int InPolygroupID )


description: Tessellate only triangles that belong to a given triangle group id. Triangle groups are defined by theFDynamicMesh3::GetTriangleGroup().

code: static [TUniquePtr](API\Runtime\Core\Templates\TUniquePtr)< [FTessellationPattern](API\Plugins\DynamicMesh\Operations\FTessellationPattern) > CreateConcentricRingsPatternFromTriangleGroup ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * InMesh, const int InTessellationLevel, const int InPolygroupID )


description:
Tessellate only triangles that belong to a given material (FDynamicMeshMaterialAttribute).
nullptr if InMesh has no attributes, no material attribute or if no material attribute with the given id exists.

code: static [TUniquePtr](API\Runtime\Core\Templates\TUniquePtr)< [FTessellationPattern](API\Plugins\DynamicMesh\Operations\FTessellationPattern) > CreateConcentricRingsPatternFromMaterial ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * InMesh, const int InTessellationLevel, const int MaterialID )


description: not yet implemented

code: static [TUniquePtr](API\Runtime\Core\Templates\TUniquePtr)< [FTessellationPattern](API\Plugins\DynamicMesh\Operations\FTessellationPattern) > CreateInnerUnifromTessellationPattern ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * InMesh, const [TArray](API\Runtime\Core\Containers\TArray)< int > & InEdgeTessLevels, const [TArray](API\Runtime\Core\Containers\TArray)< int > & InInnerTessLevels )


className: FTessellationInformation

description: The caller is responsible for managing the memmory the pointers are pointing to. The operator simply populates the data structures if they are not null.

code: struct FTessellationInformation

SelectedVertices

type: TArray< int32 >...

description: If not null, construction of tessellated mesh will append a list of all the vertices that belong to triangles affected by the tessellation.


description: not yet implemented

code: static [TUniquePtr](API\Runtime\Core\Templates\TUniquePtr)< [FTessellationPattern](API\Plugins\DynamicMesh\Operations\FTessellationPattern) > CreateUniformTessellationPattern ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * InMesh, const int InTessellationLevel, const [TArray](API\Runtime\Core\Containers\TArray)< int > & InTriangleList )


code: void SetPattern ( [FTessellationPattern](API\Plugins\DynamicMesh\Operations\FTessellationPattern) * InPattern )


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


description: Tessellate the mesh inplace. If the tessellation fails or the user cancelled the operation, OutMesh will not be changed. //TODO: Add an option to turn off making the backup copy of the input mesh in case the computation fails.

code: FSelectiveTessellate ( [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * OutMesh )


description: Tessellate the mesh and write the result into another mesh. This will overwrite any data stored in the OutMesh.

code: FSelectiveTessellate ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * Mesh, [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * OutMesh )


code: virtual ~FSelectiveTessellate()


className: FSelectiveTessellate

description: currently not implemented |

code: class FSelectiveTessellate

bInPlace

description: If true, the mesh to tessellate is contained in the ResultMesh and will be overwritten with the tessellation result.

bUseParallel

description: Should tessellation be multi-threaded.

Mesh

type: constFDynamicM...

description: Points to either the input mesh to be used to generate the new tessellated mesh or will point to a copy of the mesh we are tessellating inplace.

Pattern

type: FTessellationPa...

description: Tessellation pattern determines how we tessellate edges and triangles.

Progress

description: Inputs Set this to be able to cancel running operation.


className: FGeometricInfo

code: struct FGeometricInfo


className: FSurfaceTraceResult

code: struct FSurfaceTraceResult

SurfacePoint

type: FSurfacePoint


description: Update the signpost after an edge flip. This requires information about the both the pre and post flip state.

code: void OnFlipEdge ( const int32 EID, const [FIndex2i](API\Runtime\GeometryCore\FIndex2i) AdjTris, const [FIndex2i](API\Runtime\GeometryCore\FIndex2i) OpposingVerts, const [FIndex2i](API\Runtime\GeometryCore\FIndex2i) PreFlipIndexOf, const double Opp0NewInternalAngle, const double Opp1NewInternalAngle )


description: FSignpost

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


className: FSignpost

description: Signpost Coordinates inspired by "Navigating Intrinsic Triangulations" Sharp, Soliman and Crane [2019, ACM Transactions on Graphics] This structure assumes that the surface mesh is fixed, but allows the intrinsic mesh to support operations like edge splits and triangle pokes. is initialized with the same connectivity as the surface mesh. Note, it is assumed that the surface mesh has no bow-ties.

code: struct FSignpost : public [UE::Geometry::IntrinsicCorrespondenceUtils::FMeshConnection](API\Plugins\DynamicMesh\Operations\FMeshConnection)

GeometricVertexInfo

type: TDynamicVector<...


className: EFillType

code: enum EFillType { TriangleFan, PolygonEarClipping, }


code: virtual bool Fill ( int32 GroupID )


code: bool Fill_Fan ( int32 NewGroupID )


code: bool Fill_EarClip ( int32 NewGroupID )


description:
Normals are shared among NewTriangles but not with the surrounding portions of the mesh.
false if there is an error, usually if VidsToUVsMap did not have an entry for a needed vertex ID.

code: bool UpdateAttributes ( [TArray](API\Runtime\Core\Containers\TArray)< [FMeshRegionBoundaryLoops::VidOverlayMap](API\Runtime\GeometryCore\FMeshRegionBoundaryLoops\VidOverlayMap)< FVector2f >> & VidUVMaps )


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


description: Construct simple hole filler (just adds a central vertex and a triangle fan)

code: FSimpleHoleFiller ( [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * Mesh, [FEdgeLoop](API\Runtime\GeometryCore\FEdgeLoop) Loop, [EFillType](API\Plugins\DynamicMesh\Operations\FSimpleHoleFiller\EFillType) InFillType )


className: FSimpleHoleFiller

description: Fill an EdgeLoop hole with triangles. Supports two fill modes, either a fan connected to a new central vertex, or a triangulation of the boundary polygon

code: class FSimpleHoleFiller : public [UE::Geometry::IHoleFiller](API\Plugins\DynamicMesh\Operations\IHoleFiller)

FillType

type: EFillType

Loop

type: FEdgeLoop

Mesh

description: Inputs

NewVertex

description: Outputs


description: Discard all data

code: void Clear()


description: Computes the angles based on the edge lengths, so must have valid EdgeLengths for this tri before calling. the order of the angles matches the order of the vertices that define the triangle, e.g. if (a, b, c) =GetTriangle()the (angle at a, angle at b, angle at c) = ComputeTriInternalAnglesR

code: FVector3d ComputeTriInternalAnglesR ( const int32 TID ) const


description: Note: if EID is a mesh boundary, cot(alpha_ij) is returned

code: double EdgeCotanWeight ( int32 EID ) const


description: number of edges in the intrinsic mesh

code: int32 EdgeCount() const


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


description: Note: if EID is a mesh boundary beta_{ij} is replaced by -MAX_DOUBLE

code: FVector2d EdgeOpposingAngles ( int32 EID ) const


description:
Flip a single edge in the Intrinsic Mesh.
a success or failure info.

code: [EMeshResult](API\Runtime\GeometryCore\UE__Geometry__EMeshResult) FlipEdge ( int32 EID, [FEdgeFlipInfo](API\Plugins\DynamicMesh\Operations\FSimpleIntrinsicEdgeFlipMesh\FEdgeFlipInfo) & EdgeFlipInfo )


description: Update the mesh topology (e.g. triangles and edges) by doing an edge flip, but does not update the intrinsic edge lengths or angles.

code: [EMeshResult](API\Runtime\GeometryCore\UE__Geometry__EMeshResult) FlipEdgeTopology ( int32 eab, [FEdgeFlipInfo](API\Plugins\DynamicMesh\Operations\FSimpleIntrinsicEdgeFlipMesh\FEdgeFlipInfo) & FlipInfo )


description: specified edge

code: [FEdge](API\Plugins\DynamicMesh\Operations\FSimpleIntrinsicEdgeFlipMesh\FEdge) GetEdge ( int32 EdgeID ) const


description: the intrinsic edge length of specified edge

code: double GetEdgeLength ( int32 EID ) const


description: three requested edge lengths

code: FVector3d GetEdgeLengthTriple ( const [FIndex3i](API\Runtime\GeometryCore\FIndex3i) & EIDs ) const


description: the vertex pair opposite specified edge. The second vertex may be InvalidID

code: [FIndex2i](API\Runtime\GeometryCore\FIndex2i) GetEdgeOpposingV ( int32 EID ) const


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

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


description: the vertex IDs that define the given edge in intrinsic mesh

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


description: vertex pair in specified edge, oriented by the given triangle. note: the vertices may be the same. note: assumes EID is an edge in Triangle TID

code: [FIndex2i](API\Runtime\GeometryCore\FIndex2i) GetOrientedEdgeV ( int32 EID, int32 TID ) const


description: the intrinsic distance between the two vertices opposite the specified edge NB: Will fail if EID is a boundary edge.

code: double GetOpposingVerticesDistance ( int32 EID ) const


description: vertex ids for the three corners of the triangle (e.g. a, b, c)

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


description: reference to vertex ids for the three corners of the triangle (e.g. a, b, c)

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


description: the intrinsic edge lengths for specified tri ordered to match the edges returned by ::GetEdges(TID)

code: FVector3d GetTriEdgeLengths ( const int32 TID ) const


description: edge ids for the three sides of the triangle (e.g. ab, bc, ca)

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


description: the interior angle of specified triangle corner

code: double GetTriInternalAngleR ( const int32 TID, const int32 IndexOf ) const


description: the r3 position of the specified vertex

code: FVector3d GetVertex ( int32 VertexID ) const


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

code: int32 GetVtxEdgeCount ( int32 VID ) const


className: InvalidID

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

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


description: true if specified edge is on the boundary of intrinsic mesh

code: bool IsBoundaryEdge ( int32 EdgeID ) const


description: true if the specified vertex is adjacent to a boundary edge

code: bool IsBoundaryVertex ( int32 VertexID ) const


description: true if intrinsic mesh contains specified edge

code: bool IsEdge ( int32 EdgeID ) const


description: true if intrinsic mesh contains specified triangle

code: bool IsTriangle ( int32 TriangleID ) const


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

code: int32 MaxEdgeID() const


description: true if intrinsic mesh contains specified vertex

code: bool IsVertex ( int32 VertexID ) const


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

code: int32 MaxTriangleID() const


description: upper bound on the vertex ID used in the mesh. i.e. all edge IDs < MaxVertexID

code: int32 MaxVertexID() const


description: Cyclic permutation of the src vector such that the 'Index' entry in the src is the first entry in the result NB:Indexmust be 0, 1, or 2.

code: template<typename Vector3Type> Vector3Type Permute ( int32 Index, const Vector3Type & Src ) const


description: Replace tOld with tNew in an existing edge

code: int32 ReplaceEdgeTriangle ( int32 eID, int32 tOld, int32 tNew )


description: Replace eOld with eNew in and existing triangle

code: int32 ReplaceTriangleEdge ( int32 tID, int32 eOld, int32 eNew )


description: Reset the mesh to an ID-matching deep copy the basic mesh topology (but no attributes or groups)

code: void Reset ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & SrcMesh )


description: Update the existing edge to reference triangles t0 and t1

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


description: Update the existing edge to reference vertices 'a' and 'b'.

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


description: number of triangles in the intrinsic mesh

code: int32 TriangleCount() const


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


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

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


code: FSimpleIntrinsicEdgeFlipMesh()


description: FSimpleIntrinsicEdgeFlipMeshMethods

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


code: FSimpleIntrinsicEdgeFlipMesh ( const [FSimpleIntrinsicEdgeFlipMesh](API\Plugins\DynamicMesh\Operations\FSimpleIntrinsicEdgeFlipMesh) & )


className: FSimpleIntrinsicEdgeFlipMesh

description: In addition to managing vertices, triangles and edges this class also tracks edge lengths (as measured on the surface mesh) and for convenience the internal angles for each triangle.

code: class FSimpleIntrinsicEdgeFlipMesh

AddOneModThree

type: const int32[3]

EdgeRefCounts

type: FRefCountVector

VertexEdgeLists

type: FSmallListSet


description: Add new edge to the mesh topology, does not update any of the intrinsic quantities

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


description: Allocate, or clear existing edge list for specified vertex

code: void AllocateEdgesList ( int32 VertexID )


description: Add new triangle to the mesh topology, does not update any of the intrinsic quantities

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


description: Add new vertex to the mesh topology, does not update any of the intrinsic quantities

code: int32 AppendVertex ( const FVector3d & vPos )


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

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


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

code: [EMeshResult](API\Runtime\GeometryCore\UE__Geometry__EMeshResult) PokeTriangle ( int32 TID, const FVector3d & BaryCoordinates, [FPokeTriangleInfo](API\Plugins\DynamicMesh\Operations\FSimpleIntrinsicMesh\FPokeTriangleInfo) & PokeInfo )


description: FSimpleIntrinsicMeshMethods

code: [EMeshResult](API\Runtime\GeometryCore\UE__Geometry__EMeshResult) PokeTriangleTopology ( int32 TID, [FPokeTriangleInfo](API\Plugins\DynamicMesh\Operations\FSimpleIntrinsicMesh\FPokeTriangleInfo) & PokeInfo )


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

code: [EMeshResult](API\Runtime\GeometryCore\UE__Geometry__EMeshResult) SplitEdge ( int32 EdgeAB, [FEdgeSplitInfo](API\Plugins\DynamicMesh\Operations\FSimpleIntrinsicMesh\FEdgeSplitInfo) & SplitInfo, double SplitParameterT )


description: Updates the mesh connectivity by adding a new vertex at the vertex-averaged location. Note: this does not update any of the intrinsic lengths, positions, angles, etc. those quantities must be updated after. See ::SplitEdge()

code: [EMeshResult](API\Runtime\GeometryCore\UE__Geometry__EMeshResult) SplitEdgeTopology ( int32 EdgeAB, [FEdgeSplitInfo](API\Plugins\DynamicMesh\Operations\FSimpleIntrinsicMesh\FEdgeSplitInfo) & SplitInfo )


description: Constructor does ID-matching deep copy the basic mesh topology (but no attributes or groups)

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


className: FSimpleIntrinsicMesh

description: FIntrinsicMeshandFIntrinsicTriangulationare derived from this class and each maintain their own connection with the surface mesh ( "normal coordinates" or "signpost data") that can track these surface mesh locations and can be used to reconstruct paths (e.g. intrinsic edges) on the surface mesh.

code: class FSimpleIntrinsicMesh : public [UE::Geometry::FSimpleIntrinsicEdgeFlipMesh](API\Plugins\DynamicMesh\Operations\FSimpleIntrinsicEdgeFlipMesh)


description: if true, abort the computation.

code: virtual bool Cancelled()


className: ESplitVertexModel

description: How to deal with the split vertices.

code: enum ESplitVertexModel { SetAllToSmoothed, BlendWithSmoothed, }


className: EEdgeWeights

code: enum EEdgeWeights { Uniform = 0, EdgeLength = 1, CotanWeights = 2, }


description: the index of the vertex into ExpandedSelection array if Selection is not empty, otherwise returns VertexID.

code: int32 MeshVIDToSelectionIdx ( int32 VertexID ) const


description: true if the algorithm succeeds, false if it failed or was canceled by the user.

code: template<typename RealType, int ElementSize> bool SmoothOverlay ( [TDynamicMeshOverlay](API\Runtime\GeometryCore\DynamicMesh\TDynamicMeshOverlay)< RealType, ElementSize > * InOverlay, const [TArray](API\Runtime\Core\Containers\TArray)< bool > & DimensionsToSmooth )


code: FSimpleIntrinsicMesh ( const [FSimpleIntrinsicMesh](API\Plugins\DynamicMesh\Operations\FSimpleIntrinsicMesh) & )


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


code: virtual ~FSmoothDynamicMeshAttributes()


className: FSmoothDynamicMeshAttributes

description: // Run the smoothing BlurOp.SmoothOverlay(Colors);

code: class FSmoothDynamicMeshAttributes

BlendWithSmoothedStrength

type: double

description: Control the amount of blending between the final smoothed value and the original element value.

bUseParallel

type: bool

description: Enable/disable multi-threading.

CotangentEdgeWeights

type: TArray< double ...

EdgeWeightMethod

type: EEdgeWeights

ExpandedSelection

type: TArray< int32 >

description: If Selection array is not empty, will contain all vertices in Selection plus one-ring neighbors for each vertex.

NumIterations

description: The number of smoothing iterations.

Progress

description: Optional InputsSet this to be able to cancel the running operation.

Selection

description: Subset of points to smooth.

SplitVertexModel

type: ESplitVertexMod...

Strength

description: The strength of each smoothing iteration.

VIDToExpandedSelectionIdx

type: TMap< int32, in...

description: Maps mesh Vertex ID to ExpandedSelection index.


description:
Compute smoothed weights at a vertex and write the result into FDynamicMeshVertexSkinWeightsAttribute passed upon construction.
true if the algorithm succeeds, false if it failed or was canceled by the user.

code: bool SmoothWeightsAtVertex ( const int32 VertexID, const float VertexFalloff )


description:
Compute smoothed weights at vertices and neighbors within distance and write the result into FDynamicMeshVertexSkinWeightsAttribute passed upon construction.
true if the algorithm succeeds, false if it failed or was canceled by the user.

code: bool SmoothWeightsAtVerticesWithinDistance ( const [TArray](API\Runtime\Core\Containers\TArray)< int32 > & Vertices, const float Strength, const double FloodFillUpToDistance, const int32 NumIterations )


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


code: FSmoothDynamicMeshVertexSkinWeights ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * InSourceMesh, const [FName](API\Runtime\Core\UObject\FName) InProfile )


code: FSmoothDynamicMeshVertexSkinWeights ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * InSourceMesh, [FDynamicMeshVertexSkinWeightsAttribute](API\Runtime\GeometryCore\DynamicMesh\FDynamicMeshVertexSkinWeightsAtt-) * InAttribute )


className: FSmoothDynamicMeshVertexSkinWeights

description: // Run the operator const float SmoothStrength = 0.2; if (SmoothBoneWeights.Validate() ==EOperationValidationResult::Ok) { for (const int32 VertexID : VerticesToSmooth) { SmoothBoneWeights.SmoothWeightsAtVertex(VertexID, SmoothStrength); } }

code: class FSmoothDynamicMeshVertexSkinWeights : public [UE::Geometry::TSmoothBoneWeights< FBoneIndexType, float >](API\Plugins\DynamicMesh\Operations\TSmoothBoneWeights)

Attribute

type: FDynamicMeshVer...

SkinWeightsAttributeDataSource

type: TUniquePtr<TBo...


className: FSmoothFillOptions

description: Fill parameters

code: struct FSmoothFillOptions

bConstrainToHoleInterior

description: If this is true, we don't modify any triangles outside hole (often results in lower-quality fill)

bProjectDuringRemesh

description: Whether to use projection in the post-smooth remeshing

FillDensityScalar

description: Controls the target edge length during remeshing.

InteriorSmoothness

description: Controls the trade off between smoothness in the fill region vs faithfulness to the original fill surface.

RemeshingExteriorRegionWidth

type: int

description: If we are not constraining remeshing to the fill interior, how many one-rings outside of the fill should we include in remeshing.

SmoothingExteriorRegionWidth

description: Number of one-rings to include when smoothing the fill region.

SmoothingInteriorRegionWidth

description: Smoothing constraint falloff region from border into the interior


code: void ConstrainSubregionSeams ( [FSubRegionRemesher](API\Plugins\DynamicMesh\FSubRegionRemesher) & Remesher, bool bConstrainROIBoundary )


code: void DefaultConfigureRemesher ( [FSubRegionRemesher](API\Plugins\DynamicMesh\FSubRegionRemesher) & Remesher, bool bConstrainROIBoundary )


code: virtual bool Fill ( int32 GroupID )


code: void SmoothAndRemesh ( [FMeshFaceSelection](API\Runtime\GeometryCore\Selections\FMeshFaceSelection) & tris )


code: void SmoothAndRemeshPreserveRegion ( [FMeshFaceSelection](API\Runtime\GeometryCore\Selections\FMeshFaceSelection) & tris, bool bFinal )


code: FSmoothHoleFiller ( [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, const [FEdgeLoop](API\Runtime\GeometryCore\FEdgeLoop) & FillLoop )


className: FSmoothHoleFiller

description: This fills a hole in a mesh by doing a trivial fill, then doing a remesh, then a laplacian smooth, then a second remesh.

code: class FSmoothHoleFiller : public [UE::Geometry::IHoleFiller](API\Plugins\DynamicMesh\Operations\IHoleFiller)

FillLoop

type: constFEdgeLoop...

description: Loop to fill.

FillOptions

type: FSmoothFillOpti...

Mesh

description: Mesh to operate on.

RemeshingTargetEdgeLength

description: Initialized to the average edge length of FillLoop / FillDensityScalar


className: EPositionType

code: enum EPositionType { Vertex, Edge, Triangle, }


className: FSurfacePositionUnion

code: union FSurfacePositionUnion

EdgePosition

type: FEdgePosition

TriPosition

type: FTrianglePositi...

VertexPosition

type: FVertexPosition


className: FTrianglePosition

code: struct FTrianglePosition


className: FVertexPosition

code: struct FVertexPosition


description: FSurfacePoint

code: FSurfacePoint()


code: FSurfacePoint ( const int32 VID )


code: FSurfacePoint ( const int32 EdgeID, const double Alpha )


className: FEdgePosition

code: struct FEdgePosition


code: FSurfacePoint ( const int32 TriID, const FVector3d & BaryCentrics )


className: FSurfacePoint

description: Location on an extrinsic (surface) mesh stored as a union.

code: struct FSurfacePoint

Position

type: FSurfacePositio...

PositionType

type: EPositionType


description: Express the vector in terms of a basis that is aligned with the EdgeIndex edge of the triangle.

code: FVector2d ChangeBasis ( const FVector2d & Vec, int32 EdgeIndex ) const


description: EdgeIndex = 0, 1, 2.

code: double DistanceToEdge ( int EdgeIndex, const FVector2d & Point ) const


description: Barycentric coords for this point in the tri2d.

code: FVector3d GetBarycentricCoords ( const FVector2d & PoinInTri2 ) const


description: Convert a point on this tri, to Barycentric coords in the un-rotated source triangle.

code: FVector3d GetBarycentricCoordsInSrcTri ( const FVector2d & PoinInTri2 ) const


description: Closest Point on the edge, given in terms of 0,1 parameter measured along the edge (EdgeIndex = 0, 1, 2)

code: double ProjectOnEdge ( int EdgeIndex, const FVector2d & Point ) const


description: Convert vertex data ordered for thisFTangentTri2into vertex data ordered for the source 3d triangle.

code: template<typename Vector3Type> Vector3Type ReorderVertexDataForSrcTri3d ( const Vector3Type & DataOrderedForTri2d ) const


description: Reset just invalidates Tri3ID.

code: void Reset()


description: The PrimaryEdge will be aligned with the x-axis in 2d ( and must be one of the edges of the triangle indicated by TriID)

code: FTangentTri2 ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, int32 TriID, int32 PrimaryEdgeID )


description: Vertices should be passed in CW order.

code: void ComputeInnerConcentricTriangle ( const FVector3d & U, const FVector3d & V, const FVector3d & W, const int EdgeTessellationLevel, FVector3d & InnerU, FVector3d & InnerV, FVector3d & InnerW ) const


description: the number of new vertices added along the edge patch. If InEdgeID is not valid then return FTessellationPattern::InvalidIndex.

code: int GetNumberOfNewVerticesForEdgePatch ( const int InEdgeID ) const


description: the number of new vertices added inside the triangle patch (i.e. exclude vertices added along edges). If InTriangleID is not valid then return FTessellationPattern::InvalidIndex.

code: int GetNumberOfNewVerticesForTrianglePatch ( const int InTriangleID ) const


className: EdgePatch

description: Represents an abstract edge as a parameterized line segment with two endpoints [v1,v2]. Contains information about the linear interpolation parameter of the new vertices added along the edge and their vertex IDs.  O----x----x----x----O           x  -  New vertices added. We only store their lerp coefficients (t1,t2,t3)v1 a1 a2 a3 v2 with respect to the end points, s.t. a_i = vi + t_i*(v2-v1).

code: struct EdgePatch

LinearCoord

type: TArrayView< dou...

VIDs

type: TArrayView< int...


description: the number of triangles that will be generated after tessellating the patch. If InTriangleID is not valid then return FTessellationPattern::InvalidIndex.

code: int GetNumberOfPatchTriangles ( const int InTriangleID ) const


className: InvalidIndex

code: static constexpr int InvalidIndex = -1;


description: Tessellate the edge patch by generating linear interpolation coefficients for each new vertex and storing the result in theEdgePatch.LinearCoord.

code: void TessellateEdgePatch ( [EdgePatch](API\Plugins\DynamicMesh\Operations\FTessellationPattern\EdgePatch) & EdgePatch ) const


description: Tessellate the triangle patch by generating new vertices inside the triangle. Compute the barycentric coordinates of the new vertices and store them in the TriPatch.BaryCoord. Using the vertices generated in the edge patches and inside the triangle patch, generate new triangles and store the result in the TriPatch.Triangles.

code: void TessellateTriPatch ( [TrianglePatch](API\Plugins\DynamicMesh\Operations\FTessellationPattern\TrianglePatch) & TriPatch ) const


className: TrianglePatch

description: Represents an abstract triangle patch with corners [u,v,w], s.t. u = (1,0,0), v = (0,1,0), w = (0,0,1). Contains information about the barycentric coordinates and IDs of the new vertices and the new triangles generated during the tessellation.

code: struct TrianglePatch

BaryCoord

type: TArrayView< FVe...

description: Barycentric coordinates of the inner vertices.

TriangleID

description: ID of the triangle in the original mesh this patch represents.

Triangles

type: TArrayView<FIn...

description: Triangles the patch is split into.

UVEdge

type: EdgePatch

description: Edge patches.

UVWCorners

description: Vertex IDs of the 3 corners of the patch. These are the triangle vertex IDs in the original mesh.

description: Vertex IDs of the inner vertices added inside the triangle.


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


code: virtual ~FTessellationPattern()


className: FTessellationPattern

description:
Using the new vertices (along edges and inside the triangle), provide connectivity for a triangle patch by
stitching those vertices together and creating triangles.

code: class FTessellationPattern

Mesh

type: constFDynamicM...


className: FTraceResult

code: struct FTraceResult

Barycentric

description: Information about the surface point //

bIsEdgePoint

type: bool

Classification

type: ETraceClassific...

EdgeAlpha

type: double

SurfaceDirection

type: FMeshSurfaceDir...


className: ETransferBoneWeightsMethod

code: enum ETransferBoneWeightsMethod { ClosestPointOnSurface = 0, InpaintWeights = 1, }


description:
Find the closest point on the surface of the source mesh and return the ID of the triangle containing it and its barycentric coordinates.
true if point is found, false otherwise

code: bool FindClosestPointOnSourceSurface ( const FVector3d & InPoint, const [FTransformSRT3d](API\Runtime\GeometryCore\FTransformSRT3d) & InToWorld, int32 & OutTriID, FVector3d & OutBary )


description: if true, abort the computation.

code: virtual bool Cancelled()


description:
Assumes that the InOutTargetMesh has bone attributes, use bIgnoreBoneAttributes flag to ignore the bone attributes and skip re-indexing.
true if the algorithm succeeds, false if it failed or was canceled by the user.

code: virtual bool TransferWeightsToMesh ( [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & InOutTargetMesh, const [FName](API\Runtime\Core\UObject\FName) & InTargetProfileName )


description:
Compute the bone weights for a given point using theETransferBoneWeightsMethod::ClosestPointOnSurfacealgorithm.
true if the algorithm succeeds, false if it failed to find the matching point or was canceled by the user.

code: virtual bool TransferWeightsToPoint ( [UE::AnimationCore::FBoneWeights](API\Runtime\AnimationCore\FBoneWeights) & OutWeights, const FVector3d & InPoint, const [TMap](API\Runtime\Core\Containers\TMap)< [FName](API\Runtime\Core\UObject\FName), uint16 > * TargetBoneToIndex, const FVector3f & InNormal )


description:
Add specialization in the source file for template types you want to use. Currently supporting int for BoneIndexType and float for BoneFloatWeightType, PosVectorType, NormalVectorType
true if the algorithm succeeds, false if it failed to find the matching point or was canceled by the user.

code: template<typename BoneIndexType, typename BoneFloatWeightType, typename PosVectorType, typename NormalVectorType> bool TransferWeightsToPoint ( [TArray](API\Runtime\Core\Containers\TArray)< BoneIndexType > & OutBones, [TArray](API\Runtime\Core\Containers\TArray)< BoneFloatWeightType > & OutWeights, const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< PosVectorType > & InPoint, const [TMap](API\Runtime\Core\Containers\TMap)< [FName](API\Runtime\Core\UObject\FName), uint16 > * TargetBoneToIndex, const [UE::Math::TVector](API\Runtime\Core\Math\TVector)< NormalVectorType > & InNormal )


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


description: Assumes that the InSourceMesh has bone attributes, use bIgnoreBoneAttributes flag to ignore the bone attributes and skip re-indexing.

code: FTransferBoneWeights ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * InSourceMesh, const [FName](API\Runtime\Core\UObject\FName) & InSourceProfileName, const [FDynamicMeshAABBTree3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMeshAABBTree3) * SourceBVH )


code: virtual ~FTransferBoneWeights()


className: FTransferBoneWeights

description: // After the transfer you can check which target mesh vertices had the weight transferred directly from the source mesh // via theFTransferBoneWeights:MatchedVertices array

code: class FTransferBoneWeights

bIgnoreBoneAttributes

description: Completely ignore the source and target mesh bone attributes when transferring weights from one dynamic mesh to another.

bUseIntrinsicLaplacian

description: If true, will use the intrinsic Delaunay mesh to construct sparse Cotangent Laplacian matrix.

bUseParallel

description: Enable/disable multi-threading.

ForceInpaint

type: TArray< float >

description: Optional mask where if ForceInpaint[VertexID] != 0 we want to force the weights for the vertex to be computed automatically.

ForceInpaintWeightMapName

type: FName

description: Alternatively, if the mask is stored as a target mesh weight map attribute, specify its name.

InternalSourceBVH

type: TUniquePtr<FDy...

description: If the caller doesn't pass BVH for the source mesh then we compute one.

InternalSourceMeshNormals

type: TUniquePtr<FMe...

description: If the source mesh doesn't have per-vertex normals then compute them

LayeredMeshSupport

description: If true, when the closest point doesn't pass the normal threshold test, will try again with a flipped normal.

MatchedVertices

type: TArray< bool >

description: OutputsMatchedVertices[VertexID] is set to true for a target mesh vertex ID with a match found, false otherwise.

NormalThreshold

description: Maximum angle (in radians) difference between target and source point normals to be considred a match.

NumSmoothingIterations

description: The number of optional post-processing smoothing iterations applied to the vertices without the match.

Progress

type: FProgressCancel...

description: Optional InputsSet this to be able to cancel the running operation.

SearchRadius

description: Optional Inputs forETransferBoneWeightsMethod::InpaintWeightsmethodRadius for searching the closest point.

SmoothingStrength

type: float

description: The strength of each post-processing smoothing iteration.

SourceBVH

description: The caller can optionally specify the source mesh BVH in case this operator is run on multiple target meshes while the source mesh remains the same.

SourceMesh

description: Source mesh we are transfering weights from.

SourceProfileName

description: The name of the source mesh skinning profile name.

TargetToWorld

description: Transform applied to the input target mesh or target point before transfer.

TransferMethod

type: ETransferBoneWe...

description: The transfer method to compute the bone weights.


description: If this returns true, abort computation.


description:
Generate tessellated geometry.
true if the algorithm succeeds, false if it failed or was cancelled by the user.

code: virtual bool Compute()


description: The number of triangles after the tessellation.

code: static int32 ExpectedNumTriangles ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, const int32 TessellationNum )


description: The number of vertices after the tessellation.

code: static int32 ExpectedNumVertices ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, const int32 TessellationNum )


description: Tessellate the mesh inplace. If the tessellation fails or the user cancelled the operation, OutMesh will not be changed.

code: FUniformTessellate ( [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * OutMesh )


description: Tessellate the mesh and write the result into another mesh. This will overwrite any data stored in the OutMesh.

code: FUniformTessellate ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * Mesh, [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * OutMesh )


code: virtual ~FUniformTessellate()


className: FUniformTessellate

description: Note: Currently does not support interpolation of the GenericAttributes besides Skin Weights.        o                                 o/ \     TessellationNum = 2       / \/   \                             /   \/     \                           x-----x/       \    FUniformTessellate   / \   / \/         \    ------------->     /   \ /   \/           \                     x-----*-----x/             \                   / \   / \   / \/ \ / \ / \ / \ o--------------o o--x--x--o

code: class FUniformTessellate

bComputeMappings

description: If true, populate VertexMap, VertexEdgeMap, VertexTriangleMap.

bInPlace

description: If true, the mesh to tessellate is contained in the ResultMesh and will be overwritten with the tessellation result.

bUseParallel

description: Should multi-threading be enabled.

Mesh

description: Points to either the input mesh to be used to generate the new tessellated mesh or will point to a copy of the mesh we are tessellating inplace.

Progress

description: InputsSet this to be able to cancel running operation.

ResultMesh

description: Input/OutputThe tessellated mesh.

TessellationNum

type: int

description: Determines the number of triangles we generate.

VertexEdgeMap

type: TMap< int32,FI...

description: Map the ID of the vertex inserted along the input mesh edge to the input mesh triangle IDs (t1,t2) that share that edge.

VertexMap

type: TArray< int32 >

description: Output Map the vertex ID in the input mesh to the corresponding vertex ID in the output mesh.

VertexTriangleMap

type: TMap< int32, in...

description: Map the ID of the vertex inserted inside the input mesh triangle to the triangle's ID.


description: Save this vertex. Does not check that VertexID hasn't already been added.

code: void AddVertex ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * Mesh, int VertexID )


description: Apply saved positions to Mesh

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


description:
Checks for edges between terminating vertices of the input spans and attempts to delete them if possible by deleting the adjacent triangle. These cases would prevent MergeEdges() from succeeding because it won't implicitly collapse/delete triangles which connect the two edges being merged.
EWeldResult::OK on success


className: FVertexPositionCache

description: Basic cache of vertex positions.

code: class FVertexPositionCache

Positions

type: TArray< FVector...

Vertices

type: TArray< int >


description:
Protected Functions
EWeldResult::OK on success


className: EWeldResult

code: enum EWeldResult { Ok = 0, Failed_EdgesNotBoundaryEdges = 10, Failed_CannotSplitEdge = 21, Failed_TriangleDeletionDisabled = 22, Failed_CannotDeleteTriangle = 23, Failed_Other = 100, }


description:
Splits largest edges of the span with fewest vertices so that both input spans have an equal number of vertices and edges after
EWeldResult::OK on success


description:
Welds edge sequence together
EWeldResult::OK on success


code: FWeldEdgeSequence ( [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * Mesh, [FEdgeSpan](API\Runtime\GeometryCore\FEdgeSpan) SpanDiscard, [FEdgeSpan](API\Runtime\GeometryCore\FEdgeSpan) SpanKeep )


className: FWeldEdgeSequence

description: User can optionally allow triangle deletion which handles cases where the group edges are connected by an edge at the end points.

code: class FWeldEdgeSequence

bAllowFailedMerge

type: bool

description: When true, failed calls to MergeEdges() will be handled by moving the edges without merging such that the final result appears to be welded but has invisible seam(s) instead of just failing.

bAllowIntermediateTriangleDeletion

description: Whether triangle deletion is allowed in order to merge edges which are connected by a different edge This specifically determines howCheckForAndCollapseSideTriangles()behaves

EdgeSpanToDiscard

type: FEdgeSpan

Mesh

description: Inputs/Outputs

UnmergedEdgePairsOut

type: TArray< TPair< ...

description: This is populated with pairs of eids which were not able to be merged.


className: IHoleFiller

code: class IHoleFiller


description: Try to compute a good "Frame" for the selected Triangles of the Mesh. Only the largest triangle-connected-component of Triangles is considered. The Frame Z is aligned with the area-weighted average normal of the connected triangles. Initially the Frame is placed at the area-weighted centroid of the connected triangles. Rays are cast along Z in both directions, if either hits, the Frame is translated to the nearer hit.

code: namespace UE { namespace Geometry { [FFrame3d](API\Runtime\GeometryCore\FFrame3d_1) UE::Geometry::ComputeFaceSelectionFrame ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, const [TArray](API\Runtime\Core\Containers\TArray)< int32 > & Triangles, bool bIsDefinitelySingleComponent ) } }


description:
Alters the existing mesh by welding two edge sequences, preserving sequence A. Conditions the mesh by splitting edges and optionally deleting triangles.
EWeldResult::OK on success


description:
Compute inclusive range [0...N] of MaterialID values currently in use on Mesh (ie range always includes 0)
true if MaterialIDs attribute exists (if false, Range is returned as [0,0])

code: namespace UE { namespace Geometry { bool UE::Geometry::ComputeMaterialIDRange ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, [FInterval1i](API\Runtime\GeometryCore\FInterval1i) & MaterialIDRange ) } }


description:
Compute a MaterialID for each edge along the VertexPath based on the MaterialID of adjacent triangles. Currently, for each Edge, EdgeTriangle.A is used.
true if MaterialIDs attribute exists

code: namespace UE { namespace Geometry { bool UE::Geometry::ComputeMaterialIDsForVertexPath ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, const [TArray](API\Runtime\Core\Containers\TArray)< int32 > & VertexPath, bool bIsLoop, [TArray](API\Runtime\Core\Containers\TArray)< int32 > & EdgeMaterialIDsOut, int32 FallbackMaterialID ) } }


description: Bone ID of the bone stored at an indexIndex, whereIndexis between 0 and GetBoneNum(InVertexIDs).

code: BoneIndexType GetBoneIndex ( const int32 InVertexIDs, const int32 Index )


description: Bone weight of the bone stored at an indexIndex, whereIndexis between 0 and GetBoneNum(InVertexIDs).

code: BoneWeightType GetBoneWeight ( const int32 InVertexIDs, const int32 Index )


description: Number of bones at a vertex.

code: int32 GetBoneNum ( const int32 InVertexIDs )


description: Bone weight of the bone with Bone ID at a vertex. Must return 0 if bone has no influence.

code: BoneWeightType GetWeightOfBoneOnVertex ( const int32 InVertexIDs, const BoneIndexType BoneIndex )


code: virtual ~TBoneWeightsDataSource()


className: TBoneWeightsDataSource

description: Interface for getting the bone weights data. Should be subclassed and implemented if the bone weights data is not stored using the FDynamicMeshVertexSkinWeightsAttribute.

code: template<typename BoneIndexType, typename BoneWeightType> class TBoneWeightsDataSource


description: TEdgeCorrespondence

code: void Setup ( const IntrinsicMeshType & IntrinsicMesh )


description: Array of FSurfacePoints relative to the ExtrinsicMesh that represent the specified intrinsic mesh edge. This is directed relative to traversal of the first adjacent triangle (GetEdgeT().[0]), unless bReverse is true

code: [TArray](API\Runtime\Core\Containers\TArray)< [UE::Geometry::IntrinsicCorrespondenceUtils::FSurfacePoint](API\Plugins\DynamicMesh\Operations\FSurfacePoint) > TraceEdge ( int32 IntrinsicEID, double CoalesceThreshold, bool bReverse ) const


code: TEdgeCorrespondence ( const IntrinsicMeshType & IntrinsicMesh )


className: TEdgeCorrespondence

description: This is only for use with intrinsic mesh implementations that support 'normal coordinates' when doing flips/splits and pokes. such as theFIntrinsicMeshandFIntrinsicEdgeFlipMesh.

code: template<typename IntrinsicMeshType> struct TEdgeCorrespondence

IntrinsicMesh

type: const Intrinsic...

SurfaceEdgesCrossed

type: TArray<TArray<...

SurfaceMesh

type: constFDynamicM...


description:
Remove the occluded triangles  single instance case w/out precomputed winding tree
true on success

code: virtual bool Apply ( const [FTransformSRT3d](API\Runtime\GeometryCore\FTransformSRT3d) & MeshLocalToOccluderSpace, [TMeshAABBTree3](API\Runtime\GeometryCore\Spatial\TMeshAABBTree3)< OccluderTriangleMeshType > * Occluder )


description:
Remove the occluded triangles, considering the given occluder AABB tree (which may represent more geometry than a single mesh) See simpler invocations below for the single instance case or the case where you'd like the spatial data structures built for you
true on success

code: virtual bool Apply ( const [TArrayView](API\Runtime\Core\Containers\TArrayView)< const [FTransformSRT3d](API\Runtime\GeometryCore\FTransformSRT3d) > MeshLocalToOccluderSpaces, [TMeshAABBTree3](API\Runtime\GeometryCore\Spatial\TMeshAABBTree3)< OccluderTriangleMeshType > * Spatial, [TFastWindingTree](API\Runtime\GeometryCore\CompGeom\TFastWindingTree)< OccluderTriangleMeshType > * FastWindingTree )


description:
Remove the occluded triangles  single instance case
true on success

code: virtual bool Apply ( const [FTransformSRT3d](API\Runtime\GeometryCore\FTransformSRT3d) & MeshLocalToOccluderSpace, [TMeshAABBTree3](API\Runtime\GeometryCore\Spatial\TMeshAABBTree3)< OccluderTriangleMeshType > * Spatial, [TFastWindingTree](API\Runtime\GeometryCore\CompGeom\TFastWindingTree)< OccluderTriangleMeshType > * FastWindingTree )


description:
Remove the occluded triangles, considering the given occluder AABB trees (which may represent more geometry than a single mesh) See simpler invocations below for the single instance case or the case where you'd like the spatial data structures built for you
true on success

code: virtual bool Apply ( const [TArrayView](API\Runtime\Core\Containers\TArrayView)< const [FTransformSRT3d](API\Runtime\GeometryCore\FTransformSRT3d) > MeshLocalToOccluderSpaces, const [TArrayView](API\Runtime\Core\Containers\TArrayView)< [TMeshAABBTree3](API\Runtime\GeometryCore\Spatial\TMeshAABBTree3)< OccluderTriangleMeshType > * > Spatials, const [TArrayView](API\Runtime\Core\Containers\TArrayView)< [TFastWindingTree](API\Runtime\GeometryCore\CompGeom\TFastWindingTree)< OccluderTriangleMeshType > * > FastWindingTrees, const [TArrayView](API\Runtime\Core\Containers\TArrayView)< const [FTransformSRT3d](API\Runtime\GeometryCore\FTransformSRT3d) > SpatialTransforms, bool bTestOccludedByAny )


description: If this returns true, abort computation.

code: virtual bool Cancelled()


description: Remove triangles that were selected (the triangle IDs in the RemoveT array)

code: virtual bool RemoveSelected()


description:
Select the occluded triangles  single instance case w/out precomputed winding tree
true on success

code: virtual bool Select ( const [FTransformSRT3d](API\Runtime\GeometryCore\FTransformSRT3d) & MeshLocalToOccluderSpace, [TMeshAABBTree3](API\Runtime\GeometryCore\Spatial\TMeshAABBTree3)< OccluderTriangleMeshType > * Occluder )


description:
Select the occluded triangles, considering the given occluder AABB tree (which may represent more geometry than a single mesh) See simpler invocations below for the single instance case or the case where you'd like the spatial data structures built for you
true on success

code: virtual bool Select ( const [TArrayView](API\Runtime\Core\Containers\TArrayView)< const [FTransformSRT3d](API\Runtime\GeometryCore\FTransformSRT3d) > MeshLocalToOccluderSpaces, [TMeshAABBTree3](API\Runtime\GeometryCore\Spatial\TMeshAABBTree3)< OccluderTriangleMeshType > * Spatial, [TFastWindingTree](API\Runtime\GeometryCore\CompGeom\TFastWindingTree)< OccluderTriangleMeshType > * FastWindingTree )


description:
Select the occluded triangles  single instance case
true on success

code: virtual bool Select ( const [FTransformSRT3d](API\Runtime\GeometryCore\FTransformSRT3d) & MeshLocalToOccluderSpace, [TMeshAABBTree3](API\Runtime\GeometryCore\Spatial\TMeshAABBTree3)< OccluderTriangleMeshType > * Spatial, [TFastWindingTree](API\Runtime\GeometryCore\CompGeom\TFastWindingTree)< OccluderTriangleMeshType > * FastWindingTree )


description:
Select the occluded triangles, considering the given occluder AABB trees (which may represent more geometry than a single mesh) See simpler invocations below for the single instance case or the case where you'd like the spatial data structures built for you Selection will be stored in the RemovedT array, but no triangles will be removed.
true on success

code: virtual bool Select ( const [TArrayView](API\Runtime\Core\Containers\TArrayView)< const [FTransformSRT3d](API\Runtime\GeometryCore\FTransformSRT3d) > MeshLocalToOccluderSpaces, const [TArrayView](API\Runtime\Core\Containers\TArrayView)< [TMeshAABBTree3](API\Runtime\GeometryCore\Spatial\TMeshAABBTree3)< OccluderTriangleMeshType > * > Spatials, const [TArrayView](API\Runtime\Core\Containers\TArrayView)< [TFastWindingTree](API\Runtime\GeometryCore\CompGeom\TFastWindingTree)< OccluderTriangleMeshType > * > FastWindingTrees, const [TArrayView](API\Runtime\Core\Containers\TArrayView)< const [FTransformSRT3d](API\Runtime\GeometryCore\FTransformSRT3d) > SpatialTransforms, bool bTestOccludedByAny )


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


code: virtual ~TRemoveOccludedTriangles()


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


className: TRemoveOccludedTriangles

description: Note this class always removes triangles from anFDynamicMesh3, but can use any mesh type to define the occluding geometry (as long as the mesh type implements theTTriangleMeshAdapterfns)

code: template<typename OccluderTriangleMeshType> class TRemoveOccludedTriangles

AddRandomRays

description: Number of additional ray directions to add to raycast-based occlusion checks, beyond the default +/- major axis directions

AddTriangleSamples

description: Number of additional samples to add per triangle

bRemoveFailed

description: True if it wanted to remove triangles but the actual remove operation failed

InsideMode

type: EOcclusionCalcu...

NormalOffset

type: double

description: We nudge points out by this amount to try to counteract numerical issues

Progress

description: Set this to be able to cancel running operation

RemovedT

description: Outputsindices of removed triangles. will be empty if nothing removed

TriangleSamplingMethod

type: EOcclusionTrian...

description: Input settings

WindingIsoValue

description: Use this as winding isovalue for WindingNumber mode


description: if true, abort the computation.


description:
Compute smoothed weights at a vertex and return the result.
true if the algorithm succeeds, false if it failed or was canceled by the user.

code: virtual bool SmoothWeightsAtVertex ( const int32 VertexID, const BoneWeightType VertexFalloff, [TMap](API\Runtime\Core\Containers\TMap)< BoneIndexType, BoneWeightType > & OutFinalWeights )


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


code: TSmoothBoneWeights ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * InSourceMesh, [TBoneWeightsDataSource](API\Plugins\DynamicMesh\Operations\TBoneWeightsDataSource)< BoneIndexType, BoneWeightType > * InDataSource )


code: virtual ~TSmoothBoneWeights()


className: TSmoothBoneWeights

description:
// Run the operator const float SmoothStrength = 0.2; if (SmoothBoneWeights.Validate() ==EOperationValidationResult::Ok) { for (const int32 VertexID : VerticesToSmooth) { TMapFinalWeights; SmoothBoneWeights.SmoothWeightsAtVertex(VertexID, SmoothStrength, FinalWeights); // Use FinalWeights to modify your weights
 } }

code: template<typename BoneIndexType, typename BoneWeightType> class TSmoothBoneWeights

DataSource

type: TBoneWeightsDat...

description: Data source supplied by the caller.

MinimumWeightThreshold

type: BoneWeightType

description: Only consider the weights above the threshold.

Progress

type: FProgressCancel...

description: Optional InputsSet this to be able to cancel the running operation.


description: The same polar point (r, AngleR) can be described by an infinite number of alternative angles, each offset by some multiple of 2pi, i.e. (r, AngleR + n * 2Pi). This selects the unique angle that falls in the [0,2pi) range.

code: namespace UE { namespace Geometry { static double UE::Geometry::AsZeroToTwoPi ( double AngleR ) } }


description: For each edge in EdgeList, compute a line segment offset from the original edge by distance InsetDistance. Assumes that each Edge is a boundary edge and so Triangle0 of that edge defines "inside" direction.

code: namespace UE { namespace Geometry { void UE::Geometry::ComputeInsetLineSegmentsFromEdges ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, const [TArray](API\Runtime\Core\Containers\TArray)< int32 > & EdgeList, double InsetDistance, [TArray](API\Runtime\Core\Containers\TArray)< [FLine3d](API\Runtime\GeometryCore\FLine3d) > & InsetLinesOut ) } }


description:
Compute the total UVLength/MeshLength ratio along the given VertexPath. Other 3D lengths can then be scaled to comparable UV-space lengths by multiplying by this value. Edges must exist between the vertices along the path, and loops are not considered. Each UV edge for a 3D edge is considered, ie if a 3D edge corresponds to 2 UV edges, both are counted, and if the 3D edge has no UV edges, it is skipped.
UVPathLength / PathLength, or 1.0 if no valid UV edges along the path existed

code: namespace UE { namespace Geometry { double UE::Geometry::ComputeAverageUVScaleRatioAlongVertexPath ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, const [FDynamicMeshUVOverlay](API\Runtime\GeometryCore\DynamicMesh\FDynamicMeshUVOverlay) & UVOverlay, const [TArray](API\Runtime\Core\Containers\TArray)< int32 > & VertexPath, double * PathLengthOut, double * UVPathLengthOut ) } }


description: Create a new single UV island for the provided TriangleSet in the given Mesh/UVOverlay, by computing an ExpMap parameterization based on an automatically-detected midpoint of the triangle patch. The UV scale is determined automatically based on the UV/3D area ratio of triangles adjacent to the TriangleSet (using a ratio of 1 if the triangles have no neighbours).

code: namespace UE { namespace Geometry { void UE::Geometry::ComputeArbitraryTrianglePatchUVs ( [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, [FDynamicMeshUVOverlay](API\Runtime\GeometryCore\DynamicMesh\FDynamicMeshUVOverlay) & UVOverlay, const [TArray](API\Runtime\Core\Containers\TArray)< int32 > & TriangleSet ) } }


description: Compute a new set of GroupIDs along an edge loop under the assumption that the edge loop is about to be split and new geometry introduced. The decision is based on a provided EdgesShouldHaveSameGroupFunc function which is called with sequential pairs of edges. For example if this function returns true when the GroupIDs are the same on both edges, then this function will create a new GroupID for each sequential span of non-matching GroupIDs (ie often the "expected" behavior).

code: namespace UE { namespace Geometry { void UE::Geometry::ComputeNewGroupIDsAlongEdgeLoop ( [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, const [TArray](API\Runtime\Core\Containers\TArray)< int32 > & LoopEdgeIDs, [TArray](API\Runtime\Core\Containers\TArray)< int32 > & NewLoopEdgeGroupIDsOut, [TArray](API\Runtime\Core\Containers\TArray)< int32 > & NewGroupIDsOut, [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< bool(int32 Eid1, int32 Eid2)> EdgesShouldHaveSameGroupFunc ) } }


description: Create a new Normals "island" (ie surrounded by hard edges) for the QuadPatch of the Mesh,

code: namespace UE { namespace Geometry { void UE::Geometry::ComputeNormalsForQuadPatch ( [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, const [FQuadGridPatch](API\Plugins\DynamicMesh\Selections\FQuadGridPatch) & QuadPatch ) } }


description: Create a new UV Island for the QuadPatch triangles of the Mesh, and then assign UVs based on the grid layout.

code: namespace UE { namespace Geometry { bool UE::Geometry::ComputeUVIslandForQuadPatch ( [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, const [FQuadGridPatch](API\Plugins\DynamicMesh\Selections\FQuadGridPatch) & QuadPatch, double UVScaleFactor, int UVOverlayIndex ) } }


description: Forward declarations

code: namespace UE { namespace Geometry { enum ELatticeInterpolation { Linear = 0, Cubic = 1, } } }


description: Forward declarations

code: namespace UE { namespace Geometry { enum EMeshAttributeTransferType { MaterialID, } } }


description: Forward declarations

code: namespace UE { namespace Geometry { enum EMeshAttributeTransferError { InvalidSource, InvalidTarget, SourceMissingAttribute, TargetMissingAttribute, InvalidOperationForInputs, } } }


description: Forward declarations

code: namespace UE { namespace Geometry { enum EOcclusionTriangleSampling { Centroids = 0, Vertices = 1, VerticesAndCentroids = 2, } } }


description: Forward declarations

code: namespace UE { namespace Geometry { enum EOcclusionCalculationMode { FastWindingNumber = 0, SimpleOcclusionTest = 1, } } }


description:
Perform edge flips on intrinsic mesh until either the MaxFlipCount is reached or the mesh is fully Delaunay
the number of flips.

code: namespace UE { namespace Geometry { int32 UE::Geometry::FlipToDelaunay ( [FSimpleIntrinsicEdgeFlipMesh](API\Plugins\DynamicMesh\Operations\FSimpleIntrinsicEdgeFlipMesh) & IntrinsicMesh, [TSet](API\Runtime\Core\Containers\TSet)< int > & Uncorrected, const int32 MaxFlipCount ) } }


code: namespace UE { namespace Geometry { int32 UE::Geometry::FlipToDelaunay ( [FSimpleIntrinsicMesh](API\Plugins\DynamicMesh\Operations\FSimpleIntrinsicMesh) & IntrinsicMesh, [TSet](API\Runtime\Core\Containers\TSet)< int > & Uncorrected, const int32 MaxFlipCount ) } }


code: namespace UE { namespace Geometry { int32 UE::Geometry::FlipToDelaunay ( [FIntrinsicMesh](API\Plugins\DynamicMesh\Operations\FIntrinsicMesh) & IntrinsicMesh, [TSet](API\Runtime\Core\Containers\TSet)< int > & Uncorrected, const int32 MaxFlipCount ) } }


code: namespace UE { namespace Geometry { int32 UE::Geometry::FlipToDelaunay ( [FIntrinsicEdgeFlipMesh](API\Plugins\DynamicMesh\Operations\FIntrinsicEdgeFlipMesh) & IntrinsicMesh, [TSet](API\Runtime\Core\Containers\TSet)< int > & Uncorrected, const int32 MaxFlipCount ) } }


code: namespace UE { namespace Geometry { int32 UE::Geometry::FlipToDelaunay ( [FIntrinsicTriangulation](API\Plugins\DynamicMesh\Operations\FIntrinsicTriangulation) & IntrinsicMesh, [TSet](API\Runtime\Core\Containers\TSet)< int > & Uncorrected, const int32 MaxFlipCount ) } }


code: namespace UE { namespace Geometry { namespace GeodesicSingleTriangleUtils { static bool UE::Geometry::GeodesicSingleTriangleUtils::IsTerminated ( const [FTraceResult](API\Plugins\DynamicMesh\Operations\FTraceResult) & Result ) } } }


description: Classification for a trace result (i.e. for a points recorded along the path).

code: namespace UE { namespace Geometry { namespace GeodesicSingleTriangleUtils { enum ETraceClassification { Start, Continuing, DistanceTerminated, BoundaryTerminated, Failed, } } } }


description:
Functions for tracing across a single triangle on a mesh TraceFTangentTri2using a local coordinate system defined by aligning the first edge of the triangle with the positive x-direction and the opposing vertex with positive y-coordinate.
Trace Result.

code: namespace UE { namespace Geometry { namespace GeodesicSingleTriangleUtils { [FTraceResult](API\Plugins\DynamicMesh\Operations\FTraceResult) UE::Geometry::GeodesicSingleTriangleUtils::TraceTangentTriangle ( const [FTangentTri2](API\Plugins\DynamicMesh\Operations\FTangentTri2) & TangentTri2, const FVector2d & RayOrigin, const FVector2d & RayDir, double MaxDistance ) } } }


description:
Trace From an Edge crossing into the triangle TriID
NB: it is assumed the edge EID is part of the triangle TriID. ( otherwise the result will be unexpected) NB: it is assumed the BaryPoint is a valid point in the triangle ( otherwise the results will be unexpected)
Trace Result.

code: namespace UE { namespace Geometry { namespace GeodesicSingleTriangleUtils { [FTraceResult](API\Plugins\DynamicMesh\Operations\FTraceResult) UE::Geometry::GeodesicSingleTriangleUtils::TraceTriangleFromBaryPoint ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, const int32 TriID, const FVector3d & BaryPoint, const [FMeshSurfaceDirection](API\Plugins\DynamicMesh\Operations\FMeshSurfaceDirection) & Direction, [FTangentTri2](API\Plugins\DynamicMesh\Operations\FTangentTri2) & ScratchTangentTri2, double MaxDistance ) } } }


code: namespace UE { namespace Geometry { namespace GeodesicSingleTriangleUtils { [FTraceResult](API\Plugins\DynamicMesh\Operations\FTraceResult) UE::Geometry::GeodesicSingleTriangleUtils::TraceTriangleFromBaryPoint ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, const int32 TriID, const FVector3d & BaryPoint, const [FMeshSurfaceDirection](API\Plugins\DynamicMesh\Operations\FMeshSurfaceDirection) & Direction, double MaxDistance ) } } }


description:
Trace from a Vertex Crossing.
Trace Result.

code: namespace UE { namespace Geometry { namespace GeodesicSingleTriangleUtils { [FTraceResult](API\Plugins\DynamicMesh\Operations\FTraceResult) UE::Geometry::GeodesicSingleTriangleUtils::TraceFromVertex ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, const [FMeshTangentDirection](API\Plugins\DynamicMesh\Operations\FMeshTangentDirection) & Direction, double MaxDistance ) } } }


code: namespace UE { namespace Geometry { namespace GeodesicSingleTriangleUtils { [FTraceResult](API\Plugins\DynamicMesh\Operations\FTraceResult) UE::Geometry::GeodesicSingleTriangleUtils::TraceFromVertex ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, const [FMeshTangentDirection](API\Plugins\DynamicMesh\Operations\FMeshTangentDirection) & Direction, [FTangentTri2](API\Plugins\DynamicMesh\Operations\FTangentTri2) & ScratchTangentTri2, double MaxDistance ) } } }


description:
Trace from a Vertex Crossing.
NB: the direction vector is defined on the surface, not the tangent plane. This means, it must lie in a triangle adjacent to Direction.EdgeID
Trace Result.

code: namespace UE { namespace Geometry { namespace GeodesicSingleTriangleUtils { [FTraceResult](API\Plugins\DynamicMesh\Operations\FTraceResult) UE::Geometry::GeodesicSingleTriangleUtils::TraceFromVertex ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, int32 VID, const [FMeshSurfaceDirection](API\Plugins\DynamicMesh\Operations\FMeshSurfaceDirection) & Direction, double MaxDistance ) } } }


code: namespace UE { namespace Geometry { namespace GeodesicSingleTriangleUtils { [FTraceResult](API\Plugins\DynamicMesh\Operations\FTraceResult) UE::Geometry::GeodesicSingleTriangleUtils::TraceFromVertex ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, int32 VID, const [FMeshSurfaceDirection](API\Plugins\DynamicMesh\Operations\FMeshSurfaceDirection) & Direction, [FTangentTri2](API\Plugins\DynamicMesh\Operations\FTangentTri2) & ScratchTangentTri2, double MaxDistance ) } } }


description:
Trace From an Edge crossing into the triangle TriID
NB: it is assumed that the edge EID is part of the triangle TriID. (otherwise the result will be unexpected)
Trace Result.

code: namespace UE { namespace Geometry { namespace GeodesicSingleTriangleUtils { [FTraceResult](API\Plugins\DynamicMesh\Operations\FTraceResult) UE::Geometry::GeodesicSingleTriangleUtils::TraceTriangleFromEdge ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, const int32 TriID, double EdgeAlpha, const [FMeshSurfaceDirection](API\Plugins\DynamicMesh\Operations\FMeshSurfaceDirection) & Direction, double MaxDistance ) } } }


code: namespace UE { namespace Geometry { namespace GeodesicSingleTriangleUtils { [FTraceResult](API\Plugins\DynamicMesh\Operations\FTraceResult) UE::Geometry::GeodesicSingleTriangleUtils::TraceTriangleFromEdge ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, const int32 TriID, double EdgeAlpha, const [FMeshSurfaceDirection](API\Plugins\DynamicMesh\Operations\FMeshSurfaceDirection) & Direction, [FTangentTri2](API\Plugins\DynamicMesh\Operations\FTangentTri2) & ScratchTangentTri2, double MaxDistance ) } } }


description:
Trace, starting with the result of an earlier trace.
Trace Result.

code: namespace UE { namespace Geometry { namespace GeodesicSingleTriangleUtils { [FTraceResult](API\Plugins\DynamicMesh\Operations\FTraceResult) UE::Geometry::GeodesicSingleTriangleUtils::TraceNextTriangle ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, const [FTraceResult](API\Plugins\DynamicMesh\Operations\FTraceResult) & LastTrace, double MaxDistance ) } } }


code: namespace UE { namespace Geometry { namespace GeodesicSingleTriangleUtils { [FTraceResult](API\Plugins\DynamicMesh\Operations\FTraceResult) UE::Geometry::GeodesicSingleTriangleUtils::TraceNextTriangle ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, const [FTraceResult](API\Plugins\DynamicMesh\Operations\FTraceResult) & LastTrace, [FTangentTri2](API\Plugins\DynamicMesh\Operations\FTangentTri2) & ScratchTangentTri2, double MaxDistance ) } } }


description: the R3 position of this surface point as applied to the input Mesh on return bValidPoint will be false if the edge / vertex / triangle ID referenced by this surface point is not an element of the mesh in question

code: namespace UE { namespace Geometry { namespace IntrinsicCorrespondenceUtils { FVector3d UE::Geometry::IntrinsicCorrespondenceUtils::AsR3Position ( const [FSurfacePoint](API\Plugins\DynamicMesh\Operations\FSurfacePoint) & SurfacePoint, const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, bool & bValidPoint ) } } }


description: true if the SurfacePoint corresponds to a vertex

code: namespace UE { namespace Geometry { namespace IntrinsicCorrespondenceUtils { static bool UE::Geometry::IntrinsicCorrespondenceUtils::IsVertexPoint ( const [FSurfacePoint](API\Plugins\DynamicMesh\Operations\FSurfacePoint) & SurfacePoint ) } } }


description: true if the SurfacePoint corresponds to an edge

code: namespace UE { namespace Geometry { namespace IntrinsicCorrespondenceUtils { static bool UE::Geometry::IntrinsicCorrespondenceUtils::IsEdgePoint ( const [FSurfacePoint](API\Plugins\DynamicMesh\Operations\FSurfacePoint) & SurfacePoint ) } } }


description: true if the SurfacePoint corresponds to a face

code: namespace UE { namespace Geometry { namespace IntrinsicCorrespondenceUtils { static bool UE::Geometry::IntrinsicCorrespondenceUtils::IsFacePoint ( const [FSurfacePoint](API\Plugins\DynamicMesh\Operations\FSurfacePoint) & SurfacePoint ) } } }


description: Utility to walk around a vertex (VID) visiting the adjacent edges and triangles. Note: this isn't appropriate for bow-ties as it will terminate upon encountering a mesh edge. If the vertex is on the mesh boundary, StartEID should correspond to the first boundary edge allowing for a ccw traversal of the vertex-adjacent faces.

code: namespace UE { namespace Geometry { namespace IntrinsicCorrespondenceUtils { template<typename MeshType, typename FunctorType> bool UE::Geometry::IntrinsicCorrespondenceUtils::VisitVertexAdjacentElements ( const MeshType & Mesh, const int32 VID, const int32 StartEID, FunctorType & Functor ) } } }


description: For each vertex in VertexIDs, compute inset position based on list of precomputed inset lines and store in VertexPositionsOut. Assumption is that each vertex position was at the intersection point of the pre-inset lines, ie sequential edge-line-pairs determine each sequential vertex position

code: namespace UE { namespace Geometry { void UE::Geometry::SolveInsetVertexPositionsFromInsetLines ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, const [TArray](API\Runtime\Core\Containers\TArray)< [FLine3d](API\Runtime\GeometryCore\FLine3d) > & InsetEdgeLines, const [TArray](API\Runtime\Core\Containers\TArray)< int32 > & VertexIDs, [TArray](API\Runtime\Core\Containers\TArray)< FVector3d > & VertexPositionsOut, bool bIsLoop ) } }


description: Solve for a new inset position by finding the intersection point a pair of inset-lines (or handle parallel-lines case). Assumption is that Position is the location of the initial vertex on the pre-inset edge-line-pair, ie at their intersection point.

code: namespace UE { namespace Geometry { FVector3d UE::Geometry::SolveInsetVertexPositionFromLinePair ( const FVector3d & Position, const [FLine3d](API\Runtime\GeometryCore\FLine3d) & InsetEdgeLine1, const [FLine3d](API\Runtime\GeometryCore\FLine3d) & InsetEdgeLine2 ) } }


description: the length of the path, computed by suming the path segment lengths. Primarily for testing as the result should matchFDeformableEdgePath::GetPathLength()

code: namespace UE { namespace Geometry { double UE::Geometry::SumPathLength ( const [FDeformableEdgePath](API\Plugins\DynamicMesh\Operations\FDeformableEdgePath) & DeformableEdgePath ) } }


code: [TArray](API\Runtime\Core\Containers\TArray)< [FVector2i](API\Runtime\GeometryCore\FVector2i) > ActiveTiles() const


code: static [FVector2i](API\Runtime\GeometryCore\FVector2i) ClassifyBoundingBoxToUDIM ( const [FDynamicMeshUVOverlay](API\Runtime\GeometryCore\DynamicMesh\FDynamicMeshUVOverlay) * UVOverlay, const [FAxisAlignedBox2d](API\Runtime\GeometryCore\FAxisAlignedBox2d) & BoundingBox )


code: static [FVector2i](API\Runtime\GeometryCore\FVector2i) ClassifyPointToUDIM ( const FVector2f & UVPoint )


code: static [FVector2i](API\Runtime\GeometryCore\FVector2i) ClassifyTrianglesToUDIM ( const [FDynamicMeshUVOverlay](API\Runtime\GeometryCore\DynamicMesh\FDynamicMeshUVOverlay) * UVOverlay, [TArray](API\Runtime\Core\Containers\TArray)< int32 > Tids )


code: [TArray](API\Runtime\Core\Containers\TArray)< int32 > TidsForTile ( [FVector2i](API\Runtime\GeometryCore\FVector2i) TileIndexIn ) const


code: FDynamicMeshUDIMClassifier ( const [FDynamicMeshUVOverlay](API\Runtime\GeometryCore\DynamicMesh\FDynamicMeshUVOverlay) * UVOverlay, [TOptional](API\Runtime\Core\IO\TOptional)< [TArray](API\Runtime\Core\Containers\TArray)< int32 >> Selection )


className: FDynamicMeshUDIMClassifier

description: FDynamicMeshUDIMClassifieris a utility class for identifying active UDIMs from a FDynamicMesh's UV overlay

code: class FDynamicMeshUDIMClassifier

Selection

type: TOptional<TArr...

UVOverlay

description: The UV Overlay to analyze for UDIMs


description: Append new UV layer to the end of the array, returning the newly added index, or -1 if at max layers already

code: int32 AddUVLayer()


description: Compute an oriented UV-space bounding box for the given Triangles, and then rotate the UVs such that the box is aligned with the X axis. The UV-space box is found by computing the 2D Convex Hull and then finding the hull edge that results in the minimal box.

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


description: Copy UVs from another overlay

code: bool CopyUVLayer ( [FDynamicMeshUVOverlay](API\Runtime\GeometryCore\DynamicMesh\FDynamicMeshUVOverlay) * FromUVOverlay )


description:
Avoids creating bowties. In cases where an edge is not next to any present or future seams/borders, some adjacent edge will be picked to be made into a seam as well, since it's impossible to make the original into a seam otherwise.
true on success

code: bool CreateSeamsAtEdges ( const [TSet](API\Runtime\Core\Containers\TSet)< int32 > & EidsToMakeIntoSeams, [FUVEditResult](API\Plugins\DynamicMesh\Parameterization\FUVEditResult) * Result )


description: Compute the occupied 2D area for the UVs for the specified triangles and channel.

code: static double DetermineAreaFromUVs ( const [FDynamicMeshUVOverlay](API\Runtime\GeometryCore\DynamicMesh\FDynamicMeshUVOverlay) & UVOverlay, const [TArray](API\Runtime\Core\Containers\TArray)< int32 > & Triangles, [FAxisAlignedBox2f](API\Runtime\GeometryCore\FAxisAlignedBox2f) * BoundingBox )


description:
Utility functions that could maybe go elsewhere but are mainly useful in parameterization context Compute geodesic center of given Mesh
true if a central vertex was found (but if false, will still give a frame forsomevertex as long as there is at least one vertex in the mesh)

code: static bool EstimateGeodesicCenterFrameVertex ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, [FFrame3d](API\Runtime\GeometryCore\FFrame3d_1) & FrameOut, int32 & VertexIDOut, bool bAlignToUnitAxes )


description:
Compute geodesic center of given Mesh triangles (assumes they are connected)
true if a central vertex was found (but if false, will still give a frame forsomevertex as long as there is at least one triangle)

code: static bool EstimateGeodesicCenterFrameVertex ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, const [TArray](API\Runtime\Core\Containers\TArray)< int32 > & Triangles, [FFrame3d](API\Runtime\GeometryCore\FFrame3d_1) & FrameOut, int32 & VertexIDOut, bool bAlignToUnitAxes )


className: FExpMapOptions

description: FExpMapOptionsprovides additional control over ExpMap UV generation below

code: struct FExpMapOptions

NormalSmoothingAlpha

description: Alpha for smoothing, valid range is 0-1

NormalSmoothingRounds

description: Number of rounds of explicit uniform normal smoothing to apply to mesh normals


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


description: Create specified UVLayer if it does not exist

code: void CreateUVLayer ( int32 UVLayerIndex )


code: const [FDynamicMeshUVOverlay](API\Runtime\GeometryCore\DynamicMesh\FDynamicMeshUVOverlay) * GetOverlay() const


description: Remove active layer, setting active layer to highest, preceeding layer. Will not remove the final layer from the mesh. Returns the resulting active layer index.

code: int32 RemoveUVLayer()


description: Pack UVs into unit rectangle

code: bool QuickPack ( int32 TargetTextureResolution, float GutterSize )


description:
Merge existing UV topology with a set of edges, removing seams at edges if they exist within the UV topology.
true on success

code: bool RemoveSeamsAtEdges ( const [TSet](API\Runtime\Core\Containers\TSet)< int32 > & EidsToRemoveAsSeams )


description: Clear UVs for all triangles on active layer

code: void ResetUVs()


description: Clear UVs for given triangles on active layer

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


description: Compute the UV-space and 3D area of the given Triangles, and then scale the UV area to be equvalent to the 3D area. Scaling is around the center of the UV bounding box.

code: bool ScaleUVAreaTo3DArea ( const [TArray](API\Runtime\Core\Containers\TArray)< int32 > & Triangles, bool bRecenterAtOrigin )


description: Scale UVs of the given triangles to fit within the provided provided bounding box.

code: bool ScaleUVAreaToBoundingBox ( const [TArray](API\Runtime\Core\Containers\TArray)< int32 > & Triangles, const [FAxisAlignedBox2f](API\Runtime\GeometryCore\FAxisAlignedBox2f) & BoundingBox, bool bPreserveAspectRatio, bool bRecenterAtBoundingBox )


description: Create new UV island for given Triangles, and set UVs by planar projection to ProjectionFrame. No transforms/etc are applied.

code: void SetPerTriangleUVs ( double ScaleFactor, [FUVEditResult](API\Plugins\DynamicMesh\Parameterization\FUVEditResult) * Result )


description: Create new UV island for each Triangle, by planar projection onto plane of Triangle. No transforms/etc are applied.

code: void SetPerTriangleUVs ( const [TArray](API\Runtime\Core\Containers\TArray)< int32 > & Triangles, double ScaleFactor, [FUVEditResult](API\Plugins\DynamicMesh\Parameterization\FUVEditResult) * Result )


code: void SetTriangleUVsFromProjection ( const [TArray](API\Runtime\Core\Containers\TArray)< int32 > & Triangles, const [FFrame3d](API\Runtime\GeometryCore\FFrame3d_1) & ProjectionFrame, [FUVEditResult](API\Plugins\DynamicMesh\Parameterization\FUVEditResult) * Result )


description: Create new UV island for given Triangles, and set UVs by planar projection to ProjectionFrame. PointTransform is applied to points before projectiong onto ProjectionFrame X/Y axes Projected U/V coordinates are divided by Dimensions.X/Y

code: void SetTriangleUVsFromPlanarProjection ( const [TArray](API\Runtime\Core\Containers\TArray)< int32 > & Triangles, [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< FVector3d(const FVector3d &)> PointTransform, const [FFrame3d](API\Runtime\GeometryCore\FFrame3d_1) & ProjectionFrame, const FVector2d & Dimensions, [FUVEditResult](API\Plugins\DynamicMesh\Parameterization\FUVEditResult) * Result )


description: computes a single ExpMap, so input triangle set must be connected, however this is not verified internally

code: bool SetTriangleUVsFromExpMap ( const [TArray](API\Runtime\Core\Containers\TArray)< int32 > & Triangles, const [FExpMapOptions](API\Plugins\DynamicMesh\Parameterization\FDynamicMeshUVEditor\FExpMapOptions) & Options, [FUVEditResult](API\Plugins\DynamicMesh\Parameterization\FUVEditResult) * Result )


code: bool SetTriangleUVsFromExpMap ( const [TArray](API\Runtime\Core\Containers\TArray)< int32 > & Triangles, [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< FVector3d(const FVector3d &)> PointTransform, const [FFrame3d](API\Runtime\GeometryCore\FFrame3d_1) & ProjectionFrame, const FVector2d & Dimensions, int32 NormalSmoothingRounds, double NormalSmoothingAlpha, double FrameNormalBlendWeight, [FUVEditResult](API\Plugins\DynamicMesh\Parameterization\FUVEditResult) * Result )


description: computes a single parameterization, so input triangle set must be connected, however this is not verified internally

code: bool SetTriangleUVsFromFreeBoundaryConformal ( const [TArray](API\Runtime\Core\Containers\TArray)< int32 > & Triangles, [FUVEditResult](API\Plugins\DynamicMesh\Parameterization\FUVEditResult) * Result )


code: bool SetTriangleUVsFromFreeBoundaryConformal ( const [TArray](API\Runtime\Core\Containers\TArray)< int32 > & Triangles, bool bUseExistingUVTopology, [FUVEditResult](API\Plugins\DynamicMesh\Parameterization\FUVEditResult) * Result )


code: bool SetTriangleUVsFromFreeBoundarySpectralConformal ( const [TArray](API\Runtime\Core\Containers\TArray)< int32 > & Triangles, bool bUseExistingUVTopology, bool bPreserveIrregularity, [FUVEditResult](API\Plugins\DynamicMesh\Parameterization\FUVEditResult) * Result )


description: Set UVs by box projection. Triangles will be grouped to "best" box face PointTransform is applied to points before projectiong onto ProjectionFrame X/Y axes Projected U/V coordinates are divided by Dimensions.X/Y

code: void SetTriangleUVsFromBoxProjection ( const [TArray](API\Runtime\Core\Containers\TArray)< int32 > & Triangles, [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< FVector3d(const FVector3d &)> PointTransform, const [FFrame3d](API\Runtime\GeometryCore\FFrame3d_1) & BoxFrame, const FVector3d & BoxDimensions, int32 MinIslandTriCount, [FUVEditResult](API\Plugins\DynamicMesh\Parameterization\FUVEditResult) * Result )


description: Set UVs by cylinder projection. Triangles will be grouped to cylinder endcaps or side based on CylinderSplitAngle. PointTransform is applied to points before projectiong onto ProjectionFrame X/Y axes Projected U/V coordinates are divided by Dimensions.X/Y

code: void SetTriangleUVsFromCylinderProjection ( const [TArray](API\Runtime\Core\Containers\TArray)< int32 > & Triangles, [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< FVector3d(const FVector3d &)> PointTransform, const [FFrame3d](API\Runtime\GeometryCore\FFrame3d_1) & CylFrame, const FVector3d & CylDimensions, float CylinderSplitAngle, [FUVEditResult](API\Plugins\DynamicMesh\Parameterization\FUVEditResult) * Result )


description: Switch to new layer

code: void SwitchActiveLayer ( int32 UVLayerIndex )


description: Apply arbitrary transform to UV elements

code: void TransformUVElements ( const [TArray](API\Runtime\Core\Containers\TArray)< int32 > & ElementIDs, [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< FVector2f(const FVector2f &)> TransformFunc )


description: Pack specific UVs triangles into the specific unit rectangle at the specified index

code: bool UDIMPack ( int32 TargetTextureResolution, float GutterSize, const [FVector2i](API\Runtime\GeometryCore\FVector2i) & UDIMCoordsIn, const [TArray](API\Runtime\Core\Containers\TArray)< int32 > * Triangles )


description: Construct UV Editor for a UV Overlay of the given Mesh.

code: FDynamicMeshUVEditor ( [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * MeshIn, [FDynamicMeshUVOverlay](API\Runtime\GeometryCore\DynamicMesh\FDynamicMeshUVOverlay) * UVOverlayIn )


code: FDynamicMeshUVEditor ( [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * MeshIn, int32 UVLayerIndex, bool bCreateIfMissing )


className: FDynamicMeshUVEditor

description: FDynamicMeshUVEditorimplements various UV overlay editing operations.

code: class FDynamicMeshUVEditor


code: [FMeshConnectedComponents](API\Runtime\GeometryCore\Selections\FMeshConnectedComponents) CollectUVIslandsToPack ( const FUVOverlayView & MeshView )


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

code: bool StackPack()


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

code: bool StandardPack()


code: FDynamicMeshUVPacker ( [FDynamicMeshUVOverlay](API\Runtime\GeometryCore\DynamicMesh\FDynamicMeshUVOverlay) * UVOverlay )


code: FDynamicMeshUVPacker ( [FDynamicMeshUVOverlay](API\Runtime\GeometryCore\DynamicMesh\FDynamicMeshUVOverlay) * UVOverlay, [TUniquePtr](API\Runtime\Core\Templates\TUniquePtr)< [TArray](API\Runtime\Core\Containers\TArray)< int32 >> && TidsToRepackIn )


className: FDynamicMeshUVPacker

description: FDynamicMeshUVPackerimplements various strategies for packing UV islands in a UV Overlay. The island topology and UV unwraps must already be created, this class simply scales/rotates/translates the islands to fit.

code: class FDynamicMeshUVPacker

bAllowFlips

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

bScaleIslandsByWorldSpaceTexelRatio

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

GutterSize

type: float

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

TextureResolution

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

TidsToRepack

type: TUniquePtr<TAr...

description: The explicit triangle ids to repack, repack all triangles if null

UVOverlay

type: FDynamicMeshUVO...

description: The UV Overlay we will be repacking


className: FSymmetryVertex

code: struct FSymmetryVertex

bIsSourceVertex

description: True if this is a positive-side vertex

bOnPlane

description: True if this is an on-plane vertex (todo: possibly combine with bIsSourceVertex as an enum)

PairedVertex

description: VertexID of paired vertex.

PlaneSignedDistance

description: Initial distance to symmetry plane


description: Given the pairing (SourceVertexROI, SourceVertexPositions), compute the symmetry-constrained vertex positions for MirrorVertexROI and store in MirrorVertexPositionsOut. This function assumes that the MirrorVertexROI was computed by calling GetMirrorVertexROI(SourceVertexROI, MirrorVertexROI, bForceSameSizeWithGaps=true), ie all the arrays must be the same length

code: void ComputeSymmetryConstrainedPositions ( const [TArray](API\Runtime\Core\Containers\TArray)< int > & SourceVertexROI, const [TArray](API\Runtime\Core\Containers\TArray)< int > & MirrorVertexROI, const [TArray](API\Runtime\Core\Containers\TArray)< FVector3d > & SourceVertexPositions, [TArray](API\Runtime\Core\Containers\TArray)< FVector3d > & MirrorVertexPositionsOut ) const


description:
Given a Mesh and its bounding box, find a Symmetry Plane/Frame and detect any pairs of vertices with planar/mirror-symmetry relationships, as well as "on plane" vertices
false if any non-on-plane vertex fails to find a match.

code: bool FindPlaneAndInitialize ( [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * Mesh, const [FAxisAlignedBox3d](API\Runtime\GeometryCore\FAxisAlignedBox3d) & Bounds, [FFrame3d](API\Runtime\GeometryCore\FFrame3d_1) & SymmetryFrameOut, [TArrayView](API\Runtime\Core\Containers\TArrayView)< const FVector3d > PreferredNormals )


description: Update all the symmetry vertex positions based on their Positive-side pair vertex. Also snap all on-plane vertices to the symmetry plane

code: void FullSymmetryUpdate()


description: the input Vector/Axis mirrored across the Symmetry plane

code: FVector3d GetMirroredAxis ( const FVector3d & Axis ) const


description: the input Quaternion mirrored across the Symmetry plane

code: [FQuaterniond](API\Runtime\GeometryCore\FQuaterniond) GetMirroredOrientation ( const [FQuaterniond](API\Runtime\GeometryCore\FQuaterniond) & Orientation ) const


description: the input Point mirrored across the Symmetry plane

code: FVector3d GetMirroredPosition ( const FVector3d & Position ) const