StitchingTechnique

StitchingTechnique

#Overview

name: StitchingTechnique

The value of this variable can be defined or overridden in .ini config files. 1 .ini config file referencing this setting variable.

It is referenced in 28 C++ source files.

#Summary

#Usage in the C++ source code

The purpose of StitchingTechnique is to define the method used for joining or repairing CAD geometry during the tessellation process in Unreal Engine’s Datasmith CAD importer.

This setting variable is primarily used by the Datasmith CAD importer subsystem, which is part of the Enterprise plugin suite for Unreal Engine. It’s utilized in various CAD-related modules such as DatasmithCADTranslator, DatasmithOpenNurbsTranslator, DatasmithPLMXMLTranslator, and DatasmithWireTranslator.

The value of this variable is typically set through import options or configuration files. It’s often initialized in the FDatasmithTessellationOptions structure, which is part of the broader Datasmith import settings.

StitchingTechnique interacts closely with other tessellation parameters like ChordTolerance, MaxEdgeLength, and NormalTolerance. Together, these parameters control the quality and characteristics of the resulting mesh when importing CAD data.

Developers should be aware that:

  1. The choice of stitching technique can significantly impact the number of objects in the resulting mesh.
  2. Different stitching techniques may be more suitable for different types of CAD data or desired outcomes.
  3. This setting is part of the advanced tessellation options and may require some expertise to use effectively.

Best practices when using this variable include:

  1. Understanding the differences between the available stitching techniques (None, Heal, Sew) and their impacts on the imported geometry.
  2. Experimenting with different stitching techniques to find the best balance between geometry accuracy and performance for your specific use case.
  3. Considering the stitching technique in conjunction with other tessellation parameters for optimal results.
  4. Documenting the chosen settings for consistency across team members and project iterations.

#Setting Variables

#References In INI files

Location: <Workspace>/Engine/Plugins/Enterprise/DatasmithImporter/Config/BaseDatasmithImporter.ini:9, section: [FileProducerTessellationOptions]

#References in C++ code

#Callsites

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

#Loc: <Workspace>/Engine/Plugins/Enterprise/DatasmithCADImporter/Source/CADKernelSurface/Private/CADKernelSurfaceExtension.cpp:37

Scope (from outer to inner):

file
function     bool UCADKernelParametricSurfaceData::Tessellate

Source code excerpt:

	CADLibrary::FImportParameters ImportParameters;
	ImportParameters.SetModelCoordinateSystem((FDatasmithUtils::EModelCoordSystem) SceneParameters.ModelCoordSys);
	ImportParameters.SetTesselationParameters(RetessellateOptions.ChordTolerance, RetessellateOptions.MaxEdgeLength, RetessellateOptions.NormalTolerance, (CADLibrary::EStitchingTechnique) RetessellateOptions.StitchingTechnique);

	CADLibrary::FMeshParameters CadMeshParameters;
	CadMeshParameters.bNeedSwapOrientation = MeshParameters.bNeedSwapOrientation;
	CadMeshParameters.bIsSymmetric = MeshParameters.bIsSymmetric;
	CadMeshParameters.SymmetricNormal = (FVector3f) MeshParameters.SymmetricNormal;
	CadMeshParameters.SymmetricOrigin = (FVector3f) MeshParameters.SymmetricOrigin;

#Loc: <Workspace>/Engine/Plugins/Enterprise/DatasmithCADImporter/Source/CADKernelSurface/Public/CADModelToCADKernelConverterBase.h:71

Scope (from outer to inner):

file
class        class FCADModelToCADKernelConverterBase : public CADLibrary::ICADModelConverter
function     virtual void SetImportParameters

Source code excerpt:

	}

	virtual void SetImportParameters(double ChordTolerance, double MaxEdgeLength, double NormalTolerance, CADLibrary::EStitchingTechnique StitchingTechnique) override
	{
		ImportParameters.SetTesselationParameters(ChordTolerance, MaxEdgeLength, NormalTolerance, StitchingTechnique);
	}

	virtual bool IsSessionValid() override
	{
		return true;
	}

#Loc: <Workspace>/Engine/Plugins/Enterprise/DatasmithCADImporter/Source/CADTools/Private/CADOption.cpp:163

Scope (from outer to inner):

