// 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 "AGXUnrealBarrier/Public/Materials/AGX_ContactMaterialEnums.h"
PRAGMA_DISABLE_DEPRECATION_WARNINGS
void EmptyLinkFunctionForGeneratedCodeAGX_ContactMaterialEnums() {}
// Cross Module References
	AGXUNREALBARRIER_API UEnum* Z_Construct_UEnum_AGXUnrealBarrier_EAGX_ContactReductionLevel();
	AGXUNREALBARRIER_API UEnum* Z_Construct_UEnum_AGXUnrealBarrier_EAGX_ContactReductionMode();
	AGXUNREALBARRIER_API UEnum* Z_Construct_UEnum_AGXUnrealBarrier_EAGX_ContactSolver();
	AGXUNREALBARRIER_API UEnum* Z_Construct_UEnum_AGXUnrealBarrier_EAGX_FrictionModel();
	UPackage* Z_Construct_UPackage__Script_AGXUnrealBarrier();
// End Cross Module References
	static FEnumRegistrationInfo Z_Registration_Info_UEnum_EAGX_ContactSolver;
	static UEnum* EAGX_ContactSolver_StaticEnum()
	{
		if (!Z_Registration_Info_UEnum_EAGX_ContactSolver.OuterSingleton)
		{
			Z_Registration_Info_UEnum_EAGX_ContactSolver.OuterSingleton = GetStaticEnum(Z_Construct_UEnum_AGXUnrealBarrier_EAGX_ContactSolver, (UObject*)Z_Construct_UPackage__Script_AGXUnrealBarrier(), TEXT("EAGX_ContactSolver"));
		}
		return Z_Registration_Info_UEnum_EAGX_ContactSolver.OuterSingleton;
	}
	template<> AGXUNREALBARRIER_API UEnum* StaticEnum<EAGX_ContactSolver>()
	{
		return EAGX_ContactSolver_StaticEnum();
	}
	struct Z_Construct_UEnum_AGXUnrealBarrier_EAGX_ContactSolver_Statics
	{
		static const UECodeGen_Private::FEnumeratorParam Enumerators[];
#if WITH_METADATA
		static const UECodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[];
#endif
		static const UECodeGen_Private::FEnumParams EnumParams;
	};
	const UECodeGen_Private::FEnumeratorParam Z_Construct_UEnum_AGXUnrealBarrier_EAGX_ContactSolver_Statics::Enumerators[] = {
		{ "EAGX_ContactSolver::NotDefined", (int64)EAGX_ContactSolver::NotDefined },
		{ "EAGX_ContactSolver::Direct", (int64)EAGX_ContactSolver::Direct },
		{ "EAGX_ContactSolver::Iterative", (int64)EAGX_ContactSolver::Iterative },
		{ "EAGX_ContactSolver::Split", (int64)EAGX_ContactSolver::Split },
		{ "EAGX_ContactSolver::DirectAndIterative", (int64)EAGX_ContactSolver::DirectAndIterative },
	};
#if WITH_METADATA
	const UECodeGen_Private::FMetaDataPairParam Z_Construct_UEnum_AGXUnrealBarrier_EAGX_ContactSolver_Statics::Enum_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "Comment", "/**\n * Specifies in what solvers the normal and friction equations will be calculated.\n */" },
		{ "Direct.Comment", "/** Normal and friction equations calculated only in the DIRECT solver. */" },
		{ "Direct.Name", "EAGX_ContactSolver::Direct" },
		{ "Direct.ToolTip", "Normal and friction equations calculated only in the DIRECT solver." },
		{ "DirectAndIterative.Comment", "/** Normal and friction equation calculated both in the ITERATIVE and the DIRECT solver. */" },
		{ "DirectAndIterative.DisplayName", "Direct & Iterative" },
		{ "DirectAndIterative.Name", "EAGX_ContactSolver::DirectAndIterative" },
		{ "DirectAndIterative.ToolTip", "Normal and friction equation calculated both in the ITERATIVE and the DIRECT solver." },
		{ "Iterative.Comment", "/** Normal and friction equations calculated only in the ITERATIVE solver. */" },
		{ "Iterative.Name", "EAGX_ContactSolver::Iterative" },
		{ "Iterative.ToolTip", "Normal and friction equations calculated only in the ITERATIVE solver." },
		{ "ModuleRelativePath", "Public/Materials/AGX_ContactMaterialEnums.h" },
		{ "NotDefined.Name", "EAGX_ContactSolver::NotDefined" },
		{ "Split.Comment", "/**\n\x09 * First Normal equation is calculated in the DIRECT solver, then in a second pass the normal\n\x09 * and the friction equations are solved in the ITERATIVE solver.\n\x09 */" },
		{ "Split.Name", "EAGX_ContactSolver::Split" },
		{ "Split.ToolTip", "First Normal equation is calculated in the DIRECT solver, then in a second pass the normal\nand the friction equations are solved in the ITERATIVE solver." },
		{ "ToolTip", "Specifies in what solvers the normal and friction equations will be calculated." },
	};
