className: FGeometrySelectionEditor

description: Note, however, this means thatFGeometrySelectionEditor.IsSelected()must be used to determine whether an ID is selected, rather thanSelection.Contains()

code: class FGeometrySelectionEditor

QueryConfig

type: FGeometrySelect...


className: FGeometrySelectionElements

description: 3D Geometry representing aFGeometrySelection, for example suitable for passing to rendering code, etc

module: DynamicMesh

code: struct FGeometrySelectionElements

Points

type: TArray< FVector...


className: FGeometrySelectionHitQueryConfig

description: FGeometrySelectionHitQueryConfigdefines the desired settings for a "hit query" on selected meshes/objects.

code: struct FGeometrySelectionHitQueryConfig

bOnlyVisible

type: bool

description: If true, only "visible" elements are considered, otherwise query may return obscured elements (eg, hidden edges occluded by mesh surface)

ElementType

type: EGeometryElemen...

description: Type of object topological element to query

TopologyType

type: EGeometryTopolo...

description: Type of object topology to query


code: FGeometrySelectionPreview ( const [FGeometrySelectionEditor](API\Plugins\DynamicMesh\Selections\FGeometrySelectionEditor) & ActiveEditor )


className: FGeometrySelectionPreview

description: FGeometrySelectionPreviewis a combinedFGeometrySelectionandFGeometrySelectionEditor. The purpose of this class is to support things like hover-highlighting, where the Selection system needs to be queried but the result is going to be discarded.FGeometrySelectionPreviewcan only be constructed based on a parentFGeometrySelectionEditor, from which it derives it's configuration, which is then how the rest of the system knows what geometry to provide as a preview/etc

code: class FGeometrySelectionPreview : public [UE::Geometry::FGeometrySelectionEditor](API\Plugins\DynamicMesh\Selections\FGeometrySelectionEditor)


className: FGeometrySelectionUpdateResult

code: struct FGeometrySelectionUpdateResult


className: FGeometrySelectionUpdateConfig

description: FGeometrySelectionUpdateConfigis passed to various Selection Editing functions/classes to indicate what type of change should be applied to aFGeometrySelection(based on additional parameters, generally)

code: struct FGeometrySelectionUpdateConfig

ChangeType

type: EGeometrySelect...


description: the packed 64-bit representation of [TopologyID, GeometryID]

code: uint64 Encoded() const


description: aFGeoSelectionIDinitialized with the given 32-bit encoding of the MeshTriEdgeID, and a TopologyID of 0

code: static [FGeoSelectionID](API\Plugins\DynamicMesh\Selections\FGeoSelectionID) MeshEdge ( [UE::Geometry::FMeshTriEdgeID](API\Runtime\GeometryCore\DynamicMesh\FMeshTriEdgeID) EdgeKey )


description: aFGeoSelectionIDinitialized with the given TriangleID and GroupID used as the TopologyID

code: static [FGeoSelectionID](API\Plugins\DynamicMesh\Selections\FGeoSelectionID) GroupFace ( int32 TriangleID, int32 GroupID )


description: aFGeoSelectionIDinitialized with the given TriangleID, and a TopologyID of 0

code: static [FGeoSelectionID](API\Plugins\DynamicMesh\Selections\FGeoSelectionID) MeshTriangle ( int32 TriangleID )


description: aFGeoSelectionIDinitialized with the given VertexID, and a TopologyID of 0

code: static [FGeoSelectionID](API\Plugins\DynamicMesh\Selections\FGeoSelectionID) MeshVertex ( int32 VertexID )


description: Initialize the TopologyID and GeometryID by unpacking the 64-bit packed EncodedID

code: FGeoSelectionID ( uint64 EncodedID )


description: Initialize the TopologyID and GeometryID with the given values

code: FGeoSelectionID ( uint32 GeometryIDIn, uint32 TopologyIDIn )


className: FGeoSelectionID

description: Note that since the ints are unsigned,IndexConstants::InvalidIDis not directly representable (-1 will become positive 0xFFFFFFFF).

code: struct FGeoSelectionID

GeometryID

description: Geometry ID, stored in lower 32 bits when packed into 64-bits

TopologyID

description: Topology ID, stored in upper 32 bits when packed into 64-bits


description:
Append the rows of NextPatch to the rows of the current QuadGrid. NextPatch must have the same number of vertex-columns as this Patch. Requires that the last vertex-row of this Patch be the same as the first vertex-row of NextPatch.
true if append succeeded

code: bool AppendQuadPatchRows ( [FQuadGridPatch](API\Plugins\DynamicMesh\Selections\FQuadGridPatch) && NextPatch, bool bChecked )


description: Recover row and column indices from an int32 encoded via EncodeRowColumnIndex

code: [FIndex2i](API\Runtime\GeometryCore\FIndex2i) DecodeRowColumnIndex ( int32 Encoded ) const


description: Map a row and column index pair into a single int32. 11 Bits are available for the row, and 20 for the column

code: int32 EncodeRowColumnIndex ( int32 Row, int32 Column ) const


description: a list of all the triangles in the grid

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


description: Call ApplyFunc for each quad, passing it's grid index and triangle pair

code: void ForEachQuad ( [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< void(int32 QuadRow, int32 QuadCol, [FIndex2i](API\Runtime\GeometryCore\FIndex2i) QuadTris)> ApplyFunc ) const


description: the total number of quads in the grid

code: int32 GetNumQuads() const


description:
Compute the opening angle between the two quads in Column0 and Column1 of the given Row. This is based on the face normals of the two triangles connected to the edge between Column0 and Column1, so any non-planarity of the quads is ignored.
unsigned opening angle in degrees in range [0,180], where 0 means quads are parallel

code: double GetQuadOpeningAngleDeg ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, int32 Column0, int32 Column1, int32 Row ) const


description: Initialize an Nx1 grid from a list of quads and the row of vertices on the "bottom" (ie first span)

code: void InitializeFromQuadStrip ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, const [TArray](API\Runtime\Core\Containers\TArray)< [FIndex2i](API\Runtime\GeometryCore\FIndex2i) > & SequentialQuadsIn, const [TArray](API\Runtime\Core\Containers\TArray)< int32 > & FirstVertexSpan )


description: Construct a new QuadGridPatch that is a subset of the current QuadGridPatch The values (Start|End)Quad(Row|Col) define the sub-patch, the values are inclusive, so passing (1,2,1,2) defines a 2x2 quad patch

code: void GetSubPatchByQuadRange ( int StartQuadRow, int EndQuadRow, int StartQuadCol, int EndQuadCol, [FQuadGridPatch](API\Plugins\DynamicMesh\Selections\FQuadGridPatch) & PatchOut ) const


description:
In cases like assigning UVs or Normals to a QuadGridPatch, we want to assign a unique element to each of the vertices in the grid, and then generate "element triangles" that index into those new elements. To do this we need to know the (row,column) pair ("Vertex Span Index") for each triangle vertex. This function returns a 3-tuple of vertex span indices for a given quad triangle. The functionEncodeRowColumnIndex()is used to map the (row,column) to a single integer, and callers can useDecodeRowColumnIndex()to recover the (row,column)
tuple of encoded (row,column) vertex span indices, in the same ordering as the identified triangle

code: [FIndex3i](API\Runtime\GeometryCore\FIndex3i) GetQuadTriMappedToSpanIndices ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, int QuadRow, int QuadIndex, int TriIndex ) const


description: Reverse the order of the vertex/quad rows, ie "flip" vertically

code: void ReverseRows()


description: Split the Columns of the QuadGridPatch into new QuadGridPatches where the columns are grouped via the PredicateFunc.