file
namespace    CADLibrary
function     uint32 GetTypeHash

Source code excerpt:

	ParametersHash = HashCombine(ParametersHash, ::GetTypeHash(ImportParameters.MaxEdgeLength));
	ParametersHash = HashCombine(ParametersHash, ::GetTypeHash(ImportParameters.MaxNormalAngle));
	ParametersHash = HashCombine(ParametersHash, ::GetTypeHash(ImportParameters.StitchingTechnique));
	return ParametersHash;
}

}

#Loc: <Workspace>/Engine/Plugins/Enterprise/DatasmithCADImporter/Source/CADTools/Public/CADOptions.h:52

Scope (from outer to inner):

file
namespace    CADLibrary
class        class FImportParameters

Source code excerpt:

		double MaxEdgeLength;
		double MaxNormalAngle;
		EStitchingTechnique StitchingTechnique;
		EMesher Mesher;
		FDatasmithUtils::EModelCoordSystem ModelCoordSys;
		
	public:
		static bool bGDisableCADKernelTessellation;
		static bool bGEnableCADCache;

#Loc: <Workspace>/Engine/Plugins/Enterprise/DatasmithCADImporter/Source/CADTools/Public/CADOptions.h:80

Scope (from outer to inner):

file
namespace    CADLibrary
class        class FImportParameters
function     FImportParameters

Source code excerpt:

			, MaxEdgeLength(0.0)
			, MaxNormalAngle(20.0)
			, StitchingTechnique(EStitchingTechnique::StitchingNone)
			, Mesher(EMesher::TechSoft)
			, ModelCoordSys(NewCoordinateSystem)
		{
		}
	
		FImportParameters(const FImportParameters& InParamneters, EMesher InMesher)

#Loc: <Workspace>/Engine/Plugins/Enterprise/DatasmithCADImporter/Source/CADTools/Public/CADOptions.h:90

Scope (from outer to inner):

file
namespace    CADLibrary
class        class FImportParameters
function     FImportParameters

Source code excerpt:

			, MaxEdgeLength(InParamneters.MaxEdgeLength)
			, MaxNormalAngle(InParamneters.MaxNormalAngle)
			, StitchingTechnique(InParamneters.StitchingTechnique)
			, Mesher(InMesher)
			, ModelCoordSys(InParamneters.ModelCoordSys)
		{
		}

		void SetTesselationParameters(double InChordTolerance, double InMaxEdgeLength, double InMaxNormalAngle, EStitchingTechnique InStitchingTechnique)

#Loc: <Workspace>/Engine/Plugins/Enterprise/DatasmithCADImporter/Source/CADTools/Public/CADOptions.h:101

Scope (from outer to inner):

file
namespace    CADLibrary
class        class FImportParameters
function     void SetTesselationParameters