#endif
	const UECodeGen_Private::FEnumParams Z_Construct_UEnum_AGXUnrealBarrier_EAGX_ContactSolver_Statics::EnumParams = {
		(UObject*(*)())Z_Construct_UPackage__Script_AGXUnrealBarrier,
		nullptr,
		"EAGX_ContactSolver",
		"EAGX_ContactSolver",
		Z_Construct_UEnum_AGXUnrealBarrier_EAGX_ContactSolver_Statics::Enumerators,
		RF_Public|RF_Transient|RF_MarkAsNative,
		UE_ARRAY_COUNT(Z_Construct_UEnum_AGXUnrealBarrier_EAGX_ContactSolver_Statics::Enumerators),
		EEnumFlags::None,
		(uint8)UEnum::ECppForm::EnumClass,
		METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UEnum_AGXUnrealBarrier_EAGX_ContactSolver_Statics::Enum_MetaDataParams), Z_Construct_UEnum_AGXUnrealBarrier_EAGX_ContactSolver_Statics::Enum_MetaDataParams)
	};
	UEnum* Z_Construct_UEnum_AGXUnrealBarrier_EAGX_ContactSolver()
	{
		if (!Z_Registration_Info_UEnum_EAGX_ContactSolver.InnerSingleton)
		{
			UECodeGen_Private::ConstructUEnum(Z_Registration_Info_UEnum_EAGX_ContactSolver.InnerSingleton, Z_Construct_UEnum_AGXUnrealBarrier_EAGX_ContactSolver_Statics::EnumParams);
		}
		return Z_Registration_Info_UEnum_EAGX_ContactSolver.InnerSingleton;
	}
	static FEnumRegistrationInfo Z_Registration_Info_UEnum_EAGX_FrictionModel;
	static UEnum* EAGX_FrictionModel_StaticEnum()
	{
		if (!Z_Registration_Info_UEnum_EAGX_FrictionModel.OuterSingleton)
		{
			Z_Registration_Info_UEnum_EAGX_FrictionModel.OuterSingleton = GetStaticEnum(Z_Construct_UEnum_AGXUnrealBarrier_EAGX_FrictionModel, (UObject*)Z_Construct_UPackage__Script_AGXUnrealBarrier(), TEXT("EAGX_FrictionModel"));
		}
		return Z_Registration_Info_UEnum_EAGX_FrictionModel.OuterSingleton;
	}
	template<> AGXUNREALBARRIER_API UEnum* StaticEnum<EAGX_FrictionModel>()
	{
		return EAGX_FrictionModel_StaticEnum();
	}
	struct Z_Construct_UEnum_AGXUnrealBarrier_EAGX_FrictionModel_Statics
	{
		static const UECodeGen_Private::FEnumeratorParam Enumerators[];
#if WITH_METADATA
		static const UECodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[];
#endif
		static const UECodeGen_Private::FEnumParams EnumParams;
	};
	const UECodeGen_Private::FEnumeratorParam Z_Construct_UEnum_AGXUnrealBarrier_EAGX_FrictionModel_Statics::Enumerators[] = {
		{ "EAGX_FrictionModel::NotDefined", (int64)EAGX_FrictionModel::NotDefined },
		{ "EAGX_FrictionModel::BoxFriction", (int64)EAGX_FrictionModel::BoxFriction },
		{ "EAGX_FrictionModel::ScaledBoxFriction", (int64)EAGX_FrictionModel::ScaledBoxFriction },
		{ "EAGX_FrictionModel::IterativeProjectedConeFriction", (int64)EAGX_FrictionModel::IterativeProjectedConeFriction },
		{ "EAGX_FrictionModel::OrientedBoxFriction", (int64)EAGX_FrictionModel::OrientedBoxFriction },
		{ "EAGX_FrictionModel::OrientedScaledBoxFriction", (int64)EAGX_FrictionModel::OrientedScaledBoxFriction },
		{ "EAGX_FrictionModel::OrientedIterativeProjectedConeFriction", (int64)EAGX_FrictionModel::OrientedIterativeProjectedConeFriction },
		{ "EAGX_FrictionModel::OrientedConstantNormalForceBoxFriction", (int64)EAGX_FrictionModel::OrientedConstantNormalForceBoxFriction },
	};