code: void SplitColumnsByPredicate ( [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< bool(int32 QuadColumn0, int32 QuadColumn1)> PredicateFunc, [TArray](API\Runtime\Core\Containers\TArray)< [FQuadGridPatch](API\Plugins\DynamicMesh\Selections\FQuadGridPatch) > & SplitPatchesOut ) const


className: FQuadGridPatch

description: Generally the quad triangles will not be assumed to form any consistent pattern. This complicates some of the functions however, and perhaps this assumption could be optionally provided in the future

code: class FQuadGridPatch

NumVertexColsU

type: int

QuadTriangles

type: TArray<TArray<...

description: Quads stored as pairs of triangle indices, (NumVertexRowsV-1) rows of (NumVertexColsU-1)

VertexSpans

description: NumVertexRowsV rows of NumVertexColsU VertexIDs, may contain repeated element if the patch forms a loop


description:
Test if SelectionA and SelectionB are the same selection. This is currently relatively expensive on Polygroup selections due to how they are encoded
true if the selections are iddentical

code: namespace UE { namespace Geometry { bool UE::Geometry::AreSelectionsIdentical ( const [FGeometrySelection](API\Plugins\DynamicMesh\Selections\FGeometrySelection) & SelectionA, const [FGeometrySelection](API\Plugins\DynamicMesh\Selections\FGeometrySelection) & SelectionB ) } }


description: Convert a MeshSelection with Polygroup topology type to aFGroupTopologySelection

code: namespace UE { namespace Geometry { bool UE::Geometry::ConvertPolygroupSelectionToTopologySelection ( const [FGeometrySelection](API\Plugins\DynamicMesh\Selections\FGeometrySelection) & MeshSelection, const [UE::Geometry::FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, const [FGroupTopology](API\Plugins\DynamicMesh\FGroupTopology) * GroupTopology, [FGroupTopologySelection](API\Plugins\DynamicMesh\FGroupTopologySelection) & TopologySelectionOut ) } }


description:
it is not necessarily the case that all vertices of triangles in TrianglesOut will be in VerticesOut.
false if the MeshSelection topology type is not Triangle and true otherwise

code: namespace UE { namespace Geometry { bool UE::Geometry::ConvertTriangleSelectionToOverlaySelection ( const [UE::Geometry::FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, const [FGeometrySelection](API\Plugins\DynamicMesh\Selections\FGeometrySelection) & MeshSelection, [TSet](API\Runtime\Core\Containers\TSet)< int > & TrianglesOut, [TSet](API\Runtime\Core\Containers\TSet)< int > & VerticesOut ) } }


description:
Combine the elements of SelectionA and SelectionB using the provided CombineMode, and store the result in SelectionA.
true if the selectins were compatible (ie both the same type) and of supported geometry/topology type.

code: namespace UE { namespace Geometry { bool UE::Geometry::CombineSelectionInPlace ( [FGeometrySelection](API\Plugins\DynamicMesh\Selections\FGeometrySelection) & SelectionA, const [FGeometrySelection](API\Plugins\DynamicMesh\Selections\FGeometrySelection) & SelectionB, [EGeometrySelectionCombineModes](API\Plugins\DynamicMesh\Selections\UE__Geometry__EGeometrySelection-_1) CombineMode ) } }


description:
Key: . These conversions are not implemented... yet? GroupTopology is ignored 1 supported. The implementation is obvious/unambiguous 2 supported. Polygroup faces containing any input triangle are selected 3 supported. Polygroup edges containing any input triangle edge are selected, but polygroup edges containing only input triangle vertices are not. 4 supported. Polygroup corners coinciding with any input triangle vertex are selected 5 supported. All mesh vertices along the polygroup edge are selected 6 supported. All mesh vertices coinciding with polygroup corners are selected indicates GroupTopology must not be null for this combination. If this symbol is missing GroupTopology is ignored
true if conversion is supported and was computed successfully, return false otherwise

code: namespace UE { namespace Geometry { bool UE::Geometry::ConvertSelection ( const [UE::Geometry::FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, const [FGroupTopology](API\Plugins\DynamicMesh\FGroupTopology) * GroupTopology, const [FGeometrySelection](API\Plugins\DynamicMesh\Selections\FGeometrySelection) & FromSelectionIn, [FGeometrySelection](API\Plugins\DynamicMesh\Selections\FGeometrySelection) & ToSelectionOut ) } }


description: Type of selected Elements in aFGeometrySelection

code: namespace UE { namespace Geometry { enum EGeometryElementType { Vertex = 1, Edge = 2, Face = 4, } } }


description: Type of change, relative to aFGeometrySelection

code: namespace UE { namespace Geometry { enum EGeometrySelectionChangeType { Add, Remove, Replace, } } }


description: Forward declarations

code: namespace UE { namespace Geometry { enum EGeometrySelectionCombineModes { Add, Subtract, Intersection, } } }


description: Type of selected Topology in aFGeometrySelection.

code: namespace UE { namespace Geometry { enum EGeometryTopologyType { Triangle = 1, Polygroup = 2, } } }


description: Call VertexFunc for each selected Mesh element (vertex/edge/tri) in MeshSelection. ApplyTransform will be applied to Vertex Positions before calling VertexFunc

code: namespace UE { namespace Geometry { bool UE::Geometry::EnumerateTriangleSelectionVertices ( const [FGeometrySelection](API\Plugins\DynamicMesh\Selections\FGeometrySelection) & MeshSelection, const [UE::Geometry::FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, const FTransform & ApplyTransform, [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< void(uint64, const FVector3d &)> VertexFunc ) } }


description: Call VertexFunc for each selected Mesh element (vertex/edge/tri) in the set of polygroup faces/edges/corners specified by GroupSelection (relative to GroupTopology parameter) ApplyTransform will be applied to Vertex Positions before calling VertexFunc

code: namespace UE { namespace Geometry { bool UE::Geometry::EnumeratePolygroupSelectionVertices ( const [FGeometrySelection](API\Plugins\DynamicMesh\Selections\FGeometrySelection) & GroupSelection, const [UE::Geometry::FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, const [FGroupTopology](API\Plugins\DynamicMesh\FGroupTopology) * GroupTopology, const FTransform & ApplyTransform, [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< void(uint64, const FVector3d &)> VertexFunc ) } }


description: Call TriangleFunc for each mesh TriangleID included in MeshSelection. For Edges, both connected edges are included. For Vertices, all triangles in the vertex one-ring are included.

code: namespace UE { namespace Geometry { bool UE::Geometry::EnumerateTriangleSelectionTriangles ( const [FGeometrySelection](API\Plugins\DynamicMesh\Selections\FGeometrySelection) & MeshSelection, const [UE::Geometry::FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< void(int32)> TriangleFunc ) } }


description: Call TriangleFunc for each mesh TriangleID included in MeshSelection, where MeshSelection has polygroup topology. For Polygroup Faces, all triangles in the face are included. For Polygroup Edges, currently all triangles in any group adjacent to the edge For Polygroup Corners, currently all triangles in any group touching the corner

code: namespace UE { namespace Geometry { bool UE::Geometry::EnumeratePolygroupSelectionTriangles ( const [FGeometrySelection](API\Plugins\DynamicMesh\Selections\FGeometrySelection) & MeshSelection, const [UE::Geometry::FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, const [UE::Geometry::FPolygroupSet](API\Plugins\DynamicMesh\Polygroups\FPolygroupSet) & GroupSet, [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< void(int32)> TriangleFunc ) } }


description: Call VertexFunc/EdgeFunc/TriangleFunc for the mesh vertices/edges/triangles identified by MeshSelection, where MeshSelection has polygroup topology referring to the provided GroupTopology Since a MeshSelection only stores vertices, edges, or triangles, but not combined, only one of these functions will be invoked during a call to this function. This function is useful to collect up geometry that needs to be rendered for a given MeshSelection

code: namespace UE { namespace Geometry { bool UE::Geometry::EnumeratePolygroupSelectionElements ( const [FGeometrySelection](API\Plugins\DynamicMesh\Selections\FGeometrySelection) & MeshSelection, const [UE::Geometry::FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, const [FGroupTopology](API\Plugins\DynamicMesh\FGroupTopology) * GroupTopology, [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< void(int32, const FVector3d &)> VertexFunc, [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< void(int32, const [FSegment3d](API\Runtime\GeometryCore\FSegment3d) &)> EdgeFunc, [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< void(int32, const [FTriangle3d](API\Runtime\GeometryCore\FTriangle3d) &)> TriangleFunc, const FTransform * ApplyTransform, bool bMapFacesToEdgeLoops ) } }


description: Call VertexFunc/EdgeFunc/TriangleFunc for the vertices/edges/triangles identified by MeshSelection. Since a MeshSelection only stores vertices, edges, or triangles, but not combined, only one of these functions will be invoked during a call to this function. This function is useful to collect up geometry that needs to be rendered for a given MeshSelection

code: namespace UE { namespace Geometry { bool UE::Geometry::EnumerateTriangleSelectionElements ( const [FGeometrySelection](API\Plugins\DynamicMesh\Selections\FGeometrySelection) & MeshSelection, const [UE::Geometry::FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< void(int32, const FVector3d &)> VertexFunc, [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< void(int32, const [FSegment3d](API\Runtime\GeometryCore\FSegment3d) &)> EdgeFunc, [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< void(int32, const [FTriangle3d](API\Runtime\GeometryCore\FTriangle3d) &)> TriangleFunc, const FTransform * ApplyTransform, bool bMapFacesToEdgeLoops ) } }


description: Call TriangleFunc for each mesh TriangleID included in MeshSelection. TriangleFunc may be called multiple times for the same TriangleID. This will forward toEnumerateTriangleSelectionTriangles()orEnumeratePolygroupSelectionTriangles()depending on the selection topology type. If UseGroupSet and MeshSelection is for polygroups, the default Mesh group layer will be used.

code: namespace UE { namespace Geometry { bool UE::Geometry::EnumerateSelectionTriangles ( const [FGeometrySelection](API\Plugins\DynamicMesh\Selections\FGeometrySelection) & MeshSelection, const [UE::Geometry::FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< void(int32)> TriangleFunc, const [UE::Geometry::FPolygroupSet](API\Plugins\DynamicMesh\Polygroups\FPolygroupSet) * UseGroupSet ) } }


description:
Assuming that the uint64 values in the GeometrySelection are encodedFGeoSelectionID's, find the item that has a matching TopologyID, ignoring the GeometryID.
true if an item was found

code: namespace UE { namespace Geometry { bool UE::Geometry::FindInSelectionByTopologyID ( const [FGeometrySelection](API\Plugins\DynamicMesh\Selections\FGeometrySelection) & GeometrySelection, uint32 TopologyID, uint64 & FoundValue ) } }


description:
For selections of typeEGeometryTopologyType::Polygroup, the results are equivalent to first converting the selection to correspondingEGeometryTopologyType::Triangleselection and then finding the boundary vertices. This gives the intuitive result for face selections, but may or may not be what is desired for polygroup vertex/edge selections, because vertices/edges that seem to be on the interior of the polygroup selection may be considered border vertices if the tesselation is such that they are adjacent to unselected triangle vertices/edges.
true if successful. For instance, could fail if GroupTopology was null for aEGeometryTopologyType::Polygroupselection

code: namespace UE { namespace Geometry { bool UE::Geometry::GetSelectionBoundaryVertices ( const [UE::Geometry::FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, const [UE::Geometry::FGroupTopology](API\Plugins\DynamicMesh\FGroupTopology) * GroupTopology, const [UE::Geometry::FGeometrySelection](API\Plugins\DynamicMesh\Selections\FGeometrySelection) & ReferenceSelection, [TSet](API\Runtime\Core\Containers\TSet)< int32 > & BorderVidsOut, [TSet](API\Runtime\Core\Containers\TSet)< int32 > & CurVerticesOut ) } }


description:
Selection must be of typeEGeometryTopologyType::Polygroup, and GroupTopology must not be null.
true if successful. For instance, could fail if GroupTopology was null

code: namespace UE { namespace Geometry { bool UE::Geometry::GetSelectionBoundaryCorners ( const [UE::Geometry::FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, const [UE::Geometry::FGroupTopology](API\Plugins\DynamicMesh\FGroupTopology) * GroupTopology, const [UE::Geometry::FGeometrySelection](API\Plugins\DynamicMesh\Selections\FGeometrySelection) & ReferenceSelection, [TSet](API\Runtime\Core\Containers\TSet)< int32 > & BorderCornerIDsOut, [TSet](API\Runtime\Core\Containers\TSet)< int32 > & CurCornerIDsOut ) } }


description: Compute a 3D Frame suitable for use as a 3D transform gizmo position/orientation for the given MeshSelection

code: namespace UE { namespace Geometry { bool UE::Geometry::GetTriangleSelectionFrame ( const [FGeometrySelection](API\Plugins\DynamicMesh\Selections\FGeometrySelection) & MeshSelection, const [UE::Geometry::FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, [FFrame3d](API\Runtime\GeometryCore\FFrame3d_1) & SelectionFrameOut ) } }


description: Convert Triangle IDs to target Selection type

code: namespace UE { namespace Geometry { bool UE::Geometry::InitializeSelectionFromTriangles ( const [UE::Geometry::FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, const [FGroupTopology](API\Plugins\DynamicMesh\FGroupTopology) * GroupTopology, [TArrayView](API\Runtime\Core\Containers\TArrayView)< const int > Triangles, [FGeometrySelection](API\Plugins\DynamicMesh\Selections\FGeometrySelection) & SelectionOut ) } }


description:
Create a selection of the elements adjacent to the "Border" of the given ReferenceSelection and return in BoundaryConnectedSelection. The type of selected element is defined by ReferenceSelection. Currently "adjacency" is defined as "included in the one-ring of the boundary vertices of the ReferenceSelection", ie first the vertices on boundary edges are found, and then their one-rings are enumerated. Note that this will include "inside" and "outside" adjacent elements, and for vertices, the boundary vertices will still also be included. The main purpose of this function is to implement expand/contract selection operations, which would typically involve first finding the boundary-connected set and then using CombineSelectionInPlace to modify the original selection.
true if ReferenceSelection had a known geometry/topology type pair and BoundaryConnectedSelection was populated

code: namespace UE { namespace Geometry { bool UE::Geometry::MakeBoundaryConnectedSelection ( const [UE::Geometry::FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, const [FGroupTopology](API\Plugins\DynamicMesh\FGroupTopology) * GroupTopology, const [FGeometrySelection](API\Plugins\DynamicMesh\Selections\FGeometrySelection) & ReferenceSelection, [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< bool([FGeoSelectionID](API\Plugins\DynamicMesh\Selections\FGeoSelectionID))> SelectionIDPredicate, [FGeometrySelection](API\Plugins\DynamicMesh\Selections\FGeometrySelection) & BoundaryConnectedSelection ) } }


description:
Expand the input ReferenceSelection to include all "connected" elements and return in AllConnectedSelection. The type of selected element is defined by ReferenceSelection.
true if ReferenceSelection had a known geometry/topology type pair and AllConnectedSelection was populated

code: namespace UE { namespace Geometry { bool UE::Geometry::MakeSelectAllConnectedSelection ( const [UE::Geometry::FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, const [FGroupTopology](API\Plugins\DynamicMesh\FGroupTopology) * GroupTopology, const [FGeometrySelection](API\Plugins\DynamicMesh\Selections\FGeometrySelection) & ReferenceSelection, [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< bool([FGeoSelectionID](API\Plugins\DynamicMesh\Selections\FGeoSelectionID))> SelectionIDPredicate, [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< bool([FGeoSelectionID](API\Plugins\DynamicMesh\Selections\FGeoSelectionID) A, [FGeoSelectionID](API\Plugins\DynamicMesh\Selections\FGeoSelectionID) B)> IsConnectedPredicate, [FGeometrySelection](API\Plugins\DynamicMesh\Selections\FGeometrySelection) & AllConnectedSelection ) } }


description:
Select all elements of the provided Mesh and GroupTopology that pass the provided SelectionIDPredicate, and store in the output AllSelection. The type of elements selected is defined by the existing configured type of the AllSelection parameter.
true if AllSelection had a known geometry/topology type pair and was populated

code: namespace UE { namespace Geometry { bool UE::Geometry::MakeSelectAllSelection ( const [UE::Geometry::FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, const [FGroupTopology](API\Plugins\DynamicMesh\FGroupTopology) * GroupTopology, [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< bool([FGeoSelectionID](API\Plugins\DynamicMesh\Selections\FGeoSelectionID))> SelectionIDPredicate, [FGeometrySelection](API\Plugins\DynamicMesh\Selections\FGeometrySelection) & AllSelection ) } }


description: Update aFGeometrySelection(via the Editor) of mesh vertices/edges/triangles based on a raycast

code: namespace UE { namespace Geometry { void UE::Geometry::UpdateTriangleSelectionViaRaycast ( const [FColliderMesh](API\Runtime\GeometryCore\DynamicMesh\FColliderMesh) * ColliderMesh, [FGeometrySelectionEditor](API\Plugins\DynamicMesh\Selections\FGeometrySelectionEditor) * Editor, const FRay3d & LocalRay, const [FGeometrySelectionUpdateConfig](API\Plugins\DynamicMesh\Selections\FGeometrySelectionUpdateConfig) & UpdateConfig, [FGeometrySelectionUpdateResult](API\Plugins\DynamicMesh\Selections\FGeometrySelectionUpdateResult) & ResultOut ) } }


description: Update aFGeometrySelection(via the Editor) of mesh polygroup faces/edges/corners, based on a raycast

code: namespace UE { namespace Geometry { void UE::Geometry::UpdateGroupSelectionViaRaycast ( const [FColliderMesh](API\Runtime\GeometryCore\DynamicMesh\FColliderMesh) * ColliderMesh, const [FGroupTopology](API\Plugins\DynamicMesh\FGroupTopology) * GroupTopology, [FGeometrySelectionEditor](API\Plugins\DynamicMesh\Selections\FGeometrySelectionEditor) * Editor, const FRay3d & LocalRay, const [FGeometrySelectionUpdateConfig](API\Plugins\DynamicMesh\Selections\FGeometrySelectionUpdateConfig) & UpdateConfig, [FGeometrySelectionUpdateResult](API\Plugins\DynamicMesh\Selections\FGeometrySelectionUpdateResult) & ResultOut ) } }


description: Update aFGeometrySelection(via the Editor)

code: namespace UE { namespace Geometry { bool UE::Geometry::UpdateSelectionWithNewElements ( [FGeometrySelectionEditor](API\Plugins\DynamicMesh\Selections\FGeometrySelectionEditor) * Editor, [EGeometrySelectionChangeType](API\Plugins\DynamicMesh\Selections\UE__Geometry__EGeometrySelection-) ChangeType, const [TArray](API\Runtime\Core\Containers\TArray)< uint64 > & NewIDs, [FGeometrySelectionDelta](API\Plugins\DynamicMesh\Selections\FGeometrySelectionDelta) * DeltaOut ) } }


code: FBoxShape3d ( const [FOrientedBox3d](API\Runtime\GeometryCore\FOrientedBox3d) & BoxIn )


description: FBoxShape is a 3D oriented box

code: struct FBoxShape3d


code: FCapsuleShape3d ( const [FCapsule3d](API\Runtime\GeometryCore\FCapsule3d) & CapsuleIn )


description: FCapsuleShape is a 3D oriented capsule/sphyl

code: struct FCapsuleShape3d


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


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


description: FConvexShape is a 3D convex hull, currently stored as a triangle mesh

code: struct FConvexShape3d


code: FLevelSetShape3d ( const FTransform3d & GridTransform, const [FDenseGrid3f](API\Runtime\GeometryCore\Spatial\FDenseGrid3f) & Grid, float CellSize )


code: FLevelSetShape3d ( FTransform3d && GridTransform, [FDenseGrid3f](API\Runtime\GeometryCore\Spatial\FDenseGrid3f) && Grid, float CellSize )


description: FLevelSetShape is a 3D signed distance function sampled on a regular grid

code: struct FLevelSetShape3d

CellSize

type: float


code: void DetectAndCacheSimpleShapeType ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * SourceMesh, [FSourceMeshCache](API\Plugins\DynamicMesh\ShapeApproximation\FMeshSimpleShapeApproximation\FSourceMeshCache) & CacheOut )


className: EProjectedHullAxisMode

description: Type/Mode for deciding 3D axis to use inGenerate_ProjectedHulls()

code: enum EProjectedHullAxisMode { X = 0, Y = 1, Z = 2, SmallestBoxDimension = 3, SmallestVolume = 4, }


className: FSourceMeshCache

code: struct FSourceMeshCache

DetectedType

type: EDetectedSimple...


description: Approximation generators Fit containing axis-aligned boxes to each input mesh and store in ShapeSetOut

code: void Generate_AlignedBoxes ( [FSimpleShapeSet3d](API\Plugins\DynamicMesh\ShapeApproximation\FSimpleShapeSet3d) & ShapeSetOut )


description: the capsule is fit by first fitting a line to the vertices, and then containing the points, so the fit can deviate quite a bit from a truly "minimal" capsule

code: void Generate_Capsules ( [FSimpleShapeSet3d](API\Plugins\DynamicMesh\ShapeApproximation\FSimpleShapeSet3d) & ShapeSetOut )


description: Calculate 3D Convex Hulls for each input mesh and store in ShapeSetOut. Each convex hull is stored as a triangle mesh, and optionally simplified if bSimplifyHulls=true

code: void Generate_ConvexHulls ( [FSimpleShapeSet3d](API\Plugins\DynamicMesh\ShapeApproximation\FSimpleShapeSet3d) & ShapeSetOut, [FProgressCancel](API\Runtime\GeometryCore\Util\FProgressCancel) * Progress )


description: Calculate multiple 3D Convex Hulls for each input mesh and store in ShapeSetOut. Each convex hull is stored as a triangle mesh, and optionally simplified if bSimplifyHulls=true

code: void Generate_ConvexHullDecompositions ( [FSimpleShapeSet3d](API\Plugins\DynamicMesh\ShapeApproximation\FSimpleShapeSet3d) & ShapeSetOut, [FProgressCancel](API\Runtime\GeometryCore\Util\FProgressCancel) * Progress )


code: void Generate_LevelSets ( [FSimpleShapeSet3d](API\Plugins\DynamicMesh\ShapeApproximation\FSimpleShapeSet3d) & ShapeSetOut, [FProgressCancel](API\Runtime\GeometryCore\Util\FProgressCancel) * Progress )


description: Fit containing minimal-volume spheres to each input mesh and store in ShapeSetOut

code: void Generate_MinimalSpheres ( [FSimpleShapeSet3d](API\Plugins\DynamicMesh\ShapeApproximation\FSimpleShapeSet3d) & ShapeSetOut )


description: Fit containing axis-aligned box, oriented box, capsule, and sphere to each input mesh, and store the one with smallest volume in ShapeSetOut

code: void Generate_MinVolume ( [FSimpleShapeSet3d](API\Plugins\DynamicMesh\ShapeApproximation\FSimpleShapeSet3d) & ShapeSetOut )


description: Fit containing minimal-volume oriented boxes to each input mesh and store in ShapeSetOut

code: void Generate_OrientedBoxes ( [FSimpleShapeSet3d](API\Plugins\DynamicMesh\ShapeApproximation\FSimpleShapeSet3d) & ShapeSetOut, [FProgressCancel](API\Runtime\GeometryCore\Util\FProgressCancel) * Progress )


description: Calculate Projected Convex Hulls for each input mesh and store in ShapeSetOut. A Projected Hull is computed by first projecting all the mesh vertices to a plane, computing a 2D convex hull polygon, and then sweeping the polygon in 3D to contain all the mesh vertices. The 2D convex hull polygons are optionally simplified if bSimplifyHulls=true.

code: void Generate_ProjectedHulls ( [FSimpleShapeSet3d](API\Plugins\DynamicMesh\ShapeApproximation\FSimpleShapeSet3d) & ShapeSetOut, [EProjectedHullAxisMode](API\Plugins\DynamicMesh\ShapeApproximation\FMeshSimpleShapeApproximation\EProjectedHullAx-) AxisMode )


code: bool GetDetectedSimpleShape ( const [FSourceMeshCache](API\Plugins\DynamicMesh\ShapeApproximation\FMeshSimpleShapeApproximation\FSourceMeshCache) & Cache, [FSimpleShapeSet3d](API\Plugins\DynamicMesh\ShapeApproximation\FSimpleShapeSet3d) & ShapeSetOut, FCriticalSection & ShapeSetLock )


description: Setup/initialization Initialize internal mesh sets. This also detects/caches the precise simple shape fits controlled by bDetectSpheres/etc above, so those cannot be modified without callingInitializeSourceMeshes()again. The TSharedPtrs are stored, rather than making a copy of the input meshes

code: void InitializeSourceMeshes ( const [TArray](API\Runtime\Core\Containers\TArray)< const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * > & InputMeshSet )


className: FMeshSimpleShapeApproximation

description: There are various Generate_X() functions which apply different strategies, generally to fit a containing simple shape or hull to the mesh. However in addition to these explicit strategies, input meshes that are very close to approximations of spheres/boxes/capsules (ie basically meshed versions of these primitives) can be identified and used directly, skipping the fitting process.

code: class FMeshSimpleShapeApproximation

bDetectBoxes

description: Should boxes be auto-detected

bDetectCapsules

description: Should capsules be auto-detected

bDetectConvexes

description: Should convex be auto-detected

bDetectSpheres

description: Configuration parametersShould spheres be auto-detected

bSimplifyHulls

description: Should hulls be simplified as a post-process

ConvexDecompositionErrorTolerance

type: double

description: Error tolerance to guide convex decomposition (in cm); we stop adding new parts if the volume error is below the threshold.

ConvexDecompositionMaxPieces

description: How many convex pieces to target per mesh when creating convex decompositions.

ConvexDecompositionMinPartThickness

description: Minimum part thickness for convex decomposition (in cm); hulls thinner than this will be merged into adjacent hulls, if possible.

ConvexDecompositionSearchFactor

description: How much additional decomposition decomposition + merging to do, as a fraction of max pieces.

HullSimplifyTolerance

description: Simplification tolerance when simplifying 2D convex hulls, eg for swept/projected hulls

HullTargetFaceCount

description: Target number of triangles when simplifying 3D convex hulls

LevelSetGridResolution

description: Level Set Grid resolution along longest axis

MinDimension

description: Minimal dimension of fit shapes, eg thickness/radius/etc (currently only enforced in certain cases)

SourceMeshCaches

type: TArray<FSource...

SourceMeshes

type: TArray< constF...


description: Append elements of another shape set

code: void Append ( const [FSimpleShapeSet3d](API\Plugins\DynamicMesh\ShapeApproximation\FSimpleShapeSet3d) & OtherShapeSet )


description: Append elements of another shape set with given transform applied

code: void Append ( const [FSimpleShapeSet3d](API\Plugins\DynamicMesh\ShapeApproximation\FSimpleShapeSet3d) & OtherShapeSet, const FTransform3d & Transform )


description: Append elements of another shape set with given transforms applied

code: void Append ( const [FSimpleShapeSet3d](API\Plugins\DynamicMesh\ShapeApproximation\FSimpleShapeSet3d) & OtherShapeSet, const [TArray](API\Runtime\Core\Containers\TArray)< FTransform3d > & TransformSequence )


code: void Append ( const [FSimpleShapeSet3d](API\Plugins\DynamicMesh\ShapeApproximation\FSimpleShapeSet3d) & OtherShapeSet, const [FTransformSequence3d](API\Runtime\GeometryCore\FTransformSequence3d) & TransformSequence )


description: Transform shape elements. This will be a best-effort as if there is non-uniform scaling only Convexes can be transformed correctly

code: void ApplyTransform ( const FTransform3d & Transform )


description: Sort the elements by volume and then discard all but the largest MaximumCount elements

code: void FilterByVolume ( int32 MaximumCount )


description: Remove any of the elements that are fully contained in larger elements

code: void RemoveContainedGeometry()


description: total number of elements in all sets

code: int32 TotalElementsNum() const


description: FSimpleShapeSet stores a set of simple geometry shapes useful for things like collision detection/etc. Various functions set-processing operations are supported.

code: struct FSimpleShapeSet3d

Boxes

type: TArray<FBoxSha...

Convexes

type: TArray<FConvex...

LevelSets

type: TArray<FLevelS...

Spheres

type: TArray<FSphere...


code: FSphereShape3d ( const [FSphere3d](API\Runtime\GeometryCore\FSphere3d) & SphereIn )


description: FSphereShape is a 3D sphere

code: class FSphereShape3d


description: EDetectedSimpleShapeType is used to identify auto-detected simple shapes for a mesh/etc

code: namespace UE { namespace Geometry { enum EDetectedSimpleShapeType { None = 0, Sphere = 2, Box = 4, Capsule = 8, Convex = 16, } } }


description: Supported/known types of Simple Shapes

code: namespace UE { namespace Geometry { enum ESimpleShapeType { Sphere = 2, Box = 4, Capsule = 8, Convex = 16, LevelSet = 32, } } }


description:
Detect if input Mesh is a meshed box, and if so return analytic box in BoxOut. Clusters face normals, looking to find 6 unique normals grouped into 3 opposite-direction pairs. If this configuraiton is found, computing minimal box is trivial.
true if mesh is a Box and BoxOut is initialized

code: namespace UE { namespace Geometry { bool UE::Geometry::IsBoxMesh ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, [FOrientedBox3d](API\Runtime\GeometryCore\FOrientedBox3d) & BoxOut, double AngleToleranceDeg ) } }


description:
Detect if input Mesh is a meshed approximation of an analytic Capsule, and if so return best guess in CapsuleOut. Fits a capsule to input points, then measures chordal deviation of edge midpoints.
true if mesh is a Capsule and CapsuleOut is initialized

code: namespace UE { namespace Geometry { bool UE::Geometry::IsCapsuleMesh ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, [FCapsule3d](API\Runtime\GeometryCore\FCapsule3d) & CapsuleOut, double RelativeDeviationTol ) } }


description:
Detect if input Mesh is a meshed approximation of an analytic Sphere, and if so return best guess in SphereOut. Fits a sphere to input points with several rounds of incremental improvement, then measures chordal deviation of edge midpoints.
true if mesh is a Sphere and SphereOut is initialized

code: namespace UE { namespace Geometry { bool UE::Geometry::IsSphereMesh ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, [FSphere3d](API\Runtime\GeometryCore\FSphere3d) & SphereOut, double RelativeDeviationTol ) } }


code: namespace UE { namespace Geometry { [ESimpleShapeType](API\Plugins\DynamicMesh\ShapeApproximation\UE__Geometry__ESimpleShapeType) & UE::Geometry::operator&= ( [ESimpleShapeType](API\Plugins\DynamicMesh\ShapeApproximation\UE__Geometry__ESimpleShapeType) & Lhs, [ESimpleShapeType](API\Plugins\DynamicMesh\ShapeApproximation\UE__Geometry__ESimpleShapeType) Rhs ) } }


code: namespace UE { namespace Geometry { [ESimpleShapeType](API\Plugins\DynamicMesh\ShapeApproximation\UE__Geometry__ESimpleShapeType) & UE::Geometry::operator^= ( [ESimpleShapeType](API\Plugins\DynamicMesh\ShapeApproximation\UE__Geometry__ESimpleShapeType) & Lhs, [ESimpleShapeType](API\Plugins\DynamicMesh\ShapeApproximation\UE__Geometry__ESimpleShapeType) Rhs ) } }


code: namespace UE { namespace Geometry { constexpr [ESimpleShapeType](API\Plugins\DynamicMesh\ShapeApproximation\UE__Geometry__ESimpleShapeType) UE::Geometry::operator& ( [ESimpleShapeType](API\Plugins\DynamicMesh\ShapeApproximation\UE__Geometry__ESimpleShapeType) Lhs, [ESimpleShapeType](API\Plugins\DynamicMesh\ShapeApproximation\UE__Geometry__ESimpleShapeType) Rhs ) } }


code: namespace UE { namespace Geometry { constexpr bool UE::Geometry::operator! ( [ESimpleShapeType](API\Plugins\DynamicMesh\ShapeApproximation\UE__Geometry__ESimpleShapeType) E ) } }


code: namespace UE { namespace Geometry { constexpr [ESimpleShapeType](API\Plugins\DynamicMesh\ShapeApproximation\UE__Geometry__ESimpleShapeType) UE::Geometry::operator^ ( [ESimpleShapeType](API\Plugins\DynamicMesh\ShapeApproximation\UE__Geometry__ESimpleShapeType) Lhs, [ESimpleShapeType](API\Plugins\DynamicMesh\ShapeApproximation\UE__Geometry__ESimpleShapeType) Rhs ) } }


code: namespace UE { namespace Geometry { constexpr [ESimpleShapeType](API\Plugins\DynamicMesh\ShapeApproximation\UE__Geometry__ESimpleShapeType) UE::Geometry::operator~ ( [ESimpleShapeType](API\Plugins\DynamicMesh\ShapeApproximation\UE__Geometry__ESimpleShapeType) E ) } }


className: bIsSymmetricLaplacian

description: true if Laplacian scheme produces a symmetric matrix

code: bool bIsSymmetricLaplacian ( const [ELaplacianWeightScheme](API\Plugins\DynamicMesh\Solvers\ELaplacianWeightScheme) Scheme )


code: int32 GetLocalEdgeIdx ( const int32 DynamicsMeshEdgeId ) const


code: double GetOpposingCotangent ( const int32 DynamicsMeshEdgeId ) const


description:
Helper to return the cotangent of the angle opposite the given edge
Cotangent of the opposite angle.

code: double GetOpposingCotangent ( const int32 DynamicsMeshEdgeId, bool & bValid ) const


code: void Initialize ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & DynamicMesh, int32 SrcTriId )


className: SmallTriangleArea

description: The "floor" for triangle area. NB: the cotan laplacian has terms ~ 1/TriArea and the deformation matrix has terms ~ 1/TriArea**2

code: static constexpr double SmallTriangleArea = (1.e-8f);


className: TriangleVertices

code: typedef FVector3d TriangleVertices


code: CotanTriangleData ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & DynamicMesh, int32 TriId )


className: CotanTriangleData

description: The per-triangle data used in constructing the cotangent weighted laplacian.

code: class CotanTriangleData

Cotangent

description: Total byte count: 6 double + 3 int32 = 60 bytes.

OppositeEdge

description: OppositeEdge[i] = Corresponding DynamicsMesh3::EdgeId for the edge that is opposite the i'th vertex in this triangle

TriId

description: Testing


className: ELaplacianWeightScheme

description: Types of Laplacian weights. This enum is used to indicate which type of Mesh Laplacian should be used in various Mesh Deformation solvers. See LaplacianMatrixAssembly.h for specifics

code: enum ELaplacianWeightScheme { Uniform, Umbrella, Valence, MeanValue, Cotangent, ClampedCotangent, IDTCotanget, }


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


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


code: FTriangleLinearization &40; const FTriangleLinearization & &41;


className: FTriangleLinearization

description: Used linearize the TriIds in a mesh as a single array and allow mapping from array offset to mesh TriId.

code: class FTriangleLinearization : public [UE::Geometry::FElementLinearization](API\Runtime\GeometryCore\Util\FElementLinearization)


code: int32 NumBoundaryVerts() const


code: template<typename MeshType> void Reset ( const MeshType & Mesh, bool bRemapBoundary )


code: FVertexLinearization &40; const FVertexLinearization & &41;


code: template<typename MeshType> FVertexLinearization ( const MeshType & Mesh, bool bRemapBoundary )


className: FVertexLinearization

description: Used to linearize the VtxIds in a mesh as a single array and allow mapping from array offset to mesh VtxId. Generally, the array offset will correspond to a matrix row when forming a Laplacian. The last NumBoundaryVerts are the boundary verts. This may be zero.

code: class FVertexLinearization : public [UE::Geometry::FElementLinearization](API\Runtime\GeometryCore\Util\FElementLinearization)


description: Update global scale applied to Laplacian vectors before solve.

code: void UpdateLaplacianScale ( double UniformScale )


className: IConstrainedLaplacianMeshSolver

description: Extension ofIConstrainedMeshSolverthat supports manipulating the underlying Laplacian vectors used in Laplacian-based Deformation Solvers.

code: class IConstrainedLaplacianMeshSolver : public [UE::Solvers::IConstrainedMeshSolver](API\Plugins\DynamicMesh\Solvers\IConstrainedMeshSolver)


description: Add or update a weighted positional constraint associated with VtxId

code: void AddConstraint ( const int32 VtxId, const double Weight, const FVector3d & Position, const bool bPostFix )


description: Clear all Constraint Positions.

code: void ClearConstraintPositions()


description: Clear all constraints (Positions and Weights)

code: void ClearConstraints()


description: Clear all Constraint Weights.

code: void ClearConstraintWeights()


description: Returns the vertex locations of the deformed mesh. Note the array may have empty elements as the index matches the Mesh based VtxId. PositionBuffer[VtxId] = Pos.

code: bool Deform ( [TArray](API\Runtime\Core\Containers\TArray)< FVector3d > & PositionBuffer )


description: Test if a non-zero weighted constraint is associated with VtxId.

code: bool IsConstrained ( const int32 VtxId ) const


description:
Update or Create a constraint position associated with
true if a constraint weight is associated with

code: bool UpdateConstraintPosition ( const int32 VtxId, const FVector3d & Position, const bool bPostFix )


description:
Update or Create a constraint weight associated with
true if a constraint position is associated with

code: bool UpdateConstraintWeight ( const int32 VtxId, const double Weight )


code: virtual ~IConstrainedMeshSolver()


className: IConstrainedMeshSolver

description: Interface to a index-based deformation solver for a 3D mesh vertex set that supports weighted point constraints.

code: class IConstrainedMeshSolver


code: void AddConstraint ( const int32 VtxId, const double Weight, const FVector2d & Position, const bool bPostFix )


code: bool SolveUVs ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * DynamicMesh, [TArray](API\Runtime\Core\Containers\TArray)< FVector2d > & UVBuffer )


code: bool UpdateConstraintPosition ( const int32 VtxId, const FVector2d & Position, const bool bPostFix )


code: virtual ~IConstrainedMeshUVSolver()


className: LaplacianSchemeName

description: Utility to map the enum names for debuging etc.

code: [FString](API\Runtime\Core\Containers\FString) LaplacianSchemeName ( const [ELaplacianWeightScheme](API\Plugins\DynamicMesh\Solvers\ELaplacianWeightScheme) Scheme )


className: IConstrainedMeshUVSolver

description: Interface to a index-based UV solver for a 3D triangle mesh that supports weighted point constraints.

code: class IConstrainedMeshUVSolver


description: Return the length of the indicated edge

code: double GetEdgeLength ( int32 EdgeId ) const


description: Return Tan(angle / 2) for the corner indicated by this vert id.

code: double GetTanHalfAngle ( int32 VtxId ) const


code: void Initialize ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & DynamicMesh, int32 SrcTriId )


className: MeanValueTriangleData

description: The per-triangle data used in constructing the mean-value weighted laplacian.

code: class MeanValueTriangleData


description: // Solve for new vertex locations. MeshDeformer->Deform(PositionBuffer); // Update Mesh?

code: namespace UE { namespace MeshDeformation { [TUniquePtr](API\Runtime\Core\Templates\TUniquePtr)< [UE::Solvers::IConstrainedMeshSolver](API\Plugins\DynamicMesh\Solvers\IConstrainedMeshSolver) > UE::MeshDeformation::ConstructConstrainedMeshDeformer ( const [ELaplacianWeightScheme](API\Plugins\DynamicMesh\Solvers\ELaplacianWeightScheme) WeightScheme, const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & DynamicMesh ) } }


description: Similar toConstructConstrainedMeshDeformer()however a uniform-weighted Laplacian is always used. This allows for the solution of deformation problems on a more generic mesh type (triangles or faces are not required.)

code: namespace UE { namespace MeshDeformation { [TUniquePtr](API\Runtime\Core\Templates\TUniquePtr)< [UE::Solvers::IConstrainedMeshSolver](API\Plugins\DynamicMesh\Solvers\IConstrainedMeshSolver) > UE::MeshDeformation::ConstructUniformConstrainedMeshDeformer ( const [FDynamicGraph3d](API\Runtime\GeometryCore\Curve\FDynamicGraph3d) & Graph ) } }


code: namespace UE { namespace MeshDeformation { void UE::MeshDeformation::ComputeSmoothing_ImplicitBiHarmonicPCG ( const [ELaplacianWeightScheme](API\Plugins\DynamicMesh\Solvers\ELaplacianWeightScheme) WeightScheme, const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & OriginalMesh, const double Speed, const double Weight, const int32 MaxIterations, [TArray](API\Runtime\Core\Containers\TArray)< FVector3d > & PositionArray ) } }


description: Expected Use: same as the ConstrainedMeshDeformer above.

code: namespace UE { namespace MeshDeformation { [TUniquePtr](API\Runtime\Core\Templates\TUniquePtr)< [UE::Solvers::IConstrainedMeshSolver](API\Plugins\DynamicMesh\Solvers\IConstrainedMeshSolver) > UE::MeshDeformation::ConstructConstrainedMeshSmoother ( const [ELaplacianWeightScheme](API\Plugins\DynamicMesh\Solvers\ELaplacianWeightScheme) WeightScheme, const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & DynamicMesh ) } }


description: Edge cotanget weights.

code: namespace UE { namespace MeshDeformation { void UE::MeshDeformation::ConstructEdgeCotanWeightsDataArray ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, [TArray](API\Runtime\Core\Containers\TArray)< double > & EdgeWeightsDataArray, double ClampMin, double ClampMax ) } }


description: LaplacianInterior * Vector_InteriorVerts + LaplacianBoundary * Vector_BoundaryVerts = Full Laplacian applied to interior vertices.

code: namespace UE { namespace MeshDeformation { template<typename RealType> void UE::MeshDeformation::ConstructValenceWeightedLaplacian ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & DynamicMesh, const [FVertexLinearization](API\Plugins\DynamicMesh\Solvers\FVertexLinearization) & VertexMap, [UE::Solvers::TSparseMatrixAssembler](API\Runtime\GeometryCore\Solvers\TSparseMatrixAssembler)< RealType > & LaplacianInterior, [UE::Solvers::TSparseMatrixAssembler](API\Runtime\GeometryCore\Solvers\TSparseMatrixAssembler)< RealType > & LaplacianBoundary ) } }


code: namespace UE { namespace MeshDeformation { template<typename RealType> void UE::MeshDeformation::ConstructMeanValueWeightLaplacian ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & DynamicMesh, const [FVertexLinearization](API\Plugins\DynamicMesh\Solvers\FVertexLinearization) & VertexMap, [UE::Solvers::TSparseMatrixAssembler](API\Runtime\GeometryCore\Solvers\TSparseMatrixAssembler)< RealType > & LaplacianInterior, [UE::Solvers::TSparseMatrixAssembler](API\Runtime\GeometryCore\Solvers\TSparseMatrixAssembler)< RealType > & LaplacianBoundary ) } }


code: namespace UE { namespace MeshDeformation { template<typename RealType> void UE::MeshDeformation::ConstructIDTCotangentLaplacian ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & DynamicMesh, const [FVertexLinearization](API\Plugins\DynamicMesh\Solvers\FVertexLinearization) & VertexMap, [UE::Solvers::TSparseMatrixAssembler](API\Runtime\GeometryCore\Solvers\TSparseMatrixAssembler)< RealType > & LaplacianInterior, [UE::Solvers::TSparseMatrixAssembler](API\Runtime\GeometryCore\Solvers\TSparseMatrixAssembler)< RealType > & LaplacianBoundary, const bool bClampWeights ) } }


description: FDynamicMesh3 DynamicMesh; const bool bRemapBoundary = false; FVertexLinearization VertexMap(DynamicMesh, bRemapBoundary); ConstructFullCotangentLaplacian(DynamicMesh, VertexMap, ECotangentWeightMode::Default, ECotangentAreaMode::NoArea);

code: namespace UE { namespace MeshDeformation { template<typename RealType> void UE::MeshDeformation::ConstructFullCotangentLaplacian ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & DynamicMesh, const [FVertexLinearization](API\Plugins\DynamicMesh\Solvers\FVertexLinearization) & VertexMap, [UE::Solvers::TSparseMatrixAssembler](API\Runtime\GeometryCore\Solvers\TSparseMatrixAssembler)< RealType > & LaplacianMatrix, [ECotangentWeightMode](API\Plugins\DynamicMesh\Solvers\UE__MeshDeformation__ECotangentW-) WeightMode, [ECotangentAreaMode](API\Plugins\DynamicMesh\Solvers\UE__MeshDeformation__ECotangentA-) AreaMode ) } }


description: Use intrinsic Delaunay mesh to construct sparse Cotangent Laplacian matrix. This variant combines the N interior and M boundary vertices into a single (N+M) matrix and does not do any special treatment of boundaries, they just get standard Cotan weights.

code: namespace UE { namespace MeshDeformation { template<typename RealType> void UE::MeshDeformation::ConstructFullIDTCotangentLaplacian ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, const [FVertexLinearization](API\Plugins\DynamicMesh\Solvers\FVertexLinearization) & VertexMap, [UE::Solvers::TSparseMatrixAssembler](API\Runtime\GeometryCore\Solvers\TSparseMatrixAssembler)< RealType > & LaplacianMatrix, [ECotangentWeightMode](API\Plugins\DynamicMesh\Solvers\UE__MeshDeformation__ECotangentW-) WeightMode, [ECotangentAreaMode](API\Plugins\DynamicMesh\Solvers\UE__MeshDeformation__ECotangentA-) AreaMode ) } }


description: Assumption is that mesh is a single connected component.

code: namespace UE { namespace MeshDeformation { [TUniquePtr](API\Runtime\Core\Templates\TUniquePtr)< [UE::Solvers::IConstrainedMeshUVSolver](API\Plugins\DynamicMesh\Solvers\IConstrainedMeshUVSolver) > UE::MeshDeformation::ConstructSpectralConformalParamSolver ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & DynamicMesh, bool bPreserveIrregularity ) } }


code: namespace UE { namespace MeshDeformation { [TUniquePtr](API\Runtime\Core\Templates\TUniquePtr)< [UE::Solvers::IConstrainedMeshUVSolver](API\Plugins\DynamicMesh\Solvers\IConstrainedMeshUVSolver) > UE::MeshDeformation::ConstructNaturalConformalParamSolver ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & DynamicMesh ) } }


description: Utility to compute the number of elements in the sparse laplacian matrix.

code: namespace UE { namespace MeshDeformation { template<typename MeshT> int32 UE::MeshDeformation::ComputeNumMatrixElements ( const MeshT & DynamicMesh, const [TArray](API\Runtime\Core\Containers\TArray)< int32 > & ToVtxId ) } }


description: The result is returned in the PositionArray

code: namespace UE { namespace MeshDeformation { void UE::MeshDeformation::ComputeSmoothing_BiHarmonic ( const [ELaplacianWeightScheme](API\Plugins\DynamicMesh\Solvers\ELaplacianWeightScheme) WeightingScheme, const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & OriginalMesh, const double Speed, const double Weight, const int32 NumIterations, [TArray](API\Runtime\Core\Containers\TArray)< FVector3d > & PositionArray ) } }


description: here w_ii are the diagonal values of L

code: namespace UE { namespace MeshDeformation { void UE::MeshDeformation::ComputeSmoothing_Diffusion ( const [ELaplacianWeightScheme](API\Plugins\DynamicMesh\Solvers\ELaplacianWeightScheme) WeightScheme, const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & OriginalMesh, bool bForwardEuler, const double Speed, double Weight, const int32 NumIterations, [TArray](API\Runtime\Core\Containers\TArray)< FVector3d > & PositionArray ) } }


description: Simple iterative smoothing with an optional weight map Each iteration Lerps towards the weighted neighbor centroid by the GetSmoothingAlpha amount

code: namespace UE { namespace MeshDeformation { void UE::MeshDeformation::ComputeSmoothing_Forward ( bool bUniformWeightScheme, bool bSmoothBoundary, const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & OriginalMesh, [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< double(int VID, bool bBoundary)> GetSmoothingAlpha, const int32 NumIterations, [TArray](API\Runtime\Core\Containers\TArray)< FVector3d > & PositionArray ) } }


description: AreaMatrix^{-1} * ( LaplacianInterior * Vector_InteriorVerts + LaplacianBoundary * Vector_BoundaryVerts) = Full Laplacian applied to interior vertices.

code: namespace UE { namespace MeshDeformation { template<typename RealType> void UE::MeshDeformation::ConstructCotangentLaplacian ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & DynamicMesh, const [FVertexLinearization](API\Plugins\DynamicMesh\Solvers\FVertexLinearization) & VertexMap, [UE::Solvers::TSparseMatrixAssembler](API\Runtime\GeometryCore\Solvers\TSparseMatrixAssembler)< RealType > & AreaMatrix, [UE::Solvers::TSparseMatrixAssembler](API\Runtime\GeometryCore\Solvers\TSparseMatrixAssembler)< RealType > & LaplacianInterior, [UE::Solvers::TSparseMatrixAssembler](API\Runtime\GeometryCore\Solvers\TSparseMatrixAssembler)< RealType > & LaplacianBoundary ) } }


description: Similar toConstructConstrainedMeshDeformer()however (1) a Voronoi-Area Weighted Clamped Cotangent Laplacian is always used and (2) the boundary positions are included in the system. This allows for the solution of deformation problems where the boundary also moves, however it also means that constraints should be added for all boundary vertices or the deformation may be unstable.

code: namespace UE { namespace MeshDeformation { [TUniquePtr](API\Runtime\Core\Templates\TUniquePtr)< [UE::Solvers::IConstrainedLaplacianMeshSolver](API\Plugins\DynamicMesh\Solvers\IConstrainedLaplacianMeshSolver) > UE::MeshDeformation::ConstructSoftMeshDeformer ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & DynamicMesh ) } }


description: Return and array in triangle order that holds the per-triangle derived data needed

code: namespace UE { namespace MeshDeformation { template<typename TriangleDataType> void UE::MeshDeformation::ConstructTriangleDataArray ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & DynamicMesh, const [FTriangleLinearization](API\Plugins\DynamicMesh\Solvers\FTriangleLinearization) & TriangleLinearization, [TArray](API\Runtime\Core\Containers\TArray)< TriangleDataType > & TriangleDataArray ) } }


code: namespace UE { namespace MeshDeformation { template<typename RealType> void UE::MeshDeformation::ConstructUmbrellaLaplacian ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & DynamicMesh, const [FVertexLinearization](API\Plugins\DynamicMesh\Solvers\FVertexLinearization) & VertexMap, [UE::Solvers::TSparseMatrixAssembler](API\Runtime\GeometryCore\Solvers\TSparseMatrixAssembler)< RealType > & LaplacianInterior, [UE::Solvers::TSparseMatrixAssembler](API\Runtime\GeometryCore\Solvers\TSparseMatrixAssembler)< RealType > & LaplacianBoundary ) } }


code: namespace UE { namespace MeshDeformation { template<typename RealType> void UE::MeshDeformation::ConstructCotangentLaplacian ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & DynamicMesh, const [FVertexLinearization](API\Plugins\DynamicMesh\Solvers\FVertexLinearization) & VertexMap, [UE::Solvers::TSparseMatrixAssembler](API\Runtime\GeometryCore\Solvers\TSparseMatrixAssembler)< RealType > & LaplacianInterior, [UE::Solvers::TSparseMatrixAssembler](API\Runtime\GeometryCore\Solvers\TSparseMatrixAssembler)< RealType > & LaplacianBoundary, const bool bClampWeights ) } }


description: Implementations

code: namespace UE { namespace MeshDeformation { template<typename RealType, typename MeshType> void UE::MeshDeformation::ConstructUniformLaplacian ( const MeshType & Mesh, const [FVertexLinearization](API\Plugins\DynamicMesh\Solvers\FVertexLinearization) & VertexMap, [UE::Solvers::TSparseMatrixAssembler](API\Runtime\GeometryCore\Solvers\TSparseMatrixAssembler)< RealType > & LaplacianInterior, [UE::Solvers::TSparseMatrixAssembler](API\Runtime\GeometryCore\Solvers\TSparseMatrixAssembler)< RealType > & LaplacianBoundary ) } }


code: namespace UE { namespace MeshDeformation { enum ECotangentAreaMode { NoArea = 0, VoronoiArea = 1, } } }


code: namespace UE { namespace MeshDeformation { enum ECotangentWeightMode { Default = 0, ClampedMagnitude = 1, TriangleArea = 2, } } }


code: virtual void ApplyToProjectVertices ( const [TFunction](API\Runtime\Core\GenericPlatform\TFunction)< void(int)> & apply_f )


description: Uses pre-computed vertex, face and seam quadrics to construct the edge quadric.

code: [FQuadricErrorType](API\Plugins\DynamicMesh\TMeshSimplification\FQuadricErrorType) AssembleEdgeQuadric ( const [FDynamicMesh3::FEdge](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3\FEdge) & edge ) const


description: Figure out if we can collapse edge eid=[a,b] under current constraint set This depends on the base class functionFMeshRefinerBase::CanCollapseEdge, but includes additional restrictions specified by the CollapseMode of this simplifier. See the base class for description of parameters.

code: bool CanCollapseEdge ( int edgeID, int a, int b, int c, int d, int t0, int t1, int & collapse_to ) const


description: Check if edge collapse would violate geometric error criteria

code: bool CheckIfCollapseWithinGeometricTolerance ( int vid, int vother, const FVector3d & newv, int tc, int td )


description: Collapse given edge.

code: [ESimplificationResult](API\Plugins\DynamicMesh\UE__Geometry__ESimplificationRes-) CollapseEdge ( int edgeID, FVector3d vNewPos, [FDynamicMesh3::FEdgeCollapseInfo](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3\FEdgeCollapseInfo) & collapseInfo, int32 RequireKeepVert )


code: [FQuadricErrorType](API\Plugins\DynamicMesh\TMeshSimplification\FQuadricErrorType) ComputeFaceQuadric ( const int tid, FVector3d & nface, FVector3d & c, double & Area ) const


description: Top-level function that does the simplification

code: virtual void DoSimplify()


className: EGeometricErrorCriteria

description: Ways to measure geometric error

code: enum EGeometricErrorCriteria { None = 0, PredictedPointToProjectionTarget = 1, }


description: This just lets us write more concise code

code: bool EnableInlineProjection() const


className: ESimplificationCollapseModes

code: enum ESimplificationCollapseModes { MinimalQuadricPositionError = 0, MinimalExistingVertexError = 1, AverageVertexPosition = 2, }


className: ETargetModes

code: enum ETargetModes { TriangleCount = 0, VertexCount = 1, MinEdgeLength = 2, MaxError = 3, }


description: Does N rounds of collapsing edges longer than fMinEdgeLength. Does not use Quadrics or priority queue. This is a quick way to get triangle count down on huge meshes (eg like marching cubes output).

code: virtual void FastCollapsePass ( double MinEdgeLength, int Rounds, bool bMeshIsClosedHint, uint32 MinTriangleCount )


code: bool operator< &40; const FEdgeError & e2 &41; const


className: FEdgeError

code: struct FEdgeError


description: Project vertices onto projection target.

code: virtual void FullProjectionPass()


code: virtual int GetNextEdge ( int CurEdgeID, bool & bDoneOut )


className: FSeamQuadricType

code: typedef [TQuadricError](API\Runtime\GeometryCore\TQuadricError)< [RealType](API\Plugins\DynamicMesh\TMeshSimplification\RealType) > FSeamQuadricType


description: Used by collapse-edge to get projected position for new vertex

code: virtual FVector3d GetProjectedCollapsePosition ( int vid, const FVector3d & vNewPos )


code: FVector3d GetProjectedPoint ( const FVector3d & pos )


code: virtual void InitializeQueue()


code: virtual void InitializeSeamQuadrics()


code: virtual void InitializeTriQuadrics()


code: virtual void InitializeVertexQuadrics()


code: bool IsBoundaryVertex ( int vid ) const


description: Subclasses can override these to implement custom behavior...

code: virtual void OnEdgeCollapse ( int edgeID, int va, int vb, const [FDynamicMesh3::FEdgeCollapseInfo](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3\FEdgeCollapseInfo) & collapseInfo )


code: template<> void OnEdgeCollapse ( int edgeID, int va, int vb, const [FDynamicMesh3::FEdgeCollapseInfo](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3\FEdgeCollapseInfo) & collapseInfo )


code: virtual void OnRemoveIsolatedTriangle ( int tId )


description: Return point that minimizes quadric error for edge [ea,eb]

code: FVector3d OptimalPoint ( int eid, const [FQuadricErrorType](API\Plugins\DynamicMesh\TMeshSimplification\FQuadricErrorType) & q, int ea, int eb )


code: void Precompute ( bool bMeshIsClosed )


code: virtual void ProfileBeginCollapse()


code: virtual void ProfileBeginOps()


code: virtual void ProfileBeginPass()


code: virtual void ProfileBeginProject()


code: virtual void ProfileBeginSetup()


code: virtual void ProfileEndCollapse()


code: virtual void ProfileEndPass()


code: virtual void ProfileEndProject()


code: virtual void ProjectVertex ( int vID, [IProjectionTarget](API\Runtime\GeometryCore\Spatial\IProjectionTarget) * targetIn )


code: QEdge &40; int edge_id, const FQuadricErrorType & qin, const FVector3d & pt &41;


className: QEdge

description: Internal class for priority queue

code: struct QEdge

q

type: FQuadricErrorTy...


description:
Remove an isolated triangle.
false if the triangle shares a vertex with another triangle

code: bool RemoveIsolatedTriangle ( int tID )


description: Simplify mesh until no edges smaller than min length remain. This is not a great criteria.

code: virtual void SimplifyToEdgeLength ( double MinEdgeLength )


code: virtual void ProfileEndSetup()


description: Simplify mesh until the quadric error of an edge collapse exceeds the specified criteria.

code: virtual void SimplifyToMaxError ( double MaxError )


description: Maximally collapse mesh in a way that does not change shape at all. This process does not involve quadric error at all.

code: virtual void SimplifyToMinimalPlanar ( double CoplanarAngleTolDeg, [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< bool(int32 EdgeID)> EdgeFilterPredicate )


description: Simplify mesh until we reach a specific triangle count. Note that because triangles are removed in pairs, the resulting count may be TriangleCount-1

code: virtual void SimplifyToTriangleCount ( int TriangleCount )


description: Simplify mesh until it has a specific vertex count

code: virtual void SimplifyToVertexCount ( int VertexCount )


description: Update queue weight for each edge in vertex one-ring and rebuild and quadrics necessary

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


code: TMeshSimplification ( [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) * m )


className: TMeshSimplification

description: Implementation of Garland & Heckbert Quadric Error Metric (QEM) Triangle Mesh Simplification

code: template<typename QuadricErrorType> class TMeshSimplification : public [UE::Geometry::FMeshRefinerBase](API\Plugins\DynamicMesh\FMeshRefinerBase)

bAllowSeamCollapse

description: If true, we allow UV and Normal seams to collapse during simplification.

bPreserveBoundaryShape

description: If true, we try to keep boundary vertices on boundary.

bPreventTinyTriangles

description: Controls whether we disallow creation of triangles with small areas inside edge operations.

bRetainQuadricMemory

description: If false, face and vertex quadrics are recomputed in the neighborhood of each collapse, definitely slower but maybe higher quality

CollapseMode

type: ESimplification...

description: Controls the method used when selecting the position the results from an edge collapse.

description: Testing/debug/profiling stuff profiling functions, turn on ENABLE_PROFILING to see output in console

EdgeQuadrics

type: TArray<QEdge>

EdgeQueue

type: FIndexPriorityQ...

GeometricErrorConstraint

type: EGeometricError...

description: Geometric error measurement/check to perform before allowing an edge collapse

GeometricErrorTolerance

description: Tolerance to use in geometric error checking

GroupBoundaryConstraint

type: EEdgeRefineFlag...

IsBoundaryVtxCache

type: TArray< bool >

MeshBoundaryConstraint

description: When using the constraint system, these options will apply to the appropriate boundaries.

ModuloPrime

type: const int

description: We are using a modulo-index loop to break symmetry/pathological conditions.

NormalOverlay

type: FDynamicMeshNor...

seamQuadrics

type: TMap< int,FSea...

SimplifyMode

type: ETargetModes

triAreas

type: TArray< double ...

triQuadrics

type: TArray<FQuadri...


description: EEdgeRefineFlags indicate constraints on triangle mesh edges

code: namespace UE { namespace Geometry { enum EEdgeRefineFlags { NoConstraint = 0, NoFlip = 1, NoSplit = 2, NoCollapse = 4, FullyConstrained = NoFlip | NoSplit | NoCollapse, SplitsOnly = NoFlip | NoCollapse, FlipOnly = NoSplit | NoCollapse, CollapseOnly = NoFlip | NoSplit, } } }


description: Forward declarations

code: namespace UE { namespace Geometry { enum ESimplificationResult { Ok_Collapsed = 0, Ignored_CannotCollapse = 1, Ignored_EdgeIsFullyConstrained = 2, Ignored_EdgeTooLong = 3, Ignored_Constrained = 4, Ignored_CreatesFlip = 5, Failed_OpNotSuccessful = 6, Failed_NotAnEdge = 7, Failed_IsolatedTriangle = 8, Failed_GeometricDeviation = 9, Ignored_CreatesTinyTriangle = 10, } } }


description: Calculate the Discrete Gaussian Curvature at a vertex as defined by discrete differential geometry Based on Eq 9 from "Discrete Differential-Geometry Operators for Triangulated 2-Manifolds", Meyer et al 2002

code: namespace UE { namespace MeshCurvature { double UE::MeshCurvature::GaussianCurvature ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, int32 VertexIndex ) } }


code: namespace UE { namespace MeshCurvature { double UE::MeshCurvature::GaussianCurvature ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, int32 VertexIndex, [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< FVector3d(int32)> VertexPositionFunc ) } }


description: Calculate the Discrete Mean-Curvature Normal at a vertex as defined by discrete differential geometry. Based on Eq 8 from "Discrete Differential-Geometry Operators for Triangulated 2-Manifolds", Meyer et al 2002 The Discrete Mean-Curvature Normal is (2.0 * MeanCurvature * SurfaceNormal) ((unclear why it has the 2.0))

code: namespace UE { namespace MeshCurvature { FVector3d UE::MeshCurvature::MeanCurvatureNormal ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, int32 VertexIndex ) } }


code: namespace UE { namespace MeshCurvature { FVector3d UE::MeshCurvature::MeanCurvatureNormal ( const [FDynamicMesh3](API\Runtime\GeometryCore\DynamicMesh\FDynamicMesh3) & Mesh, int32 VertexIndex, [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< FVector3d(int32)> VertexPositionFunc ) } }


description: Pure virtual to override; describe and instantiate the commands in here by using the UI COMMAND macro.

module: EditorDebugTools

code: virtual void RegisterCommands()


code: FEditorDebugToolsCommands()


className: FEditorDebugToolsCommands

code: class FEditorDebugToolsCommands : public [TCommands< FEditorDebugToolsCommands >](API\Runtime\Slate\Framework\Commands\TCommands)

OpenPluginWindow

type: TSharedPtr<FUI...


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

code: virtual void ShutdownModule()


className: FEditorDebugToolsModule

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


description: IModuleInterfaceimplementation

code: virtual void StartupModule()


description: The Slate style set for the Shooter game

code: static const [ISlateStyle](API\Runtime\SlateCore\Styling\ISlateStyle) & Get()


code: static void Initialize()


className: StyleInstance

code: static [TSharedPtr](API\Runtime\Core\Templates\TSharedPtr)< class [FSlateStyleSet](API\Runtime\SlateCore\Styling\FSlateStyleSet) > StyleInstance = NULL;


className: FEditorDebugToolsStyle

code: class FEditorDebugToolsStyle


module: EditorPerformanceModule

code: static [IEditorPerformanceModule](API\Plugins\EditorPerformanceModule\IEditorPerformanceModule) & Get()


className: IEditorPerformanceModule

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


description: Implement this for initialization of instances of the system

code: virtual void Initialize ( [FSubsystemCollectionBase](API\Runtime\Engine\Subsystems\FSubsystemCollectionBase) & Collection )


description: Implement this for deinitialization of instances of the system

code: virtual void Deinitialize()


description: Note: This function is called on the CDO prior to instances being created!

code: virtual bool ShouldCreateSubsystem ( [UObject](API\Runtime\CoreUObject\UObject\UObject) * Outer ) const


className: UStallLogSubsystem

description: Subsystem that provides feedback on stall detection

code: [UCLASS](Programming/UnrealArchitecture/Reference/Classes#classdeclaration)() class UStallLogSubsystem : public [UEditorSubsystem](API\Editor\EditorSubsystem\UEditorSubsystem)


className: UEditorScriptableClickDragTool

description: Editor-Only variant ofUScriptableClickDragTool, which gives access to Editor-Only BP functions

module: EditorScriptableToolsFramework


className: UEditorScriptableSingleClickTool

description: Editor-Only variant ofUScriptableSingleClickTool, which gives access to Editor-Only BP functions


description: IModuleInterfaceimplementation


className: FEditorScriptableToolsFrameworkModule

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


className: UEditorScriptableInteractiveTool

description: Editor-Only variant ofUScriptableInteractiveTool, which gives access to Editor-Only BP functions


description: Allow external code to process eachUScriptableInteractiveToolin the current ToolSet

code: void ForEachScriptableTool ( [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< void([UClass](API\Runtime\CoreUObject\UObject\UClass) *ToolClass, [UBaseScriptableToolBuilder](API\Plugins\ScriptableToolsFramework\UBaseScriptableToolBuilder) *ToolBuilder)> ProcessToolFunc )


description: Find allUScriptableInteractiveToolclasses in the current project. (Currently no support for filtering/etc)

code: void ReinitializeScriptableTools()


className: FScriptableToolInfo

code: struct FScriptableToolInfo

ToolBuilder

type: TWeakObjectPtr<...


className: UScriptableToolSet

description: UScriptableToolSetrepresents a set ofUScriptableInteractiveTooltypes.

code: [UCLASS](Programming/UnrealArchitecture/Reference/Classes#classdeclaration)() class UScriptableToolSet : public [UObject](API\Runtime\CoreUObject\UObject\UObject)

ToolBuilders

type: TArray<TObject...

Tools

type: TArray<FScript...


className: EEditorScriptingStringMatchType

module: EditorScriptingUtilities

code: enum EEditorScriptingStringMatchType { Contains, MatchesWildcard, ExactMatch, }


className: EEditorScriptingFilterType

code: enum EEditorScriptingFilterType { Include, Exclude, }


description: Types of Collision Construct that are generated

code: enum EScriptingCollisionShapeType_Deprecated { Box, Sphere, Capsule, NDOP10_X, NDOP10_Y, NDOP10_Z, NDOP18, NDOP26, }


code: [USTRUCT](Programming/UnrealArchitecture/Reference/Structs)([BlueprintType](Programming/UnrealArchitecture/Reference/Structs/Specifiers/BlueprintType), Category="Editor Scripting | Object Dialog") struct FEditorDialogLibraryObjectDetailsViewOptions

bAllowSearch

type: bool

MinHeight

description: The minimum dialog height.

MinWidth

description: The minimum dialog width. If zero, default to the medium window width defined by the Editor style.

ValueColumnWidthRatio

type: float

description: The column size proportion, between 0 and 1, used to display the property value.


BasePackageName

type: FString

description: The package path you want to save to. ie: /Game/MyFolder.

bSpawnMergedActor

description: Spawn the new merged actors.

MeshProxySettings

type: FMeshProxySetti...


bDestroySourceActors

description: Destroy the provided Actors after the operation.

bRenameComponentsFromSource

description: Rename StaticMeshComponents based on source Actor's name.

NewActorLabel

description: Name of the new spawned Actor to replace the provided Actors.


bSpawnMergedActor

description: Spawn the new merged actors.

MeshMergingSettings

type: FMeshMergingSet...


description: Deprecated as of 5.0, use the structFStaticMeshReductionOptionsin Static Mesh Editor Library Instead.

bAutoComputeLODScreenSize

description: If true, the screen sizes at which LODs swap are computed automatically

ReductionSettings

type: TArray<FEditor...

description: Array of reduction settings to apply to each new LOD mesh.


description: SkeletalMesh: The SkeletalMesh we want to create the PhysicsAsset for

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="Editor Scripting | SkeletalMesh") static [UPhysicsAsset](API\Runtime\Engine\PhysicsEngine\UPhysicsAsset) * CreatePhysicsAsset ( [USkeletalMesh](API\Runtime\Engine\Engine\USkeletalMesh) * SkeletalMesh )


description: Deprecated as of 5.0, use the structFStaticMeshReductionSettingsin Static Mesh Editor Library Instead.

PercentTriangles

description: Percentage of triangles to keep. Ranges from 0.0 to 1.0: 1.0 = no reduction, 0.0 = no triangles.

ScreenSize

description: ScreenSize to display this LOD. Ranges from 0.0 to 1.0.


description:
Get number of mesh vertices for an LOD of a Skeletal Mesh
Number of vertices. Returns 0 if invalid mesh or LOD index.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintPure, Category="Editor Scripting | SkeletalMesh", Meta=(DeprecatedFunction, DeprecationMessage="The Editor Scripting Utilities Plugin is deprecated - Use the function in Skeletal Mesh Editor Subsystem")) static int32 GetNumVerts ( [USkeletalMesh](API\Runtime\Engine\Engine\USkeletalMesh) * SkeletalMesh, int32 LODIndex )


description:
Retrieve the number of LOD contain in the specified skeletal mesh.
The LOD number.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="Editor Scripting | SkeletalMesh", Meta=(DeprecatedFunction, DeprecationMessage="The Editor Scripting Utilities Plugin is deprecated - Use the function in Skeletal Mesh Editor Subsystem")) static int32 GetLODCount ( [USkeletalMesh](API\Runtime\Engine\Engine\USkeletalMesh) * SkeletalMesh )


description:
Import or re-import a LOD into the specified base mesh. If the LOD do not exist it will import it and add it to the base static mesh. If the LOD already exist it will re-import the specified LOD.
The index of the LOD that was imported or re-imported. Will return INDEX_NONE if anything goes bad.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="Editor Scripting | SkeletalMesh", Meta=(DeprecatedFunction, DeprecationMessage="The Editor Scripting Utilities Plugin is deprecated - Use the function in Skeletal Mesh Editor Subsystem")) static int32 ImportLOD ( [USkeletalMesh](API\Runtime\Engine\Engine\USkeletalMesh) * BaseMesh, const int32 LODIndex, const [FString](API\Runtime\Core\Containers\FString) & SourceFilename )


description:
Regenerate LODs of the mesh
true if succeed. If mesh reduction is not available this will return false.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="Editor Scripting | SkeletalMesh", Meta=(DeprecatedFunction, DeprecationMessage="The Editor Scripting Utilities Plugin is deprecated - Use the function in Skeletal Mesh Editor Subsystem")) static bool RegenerateLOD ( [USkeletalMesh](API\Runtime\Engine\Engine\USkeletalMesh) * SkeletalMesh, int32 NewLODCount, bool bRegenerateEvenIfImported, bool bGenerateBaseLOD )


description:
Re-import the specified skeletal mesh and all the custom LODs.
true if re-import works, false otherwise see log for explanation.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="Editor Scripting | SkeletalMesh", Meta=(DeprecatedFunction, DeprecationMessage="The Editor Scripting Utilities Plugin is deprecated - Use the function in Skeletal Mesh Editor Subsystem")) static bool ReimportAllCustomLODs ( [USkeletalMesh](API\Runtime\Engine\Engine\USkeletalMesh) * SkeletalMesh )


description:
Rename a socket within a skeleton
true if the renaming succeeded.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="Editor Scripting | SkeletalMesh", Meta=(DeprecatedFunction, DeprecationMessage="The Editor Scripting Utilities Plugin is deprecated - Use the function in Skeletal Mesh Editor Subsystem")) static bool RenameSocket ( [USkeletalMesh](API\Runtime\Engine\Engine\USkeletalMesh) * SkeletalMesh, [FName](API\Runtime\Core\UObject\FName) OldName, [FName](API\Runtime\Core\UObject\FName) NewName )


description:
Remove all the specified LODs. This function will remove all the valid LODs in the list. Valid LOD is any LOD greater then 0 that exist in the skeletalmesh. We cannot remove the base LOD 0.
true if the successfully remove all the LODs. False otherwise, but evedn if it return false it will have removed all valid LODs.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="Editor Scripting | SkeletalMesh", Meta=(ScriptMethod)) static bool RemoveLODs ( [USkeletalMesh](API\Runtime\Engine\Engine\USkeletalMesh) * SkeletalMesh, [TArray](API\Runtime\Core\Containers\TArray)< int32 > ToRemoveLODs )


description: Set the LOD build options for the specified LOD index.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="Editor Scripting | SkeletalMesh", Meta=(DeprecatedFunction, DeprecationMessage="The Editor Scripting Utilities Plugin is deprecated - Use the function in Skeletal Mesh Editor Subsystem")) static void SetLodBuildSettings ( [USkeletalMesh](API\Runtime\Engine\Engine\USkeletalMesh) * SkeletalMesh, const int32 LodIndex, const [FSkeletalMeshBuildSettings](API\Runtime\Engine\Engine\FSkeletalMeshBuildSettings) & BuildOptions )


description: Copy the build options with the specified LOD build settings.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="Editor Scripting | SkeletalMesh", Meta=(DeprecatedFunction, DeprecationMessage="The Editor Scripting Utilities Plugin is deprecated - Use the function in Skeletal Mesh Editor Subsystem")) static void GetLodBuildSettings ( const [USkeletalMesh](API\Runtime\Engine\Engine\USkeletalMesh) * SkeletalMesh, const int32 LodIndex, [FSkeletalMeshBuildSettings](API\Runtime\Engine\Engine\FSkeletalMeshBuildSettings) & OutBuildOptions )


description: SkeletalMesh: The skeletalmesh we want to optimize  LODIndex: The LOD we want to optimize  TextureMask: The texture containing the stripping mask. non black pixel strip triangle, black pixel keep them.  Threshold: The threshold we want when comparing the texture value with zero.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="Editor Scripting | SkeletalMesh", Meta=(ScriptMethod)) static bool StripLODGeometry ( [USkeletalMesh](API\Runtime\Engine\Engine\USkeletalMesh) * SkeletalMesh, const int32 LODIndex, [UTexture2D](API\Runtime\Engine\Engine\UTexture2D) * TextureMask, const float Threshold )


description:
Add simple collisions to a static mesh. This method replicates what is done when invoking menu entries "Collision > Add [...] Simplified Collision" in the Mesh Editor.
An integer indicating the index of the collision newly created. A negative value indicates the addition failed.

code: static int32 AddSimpleCollisionsWithNotification ( [UStaticMesh](API\Runtime\Engine\Engine\UStaticMesh) * StaticMesh, const [EScriptingCollisionShapeType_Deprecated](API\Plugins\EditorScriptingUtilities\EScriptingCollisionShapeType_Dep-) ShapeType, bool bApplyChanges )


description: Utility class to altering and analyzing a SkeletalMesh and use the common functionalities of the SkeletalMesh Editor. The editor should not be in play in editor mode.


description: Deprecated* The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="Editor Scripting | StaticMesh", Meta=(DeprecatedFunction, DeprecationMessage="The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem")) static int32 AddSimpleCollisionsWithNotification ( [UStaticMesh](API\Runtime\Engine\Engine\UStaticMesh) * StaticMesh, const EScriptCollisionShapeType ShapeType, bool bApplyChanges )


description: Same as AddSimpleCollisionsWithNotification but changes are automatically applied.

code: static int32 AddSimpleCollisions ( [UStaticMesh](API\Runtime\Engine\Engine\UStaticMesh) * StaticMesh, const [EScriptingCollisionShapeType_Deprecated](API\Plugins\EditorScriptingUtilities\EScriptingCollisionShapeType_Dep-) ShapeType )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="Editor Scripting | StaticMesh", Meta=(DeprecatedFunction, DeprecationMessage="The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem")) static int32 AddSimpleCollisions ( [UStaticMesh](API\Runtime\Engine\Engine\UStaticMesh) * StaticMesh, const EScriptCollisionShapeType ShapeType )