Source code excerpt:

			MaxEdgeLength = InMaxEdgeLength * GMeshingParameterFactor;
			MaxNormalAngle = InMaxNormalAngle;
			StitchingTechnique = InStitchingTechnique;
			Mesher = FImportParameters::bGDisableCADKernelTessellation ? EMesher::TechSoft : EMesher::CADKernel;
		}

		void SetTesselationParameters(double InChordTolerance, double InMaxEdgeLength, double InMaxNormalAngle, EStitchingTechnique InStitchingTechnique, EMesher InMesher)
		{
			SetTesselationParameters(InChordTolerance, InMaxEdgeLength, InMaxNormalAngle, InStitchingTechnique);

#Loc: <Workspace>/Engine/Plugins/Enterprise/DatasmithCADImporter/Source/CADTools/Public/CADOptions.h:118

Scope (from outer to inner):

file
namespace    CADLibrary
class        class FImportParameters
function     uint32 GetHash

Source code excerpt:

				Hash = HashCombine(Hash, ::GetTypeHash(Param));
			}
			for (uint32 Param : {uint32(StitchingTechnique), uint32(Mesher), uint32(ModelCoordSys)})
			{
				Hash = HashCombine(Hash, ::GetTypeHash(Param));
			}
			for (bool Param : {bGStitchingForceSew, bGStitchingRemoveThinFaces, bGStitchingRemoveDuplicatedFaces, bGDisableCADKernelTessellation, bGActivateThinZoneMeshing, bGPreferJtFileEmbeddedTessellation})
			{
				Hash = HashCombine(Hash, ::GetTypeHash(Param));

#Loc: <Workspace>/Engine/Plugins/Enterprise/DatasmithCADImporter/Source/CADTools/Public/CADOptions.h:134

Scope (from outer to inner):

file
namespace    CADLibrary
class        class FImportParameters
function     FArchive& operator<<

Source code excerpt:

			Ar << ImportParameters.MaxEdgeLength;
			Ar << ImportParameters.MaxNormalAngle;
			Ar << (uint32&) ImportParameters.StitchingTechnique;
			Ar << (uint8&) ImportParameters.Mesher;
			Ar << (uint8&) ImportParameters.ModelCoordSys;

			// these static variables have to be serialized to be transmitted to CADWorkers
			// because CADWorker has not access to CVars
			Ar << ImportParameters.bGDisableCADKernelTessellation;

#Loc: <Workspace>/Engine/Plugins/Enterprise/DatasmithCADImporter/Source/CADTools/Public/CADOptions.h:178

Scope (from outer to inner):

file
namespace    CADLibrary
class        class FImportParameters
function     EStitchingTechnique GetStitchingTechnique

Source code excerpt:

		EStitchingTechnique GetStitchingTechnique() const
		{
			return StitchingTechnique;
		}

		EMesher GetMesher() const
		{
			return Mesher;
		}

#Loc: <Workspace>/Engine/Plugins/Enterprise/DatasmithCADImporter/Source/DatasmithCADTranslator/Private/DatasmithCADTranslator.cpp:178

Scope (from outer to inner):

file
function     bool FDatasmithCADTranslator::LoadScene

Source code excerpt:

		FMath::IsNearlyZero(TesselationOptions.MaxEdgeLength) ? 0. : CheckParameterValue(TesselationOptions.MaxEdgeLength, UE::DatasmithTessellation::MinTessellationEdgeLength, TEXT("Max Edge Length")),
		CheckParameterValue(TesselationOptions.NormalTolerance, UE::DatasmithTessellation::MinTessellationAngle, TEXT("Max Angle")),
		(EStitchingTechnique)TesselationOptions.StitchingTechnique);
	ImportParameters.SetModelCoordinateSystem(FDatasmithUtils::EModelCoordSystem::ZUp_RightHanded);

	UE_LOG(LogCADTranslator, Display, TEXT(" - Import parameters:"));
	UE_LOG(LogCADTranslator, Display, TEXT("     - ChordTolerance:     %lf"), ImportParameters.GetChordTolerance());
	UE_LOG(LogCADTranslator, Display, TEXT("     - MaxEdgeLength:      %lf"), ImportParameters.GetMaxEdgeLength());
	UE_LOG(LogCADTranslator, Display, TEXT("     - MaxNormalAngle:     %lf"), ImportParameters.GetMaxNormalAngle());
	FString StitchingTechnique;
	switch(ImportParameters.GetStitchingTechnique())
	{
		case EStitchingTechnique::StitchingHeal:
			StitchingTechnique = TEXT("Heal");
			break;
		case EStitchingTechnique::StitchingSew:
			StitchingTechnique = TEXT("Sew");
			break;
		default:
			StitchingTechnique = TEXT("None");
			break;
	}
	UE_LOG(LogCADTranslator, Display, TEXT("     - StitchingTechnique: %s"), *StitchingTechnique);
	if (!FImportParameters::bGDisableCADKernelTessellation)
	{
		UE_LOG(LogCADTranslator, Display, TEXT("     - Stitching Options:"));
		UE_LOG(LogCADTranslator, Display, TEXT("         - ForceSew:              %s"), ImportParameters.bGStitchingForceSew ? TEXT("True") : TEXT("False"));
		UE_LOG(LogCADTranslator, Display, TEXT("         - RemoveThinFaces:       %s"), ImportParameters.bGStitchingRemoveThinFaces ? TEXT("True") : TEXT("False"));
		UE_LOG(LogCADTranslator, Display, TEXT("         - RemoveDuplicatedFaces: %s"), ImportParameters.bGStitchingRemoveDuplicatedFaces ? TEXT("True") : TEXT("False"));

#Loc: <Workspace>/Engine/Plugins/Enterprise/DatasmithCADImporter/Source/DatasmithOpenNurbsTranslator/Private/DatasmithOpenNurbsImportOptions.cpp:31

Scope (from outer to inner):

file
function     bool UDatasmithOpenNurbsImportOptions::CanEditChange

Source code excerpt:

		|| PropertyFName == GET_MEMBER_NAME_CHECKED(FDatasmithOpenNurbsOptions, MaxEdgeLength)
		|| PropertyFName == GET_MEMBER_NAME_CHECKED(FDatasmithOpenNurbsOptions, NormalTolerance)
		|| PropertyFName == GET_MEMBER_NAME_CHECKED(FDatasmithOpenNurbsOptions, StitchingTechnique)
		)
	{
		// Enable tessellation options only when using CAD library to tessellate
		return Options.Geometry == EDatasmithOpenNurbsBrepTessellatedSource::UseUnrealNurbsTessellation;
	}