#if WITH_METADATA
	const UECodeGen_Private::FMetaDataPairParam Z_Construct_UEnum_AGXUnrealBarrier_EAGX_FrictionModel_Statics::Enum_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "BoxFriction.Comment", "/**\n\x09 * Box friction. Static bounds during solve. The friction box is aligned with the world axes.\n\x09 * The normal force used by the box friction model is for new contacts estimated by the relative\n\x09 * impact speed, mass, and gravity, or for continuous contacts equal to the the last normal\n\x09 * force.\n\x09 */" },
		{ "BoxFriction.Name", "EAGX_FrictionModel::BoxFriction" },
		{ "BoxFriction.ToolTip", "Box friction. Static bounds during solve. The friction box is aligned with the world axes.\nThe normal force used by the box friction model is for new contacts estimated by the relative\nimpact speed, mass, and gravity, or for continuous contacts equal to the the last normal\nforce." },
		{ "Comment", "/**\n * Specifies in what way friction is modelled.\n */" },
		{ "IterativeProjectedConeFriction.Comment", "/**\n\x09 * This friction model is the default in AGX Dynamics.\n\x09 *\n\x09 * When this method is used with Solve type SPLIT (which is default), it will split the\n\x09 * normal-tangential equations. I.e., the normal forces are first solved with a direct solve,\n\x09 * and then both the normal and tangential equations are solved iteratively.\n\x09 *\n\x09 * For complex systems this could lead to viscous friction. This can be resolved by using\n\x09 * 'Direct & Iterative' solve model for other constraints (hinges, etc.) involved in the system.\n\x09 *\n\x09 * Iterative projected cone friction model is computationally cheap. Friction forces are\n\x09 * projected onto the friction cone, i.e., you will always get friction_force =\n\x09 * friction_coefficient * normal_force.\n\x09 */" },
		{ "IterativeProjectedConeFriction.Name", "EAGX_FrictionModel::IterativeProjectedConeFriction" },
		{ "IterativeProjectedConeFriction.ToolTip", "This friction model is the default in AGX Dynamics.\n\nWhen this method is used with Solve type SPLIT (which is default), it will split the\nnormal-tangential equations. I.e., the normal forces are first solved with a direct solve,\nand then both the normal and tangential equations are solved iteratively.\n\nFor complex systems this could lead to viscous friction. This can be resolved by using\n'Direct & Iterative' solve model for other constraints (hinges, etc.) involved in the system.\n\nIterative projected cone friction model is computationally cheap. Friction forces are\nprojected onto the friction cone, i.e., you will always get friction_force =\nfriction_coefficient * normal_force." },
		{ "ModuleRelativePath", "Public/Materials/AGX_ContactMaterialEnums.h" },
		{ "NotDefined.Name", "EAGX_FrictionModel::NotDefined" },
		{ "OrientedBoxFriction.Comment", "/**\n\x09 * Box friction model with oriented friction box.\n\x09 */" },
		{ "OrientedBoxFriction.Name", "EAGX_FrictionModel::OrientedBoxFriction" },
		{ "OrientedBoxFriction.ToolTip", "Box friction model with oriented friction box." },
		{ "OrientedConstantNormalForceBoxFriction.Comment", "/**\n\x09 * Oriented box friction model that uses the same normal force magnitude for all contact points\n\x09 * associated to this friction model.\n\x09 *\n\x09 * This means that the size of the friction box always will be:\n\x09 *   Primary Direction   = (Primary) Friction Coefficient * Normal Force Magnitude\n\x09 *   Secondary Direction = Secondary Friction Coefficient * Normal Force Magnitude\n\x09 *\n\x09 * The given normal force can also be scaled with the contact point depth by setting\n\x09 * 'Scale Normal Force With Depth' to true.\n\x09 */" },
		{ "OrientedConstantNormalForceBoxFriction.Name", "EAGX_FrictionModel::OrientedConstantNormalForceBoxFriction" },
		{ "OrientedConstantNormalForceBoxFriction.ToolTip", "Oriented box friction model that uses the same normal force magnitude for all contact points\nassociated to this friction model.\n\nThis means that the size of the friction box always will be:\n  Primary Direction   = (Primary) Friction Coefficient * Normal Force Magnitude\n  Secondary Direction = Secondary Friction Coefficient * Normal Force Magnitude\n\nThe given normal force can also be scaled with the contact point depth by setting\n'Scale Normal Force With Depth' to true." },
		{ "OrientedIterativeProjectedConeFriction.Comment", "/**\n\x09 * Iterative projected cone friction model with oriented friction box.\n\x09 */" },
		{ "OrientedIterativeProjectedConeFriction.Name", "EAGX_FrictionModel::OrientedIterativeProjectedConeFriction" },
		{ "OrientedIterativeProjectedConeFriction.ToolTip", "Iterative projected cone friction model with oriented friction box." },
		{ "OrientedScaledBoxFriction.Comment", "/**\n\x09 * Scale box friction model with oriented friction box.\n\x09 */" },
		{ "OrientedScaledBoxFriction.Name", "EAGX_FrictionModel::OrientedScaledBoxFriction" },
		{ "OrientedScaledBoxFriction.ToolTip", "Scale box friction model with oriented friction box." },
		{ "ScaledBoxFriction.Comment", "/**\n\x09 * This model uses the current (i.e. correct) normal force received by the solver.\n\x09 *\n\x09 * It is computationally more expensive than the box friction model but with a more realistic\n\x09 * dry friction.\n\x09 */" },
		{ "ScaledBoxFriction.Name", "EAGX_FrictionModel::ScaledBoxFriction" },
		{ "ScaledBoxFriction.ToolTip", "This model uses the current (i.e. correct) normal force received by the solver.\n\nIt is computationally more expensive than the box friction model but with a more realistic\ndry friction." },
		{ "ToolTip", "Specifies in what way friction is modelled." },
	};