description: Same as SetConvexDecompositionCollisionsWithNotification but changes are automatically applied.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="Editor Scripting | StaticMesh", Meta=(DeprecatedFunction, DeprecationMessage="The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem")) static bool BulkSetConvexDecompositionCollisions ( const [TArray](API\Runtime\Core\Containers\TArray)< [UStaticMesh](API\Runtime\Engine\Engine\UStaticMesh) * > & StaticMeshes, int32 HullCount, int32 MaxHullVerts, int32 HullPrecision )


description:
Compute convex collisions for a set of static meshes. Any existing collisions will be removed from the static meshes. This method replicates what is done when invoking menu entry "Collision > Auto Convex Collision" in the Mesh Editor.
A boolean indicating if the addition was successful or not.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="Editor Scripting | StaticMesh", Meta=(DeprecatedFunction, DeprecationMessage="The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem")) static bool BulkSetConvexDecompositionCollisionsWithNotification ( const [TArray](API\Runtime\Core\Containers\TArray)< [UStaticMesh](API\Runtime\Engine\Engine\UStaticMesh) * > & StaticMeshes, int32 HullCount, int32 MaxHullVerts, int32 HullPrecision, bool bApplyChanges )


description:
Adds an empty UV channel at the end of the existing channels on the given LOD of a StaticMesh.
true if a UV channel was added.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="Editor Scripting | StaticMesh", Meta=(DeprecatedFunction, DeprecationMessage="The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem")) static bool AddUVChannel ( [UStaticMesh](API\Runtime\Engine\Engine\UStaticMesh) * StaticMesh, int32 LODIndex )


