// Copyright Epic Games, Inc. All Rights Reserved.
/*===========================================================================
	Generated code exported from UnrealHeaderTool.
	DO NOT modify this manually! Edit the corresponding .h files instead!
===========================================================================*/

#include "UObject/GeneratedCppIncludes.h"
#include "SimplygonContent/Classes/SimplygonSettings.h"
#ifdef _MSC_VER
#pragma warning (push)
#pragma warning (disable : 4883)
#endif
PRAGMA_DISABLE_DEPRECATION_WARNINGS
void EmptyLinkFunctionForGeneratedCodeSimplygonSettings() {}
// Cross Module References
	SIMPLYGONCONTENT_API UEnum* Z_Construct_UEnum_SimplygonContent_EDistributionMethod();
	UPackage* Z_Construct_UPackage__Script_SimplygonContent();
	SIMPLYGONCONTENT_API UEnum* Z_Construct_UEnum_SimplygonContent_EDefaultTNBSimplygon();
	SIMPLYGONCONTENT_API UEnum* Z_Construct_UEnum_SimplygonContent_ERemeshingProcessorVersion();
	SIMPLYGONCONTENT_API UClass* Z_Construct_UClass_USimplygonSettings_NoRegister();
	SIMPLYGONCONTENT_API UClass* Z_Construct_UClass_USimplygonSettings();
	COREUOBJECT_API UClass* Z_Construct_UClass_UObject();
	ENGINE_API UScriptStruct* Z_Construct_UScriptStruct_FFilePath();