#Loc: <Workspace>/Engine/Plugins/Enterprise/DatasmithCADImporter/Source/DatasmithOpenNurbsTranslator/Private/DatasmithOpenNurbsTranslator.cpp:2979

Scope (from outer to inner):

file
function     bool FOpenNurbsTranslatorImpl::TranslateBRep

Source code excerpt:

	{
		// Ref. visitBRep
		CADModelConverter->SetImportParameters(OpenNurbsOptions.ChordTolerance, OpenNurbsOptions.MaxEdgeLength, OpenNurbsOptions.NormalTolerance, (CADLibrary::EStitchingTechnique)OpenNurbsOptions.StitchingTechnique);

		CADModelConverter->InitializeProcess();

		OpenNurbsBRepConverter->AddBRep(*Brep, Offset);
		CADModelConverter->RepairTopology();

#Loc: <Workspace>/Engine/Plugins/Enterprise/DatasmithCADImporter/Source/DatasmithPLMXMLTranslator/Private/DatasmithPlmXmlImporter.cpp:251

Scope (from outer to inner):

file
namespace    PlmXml
class        class FPlmXmlMeshLoaderWithDatasmithDispatcher
function     FPlmXmlMeshLoaderWithDatasmithDispatcher

Source code excerpt:


			// Setup of import parameters for DatasmithDispatcher copied from FDatasmithCADTranslator's setup
			ImportParameters.SetTesselationParameters(TessellationOptions.ChordTolerance, TessellationOptions.MaxEdgeLength, TessellationOptions.NormalTolerance, (CADLibrary::EStitchingTechnique) TessellationOptions.StitchingTechnique);

			DatasmithDispatcher = MakeUnique<DatasmithDispatcher::FDatasmithDispatcher>(ImportParameters, CacheDir, CADFileToUEFileMap, CADFileToUEGeomMap);
		}

		// Adds geom file to load and returns Id to use in InstantiateMesh later(after all is loaded)
		int32 AddMeshToLoad(const FString& FullPath)

#Loc: <Workspace>/Engine/Plugins/Enterprise/DatasmithCADImporter/Source/DatasmithPLMXMLTranslator/Private/DatasmithPlmXmlTranslator.cpp:93

Scope (from outer to inner):

file
function     bool FDatasmithPlmXmlTranslator::LoadScene