description: Converts the deprecated EScriptingCollisionShapeType_Deprecated to the new EScriptCollisionShapeType.

code: static EScriptCollisionShapeType ConvertCollisionShape ( const [EScriptingCollisionShapeType_Deprecated](API\Plugins\EditorScriptingUtilities\EScriptingCollisionShapeType_Dep-) & CollisionShape )


description: Editor Scripting | Dataprep

code: static [FStaticMeshReductionOptions](API\Editor\StaticMeshEditor\FStaticMeshReductionOptions) ConvertReductionOptions ( const [FEditorScriptingMeshReductionOptions_Deprecated](API\Plugins\EditorScriptingUtilities\FEditorScripting-_3) & ReductionOptions )


description: Enables/disables mesh section shadow casting for a specific LOD.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="Editor Scripting | StaticMesh", Meta=(DeprecatedFunction, DeprecationMessage="The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem")) static void EnableSectionCastShadow ( [UStaticMesh](API\Runtime\Engine\Engine\UStaticMesh) * StaticMesh, bool bCastShadow, int32 LODIndex, int32 SectionIndex )


description:
Generates box UV mapping in the specified UV channel on the given LOD of a StaticMesh.
true if the UV mapping was generated.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="Editor Scripting | StaticMesh", Meta=(DeprecatedFunction, DeprecationMessage="The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem")) static bool GenerateBoxUVChannel ( [UStaticMesh](API\Runtime\Engine\Engine\UStaticMesh) * StaticMesh, int32 LODIndex, int32 UVChannelIndex, const FVector & Position, const FRotator & Orientation, const FVector & Size )