// End Cross Module References
	static UEnum* EDistributionMethod_StaticEnum()
	{
		static UEnum* Singleton = nullptr;
		if (!Singleton)
		{
			Singleton = GetStaticEnum(Z_Construct_UEnum_SimplygonContent_EDistributionMethod, Z_Construct_UPackage__Script_SimplygonContent(), TEXT("EDistributionMethod"));
		}
		return Singleton;
	}
	template<> SIMPLYGONCONTENT_API UEnum* StaticEnum<EDistributionMethod>()
	{
		return EDistributionMethod_StaticEnum();
	}
	static FCompiledInDeferEnum Z_CompiledInDeferEnum_UEnum_EDistributionMethod(EDistributionMethod_StaticEnum, TEXT("/Script/SimplygonContent"), TEXT("EDistributionMethod"), false, nullptr, nullptr);
	uint32 Get_Z_Construct_UEnum_SimplygonContent_EDistributionMethod_Hash() { return 3183652021U; }
	UEnum* Z_Construct_UEnum_SimplygonContent_EDistributionMethod()
	{
#if WITH_HOT_RELOAD
		UPackage* Outer = Z_Construct_UPackage__Script_SimplygonContent();
		static UEnum* ReturnEnum = FindExistingEnumIfHotReloadOrDynamic(Outer, TEXT("EDistributionMethod"), 0, Get_Z_Construct_UEnum_SimplygonContent_EDistributionMethod_Hash(), false);
#else
		static UEnum* ReturnEnum = nullptr;
#endif // WITH_HOT_RELOAD
		if (!ReturnEnum)
		{
			static const UE4CodeGen_Private::FEnumeratorParam Enumerators[] = {
				{ "EDistributionMethod::SimplygonGrid", (int64)EDistributionMethod::SimplygonGrid },
				{ "EDistributionMethod::FastBuild", (int64)EDistributionMethod::FastBuild },
				{ "EDistributionMethod::Incredibuild", (int64)EDistributionMethod::Incredibuild },
			};
#if WITH_METADATA
			const UE4CodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
				{ "Comment", "/**\n* Enum describing the distribution method to use\n*/" },
				{ "FastBuild.Comment", "/// \n/// \n" },
				{ "FastBuild.DisplayName", "FASTBuild" },
				{ "FastBuild.Name", "EDistributionMethod::FastBuild" },
				{ "FastBuild.ToolTip", "Use FASTBuild" },
				{ "Incredibuild.Comment", "/// \n/// \n/// \n" },
				{ "Incredibuild.DisplayName", "Incredibuild" },
				{ "Incredibuild.Name", "EDistributionMethod::Incredibuild" },
				{ "Incredibuild.ToolTip", "Use Incredibuild" },
				{ "ModuleRelativePath", "Classes/SimplygonSettings.h" },
				{ "SimplygonGrid.Comment", "/// \n" },
				{ "SimplygonGrid.DisplayName", "Simplygon Grid" },
				{ "SimplygonGrid.Name", "EDistributionMethod::SimplygonGrid" },
				{ "SimplygonGrid.ToolTip", "Standard method, uses Simplygon Grid" },
				{ "ToolTip", "Enum describing the distribution method to use" },
			};
#endif
			static const UE4CodeGen_Private::FEnumParams EnumParams = {
				(UObject*(*)())Z_Construct_UPackage__Script_SimplygonContent,
				nullptr,
				"EDistributionMethod",
				"EDistributionMethod",
				Enumerators,
				UE_ARRAY_COUNT(Enumerators),
				RF_Public|RF_Transient|RF_MarkAsNative,
				EEnumFlags::None,
				UE4CodeGen_Private::EDynamicType::NotDynamic,
				(uint8)UEnum::ECppForm::EnumClass,
				METADATA_PARAMS(Enum_MetaDataParams, UE_ARRAY_COUNT(Enum_MetaDataParams))
			};
			UE4CodeGen_Private::ConstructUEnum(ReturnEnum, EnumParams);
		}
		return ReturnEnum;
	}
	static UEnum* EDefaultTNBSimplygon_StaticEnum()
	{
		static UEnum* Singleton = nullptr;
		if (!Singleton)
		{
			Singleton = GetStaticEnum(Z_Construct_UEnum_SimplygonContent_EDefaultTNBSimplygon, Z_Construct_UPackage__Script_SimplygonContent(), TEXT("EDefaultTNBSimplygon"));
		}
		return Singleton;
	}
	template<> SIMPLYGONCONTENT_API UEnum* StaticEnum<EDefaultTNBSimplygon>()
	{
		return EDefaultTNBSimplygon_StaticEnum();
	}
	static FCompiledInDeferEnum Z_CompiledInDeferEnum_UEnum_EDefaultTNBSimplygon(EDefaultTNBSimplygon_StaticEnum, TEXT("/Script/SimplygonContent"), TEXT("EDefaultTNBSimplygon"), false, nullptr, nullptr);
	uint32 Get_Z_Construct_UEnum_SimplygonContent_EDefaultTNBSimplygon_Hash() { return 1970436353U; }
	UEnum* Z_Construct_UEnum_SimplygonContent_EDefaultTNBSimplygon()
	{
#if WITH_HOT_RELOAD
		UPackage* Outer = Z_Construct_UPackage__Script_SimplygonContent();
		static UEnum* ReturnEnum = FindExistingEnumIfHotReloadOrDynamic(Outer, TEXT("EDefaultTNBSimplygon"), 0, Get_Z_Construct_UEnum_SimplygonContent_EDefaultTNBSimplygon_Hash(), false);
#else
		static UEnum* ReturnEnum = nullptr;
#endif // WITH_HOT_RELOAD
		if (!ReturnEnum)
		{
			static const UE4CodeGen_Private::FEnumeratorParam Enumerators[] = {
				{ "EDefaultTNBSimplygon::OrthonormalRightHanded", (int64)EDefaultTNBSimplygon::OrthonormalRightHanded },
				{ "EDefaultTNBSimplygon::Autodesk3dsMax", (int64)EDefaultTNBSimplygon::Autodesk3dsMax },
				{ "EDefaultTNBSimplygon::OrthonormalLeftHanded", (int64)EDefaultTNBSimplygon::OrthonormalLeftHanded },
				{ "EDefaultTNBSimplygon::MikkTSpace", (int64)EDefaultTNBSimplygon::MikkTSpace },
			};
#if WITH_METADATA
			const UE4CodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
				{ "Autodesk3dsMax.Comment", "/// \n/// \n" },
				{ "Autodesk3dsMax.DisplayName", "3dsMax" },
				{ "Autodesk3dsMax.Name", "EDefaultTNBSimplygon::Autodesk3dsMax" },
				{ "Autodesk3dsMax.ToolTip", "3dsMax compatible method, creates tangent space that is compatible with the 3dsMax renderer" },
				{ "Comment", "/**\n* Enum describing the tangent space generation method use\n*/" },
				{ "MikkTSpace.Comment", "/// \n/// \n/// \n/// \n" },
				{ "MikkTSpace.DisplayName", "MikkTSpace" },
				{ "MikkTSpace.Name", "EDefaultTNBSimplygon::MikkTSpace" },
				{ "MikkTSpace.ToolTip", "Creates a tangent space using the MikkTSpace tangent space generation algorithm. (UE4 compatible)" },
				{ "ModuleRelativePath", "Classes/SimplygonSettings.h" },
				{ "OrthonormalLeftHanded.Comment", "/// \n/// \n/// \n" },
				{ "OrthonormalLeftHanded.DisplayName", "Left(Orthonormal)" },
				{ "OrthonormalLeftHanded.Name", "EDefaultTNBSimplygon::OrthonormalLeftHanded" },
				{ "OrthonormalLeftHanded.ToolTip", "Creates an orthonormal tangent space (left-handed, D3D compatible, UE4 compatible)" },
				{ "OrthonormalRightHanded.Comment", "/// \n" },
				{ "OrthonormalRightHanded.DisplayName", "Right(Orthonormal)" },
				{ "OrthonormalRightHanded.Name", "EDefaultTNBSimplygon::OrthonormalRightHanded" },
				{ "OrthonormalRightHanded.ToolTip", "Standard method, creates an orthonormal tangent space (right-handed)" },
				{ "ToolTip", "Enum describing the tangent space generation method use" },
			};
#endif
			static const UE4CodeGen_Private::FEnumParams EnumParams = {
				(UObject*(*)())Z_Construct_UPackage__Script_SimplygonContent,
				nullptr,
				"EDefaultTNBSimplygon",
				"EDefaultTNBSimplygon",
				Enumerators,
				UE_ARRAY_COUNT(Enumerators),
				RF_Public|RF_Transient|RF_MarkAsNative,
				EEnumFlags::None,
				UE4CodeGen_Private::EDynamicType::NotDynamic,
				(uint8)UEnum::ECppForm::EnumClass,
				METADATA_PARAMS(Enum_MetaDataParams, UE_ARRAY_COUNT(Enum_MetaDataParams))
			};
			UE4CodeGen_Private::ConstructUEnum(ReturnEnum, EnumParams);
		}
		return ReturnEnum;
	}
	static UEnum* ERemeshingProcessorVersion_StaticEnum()
	{
		static UEnum* Singleton = nullptr;
		if (!Singleton)
		{
			Singleton = GetStaticEnum(Z_Construct_UEnum_SimplygonContent_ERemeshingProcessorVersion, Z_Construct_UPackage__Script_SimplygonContent(), TEXT("ERemeshingProcessorVersion"));
		}
		return Singleton;
	}
	template<> SIMPLYGONCONTENT_API UEnum* StaticEnum<ERemeshingProcessorVersion>()
	{
		return ERemeshingProcessorVersion_StaticEnum();
	}
	static FCompiledInDeferEnum Z_CompiledInDeferEnum_UEnum_ERemeshingProcessorVersion(ERemeshingProcessorVersion_StaticEnum, TEXT("/Script/SimplygonContent"), TEXT("ERemeshingProcessorVersion"), false, nullptr, nullptr);
	uint32 Get_Z_Construct_UEnum_SimplygonContent_ERemeshingProcessorVersion_Hash() { return 1407873990U; }
	UEnum* Z_Construct_UEnum_SimplygonContent_ERemeshingProcessorVersion()
	{
#if WITH_HOT_RELOAD
		UPackage* Outer = Z_Construct_UPackage__Script_SimplygonContent();
		static UEnum* ReturnEnum = FindExistingEnumIfHotReloadOrDynamic(Outer, TEXT("ERemeshingProcessorVersion"), 0, Get_Z_Construct_UEnum_SimplygonContent_ERemeshingProcessorVersion_Hash(), false);
#else
		static UEnum* ReturnEnum = nullptr;
#endif // WITH_HOT_RELOAD
		if (!ReturnEnum)
		{
			static const UE4CodeGen_Private::FEnumeratorParam Enumerators[] = {
				{ "ERemeshingProcessorVersion::Default", (int64)ERemeshingProcessorVersion::Default },
				{ "ERemeshingProcessorVersion::Legacy", (int64)ERemeshingProcessorVersion::Legacy },
			};
#if WITH_METADATA
			const UE4CodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
				{ "Comment", "/**\n* Enum describing the remeshing processor to use.\n*/" },
				{ "Default.DisplayName", "Default" },
				{ "Default.Name", "ERemeshingProcessorVersion::Default" },
				{ "Default.ToolTip", "Remesher introduced in 9.0" },
				{ "Legacy.DisplayName", "Legacy" },
				{ "Legacy.Name", "ERemeshingProcessorVersion::Legacy" },
				{ "Legacy.ToolTip", "Legacy remesher is deprecated and will be removed in future release. " },
				{ "ModuleRelativePath", "Classes/SimplygonSettings.h" },
				{ "ToolTip", "Enum describing the remeshing processor to use." },
			};
#endif
			static const UE4CodeGen_Private::FEnumParams EnumParams = {
				(UObject*(*)())Z_Construct_UPackage__Script_SimplygonContent,
				nullptr,
				"ERemeshingProcessorVersion",
				"ERemeshingProcessorVersion",
				Enumerators,
				UE_ARRAY_COUNT(Enumerators),
				RF_Public|RF_Transient|RF_MarkAsNative,
				EEnumFlags::None,
				UE4CodeGen_Private::EDynamicType::NotDynamic,
				(uint8)UEnum::ECppForm::EnumClass,
				METADATA_PARAMS(Enum_MetaDataParams, UE_ARRAY_COUNT(Enum_MetaDataParams))
			};
			UE4CodeGen_Private::ConstructUEnum(ReturnEnum, EnumParams);
		}
		return ReturnEnum;
	}
	void USimplygonSettings::StaticRegisterNativesUSimplygonSettings()
	{
	}
	UClass* Z_Construct_UClass_USimplygonSettings_NoRegister()
	{
		return USimplygonSettings::StaticClass();
	}
	struct Z_Construct_UClass_USimplygonSettings_Statics
	{
		static UObject* (*const DependentSingletons[])();
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Class_MetaDataParams[];
#endif
		static const UE4CodeGen_Private::FStructPropertyParams NewProp_LicensePaths_Inner;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_LicensePaths_MetaData[];
#endif
		static const UE4CodeGen_Private::FArrayPropertyParams NewProp_LicensePaths;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_UseDistribution_MetaData[];
#endif
		static void NewProp_UseDistribution_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_UseDistribution;
		static const UE4CodeGen_Private::FUnsizedIntPropertyParams NewProp_DistributionMethod_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_DistributionMethod_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_DistributionMethod;
		static const UE4CodeGen_Private::FUnsizedIntPropertyParams NewProp_PreferredRemesher_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_PreferredRemesher_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_PreferredRemesher;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_bDebug_MetaData[];
#endif
		static void NewProp_bDebug_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_bDebug;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_bExportPipelineAndScene_MetaData[];
#endif
		static void NewProp_bExportPipelineAndScene_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_bExportPipelineAndScene;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_DebugPath_MetaData[];
#endif
		static const UE4CodeGen_Private::FStructPropertyParams NewProp_DebugPath;
		static const UE4CodeGen_Private::FUnsizedIntPropertyParams NewProp_Tangentspace_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_Tangentspace_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_Tangentspace;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_SendInterval_MetaData[];
#endif
		static const UE4CodeGen_Private::FIntPropertyParams NewProp_SendInterval;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
		static const FCppClassTypeInfoStatic StaticCppClassTypeInfo;
		static const UE4CodeGen_Private::FClassParams ClassParams;
	};
	UObject* (*const Z_Construct_UClass_USimplygonSettings_Statics::DependentSingletons[])() = {
		(UObject* (*)())Z_Construct_UClass_UObject,
		(UObject* (*)())Z_Construct_UPackage__Script_SimplygonContent,
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_USimplygonSettings_Statics::Class_MetaDataParams[] = {
		{ "Comment", "/**\n* Implements the settings for the Simplygon Plugin.\n*/" },
		{ "IncludePath", "SimplygonSettings.h" },
		{ "ModuleRelativePath", "Classes/SimplygonSettings.h" },
		{ "ToolTip", "Implements the settings for the Simplygon Plugin." },
	};
#endif
	const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UClass_USimplygonSettings_Statics::NewProp_LicensePaths_Inner = { "LicensePaths", nullptr, (EPropertyFlags)0x0000000000004000, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, Z_Construct_UScriptStruct_FFilePath, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_USimplygonSettings_Statics::NewProp_LicensePaths_MetaData[] = {
		{ "Category", "General" },
		{ "Comment", "/** License search paths. First match in chronological order will be used. */" },
		{ "ConfigRestartRequired", "TRUE" },
		{ "ModuleRelativePath", "Classes/SimplygonSettings.h" },
		{ "ToolTip", "License search paths. First match in chronological order will be used." },
	};
#endif
	const UE4CodeGen_Private::FArrayPropertyParams Z_Construct_UClass_USimplygonSettings_Statics::NewProp_LicensePaths = { "LicensePaths", nullptr, (EPropertyFlags)0x0010000000004001, UE4CodeGen_Private::EPropertyGenFlags::Array, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(USimplygonSettings, LicensePaths), EArrayPropertyFlags::None, METADATA_PARAMS(Z_Construct_UClass_USimplygonSettings_Statics::NewProp_LicensePaths_MetaData, UE_ARRAY_COUNT(Z_Construct_UClass_USimplygonSettings_Statics::NewProp_LicensePaths_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_USimplygonSettings_Statics::NewProp_UseDistribution_MetaData[] = {
		{ "Category", "Simplygon API" },
		{ "Comment", "/** Will use distribution if enabled.*/" },
		{ "ConfigRestartRequired", "FALSE" },
		{ "ModuleRelativePath", "Classes/SimplygonSettings.h" },
		{ "ToolTip", "Will use distribution if enabled." },
	};
#endif
	void Z_Construct_UClass_USimplygonSettings_Statics::NewProp_UseDistribution_SetBit(void* Obj)
	{
		((USimplygonSettings*)Obj)->UseDistribution = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UClass_USimplygonSettings_Statics::NewProp_UseDistribution = { "UseDistribution", nullptr, (EPropertyFlags)0x0010000000004001, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(USimplygonSettings), &Z_Construct_UClass_USimplygonSettings_Statics::NewProp_UseDistribution_SetBit, METADATA_PARAMS(Z_Construct_UClass_USimplygonSettings_Statics::NewProp_UseDistribution_MetaData, UE_ARRAY_COUNT(Z_Construct_UClass_USimplygonSettings_Statics::NewProp_UseDistribution_MetaData)) };
	const UE4CodeGen_Private::FUnsizedIntPropertyParams Z_Construct_UClass_USimplygonSettings_Statics::NewProp_DistributionMethod_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_USimplygonSettings_Statics::NewProp_DistributionMethod_MetaData[] = {
		{ "Category", "Simplygon API" },
		{ "Comment", "/** Which distribution method to use if distribution is enabled. */" },
		{ "ConfigRestartRequired", "FALSE" },
		{ "ModuleRelativePath", "Classes/SimplygonSettings.h" },
		{ "ToolTip", "Which distribution method to use if distribution is enabled." },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UClass_USimplygonSettings_Statics::NewProp_DistributionMethod = { "DistributionMethod", nullptr, (EPropertyFlags)0x0010000000004001, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(USimplygonSettings, DistributionMethod), Z_Construct_UEnum_SimplygonContent_EDistributionMethod, METADATA_PARAMS(Z_Construct_UClass_USimplygonSettings_Statics::NewProp_DistributionMethod_MetaData, UE_ARRAY_COUNT(Z_Construct_UClass_USimplygonSettings_Statics::NewProp_DistributionMethod_MetaData)) };
	const UE4CodeGen_Private::FUnsizedIntPropertyParams Z_Construct_UClass_USimplygonSettings_Statics::NewProp_PreferredRemesher_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_USimplygonSettings_Statics::NewProp_PreferredRemesher_MetaData[] = {
		{ "Category", "Simplygon API" },
		{ "Comment", "/** Preferred version of the remeshing processor, default is set to use the newer version.\x09*/" },
		{ "ConfigRestartRequired", "FALSE" },
		{ "DisplayName", "Preferred Remeshing Processor" },
		{ "ModuleRelativePath", "Classes/SimplygonSettings.h" },
		{ "ToolTip", "Preferred version of the remeshing processor, default is set to use the newer version." },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UClass_USimplygonSettings_Statics::NewProp_PreferredRemesher = { "PreferredRemesher", nullptr, (EPropertyFlags)0x0010000000004001, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(USimplygonSettings, PreferredRemesher), Z_Construct_UEnum_SimplygonContent_ERemeshingProcessorVersion, METADATA_PARAMS(Z_Construct_UClass_USimplygonSettings_Statics::NewProp_PreferredRemesher_MetaData, UE_ARRAY_COUNT(Z_Construct_UClass_USimplygonSettings_Statics::NewProp_PreferredRemesher_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_USimplygonSettings_Statics::NewProp_bDebug_MetaData[] = {
		{ "Category", "General" },
		{ "Comment", "/** Enable debuging for Simplygon Plugin. */" },
		{ "ConfigRestartRequired", "TRUE" },
		{ "ModuleRelativePath", "Classes/SimplygonSettings.h" },
		{ "ToolTip", "Enable debuging for Simplygon Plugin." },
	};
#endif
	void Z_Construct_UClass_USimplygonSettings_Statics::NewProp_bDebug_SetBit(void* Obj)
	{
		((USimplygonSettings*)Obj)->bDebug = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UClass_USimplygonSettings_Statics::NewProp_bDebug = { "bDebug", nullptr, (EPropertyFlags)0x0010000000004001, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(USimplygonSettings), &Z_Construct_UClass_USimplygonSettings_Statics::NewProp_bDebug_SetBit, METADATA_PARAMS(Z_Construct_UClass_USimplygonSettings_Statics::NewProp_bDebug_MetaData, UE_ARRAY_COUNT(Z_Construct_UClass_USimplygonSettings_Statics::NewProp_bDebug_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_USimplygonSettings_Statics::NewProp_bExportPipelineAndScene_MetaData[] = {
		{ "Category", "General" },
		{ "Comment", "/** If bDebug is enabled and this flag is set will export a sgscene and pipeline when processing.*/" },
		{ "ConfigRestartRequired", "TRUE" },
		{ "EditCondition", "bDebug" },
		{ "ModuleRelativePath", "Classes/SimplygonSettings.h" },
		{ "ToolTip", "If bDebug is enabled and this flag is set will export a sgscene and pipeline when processing." },
	};
#endif
	void Z_Construct_UClass_USimplygonSettings_Statics::NewProp_bExportPipelineAndScene_SetBit(void* Obj)
	{
		((USimplygonSettings*)Obj)->bExportPipelineAndScene = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UClass_USimplygonSettings_Statics::NewProp_bExportPipelineAndScene = { "bExportPipelineAndScene", nullptr, (EPropertyFlags)0x0010000000004001, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(USimplygonSettings), &Z_Construct_UClass_USimplygonSettings_Statics::NewProp_bExportPipelineAndScene_SetBit, METADATA_PARAMS(Z_Construct_UClass_USimplygonSettings_Statics::NewProp_bExportPipelineAndScene_MetaData, UE_ARRAY_COUNT(Z_Construct_UClass_USimplygonSettings_Statics::NewProp_bExportPipelineAndScene_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_USimplygonSettings_Statics::NewProp_DebugPath_MetaData[] = {
		{ "Category", "General" },
		{ "Comment", "/** Path where debug data will be save. Default Project/Intermediate/Simplygon */" },
		{ "ConfigRestartRequired", "TRUE" },
		{ "EditCondition", "bDebug" },
		{ "ModuleRelativePath", "Classes/SimplygonSettings.h" },
		{ "ToolTip", "Path where debug data will be save. Default Project/Intermediate/Simplygon" },
	};
#endif
	const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UClass_USimplygonSettings_Statics::NewProp_DebugPath = { "DebugPath", nullptr, (EPropertyFlags)0x0010000000004001, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(USimplygonSettings, DebugPath), Z_Construct_UScriptStruct_FFilePath, METADATA_PARAMS(Z_Construct_UClass_USimplygonSettings_Statics::NewProp_DebugPath_MetaData, UE_ARRAY_COUNT(Z_Construct_UClass_USimplygonSettings_Statics::NewProp_DebugPath_MetaData)) };
	const UE4CodeGen_Private::FUnsizedIntPropertyParams Z_Construct_UClass_USimplygonSettings_Statics::NewProp_Tangentspace_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_USimplygonSettings_Statics::NewProp_Tangentspace_MetaData[] = {
		{ "Category", "SimplygonGlobal" },
		{ "Comment", "/** Which tangent space generation method to use. */" },
		{ "ConfigRestartRequired", "FALSE" },
		{ "ModuleRelativePath", "Classes/SimplygonSettings.h" },
		{ "ToolTip", "Which tangent space generation method to use." },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UClass_USimplygonSettings_Statics::NewProp_Tangentspace = { "Tangentspace", nullptr, (EPropertyFlags)0x0010000000004001, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(USimplygonSettings, Tangentspace), Z_Construct_UEnum_SimplygonContent_EDefaultTNBSimplygon, METADATA_PARAMS(Z_Construct_UClass_USimplygonSettings_Statics::NewProp_Tangentspace_MetaData, UE_ARRAY_COUNT(Z_Construct_UClass_USimplygonSettings_Statics::NewProp_Tangentspace_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_USimplygonSettings_Statics::NewProp_SendInterval_MetaData[] = {
		{ "Comment", "/** The wait interval between telemtry data sends to Simplygon DLL. Note the Simplygon DLL decides if telemetry will be uploaded or not baseed on license key */" },
		{ "ModuleRelativePath", "Classes/SimplygonSettings.h" },
		{ "ToolTip", "The wait interval between telemtry data sends to Simplygon DLL. Note the Simplygon DLL decides if telemetry will be uploaded or not baseed on license key" },
	};
#endif
	const UE4CodeGen_Private::FIntPropertyParams Z_Construct_UClass_USimplygonSettings_Statics::NewProp_SendInterval = { "SendInterval", nullptr, (EPropertyFlags)0x0010000000000000, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(USimplygonSettings, SendInterval), METADATA_PARAMS(Z_Construct_UClass_USimplygonSettings_Statics::NewProp_SendInterval_MetaData, UE_ARRAY_COUNT(Z_Construct_UClass_USimplygonSettings_Statics::NewProp_SendInterval_MetaData)) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UClass_USimplygonSettings_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_USimplygonSettings_Statics::NewProp_LicensePaths_Inner,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_USimplygonSettings_Statics::NewProp_LicensePaths,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_USimplygonSettings_Statics::NewProp_UseDistribution,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_USimplygonSettings_Statics::NewProp_DistributionMethod_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_USimplygonSettings_Statics::NewProp_DistributionMethod,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_USimplygonSettings_Statics::NewProp_PreferredRemesher_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_USimplygonSettings_Statics::NewProp_PreferredRemesher,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_USimplygonSettings_Statics::NewProp_bDebug,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_USimplygonSettings_Statics::NewProp_bExportPipelineAndScene,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_USimplygonSettings_Statics::NewProp_DebugPath,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_USimplygonSettings_Statics::NewProp_Tangentspace_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_USimplygonSettings_Statics::NewProp_Tangentspace,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_USimplygonSettings_Statics::NewProp_SendInterval,
	};
	const FCppClassTypeInfoStatic Z_Construct_UClass_USimplygonSettings_Statics::StaticCppClassTypeInfo = {
		TCppClassTypeTraits<USimplygonSettings>::IsAbstract,
	};
	const UE4CodeGen_Private::FClassParams Z_Construct_UClass_USimplygonSettings_Statics::ClassParams = {
		&USimplygonSettings::StaticClass,
		"Engine",
		&StaticCppClassTypeInfo,
		DependentSingletons,
		nullptr,
		Z_Construct_UClass_USimplygonSettings_Statics::PropPointers,
		nullptr,
		UE_ARRAY_COUNT(DependentSingletons),
		0,
		UE_ARRAY_COUNT(Z_Construct_UClass_USimplygonSettings_Statics::PropPointers),
		0,
		0x001000A6u,
		METADATA_PARAMS(Z_Construct_UClass_USimplygonSettings_Statics::Class_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UClass_USimplygonSettings_Statics::Class_MetaDataParams))
	};
	UClass* Z_Construct_UClass_USimplygonSettings()
	{
		static UClass* OuterClass = nullptr;
		if (!OuterClass)
		{
			UE4CodeGen_Private::ConstructUClass(OuterClass, Z_Construct_UClass_USimplygonSettings_Statics::ClassParams);
		}
		return OuterClass;
	}
	IMPLEMENT_CLASS(USimplygonSettings, 3223559142);
	template<> SIMPLYGONCONTENT_API UClass* StaticClass<USimplygonSettings>()
	{
		return USimplygonSettings::StaticClass();
	}
	static FCompiledInDefer Z_CompiledInDefer_UClass_USimplygonSettings(Z_Construct_UClass_USimplygonSettings, &USimplygonSettings::StaticClass, TEXT("/Script/SimplygonContent"), TEXT("USimplygonSettings"), false, nullptr, nullptr, nullptr);
	DEFINE_VTABLE_PTR_HELPER_CTOR(USimplygonSettings);
PRAGMA_ENABLE_DEPRECATION_WARNINGS
#ifdef _MSC_VER
#pragma warning (pop)
#endif