#endif
	const UECodeGen_Private::FEnumParams Z_Construct_UEnum_AGXUnrealBarrier_EAGX_FrictionModel_Statics::EnumParams = {
		(UObject*(*)())Z_Construct_UPackage__Script_AGXUnrealBarrier,
		nullptr,
		"EAGX_FrictionModel",
		"EAGX_FrictionModel",
		Z_Construct_UEnum_AGXUnrealBarrier_EAGX_FrictionModel_Statics::Enumerators,
		RF_Public|RF_Transient|RF_MarkAsNative,
		UE_ARRAY_COUNT(Z_Construct_UEnum_AGXUnrealBarrier_EAGX_FrictionModel_Statics::Enumerators),
		EEnumFlags::None,
		(uint8)UEnum::ECppForm::EnumClass,
		METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UEnum_AGXUnrealBarrier_EAGX_FrictionModel_Statics::Enum_MetaDataParams), Z_Construct_UEnum_AGXUnrealBarrier_EAGX_FrictionModel_Statics::Enum_MetaDataParams)
	};
	UEnum* Z_Construct_UEnum_AGXUnrealBarrier_EAGX_FrictionModel()
	{
		if (!Z_Registration_Info_UEnum_EAGX_FrictionModel.InnerSingleton)
		{
			UECodeGen_Private::ConstructUEnum(Z_Registration_Info_UEnum_EAGX_FrictionModel.InnerSingleton, Z_Construct_UEnum_AGXUnrealBarrier_EAGX_FrictionModel_Statics::EnumParams);
		}
		return Z_Registration_Info_UEnum_EAGX_FrictionModel.InnerSingleton;
	}
	static FEnumRegistrationInfo Z_Registration_Info_UEnum_EAGX_ContactReductionMode;
	static UEnum* EAGX_ContactReductionMode_StaticEnum()
	{
		if (!Z_Registration_Info_UEnum_EAGX_ContactReductionMode.OuterSingleton)
		{
			Z_Registration_Info_UEnum_EAGX_ContactReductionMode.OuterSingleton = GetStaticEnum(Z_Construct_UEnum_AGXUnrealBarrier_EAGX_ContactReductionMode, (UObject*)Z_Construct_UPackage__Script_AGXUnrealBarrier(), TEXT("EAGX_ContactReductionMode"));
		}
		return Z_Registration_Info_UEnum_EAGX_ContactReductionMode.OuterSingleton;
	}
	template<> AGXUNREALBARRIER_API UEnum* StaticEnum<EAGX_ContactReductionMode>()
	{
		return EAGX_ContactReductionMode_StaticEnum();
	}
	struct Z_Construct_UEnum_AGXUnrealBarrier_EAGX_ContactReductionMode_Statics
	{
		static const UECodeGen_Private::FEnumeratorParam Enumerators[];
#if WITH_METADATA
		static const UECodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[];
#endif
		static const UECodeGen_Private::FEnumParams EnumParams;
	};
	const UECodeGen_Private::FEnumeratorParam Z_Construct_UEnum_AGXUnrealBarrier_EAGX_ContactReductionMode_Statics::Enumerators[] = {
		{ "EAGX_ContactReductionMode::None", (int64)EAGX_ContactReductionMode::None },
		{ "EAGX_ContactReductionMode::Geometry", (int64)EAGX_ContactReductionMode::Geometry },
		{ "EAGX_ContactReductionMode::All", (int64)EAGX_ContactReductionMode::All },
	};