description: Enables/disables mesh section collision for a specific LOD.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="Editor Scripting | StaticMesh", Meta=(DeprecatedFunction, DeprecationMessage="The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem")) static void EnableSectionCollision ( [UStaticMesh](API\Runtime\Engine\Engine\UStaticMesh) * StaticMesh, bool bCollisionEnabled, int32 LODIndex, int32 SectionIndex )


description:
Generates cylindrical UV mapping in the specified UV channel on the given LOD of a StaticMesh.
true if the UV mapping was generated.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="Editor Scripting | StaticMesh", Meta=(DeprecatedFunction, DeprecationMessage="The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem")) static bool GenerateCylindricalUVChannel ( [UStaticMesh](API\Runtime\Engine\Engine\UStaticMesh) * StaticMesh, int32 LODIndex, int32 UVChannelIndex, const FVector & Position, const FRotator & Orientation, const FVector2D & Tiling )


description:
Generates planar UV mapping in the specified UV channel on the given LOD of a StaticMesh.
true if the UV mapping was generated.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="Editor Scripting | StaticMesh", Meta=(DeprecatedFunction, DeprecationMessage="The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem")) static bool GeneratePlanarUVChannel ( [UStaticMesh](API\Runtime\Engine\Engine\UStaticMesh) * StaticMesh, int32 LODIndex, int32 UVChannelIndex, const FVector & Position, const FRotator & Orientation, const FVector2D & Tiling )


