ShowFlag.MeshEdges

ShowFlag.MeshEdges

#Overview

name: ShowFlag.MeshEdges

This variable is created as a Console Variable (cvar).

It is referenced in 28 C++ source files.

#Summary

#Usage in the C++ source code

The purpose of ShowFlag.MeshEdges is to control the rendering of mesh edges in Unreal Engine 5. It is used to display the wireframe overlay of 3D meshes in addition to their filled surfaces in the viewport.

This setting variable is primarily used by the rendering system in Unreal Engine. It is referenced in various subsystems and modules, including:

  1. The Engine module, specifically in the PrimitiveDrawingUtils.cpp file.
  2. The Persona module, which is part of the animation editing system.
  3. The GeometryProcessing plugin, particularly in the DynamicMesh operations.

The value of this variable is typically set through the engine show flags system, which allows toggling various rendering features on and off. It can be manipulated programmatically, as seen in the SAnimationEditorViewportTabBody class where there’s a method to update this flag.

This variable interacts closely with other rendering-related variables and is often used in conjunction with other show flags to determine the overall rendering state of the viewport.

Developers should be aware that:

  1. Enabling mesh edges can impact rendering performance, especially for complex scenes.
  2. It’s primarily intended for use in editor viewports rather than in-game rendering.
  3. The visibility of mesh edges may depend on the current view mode and other rendering settings.

Best practices when using this variable include:

  1. Only enabling it when necessary for debugging or specific editing tasks.
  2. Considering performance implications when enabling it for large or complex scenes.
  3. Using it in combination with other view modes and show flags to achieve the desired visualization.

Regarding the associated variable MeshEdges, it appears to be the direct implementation of the ShowFlag.MeshEdges functionality. It’s used in various parts of the engine to actually perform the mesh edge rendering when the show flag is enabled. The same considerations and best practices apply to this variable as well.

#References in C++ code

#Callsites

This variable is referenced in the following C++ source code:

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Public/ShowFlagsValues.inl:243

Scope: file

Source code excerpt:

SHOWFLAG_FIXED_IN_SHIPPING(0, Snap, SFG_Hidden, NSLOCTEXT("UnrealEd", "SnapSF", "Snap"))
/** In the filled view modeModeWidgetss, render mesh edges as well as the filled surfaces. */
SHOWFLAG_FIXED_IN_SHIPPING(0, MeshEdges, SFG_Advanced, NSLOCTEXT("UnrealEd", "MeshEdgesSF", "Mesh Edges"))
/** Complex cover rendering */
SHOWFLAG_FIXED_IN_SHIPPING(0, Cover, SFG_Hidden, NSLOCTEXT("UnrealEd", "CoverSF", "Cover"))
/** Spline rendering */
SHOWFLAG_FIXED_IN_SHIPPING(0, Splines, SFG_Advanced, NSLOCTEXT("UnrealEd", "SplinesSF", "Splines"))
/** Selection rendering, could be useful in game as well */
SHOWFLAG_FIXED_IN_SHIPPING(0, Selection, SFG_Advanced, NSLOCTEXT("UnrealEd", "SelectionSF", "Selection"))

#Associated Variable and Callsites

This variable is associated with another variable named MeshEdges. They share the same value. See the following C++ source code.

#Loc: <Workspace>/Engine/Plugins/2D/Paper2D/Source/Paper2DEditor/Private/SpriteEditor/SpriteEditorViewportClient.cpp:672

Scope (from outer to inner):

file
function     void FSpriteEditorViewportClient::ToggleShowMeshEdges

Source code excerpt:

void FSpriteEditorViewportClient::ToggleShowMeshEdges()
{
	EngineShowFlags.SetMeshEdges(!EngineShowFlags.MeshEdges);
	Invalidate(); 
}

bool FSpriteEditorViewportClient::IsShowMeshEdgesChecked() const
{
	return EngineShowFlags.MeshEdges;
}