Source code excerpt:

	UE_LOG(LogDatasmithXMLPLMTranslator, Display, TEXT("     - MaxNormalAngle:     %f"), CommonTessellationOptions.NormalTolerance);

	FString StitchingTechnique;
	switch ((EStitchingTechnique)CommonTessellationOptions.StitchingTechnique)
	{
	case EStitchingTechnique::StitchingHeal:
		StitchingTechnique = TEXT("Heal");
		break;
	case EStitchingTechnique::StitchingSew:
		StitchingTechnique = TEXT("Sew");
		break;
	default:
		StitchingTechnique = TEXT("None");
		break;
	}
	UE_LOG(LogDatasmithXMLPLMTranslator, Display, TEXT("     - StitchingTechnique: %s"), *StitchingTechnique);

	if (!FImportParameters::bGDisableCADKernelTessellation)
	{
		UE_LOG(LogDatasmithXMLPLMTranslator, Display, TEXT("     - Stitching Options:"));
		UE_LOG(LogDatasmithXMLPLMTranslator, Display, TEXT("         - ForceSew:              %s"), FImportParameters::bGStitchingForceSew ? TEXT("True") : TEXT("False"));
		UE_LOG(LogDatasmithXMLPLMTranslator, Display, TEXT("         - RemoveThinFaces:       %s"), FImportParameters::bGStitchingRemoveThinFaces ? TEXT("True") : TEXT("False"));

#Loc: <Workspace>/Engine/Plugins/Enterprise/DatasmithCADImporter/Source/DatasmithWireTranslator/Private/DatasmithWireTranslator.cpp:480

Scope (from outer to inner):

file
namespace    UE_DATASMITHWIRETRANSLATOR_NAMESPACE
function     void FWireTranslatorImpl::SetTessellationOptions

Source code excerpt:

{
	TessellationOptions = Options;
	CADModelConverter->SetImportParameters(Options.ChordTolerance, Options.MaxEdgeLength, Options.NormalTolerance, (CADLibrary::EStitchingTechnique)Options.StitchingTechnique);
	SceneFileHash = HashCombine(Options.GetHash(), GetSceneFileHash(SceneFullPath, SceneName));
}

bool FWireTranslatorImpl::Read()
{
	// Initialize Alias.

#Loc: <Workspace>/Engine/Plugins/Enterprise/DatasmithCADImporter/Source/DatasmithWireTranslator/Private/DatasmithWireTranslator.cpp:1836

Scope (from outer to inner):

file
namespace    UE_DATASMITHWIRETRANSLATOR_NAMESPACE
function     bool FWireTranslatorImpl::RecurseDagForLeaves

Source code excerpt:

bool FWireTranslatorImpl::RecurseDagForLeaves(const TSharedPtr<AlDagNode>& FirstDagNode, FDagNodeInfo& ParentInfo)
{
	if (TessellationOptions.StitchingTechnique != EDatasmithCADStitchingTechnique::StitchingSew)
	{
		RecurseDagForLeavesNoMerge(FirstDagNode, ParentInfo);
		return true;
	}

	TSharedPtr<AlDagNode> DagNode = FirstDagNode;

#Loc: <Workspace>/Engine/Plugins/Enterprise/DatasmithCADImporter/Source/DatasmithWireTranslator/Private/DatasmithWireTranslator.cpp:2093

Scope (from outer to inner):

file
namespace    UE_DATASMITHWIRETRANSLATOR_NAMESPACE
function     TOptional<FMeshDescription> FWireTranslatorImpl::MeshDagNodeWithExternalMesher

Source code excerpt:

		ObjectReference = EAliasObjectReference::WorldReference;
	}
	else if (TessellationOptions.StitchingTechnique == EDatasmithCADStitchingTechnique::StitchingSew)
	{
		// In the case of StitchingSew, AlDagNode children of a GroupNode are merged together. To be merged, they have to be defined in the reference of parent GroupNode.
		ObjectReference = EAliasObjectReference::ParentReference;
	}

	for (const TPair<TSharedPtr<AlDagNode>, FColor>& DagNode : Body->GetShells())

#Loc: <Workspace>/Engine/Plugins/Enterprise/DatasmithCADImporter/Source/DatasmithWireTranslator/Private/DatasmithWireTranslator.cpp:2437

Scope (from outer to inner):

file
namespace    UE_DATASMITHWIRETRANSLATOR_NAMESPACE
function     bool FDatasmithWireTranslator::LoadScene

Source code excerpt:

	UE_LOG(LogDatasmithWireTranslator, Display, TEXT("     - MaxEdgeLength:      %lf"), TessellationOptions.MaxEdgeLength);
	UE_LOG(LogDatasmithWireTranslator, Display, TEXT("     - MaxNormalAngle:     %lf"), TessellationOptions.NormalTolerance);
	FString StitchingTechnique;
	switch (TessellationOptions.StitchingTechnique)
	{
	case EDatasmithCADStitchingTechnique::StitchingHeal:
		StitchingTechnique = TEXT("Heal");
		break;
	case EDatasmithCADStitchingTechnique::StitchingSew:
		StitchingTechnique = TEXT("Sew");
		break;
	default:
		StitchingTechnique = TEXT("None");
		break;
	}
	UE_LOG(LogDatasmithWireTranslator, Display, TEXT("     - StitchingTechnique: %s"), *StitchingTechnique);

	if (!CADLibrary::FImportParameters::bGDisableCADKernelTessellation)
	{
		UE_LOG(LogDatasmithWireTranslator, Display, TEXT("     - Stitching Options:"));
		UE_LOG(LogDatasmithWireTranslator, Display, TEXT("         - ForceSew:              %s"), CADLibrary::FImportParameters::bGStitchingForceSew ? TEXT("True") : TEXT("False"));
		UE_LOG(LogDatasmithWireTranslator, Display, TEXT("         - RemoveThinFaces:       %s"), CADLibrary::FImportParameters::bGStitchingRemoveThinFaces ? TEXT("True") : TEXT("False"));

#Loc: <Workspace>/Engine/Plugins/Enterprise/DatasmithCADImporter/Source/DatasmithWireTranslator/Private/DatasmithWireTranslator.h:37

Scope (from outer to inner):

file
namespace    UE_DATASMITHWIRETRANSLATOR_NAMESPACE
class        class FDatasmithWireTranslator : public FParametricSurfaceTranslator
function     virtual void InitCommonTessellationOptions

Source code excerpt:

	virtual void InitCommonTessellationOptions(FDatasmithTessellationOptions& TessellationOptions) override
	{
		TessellationOptions.StitchingTechnique = EDatasmithCADStitchingTechnique::StitchingNone;
	}
	// End ADatasmithCoreTechTranslator overrides

private:
	TSharedPtr<FWireTranslatorImpl> Translator;
};

#Loc: <Workspace>/Engine/Plugins/Enterprise/DatasmithCADImporter/Source/ParametricSurface/Private/TechSoft/TechSoftParametricSurface.cpp:36

Scope (from outer to inner):

file
function     bool UTechSoftParametricSurfaceData::Tessellate

Source code excerpt:

	{
		CADLibrary::FImportParameters ImportParameters((FDatasmithUtils::EModelCoordSystem)SceneParameters.ModelCoordSys);
		ImportParameters.SetTesselationParameters(RetessellateOptions.ChordTolerance, RetessellateOptions.MaxEdgeLength, RetessellateOptions.NormalTolerance, (CADLibrary::EStitchingTechnique)RetessellateOptions.StitchingTechnique);

		FMeshConversionContext Context(ImportParameters, MeshParameters);

		CADLibrary::FTechSoftInterface& TechSoftInterface = CADLibrary::FTechSoftInterface::Get();
		bSuccessfulTessellation = TechSoftInterface.InitializeKernel(*FPaths::EnginePluginsDir());
		if (bSuccessfulTessellation)

#Loc: <Workspace>/Engine/Plugins/Enterprise/DatasmithCADImporter/Source/ParametricSurface/Public/CADModelConverter.h:49

Scope (from outer to inner):

file
namespace    CADLibrary
class        class ICADModelConverter

Source code excerpt:

	 * @param MaxEdgeLength : max length of element's edge
	 * @param NormalTolerance : Angle between two adjacent triangles
	 * @param StitchingTechnique : CAD topology correction technique
	 * @param bScaleUVMap : Scale the UV map to a world unit.
	 */
	virtual void SetImportParameters(double ChordTolerance, double MaxEdgeLength, double NormalTolerance, CADLibrary::EStitchingTechnique StitchingTechnique) = 0;

	virtual bool IsSessionValid() = 0;

	virtual void AddSurfaceDataForMesh(const TCHAR* InFilePath, const FMeshParameters& InMeshParameters, const FDatasmithTessellationOptions& InTessellationOptions, FDatasmithMeshElementPayload& OutMeshPayload) const = 0;

};

}

#Loc: <Workspace>/Engine/Plugins/Enterprise/DatasmithCADImporter/Source/ParametricSurface/Public/CADModelToTechSoftConverterBase.h:37

Scope (from outer to inner):

file
class        class FCADModelToTechSoftConverterBase : public CADLibrary::ICADModelConverter
function     virtual void SetImportParameters

Source code excerpt:

	virtual bool Tessellate(const CADLibrary::FMeshParameters& InMeshParameters, FMeshDescription& OutMeshDescription) override;

	virtual void SetImportParameters(double ChordTolerance, double MaxEdgeLength, double NormalTolerance, CADLibrary::EStitchingTechnique StitchingTechnique) override
	{
		ImportParameters.SetTesselationParameters(ChordTolerance, MaxEdgeLength, NormalTolerance, StitchingTechnique);
	}

	virtual bool IsSessionValid() override
	{
		return true;
	}

#Loc: <Workspace>/Engine/Plugins/Enterprise/DatasmithContent/Source/DatasmithContent/Public/DatasmithImportOptions.h:227

Scope (from outer to inner):

file
function     FDatasmithTessellationOptions

Source code excerpt:

		, MaxEdgeLength(InMaxEdgeLength)
		, NormalTolerance(InNormalTolerance)
		, StitchingTechnique(InStitchingTechnique)
	{
	}

	/**
	 * Maximum distance between any point on a triangle generated by the tessellation process and the actual surface.
	 * The lower the value the more triangles.

#Loc: <Workspace>/Engine/Plugins/Enterprise/DatasmithContent/Source/DatasmithContent/Public/DatasmithImportOptions.h:266

Scope: file

Source code excerpt:

	 */
	UPROPERTY(config, EditAnywhere, BlueprintReadWrite, AdvancedDisplay, Category = "Geometry & Tessellation Options", meta = (ToolTip = "Stitching technique applied on model before tessellation. Sewing could impact number of objects."))
	EDatasmithCADStitchingTechnique StitchingTechnique;

	bool bUseCADKernel = false;

public:
	bool operator == (const FDatasmithTessellationOptions& Other) const
	{

#Loc: <Workspace>/Engine/Plugins/Enterprise/DatasmithContent/Source/DatasmithContent/Public/DatasmithImportOptions.h:276

Scope (from outer to inner):

file
function     bool operator ==

Source code excerpt:

			&& FMath::IsNearlyEqual(MaxEdgeLength, Other.MaxEdgeLength)
			&& FMath::IsNearlyEqual(NormalTolerance, Other.NormalTolerance)
			&& StitchingTechnique == Other.StitchingTechnique;
	}

	uint32 GetHash() const
	{
		uint32 Hash = uint32(StitchingTechnique);
		for (float Param : {ChordTolerance, MaxEdgeLength, NormalTolerance})
		{
			Hash = HashCombine(Hash, GetTypeHash(Param));
		}
		return Hash;
	}

#Loc: <Workspace>/Engine/Plugins/Enterprise/DatasmithContent/Source/DatasmithContent/Public/DatasmithImportOptions.h:310

Scope (from outer to inner):

file
function     void operator =

Source code excerpt:

		MaxEdgeLength = Other.MaxEdgeLength;
		NormalTolerance = Other.NormalTolerance;
		StitchingTechnique = Other.StitchingTechnique;
	}
};