#if WITH_METADATA
	const UECodeGen_Private::FMetaDataPairParam Z_Construct_UEnum_AGXUnrealBarrier_EAGX_ContactReductionMode_Statics::Enum_MetaDataParams[] = {
		{ "All.Comment", "/** Two step reduction: first between geometries, and then between rigid bodies. */" },
		{ "All.Name", "EAGX_ContactReductionMode::All" },
		{ "All.ToolTip", "Two step reduction: first between geometries, and then between rigid bodies." },
		{ "BlueprintType", "true" },
		{ "Comment", "/**\n * Specifies to what extent contact reduction will be used.\n */" },
		{ "Geometry.Comment", "/** Reduce contacts between geometries. */" },
		{ "Geometry.Name", "EAGX_ContactReductionMode::Geometry" },
		{ "Geometry.ToolTip", "Reduce contacts between geometries." },
		{ "ModuleRelativePath", "Public/Materials/AGX_ContactMaterialEnums.h" },
		{ "None.Comment", "/** No contact reduction enabled. */" },
		{ "None.Name", "EAGX_ContactReductionMode::None" },
		{ "None.ToolTip", "No contact reduction enabled." },
		{ "ToolTip", "Specifies to what extent contact reduction will be used." },
	};
#endif
	const UECodeGen_Private::FEnumParams Z_Construct_UEnum_AGXUnrealBarrier_EAGX_ContactReductionMode_Statics::EnumParams = {
		(UObject*(*)())Z_Construct_UPackage__Script_AGXUnrealBarrier,
		nullptr,
		"EAGX_ContactReductionMode",
		"EAGX_ContactReductionMode",
		Z_Construct_UEnum_AGXUnrealBarrier_EAGX_ContactReductionMode_Statics::Enumerators,
		RF_Public|RF_Transient|RF_MarkAsNative,
		UE_ARRAY_COUNT(Z_Construct_UEnum_AGXUnrealBarrier_EAGX_ContactReductionMode_Statics::Enumerators),
		EEnumFlags::None,
		(uint8)UEnum::ECppForm::EnumClass,
		METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UEnum_AGXUnrealBarrier_EAGX_ContactReductionMode_Statics::Enum_MetaDataParams), Z_Construct_UEnum_AGXUnrealBarrier_EAGX_ContactReductionMode_Statics::Enum_MetaDataParams)
	};
	UEnum* Z_Construct_UEnum_AGXUnrealBarrier_EAGX_ContactReductionMode()
	{
		if (!Z_Registration_Info_UEnum_EAGX_ContactReductionMode.InnerSingleton)
		{
			UECodeGen_Private::ConstructUEnum(Z_Registration_Info_UEnum_EAGX_ContactReductionMode.InnerSingleton, Z_Construct_UEnum_AGXUnrealBarrier_EAGX_ContactReductionMode_Statics::EnumParams);
		}
		return Z_Registration_Info_UEnum_EAGX_ContactReductionMode.InnerSingleton;
	}
	static FEnumRegistrationInfo Z_Registration_Info_UEnum_EAGX_ContactReductionLevel;
	static UEnum* EAGX_ContactReductionLevel_StaticEnum()
	{
		if (!Z_Registration_Info_UEnum_EAGX_ContactReductionLevel.OuterSingleton)
		{
			Z_Registration_Info_UEnum_EAGX_ContactReductionLevel.OuterSingleton = GetStaticEnum(Z_Construct_UEnum_AGXUnrealBarrier_EAGX_ContactReductionLevel, (UObject*)Z_Construct_UPackage__Script_AGXUnrealBarrier(), TEXT("EAGX_ContactReductionLevel"));
		}
		return Z_Registration_Info_UEnum_EAGX_ContactReductionLevel.OuterSingleton;
	}
	template<> AGXUNREALBARRIER_API UEnum* StaticEnum<EAGX_ContactReductionLevel>()
	{
		return EAGX_ContactReductionLevel_StaticEnum();
	}
	struct Z_Construct_UEnum_AGXUnrealBarrier_EAGX_ContactReductionLevel_Statics
	{
		static const UECodeGen_Private::FEnumeratorParam Enumerators[];
#if WITH_METADATA
		static const UECodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[];
#endif
		static const UECodeGen_Private::FEnumParams EnumParams;
	};
	const UECodeGen_Private::FEnumeratorParam Z_Construct_UEnum_AGXUnrealBarrier_EAGX_ContactReductionLevel_Statics::Enumerators[] = {
		{ "EAGX_ContactReductionLevel::Default", (int64)EAGX_ContactReductionLevel::Default },
		{ "EAGX_ContactReductionLevel::Aggressive", (int64)EAGX_ContactReductionLevel::Aggressive },
		{ "EAGX_ContactReductionLevel::Moderate", (int64)EAGX_ContactReductionLevel::Moderate },
		{ "EAGX_ContactReductionLevel::Minimal", (int64)EAGX_ContactReductionLevel::Minimal },
	};