description:
Get the Collision Trace behavior of a static mesh
the Collision Trace behavior.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintPure, Category="Editor Scripting | StaticMesh", Meta=(DeprecatedFunction, DeprecationMessage="The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem")) static [TEnumAsByte](API\Runtime\Core\Containers\TEnumAsByte)< ECollisionTraceFlag > GetCollisionComplexity ( [UStaticMesh](API\Runtime\Engine\Engine\UStaticMesh) * StaticMesh )


description:
Get number of convex collisions present on a static mesh.
An integer representing the number of convex collisions on the input static mesh. An negative value indicates that the command could not be executed. See log for explanation.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="Editor Scripting | StaticMesh", Meta=(DeprecatedFunction, DeprecationMessage="The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem")) static int32 GetConvexCollisionCount ( [UStaticMesh](API\Runtime\Engine\Engine\UStaticMesh) * StaticMesh )


description: Copy the build options with the specified LOD build settings.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="Editor Scripting | StaticMesh", Meta=(DeprecatedFunction, DeprecationMessage="The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem")) static void GetLodBuildSettings ( const [UStaticMesh](API\Runtime\Engine\Engine\UStaticMesh) * StaticMesh, const int32 LodIndex, [FMeshBuildSettings](API\Runtime\Engine\Engine\FMeshBuildSettings) & OutBuildOptions )