// Find all related sprites (not including self)
void FSpriteEditorViewportClient::UpdateRelatedSpritesList()
{
	UPaperSprite* Sprite = GetSpriteBeingEdited();

#Loc: <Workspace>/Engine/Plugins/2D/Paper2D/Source/Paper2DEditor/Private/TileMapEditing/TileMapEditorViewportClient.cpp:256

Scope (from outer to inner):

file
function     void FTileMapEditorViewportClient::ToggleShowMeshEdges

Source code excerpt:

void FTileMapEditorViewportClient::ToggleShowMeshEdges()
{
	EngineShowFlags.SetMeshEdges(!EngineShowFlags.MeshEdges);
	Invalidate();
}

bool FTileMapEditorViewportClient::IsShowMeshEdgesChecked() const
{
	return EngineShowFlags.MeshEdges;
}

void FTileMapEditorViewportClient::ToggleShowTileMapStats()
{
	bShowTileMapStats = !bShowTileMapStats;
	Invalidate();

#Loc: <Workspace>/Engine/Plugins/Runtime/GeometryProcessing/Source/DynamicMesh/Private/Operations/MeshBevel.cpp:323

Scope (from outer to inner):

file
function     void FMeshBevel::AddBevelGroupEdge

Source code excerpt:

	}

	Edge.MeshEdges.Append(MeshEdgeList);
	Edge.MeshVertices.Append(Topology.Edges[GroupEdgeID].Span.Vertices);
	Edge.GroupEdgeID = GroupEdgeID;
	Edge.GroupIDs = Topology.Edges[GroupEdgeID].Groups;

	Edge.MeshEdgeTris.Reserve(Edge.MeshEdges.Num());
	for (int32 eid : Edge.MeshEdges)
	{
		Edge.MeshEdgeTris.Add(Mesh.GetEdgeT(eid));
	}

	Edge.InitialPositions.Reserve(Edge.MeshVertices.Num());
	for (int32 vid : Edge.MeshVertices)

#Loc: <Workspace>/Engine/Plugins/Runtime/GeometryProcessing/Source/DynamicMesh/Private/Operations/MeshBevel.cpp:357

Scope (from outer to inner):

file
function     void FMeshBevel::AddBevelEdgeLoop

Source code excerpt:


	FBevelLoop Loop;
	Loop.MeshEdges = MeshEdgeLoop.Edges;
	Loop.MeshVertices = MeshEdgeLoop.Vertices;

	Loop.MeshEdgeTris.Reserve(Loop.MeshEdges.Num());
	for (int32 eid : Loop.MeshEdges)
	{
		Loop.MeshEdgeTris.Add(Mesh.GetEdgeT(eid));
	}

	Loop.InitialPositions.Reserve(Loop.MeshVertices.Num());
	for (int32 vid : Loop.MeshVertices)

#Loc: <Workspace>/Engine/Plugins/Runtime/GeometryProcessing/Source/DynamicMesh/Private/Operations/MeshBevel.cpp:783

Scope (from outer to inner):

file
function     void FMeshBevel::UnlinkBevelEdgeInterior

Source code excerpt:

	if (BevelEdge.bEndpointBoundaryFlag[0])
	{
		SplitsToProcess[0].bOK = SplitBoundaryVertexTrianglesIntoSubsets(&Mesh, SplitsToProcess[0].VertexID, BevelEdge.MeshEdges[0], 
			SplitsToProcess[0].TriSets[0], SplitsToProcess[0].TriSets[1]);
	}
	for (int32 k = 1; k < N - 1; ++k)
	{
		SplitsToProcess[k].VertexID = BevelEdge.MeshVertices[k];
		if (Mesh.IsBoundaryVertex(SplitsToProcess[k].VertexID))

#Loc: <Workspace>/Engine/Plugins/Runtime/GeometryProcessing/Source/DynamicMesh/Private/Operations/MeshBevel.cpp:796

Scope (from outer to inner):

file
function     void FMeshBevel::UnlinkBevelEdgeInterior

Source code excerpt:

		{
			SplitsToProcess[k].bOK = SplitInteriorVertexTrianglesIntoSubsets(&Mesh, SplitsToProcess[k].VertexID,
				BevelEdge.MeshEdges[k-1], BevelEdge.MeshEdges[k], SplitsToProcess[k].TriSets[0], SplitsToProcess[k].TriSets[1]);
		}
	}
	SplitsToProcess[N-1] = UELocal::FVertexSplit{ BevelEdge.MeshVertices[N - 1], false };
	if (BevelEdge.bEndpointBoundaryFlag[1])
	{
		SplitsToProcess[N-1].bOK = SplitBoundaryVertexTrianglesIntoSubsets(&Mesh, SplitsToProcess[N-1].VertexID, BevelEdge.MeshEdges[N-2], 
			SplitsToProcess[N-1].TriSets[0], SplitsToProcess[N-1].TriSets[1]);
	}

	// SplitInteriorVertexTrianglesIntoSubsets does not consistently order its output sets, ie, if you imagine [Edge0,Edge1] as a path
	// cutting through the one ring, the "side" that Set0 and Set1 end up is arbitrary, and depends on the ordering of edges in the triangles of Edge1.
	// This might ideally be fixed in the future, but for the time being, all we need is consistency. So we walk from the start of the

#Loc: <Workspace>/Engine/Plugins/Runtime/GeometryProcessing/Source/DynamicMesh/Private/Operations/MeshBevel.cpp:845

Scope (from outer to inner):

file
function     void FMeshBevel::UnlinkBevelEdgeInterior

Source code excerpt:

	for (int32 k = 0; k < N-1; ++k)
	{
		int32 Edge0 = BevelEdge.MeshEdges[k];
		int32 Edge1 = Mesh.FindEdge(BevelEdge.NewMeshVertices[k], BevelEdge.NewMeshVertices[k + 1]);
		BevelEdge.NewMeshEdges.Add(Edge1);
		MESH_BEVEL_DEBUG_CHECK(Edge1 >= 0);
		if ( Mesh.IsEdge(Edge1) && Edge0 != Edge1 && MeshEdgePairs.Contains(Edge0) == false )
		{
			MeshEdgePairs.Add(Edge0, Edge1);

#Loc: <Workspace>/Engine/Plugins/Runtime/GeometryProcessing/Source/DynamicMesh/Private/Operations/MeshBevel.cpp:878

Scope (from outer to inner):

file
function     void FMeshBevel::UnlinkBevelLoop

Source code excerpt:

		else
		{
			int32 PrevEdge = (k == 0) ? BevelLoop.MeshEdges.Last() : BevelLoop.MeshEdges[k-1];
			int32 CurEdge = BevelLoop.MeshEdges[k];
			SplitsToProcess[k].bOK = SplitInteriorVertexTrianglesIntoSubsets(&Mesh, SplitsToProcess[k].VertexID,
				PrevEdge, CurEdge, SplitsToProcess[k].TriSets[0], SplitsToProcess[k].TriSets[1]);
		}
	}

	// fix up triangle sets - see call in UnlinkBevelEdgeInterior() for more info

#Loc: <Workspace>/Engine/Plugins/Runtime/GeometryProcessing/Source/DynamicMesh/Private/Operations/MeshBevel.cpp:920

Scope (from outer to inner):

file
function     void FMeshBevel::UnlinkBevelLoop

Source code excerpt:

	for (int32 k = 0; k < N; ++k)
	{
		int32 Edge0 = BevelLoop.MeshEdges[k];
		int32 Edge1 = Mesh.FindEdge(BevelLoop.NewMeshVertices[k], BevelLoop.NewMeshVertices[(k + 1)%N]);
		BevelLoop.NewMeshEdges.Add(Edge1);
		MESH_BEVEL_DEBUG_CHECK(Edge1 >= 0);
		if (Mesh.IsEdge(Edge1) && Edge0 != Edge1 && MeshEdgePairs.Contains(Edge0) == false )
		{
			MeshEdgePairs.Add(Edge0, Edge1);

#Loc: <Workspace>/Engine/Plugins/Runtime/GeometryProcessing/Source/DynamicMesh/Private/Operations/MeshBevel.cpp:1077

Scope (from outer to inner):

file
function     void FMeshBevel::FixUpUnlinkedBevelEdges

Source code excerpt:

		// could not actually unlink the edge in UnlinkBevelEdgeInterior (if there were no interior vertices).
		// Now that all vertices are unlinked, take one more pass through and fix the single-edge or self-mapped edges.
		bool bSingleEdge = Edge.MeshEdges.Num() == 1;
		bool bFailedEdgePairing = false;
		for (int32 Idx = 0; Idx < Edge.MeshEdges.Num(); ++Idx)
		{
			bool bNewEdgeIsOld = Edge.MeshEdges[Idx] == Edge.NewMeshEdges[Idx];
			if (!bSingleEdge && !bNewEdgeIsOld)
			{
				continue;
			}

			int32* FoundOtherEdge = MeshEdgePairs.Find(Edge.MeshEdges[Idx]);
			MESH_BEVEL_DEBUG_CHECK(FoundOtherEdge != nullptr);
			if (FoundOtherEdge != nullptr)
			{
				Edge.NewMeshEdges[Idx] = *FoundOtherEdge;
			}
			else

#Loc: <Workspace>/Engine/Plugins/Runtime/GeometryProcessing/Source/DynamicMesh/Private/Operations/MeshBevel.cpp:1108

Scope (from outer to inner):

file
function     void FMeshBevel::FixUpUnlinkedBevelEdges

Source code excerpt:

		{
			int32 vi = (j == 0) ? 0 : (Edge.MeshVertices.Num()-1);
			int32 ei = (j == 0) ? 0 : (Edge.MeshEdges.Num()-1);
			const FBevelVertex* BevelVertex = GetBevelVertexFromVertexID(Edge.MeshVertices[vi]);
			int32& V0 = Edge.MeshVertices[vi];
			int32& V1 = Edge.NewMeshVertices[vi];
			int32 E0 = Edge.MeshEdges[ei], E1 = Edge.NewMeshEdges[ei];
			bool bFoundV0 = false, bFoundV1 = false;
			for (const FOneRingWedge& Wedge : BevelVertex->Wedges)
			{
				for (int32 tid : Wedge.Triangles)
				{
					FIndex3i TriEdges = Mesh.GetTriEdges(tid);

#Loc: <Workspace>/Engine/Plugins/Runtime/GeometryProcessing/Source/DynamicMesh/Private/Operations/MeshBevel.cpp:1171

Scope (from outer to inner):

file
function     void FMeshBevel::DisplaceVertices

Source code excerpt:

	{
		FBevelEdge& Edge = Edges[k];
		UE::Geometry::ComputeInsetLineSegmentsFromEdges(Mesh, Edge.MeshEdges, InsetDistance, AllInsetLines[k].InsetLines0);
		UE::Geometry::SolveInsetVertexPositionsFromInsetLines(Mesh, AllInsetLines[k].InsetLines0, Edge.MeshVertices, Edge.NewPositions0, false);

		UE::Geometry::ComputeInsetLineSegmentsFromEdges(Mesh, Edge.NewMeshEdges, InsetDistance, AllInsetLines[k].InsetLines1);
		UE::Geometry::SolveInsetVertexPositionsFromInsetLines(Mesh, AllInsetLines[k].InsetLines1, Edge.NewMeshVertices, Edge.NewPositions1, false);
	}

#Loc: <Workspace>/Engine/Plugins/Runtime/GeometryProcessing/Source/DynamicMesh/Private/Operations/MeshBevel.cpp:1182

Scope (from outer to inner):

file
function     void FMeshBevel::DisplaceVertices

Source code excerpt:

	{
		TArray<FLine3d> InsetLines;
		UE::Geometry::ComputeInsetLineSegmentsFromEdges(Mesh, Loop.MeshEdges, InsetDistance, InsetLines);
		UE::Geometry::SolveInsetVertexPositionsFromInsetLines(Mesh, InsetLines, Loop.MeshVertices, Loop.NewPositions0, true);

		UE::Geometry::ComputeInsetLineSegmentsFromEdges(Mesh, Loop.NewMeshEdges, InsetDistance, InsetLines);
		UE::Geometry::SolveInsetVertexPositionsFromInsetLines(Mesh, InsetLines, Loop.NewMeshVertices, Loop.NewPositions1, true);
	}

#Loc: <Workspace>/Engine/Plugins/Runtime/GeometryProcessing/Source/DynamicMesh/Private/Operations/MeshBevel.cpp:1443

Scope (from outer to inner):

file
function     void FMeshBevel::AppendEdgeQuads

Source code excerpt:

void FMeshBevel::AppendEdgeQuads(FDynamicMesh3& Mesh, FBevelEdge& Edge)
{
	int32 NumEdges = Edge.MeshEdges.Num();
	if (NumEdges != Edge.NewMeshEdges.Num())
	{
		return;
	}

	Edge.NewGroupID = Mesh.AllocateTriangleGroup();

#Loc: <Workspace>/Engine/Plugins/Runtime/GeometryProcessing/Source/DynamicMesh/Private/Operations/MeshBevel.cpp:1455

Scope (from outer to inner):

file
function     void FMeshBevel::AppendEdgeQuads

Source code excerpt:

	for (int32 k = 0; k < NumEdges; ++k)
	{
		int32 EdgeID0 = Edge.MeshEdges[k];
		int32 EdgeID1 = Edge.NewMeshEdges[k];

		// in certain cases, like bevel topo-edges with a single mesh-edge, we would not
		// have been able to construct the "other" mesh edge when processing the topo-edge
		// (where .NewMeshEdges is computed), it would only have been created when processing the
		// junction vertex. Currently we do not go back and update .NewMeshEdges in that case, but

#Loc: <Workspace>/Engine/Plugins/Runtime/GeometryProcessing/Source/DynamicMesh/Private/Operations/MeshBevel.cpp:1501

Scope (from outer to inner):

file
function     void FMeshBevel::AppendLoopQuads

Source code excerpt:

void FMeshBevel::AppendLoopQuads(FDynamicMesh3& Mesh, FBevelLoop& Loop)
{
	int32 NumEdges = Loop.MeshEdges.Num();
	if (NumEdges != Loop.NewMeshEdges.Num())
	{
		return;
	}

	auto GetGroupKey = [&Mesh, &Loop](int32 k)

#Loc: <Workspace>/Engine/Plugins/Runtime/GeometryProcessing/Source/DynamicMesh/Private/Operations/MeshBevel.cpp:1530

Scope (from outer to inner):

file
function     void FMeshBevel::AppendLoopQuads

Source code excerpt:

	for (int32 k = 0; k < NumEdges; ++k)
	{
		int32 EdgeID0 = Loop.MeshEdges[k];
		int32 EdgeID1 = Loop.NewMeshEdges[k];

		// case that happens in AppendEdgeQuads() should never happen for loops...

		FIndex2i QuadTris(IndexConstants::InvalidID, IndexConstants::InvalidID);
		if (EdgeID0 != EdgeID1 && Mesh.IsEdge(EdgeID1))

#Loc: <Workspace>/Engine/Plugins/Runtime/GeometryProcessing/Source/DynamicMesh/Private/Operations/MeshBevel.cpp:1614

Scope (from outer to inner):

file
function     void FMeshBevel::AppendEdgeQuads_Multi

Source code excerpt:

void FMeshBevel::AppendEdgeQuads_Multi(FDynamicMesh3& Mesh, FBevelEdge& Edge)
{
	int32 NumEdges = Edge.MeshEdges.Num();
	if (NumEdges != Edge.NewMeshEdges.Num())
	{
		return;
	}

	Edge.NewGroupID = Mesh.AllocateTriangleGroup();

#Loc: <Workspace>/Engine/Plugins/Runtime/GeometryProcessing/Source/DynamicMesh/Private/Operations/MeshBevel.cpp:1636

Scope (from outer to inner):

file
function     void FMeshBevel::AppendEdgeQuads_Multi

Source code excerpt:

	for (int32 k = 0; k < NumEdges && bFoundInvalidCase == false; ++k)
	{
		int32 EdgeID0 = Edge.MeshEdges[k];
		int32 EdgeID1 = Edge.NewMeshEdges[k];

		// in certain cases, like bevel topo-edges with a single mesh-edge, we would not
		// have been able to construct the "other" mesh edge when processing the topo-edge
		// (where .NewMeshEdges is computed), it would only have been created when processing the
		// junction vertex. Currently we do not go back and update .NewMeshEdges in that case, but

#Loc: <Workspace>/Engine/Plugins/Runtime/GeometryProcessing/Source/DynamicMesh/Private/Operations/MeshBevel.cpp:1844

Scope (from outer to inner):

file
function     void FMeshBevel::AppendLoopQuads_Multi

Source code excerpt:

	// AppendEdgeQuads_Multi() for anything non-obvious below

	int32 NumEdges = Loop.MeshEdges.Num();
	if (NumEdges != Loop.NewMeshEdges.Num())
	{
		return;
	}

	auto GetGroupKey = [&Mesh, &Loop](int32 k)

#Loc: <Workspace>/Engine/Plugins/Runtime/GeometryProcessing/Source/DynamicMesh/Private/Operations/MeshBevel.cpp:1882

Scope (from outer to inner):

file
function     void FMeshBevel::AppendLoopQuads_Multi

Source code excerpt:

	for (int32 k = 0; k < NumEdges && bFoundInvalidCase == false; ++k)
	{
		int32 EdgeID0 = Loop.MeshEdges[k];
		int32 EdgeID1 = Loop.NewMeshEdges[k];

		// case that happens in AppendEdgeQuads() should never happen for loops...

		FIndex2i QuadTris(IndexConstants::InvalidID, IndexConstants::InvalidID);
		if (EdgeID0 != EdgeID1 && Mesh.IsEdge(EdgeID1))

#Loc: <Workspace>/Engine/Plugins/Runtime/GeometryProcessing/Source/DynamicMesh/Public/Operations/MeshBevel.h:143

Scope (from outer to inner):

file
namespace    UE
namespace    Geometry
class        class FMeshBevel

Source code excerpt:

		// initial topological information that defines what happens in unlink/displace/mesh steps
		TArray<int32> MeshVertices;		// sequential list of mesh vertex IDs along edge loop
		TArray<int32> MeshEdges;		// sequential list of mesh edge IDs along edge loop
		TArray<FIndex2i> MeshEdgeTris;	// the one or two triangles associated w/ each MeshEdges element in the input mesh
		TArray<FVector3d> InitialPositions;		// initial vertex positions

		// new mesh topology computed during unlink step
		TArray<int32> NewMeshVertices;		// list of new vertices on "other" side of unlinked edge, 1-1 with MeshVertices
		TArray<int32> NewMeshEdges;			// list of new edges on "other" side of unlinked edge, 1-1 with MeshEdges

		// buffers for new vertex positions computed during displace step
		TArray<FVector3d> NewPositions0;	// new positions for MeshVertices list
		TArray<FVector3d> NewPositions1;	// new positions for NewMeshVertices list

		// new geometry computed during mesh step
		TArray<int32> NewGroupIDs;
		TArray<FIndex2i> StripQuads;		// triangle-ID-pairs for each new quad added along edge, 1-1 with MeshEdges
		FQuadGridPatch StripQuadPatch;			// only initialized in multi-segment bevel
		TArray<FVector3d> NormalsA, NormalsB;	// normals at NewPositions0 and NewPositions1, before internal meshing is added (ie the tangent-boundary condition)
	};

	// FBevelEdge is the accumulated data for an open span of mesh-edges, which possibly meets up with other bevel-edges
	// at the vertices on either end of the span. Each mesh-edge of the bevel-edge will become a quad

#Loc: <Workspace>/Engine/Plugins/Runtime/GeometryProcessing/Source/DynamicMesh/Public/Operations/MeshBevel.h:169

Scope (from outer to inner):

file
namespace    UE
namespace    Geometry
class        class FMeshBevel

Source code excerpt:

		int32 EdgeIndex;				// index of this BevelEdge in Edges array
		TArray<int32> MeshVertices;		// sequential list of mesh vertex IDs along edge
		TArray<int32> MeshEdges;		// sequential list of mesh edge IDs along edge
		TArray<FIndex2i> MeshEdgeTris;	// the one or two triangles associated w/ each MeshEdges element in the input mesh
		int32 GroupEdgeID;				// ID of this edge in external topology (eg FGroupTopology)
		FIndex2i GroupIDs;				// topological IDs of groups on either side of topological edge
		bool bEndpointBoundaryFlag[2];	// flag defining whether vertex at start/end of MeshVertices was a boundary vertex
		TArray<FVector3d> InitialPositions;		// initial vertex positions
		FIndex2i BevelVertices;			// indices of Bevel Vertices at either end of Bevel Edge

		// new mesh topology computed during unlink step
		TArray<int32> NewMeshVertices;		// list of new vertices on "other" side of unlinked edge, 1-1 with MeshVertices
		TArray<int32> NewMeshEdges;			// list of new edges on "other" side of unlinked edge, 1-1 with MeshEdges

		// buffers for new vertex positions computed during displace step
		TArray<FVector3d> NewPositions0;	// new positions for MeshVertices list
		TArray<FVector3d> NewPositions1;	// new positions for NewMeshVertices list

		// new geometry computed during mesh step
		int32 NewGroupID;
		TArray<FIndex2i> StripQuads;		// triangle-ID-pairs for each new quad added along edge, 1-1 with MeshEdges
		FQuadGridPatch StripQuadPatch;			// only initialized in multi-segment bevel
		TArray<FVector3d> NormalsA, NormalsB;	// normals at NewPositions0 and NewPositions1, before internal meshing is added (ie the tangent-boundary condition)
	};


	// A FOneRingWedge represents a sequential set of connected triangles around a vertex, ie a subset of an ordered triangle one-ring.

#Loc: <Workspace>/Engine/Source/Editor/Persona/Private/SAnimationEditorViewport.h:647

Scope (from outer to inner):

file
class        class SAnimationEditorViewportTabBody : public IPersonaViewport

Source code excerpt:

	float GetViewMaxInput() const;

	/** Sets The EngineShowFlags.MeshEdges flag on the viewport based on current state */
	void UpdateShowFlagForMeshEdges();

	/** Update scrub panel to reflect viewed animation asset */
	void UpdateScrubPanel(UAnimationAsset* AnimAsset);

	/** Adds a persistent notification to display recording state when recording */

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/PrimitiveDrawingUtils.cpp:1538

Scope (from outer to inner):

file
function     bool IsRichView

Source code excerpt:

		ViewFamily.EngineShowFlags.BSPSplit ||
		ViewFamily.EngineShowFlags.LightMapDensity ||
		ViewFamily.EngineShowFlags.MeshEdges ||
		ViewFamily.EngineShowFlags.LightInfluences ||
		ViewFamily.EngineShowFlags.Wireframe ||
		ViewFamily.EngineShowFlags.ActorColoration ||
		ViewFamily.EngineShowFlags.LODColoration ||
		ViewFamily.EngineShowFlags.HLODColoration ||
		ViewFamily.EngineShowFlags.MassProperties )

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/PrimitiveDrawingUtils.cpp:1713

Scope (from outer to inner):

file
function     void ApplyViewModeOverrides

Source code excerpt:


		//Draw a wireframe overlay last, if requested
		if (EngineShowFlags.MeshEdges)
		{
			FMeshBatch& MeshEdgeElement = Collector.AllocateMesh();
			MeshEdgeElement = Mesh;
			// Avoid infinite recursion
			MeshEdgeElement.bCanApplyViewModeOverrides = false;

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Public/ShowFlagsValues.inl:243

Scope: file

Source code excerpt:

SHOWFLAG_FIXED_IN_SHIPPING(0, Snap, SFG_Hidden, NSLOCTEXT("UnrealEd", "SnapSF", "Snap"))
/** In the filled view modeModeWidgetss, render mesh edges as well as the filled surfaces. */
SHOWFLAG_FIXED_IN_SHIPPING(0, MeshEdges, SFG_Advanced, NSLOCTEXT("UnrealEd", "MeshEdgesSF", "Mesh Edges"))
/** Complex cover rendering */
SHOWFLAG_FIXED_IN_SHIPPING(0, Cover, SFG_Hidden, NSLOCTEXT("UnrealEd", "CoverSF", "Cover"))
/** Spline rendering */
SHOWFLAG_FIXED_IN_SHIPPING(0, Splines, SFG_Advanced, NSLOCTEXT("UnrealEd", "SplinesSF", "Splines"))
/** Selection rendering, could be useful in game as well */
SHOWFLAG_FIXED_IN_SHIPPING(0, Selection, SFG_Advanced, NSLOCTEXT("UnrealEd", "SelectionSF", "Selection"))