#if WITH_METADATA
	const UECodeGen_Private::FMetaDataPairParam Z_Construct_UEnum_AGXUnrealBarrier_EAGX_ContactReductionLevel_Statics::Enum_MetaDataParams[] = {
		{ "Aggressive.Comment", "/** Remove contacts aggressively. */" },
		{ "Aggressive.Name", "EAGX_ContactReductionLevel::Aggressive" },
		{ "Aggressive.ToolTip", "Remove contacts aggressively." },
		{ "BlueprintType", "true" },
		{ "Comment", "/**\n * Specifies the level of contact reduction used.\n */" },
		{ "Default.Comment", "/** AGX Dynamics default contact reduction level. */" },
		{ "Default.Name", "EAGX_ContactReductionLevel::Default" },
		{ "Default.ToolTip", "AGX Dynamics default contact reduction level." },
		{ "Minimal.Comment", "/** Remove few contacts. */" },
		{ "Minimal.Name", "EAGX_ContactReductionLevel::Minimal" },
		{ "Minimal.ToolTip", "Remove few contacts." },
		{ "Moderate.Comment", "/** Moderate contact reduction. */" },
		{ "Moderate.Name", "EAGX_ContactReductionLevel::Moderate" },
		{ "Moderate.ToolTip", "Moderate contact reduction." },
		{ "ModuleRelativePath", "Public/Materials/AGX_ContactMaterialEnums.h" },
		{ "ToolTip", "Specifies the level of contact reduction used." },
	};