/**
 * Base class for all import options in datasmith.
 *

#Loc: <Workspace>/Engine/Plugins/Enterprise/DatasmithImporter/Source/DatasmithImporter/Private/DatasmithFileProducer.cpp:1931

Scope (from outer to inner):

file
function     void UDatasmithFileProducer::LoadDefaultSettings

Source code excerpt:

		GConfig->GetFloat( TessellationSectionName, TEXT("NormalTolerance"), DefaultTessellationOptions.NormalTolerance, DatasmithImporterIni);

		FString StitchingTechnique = GConfig->GetStr( TessellationSectionName, TEXT("StitchingTechnique"), DatasmithImporterIni);
		if(StitchingTechnique == TEXT("StitchingHeal"))
		{
			DefaultTessellationOptions.StitchingTechnique =  EDatasmithCADStitchingTechnique::StitchingHeal;
		}
		else if(StitchingTechnique == TEXT("StitchingSew"))
		{
			DefaultTessellationOptions.StitchingTechnique =  EDatasmithCADStitchingTechnique::StitchingSew;
		}
		else
		{
			DefaultTessellationOptions.StitchingTechnique =  EDatasmithCADStitchingTechnique::StitchingNone;
		}
	}

	const TCHAR* ImportSectionName = TEXT("FileProducerImportOptions");
	if(GConfig->DoesSectionExist( ImportSectionName, DatasmithImporterIni ))
	{