description:
Get number of LODs present on a static mesh.
the number of LODs present on the input mesh. An negative value indicates that the command could not be executed. See log for explanation.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="Editor Scripting | StaticMesh", Meta=(DeprecatedFunction, DeprecationMessage="The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem")) static int32 GetLodCount ( [UStaticMesh](API\Runtime\Engine\Engine\UStaticMesh) * StaticMesh )


description: Copy the reduction options with the specified LOD reduction settings.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="Editor Scripting | StaticMesh", Meta=(DeprecatedFunction, DeprecationMessage="The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem")) static void GetLodReductionSettings ( const [UStaticMesh](API\Runtime\Engine\Engine\UStaticMesh) * StaticMesh, const int32 LodIndex, [FMeshReductionSettings](API\Runtime\Engine\Engine\FMeshReductionSettings) & OutReductionOptions )


description:
Get an array of LOD screen sizes for evaluation.
array of LOD screen sizes.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintPure, Category="Editor Scripting | StaticMesh", Meta=(DeprecatedFunction, DeprecationMessage="The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem")) static [TArray](API\Runtime\Core\Containers\TArray)< float > GetLodScreenSizes ( [UStaticMesh](API\Runtime\Engine\Engine\UStaticMesh) * StaticMesh )


description: Get number of Materials for a StaticMesh

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintPure, Category="Editor Scripting | StaticMesh", Meta=(DeprecatedFunction, DeprecationMessage="The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem")) static int32 GetNumberMaterials ( [UStaticMesh](API\Runtime\Engine\Engine\UStaticMesh) * StaticMesh )