#endif
	const UECodeGen_Private::FEnumParams Z_Construct_UEnum_AGXUnrealBarrier_EAGX_ContactReductionLevel_Statics::EnumParams = {
		(UObject*(*)())Z_Construct_UPackage__Script_AGXUnrealBarrier,
		nullptr,
		"EAGX_ContactReductionLevel",
		"EAGX_ContactReductionLevel",
		Z_Construct_UEnum_AGXUnrealBarrier_EAGX_ContactReductionLevel_Statics::Enumerators,
		RF_Public|RF_Transient|RF_MarkAsNative,
		UE_ARRAY_COUNT(Z_Construct_UEnum_AGXUnrealBarrier_EAGX_ContactReductionLevel_Statics::Enumerators),
		EEnumFlags::None,
		(uint8)UEnum::ECppForm::EnumClass,
		METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UEnum_AGXUnrealBarrier_EAGX_ContactReductionLevel_Statics::Enum_MetaDataParams), Z_Construct_UEnum_AGXUnrealBarrier_EAGX_ContactReductionLevel_Statics::Enum_MetaDataParams)
	};
	UEnum* Z_Construct_UEnum_AGXUnrealBarrier_EAGX_ContactReductionLevel()
	{
		if (!Z_Registration_Info_UEnum_EAGX_ContactReductionLevel.InnerSingleton)
		{
			UECodeGen_Private::ConstructUEnum(Z_Registration_Info_UEnum_EAGX_ContactReductionLevel.InnerSingleton, Z_Construct_UEnum_AGXUnrealBarrier_EAGX_ContactReductionLevel_Statics::EnumParams);
		}
		return Z_Registration_Info_UEnum_EAGX_ContactReductionLevel.InnerSingleton;
	}
	struct Z_CompiledInDeferFile_FID_GitLab_Runner_builds_9YzzThLq_0_algoryx_unreal_agxunreal_staging_selfhosted_build_AGXUnreal_HostProject_Plugins_AGXUnreal_Source_AGXUnrealBarrier_Public_Materials_AGX_ContactMaterialEnums_h_Statics
	{
		static const FEnumRegisterCompiledInInfo EnumInfo[];
	};
	const FEnumRegisterCompiledInInfo Z_CompiledInDeferFile_FID_GitLab_Runner_builds_9YzzThLq_0_algoryx_unreal_agxunreal_staging_selfhosted_build_AGXUnreal_HostProject_Plugins_AGXUnreal_Source_AGXUnrealBarrier_Public_Materials_AGX_ContactMaterialEnums_h_Statics::EnumInfo[] = {
		{ EAGX_ContactSolver_StaticEnum, TEXT("EAGX_ContactSolver"), &Z_Registration_Info_UEnum_EAGX_ContactSolver, CONSTRUCT_RELOAD_VERSION_INFO(FEnumReloadVersionInfo, 1005574536U) },
		{ EAGX_FrictionModel_StaticEnum, TEXT("EAGX_FrictionModel"), &Z_Registration_Info_UEnum_EAGX_FrictionModel, CONSTRUCT_RELOAD_VERSION_INFO(FEnumReloadVersionInfo, 581889954U) },
		{ EAGX_ContactReductionMode_StaticEnum, TEXT("EAGX_ContactReductionMode"), &Z_Registration_Info_UEnum_EAGX_ContactReductionMode, CONSTRUCT_RELOAD_VERSION_INFO(FEnumReloadVersionInfo, 3677276119U) },
		{ EAGX_ContactReductionLevel_StaticEnum, TEXT("EAGX_ContactReductionLevel"), &Z_Registration_Info_UEnum_EAGX_ContactReductionLevel, CONSTRUCT_RELOAD_VERSION_INFO(FEnumReloadVersionInfo, 876211580U) },
	};
	static FRegisterCompiledInInfo Z_CompiledInDeferFile_FID_GitLab_Runner_builds_9YzzThLq_0_algoryx_unreal_agxunreal_staging_selfhosted_build_AGXUnreal_HostProject_Plugins_AGXUnreal_Source_AGXUnrealBarrier_Public_Materials_AGX_ContactMaterialEnums_h_545183481(TEXT("/Script/AGXUnrealBarrier"),
		nullptr, 0,
		nullptr, 0,
		Z_CompiledInDeferFile_FID_GitLab_Runner_builds_9YzzThLq_0_algoryx_unreal_agxunreal_staging_selfhosted_build_AGXUnreal_HostProject_Plugins_AGXUnreal_Source_AGXUnrealBarrier_Public_Materials_AGX_ContactMaterialEnums_h_Statics::EnumInfo, UE_ARRAY_COUNT(Z_CompiledInDeferFile_FID_GitLab_Runner_builds_9YzzThLq_0_algoryx_unreal_agxunreal_staging_selfhosted_build_AGXUnreal_HostProject_Plugins_AGXUnreal_Source_AGXUnrealBarrier_Public_Materials_AGX_ContactMaterialEnums_h_Statics::EnumInfo));
PRAGMA_ENABLE_DEPRECATION_WARNINGS