description: Get number of StaticMesh verts for an LOD

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintPure, Category="Editor Scripting | StaticMesh", Meta=(DeprecatedFunction, DeprecationMessage="The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem")) static int32 GetNumberVerts ( [UStaticMesh](API\Runtime\Engine\Engine\UStaticMesh) * StaticMesh, int32 LODIndex )


description:
Returns the number of UV channels for the given LOD of a StaticMesh.
the number of UV channels.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="Editor Scripting | StaticMesh", Meta=(DeprecatedFunction, DeprecationMessage="The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem")) static int32 GetNumUVChannels ( [UStaticMesh](API\Runtime\Engine\Engine\UStaticMesh) * StaticMesh, int32 LODIndex )


description:
Get number of simple collisions present on a static mesh.
An integer representing the number of simple collisions on the input static mesh. An negative value indicates that the command could not be executed. See log for explanation.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="Editor Scripting | StaticMesh", Meta=(DeprecatedFunction, DeprecationMessage="The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem")) static int32 GetSimpleCollisionCount ( [UStaticMesh](API\Runtime\Engine\Engine\UStaticMesh) * StaticMesh )


description: Check whether a static mesh component has vertex colors

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintPure, Category="Editor Scripting | StaticMesh", Meta=(DeprecatedFunction, DeprecationMessage="The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem")) static bool HasInstanceVertexColors ( [UStaticMeshComponent](API\Runtime\Engine\Components\UStaticMeshComponent) * StaticMeshComponent )


description: Check whether a static mesh has vertex colors

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintPure, Category="Editor Scripting | StaticMesh", Meta=(DeprecatedFunction, DeprecationMessage="The Editor Scripting Utilities Plugin is deprecated - Use the function in Static Mesh Editor Subsystem")) static bool HasVertexColors ( [UStaticMesh](API\Runtime\Engine\Engine\UStaticMesh) * StaticMesh )