DedicatedServerCourse/Intermediate/Build/Win64/FPSTemplateEditor/Inc/Engine/UHT/PhysicsSettings.gen.cpp

// 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 "PhysicsEngine/PhysicsSettings.h"
#include "Engine/EngineTypes.h"
#include "GameFramework/WorldSettings.h"

PRAGMA_DISABLE_DEPRECATION_WARNINGS
static_assert(!UE_WITH_CONSTINIT_UOBJECT, "This generated code can only be compiled with !UE_WITH_CONSTINIT_OBJECT");
void EmptyLinkFunctionForGeneratedCodePhysicsSettings() {}

// ********** Begin Cross Module References ********************************************************
CHAOS_API UEnum* Z_Construct_UEnum_Chaos_EChaosBufferMode();
CHAOS_API UEnum* Z_Construct_UEnum_Chaos_EChaosSolverTickMode();
CHAOS_API UEnum* Z_Construct_UEnum_Chaos_EChaosThreadingMode();
ENGINE_API UClass* Z_Construct_UClass_UPhysicsSettings();
ENGINE_API UClass* Z_Construct_UClass_UPhysicsSettings_NoRegister();
ENGINE_API UEnum* Z_Construct_UEnum_Engine_ESettingsDOF();
ENGINE_API UEnum* Z_Construct_UEnum_Engine_ESettingsLockedAxis();
ENGINE_API UScriptStruct* Z_Construct_UScriptStruct_FBroadphaseSettings();
ENGINE_API UScriptStruct* Z_Construct_UScriptStruct_FChaosPhysicsSettings();
ENGINE_API UScriptStruct* Z_Construct_UScriptStruct_FPhysicalSurfaceName();
ENGINE_API UScriptStruct* Z_Construct_UScriptStruct_FPhysicsPredictionSettings();
ENGINE_API UScriptStruct* Z_Construct_UScriptStruct_FPhysicsReplicationLODSettings();
ENGINE_API UScriptStruct* Z_Construct_UScriptStruct_FPhysicsReplicationResimulationSettings();
ENGINE_API UScriptStruct* Z_Construct_UScriptStruct_FRigidBodyErrorCorrection();
PHYSICSCORE_API UClass* Z_Construct_UClass_UPhysicsSettingsCore();
PHYSICSCORE_API UEnum* Z_Construct_UEnum_PhysicsCore_EPhysicalSurface();
UPackage* Z_Construct_UPackage__Script_Engine();
// ********** End Cross Module References **********************************************************

// ********** Begin ScriptStruct FPhysicalSurfaceName **********************************************
struct Z_Construct_UScriptStruct_FPhysicalSurfaceName_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FPhysicalSurfaceName); }
	static inline consteval int16 GetStructAlignment() { return alignof(FPhysicalSurfaceName); }
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
		{ "Comment", "/**\n * Structure that represents the name of physical surfaces.\n */" },
		{ "ModuleRelativePath", "Classes/PhysicsEngine/PhysicsSettings.h" },
		{ "ToolTip", "Structure that represents the name of physical surfaces." },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Type_MetaData[] = {
		{ "ModuleRelativePath", "Classes/PhysicsEngine/PhysicsSettings.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Name_MetaData[] = {
		{ "ModuleRelativePath", "Classes/PhysicsEngine/PhysicsSettings.h" },
	};
#endif // WITH_METADATA

// ********** Begin ScriptStruct FPhysicalSurfaceName constinit property declarations **************
	static const UECodeGen_Private::FBytePropertyParams NewProp_Type;
	static const UECodeGen_Private::FNamePropertyParams NewProp_Name;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End ScriptStruct FPhysicalSurfaceName constinit property declarations ****************
	static void* NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FPhysicalSurfaceName>();
	}
	static const UECodeGen_Private::FStructParams StructParams;
}; // struct Z_Construct_UScriptStruct_FPhysicalSurfaceName_Statics
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FPhysicalSurfaceName;
class UScriptStruct* FPhysicalSurfaceName::StaticStruct()
{
	if (!Z_Registration_Info_UScriptStruct_FPhysicalSurfaceName.OuterSingleton)
	{
		Z_Registration_Info_UScriptStruct_FPhysicalSurfaceName.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FPhysicalSurfaceName, (UObject*)Z_Construct_UPackage__Script_Engine(), TEXT("PhysicalSurfaceName"));
	}
	return Z_Registration_Info_UScriptStruct_FPhysicalSurfaceName.OuterSingleton;
	}

// ********** Begin ScriptStruct FPhysicalSurfaceName Property Definitions *************************
const UECodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FPhysicalSurfaceName_Statics::NewProp_Type = { "Type", nullptr, (EPropertyFlags)0x0010000000000000, UECodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FPhysicalSurfaceName, Type), Z_Construct_UEnum_PhysicsCore_EPhysicalSurface, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Type_MetaData), NewProp_Type_MetaData) }; // 2774282401
const UECodeGen_Private::FNamePropertyParams Z_Construct_UScriptStruct_FPhysicalSurfaceName_Statics::NewProp_Name = { "Name", nullptr, (EPropertyFlags)0x0010000000000000, UECodeGen_Private::EPropertyGenFlags::Name, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FPhysicalSurfaceName, Name), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Name_MetaData), NewProp_Name_MetaData) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FPhysicalSurfaceName_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FPhysicalSurfaceName_Statics::NewProp_Type,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FPhysicalSurfaceName_Statics::NewProp_Name,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FPhysicalSurfaceName_Statics::PropPointers) < 2048);
// ********** End ScriptStruct FPhysicalSurfaceName Property Definitions ***************************
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FPhysicalSurfaceName_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_Engine,
	nullptr,
	&NewStructOps,
	"PhysicalSurfaceName",
	Z_Construct_UScriptStruct_FPhysicalSurfaceName_Statics::PropPointers,
	UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FPhysicalSurfaceName_Statics::PropPointers),
	sizeof(FPhysicalSurfaceName),
	alignof(FPhysicalSurfaceName),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FPhysicalSurfaceName_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FPhysicalSurfaceName_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FPhysicalSurfaceName()
{
	if (!Z_Registration_Info_UScriptStruct_FPhysicalSurfaceName.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FPhysicalSurfaceName.InnerSingleton, Z_Construct_UScriptStruct_FPhysicalSurfaceName_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FPhysicalSurfaceName.InnerSingleton);
}
// ********** End ScriptStruct FPhysicalSurfaceName ************************************************

// ********** Begin ScriptStruct FChaosPhysicsSettings *********************************************
struct Z_Construct_UScriptStruct_FChaosPhysicsSettings_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FChaosPhysicsSettings); }
	static inline consteval int16 GetStructAlignment() { return alignof(FChaosPhysicsSettings); }
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
		{ "Comment", "/** \n  * Settings container for Chaos physics engine settings, accessed in Chaos through a setting provider interface.\n  * See: IChaosSettingsProvider\n  */" },
		{ "ModuleRelativePath", "Classes/PhysicsEngine/PhysicsSettings.h" },
		{ "ToolTip", "Settings container for Chaos physics engine settings, accessed in Chaos through a setting provider interface.\nSee: IChaosSettingsProvider" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_DefaultThreadingModel_MetaData[] = {
		{ "Category", "ChaosPhysics" },
		{ "Comment", "/** Default threading model to use on module initialisation. Can be switched at runtime using p.Chaos.ThreadingModel */" },
		{ "ModuleRelativePath", "Classes/PhysicsEngine/PhysicsSettings.h" },
		{ "ToolTip", "Default threading model to use on module initialisation. Can be switched at runtime using p.Chaos.ThreadingModel" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_DedicatedThreadTickMode_MetaData[] = {
		{ "Category", "Framerate" },
		{ "Comment", "/** The framerate/timestep ticking mode when running with a dedicated thread */" },
		{ "ModuleRelativePath", "Classes/PhysicsEngine/PhysicsSettings.h" },
		{ "ToolTip", "The framerate/timestep ticking mode when running with a dedicated thread" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_DedicatedThreadBufferMode_MetaData[] = {
		{ "Category", "Framerate" },
		{ "Comment", "/** The buffering mode to use when running with a dedicated thread */" },
		{ "ModuleRelativePath", "Classes/PhysicsEngine/PhysicsSettings.h" },
		{ "ToolTip", "The buffering mode to use when running with a dedicated thread" },
	};
#endif // WITH_METADATA

// ********** Begin ScriptStruct FChaosPhysicsSettings constinit property declarations *************
	static const UECodeGen_Private::FBytePropertyParams NewProp_DefaultThreadingModel_Underlying;
	static const UECodeGen_Private::FEnumPropertyParams NewProp_DefaultThreadingModel;
	static const UECodeGen_Private::FBytePropertyParams NewProp_DedicatedThreadTickMode_Underlying;
	static const UECodeGen_Private::FEnumPropertyParams NewProp_DedicatedThreadTickMode;
	static const UECodeGen_Private::FBytePropertyParams NewProp_DedicatedThreadBufferMode_Underlying;
	static const UECodeGen_Private::FEnumPropertyParams NewProp_DedicatedThreadBufferMode;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End ScriptStruct FChaosPhysicsSettings constinit property declarations ***************
	static void* NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FChaosPhysicsSettings>();
	}
	static const UECodeGen_Private::FStructParams StructParams;
}; // struct Z_Construct_UScriptStruct_FChaosPhysicsSettings_Statics
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FChaosPhysicsSettings;
class UScriptStruct* FChaosPhysicsSettings::StaticStruct()
{
	if (!Z_Registration_Info_UScriptStruct_FChaosPhysicsSettings.OuterSingleton)
	{
		Z_Registration_Info_UScriptStruct_FChaosPhysicsSettings.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FChaosPhysicsSettings, (UObject*)Z_Construct_UPackage__Script_Engine(), TEXT("ChaosPhysicsSettings"));
	}
	return Z_Registration_Info_UScriptStruct_FChaosPhysicsSettings.OuterSingleton;
	}

// ********** Begin ScriptStruct FChaosPhysicsSettings Property Definitions ************************
const UECodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FChaosPhysicsSettings_Statics::NewProp_DefaultThreadingModel_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UECodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, 0, nullptr, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FChaosPhysicsSettings_Statics::NewProp_DefaultThreadingModel = { "DefaultThreadingModel", nullptr, (EPropertyFlags)0x0010000000000001, UECodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FChaosPhysicsSettings, DefaultThreadingModel), Z_Construct_UEnum_Chaos_EChaosThreadingMode, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_DefaultThreadingModel_MetaData), NewProp_DefaultThreadingModel_MetaData) }; // 2526149149
const UECodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FChaosPhysicsSettings_Statics::NewProp_DedicatedThreadTickMode_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UECodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, 0, nullptr, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FChaosPhysicsSettings_Statics::NewProp_DedicatedThreadTickMode = { "DedicatedThreadTickMode", nullptr, (EPropertyFlags)0x0010000000000001, UECodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FChaosPhysicsSettings, DedicatedThreadTickMode), Z_Construct_UEnum_Chaos_EChaosSolverTickMode, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_DedicatedThreadTickMode_MetaData), NewProp_DedicatedThreadTickMode_MetaData) }; // 686491542
const UECodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FChaosPhysicsSettings_Statics::NewProp_DedicatedThreadBufferMode_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UECodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, 0, nullptr, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FChaosPhysicsSettings_Statics::NewProp_DedicatedThreadBufferMode = { "DedicatedThreadBufferMode", nullptr, (EPropertyFlags)0x0010000000000001, UECodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FChaosPhysicsSettings, DedicatedThreadBufferMode), Z_Construct_UEnum_Chaos_EChaosBufferMode, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_DedicatedThreadBufferMode_MetaData), NewProp_DedicatedThreadBufferMode_MetaData) }; // 340018751
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FChaosPhysicsSettings_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FChaosPhysicsSettings_Statics::NewProp_DefaultThreadingModel_Underlying,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FChaosPhysicsSettings_Statics::NewProp_DefaultThreadingModel,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FChaosPhysicsSettings_Statics::NewProp_DedicatedThreadTickMode_Underlying,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FChaosPhysicsSettings_Statics::NewProp_DedicatedThreadTickMode,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FChaosPhysicsSettings_Statics::NewProp_DedicatedThreadBufferMode_Underlying,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FChaosPhysicsSettings_Statics::NewProp_DedicatedThreadBufferMode,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FChaosPhysicsSettings_Statics::PropPointers) < 2048);
// ********** End ScriptStruct FChaosPhysicsSettings Property Definitions **************************
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FChaosPhysicsSettings_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_Engine,
	nullptr,
	&NewStructOps,
	"ChaosPhysicsSettings",
	Z_Construct_UScriptStruct_FChaosPhysicsSettings_Statics::PropPointers,
	UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FChaosPhysicsSettings_Statics::PropPointers),
	sizeof(FChaosPhysicsSettings),
	alignof(FChaosPhysicsSettings),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FChaosPhysicsSettings_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FChaosPhysicsSettings_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FChaosPhysicsSettings()
{
	if (!Z_Registration_Info_UScriptStruct_FChaosPhysicsSettings.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FChaosPhysicsSettings.InnerSingleton, Z_Construct_UScriptStruct_FChaosPhysicsSettings_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FChaosPhysicsSettings.InnerSingleton);
}
// ********** End ScriptStruct FChaosPhysicsSettings ***********************************************

// ********** Begin Enum ESettingsDOF **************************************************************
static FEnumRegistrationInfo Z_Registration_Info_UEnum_ESettingsDOF;
static UEnum* ESettingsDOF_StaticEnum()
{
	if (!Z_Registration_Info_UEnum_ESettingsDOF.OuterSingleton)
	{
		Z_Registration_Info_UEnum_ESettingsDOF.OuterSingleton = GetStaticEnum(Z_Construct_UEnum_Engine_ESettingsDOF, (UObject*)Z_Construct_UPackage__Script_Engine(), TEXT("ESettingsDOF"));
	}
	return Z_Registration_Info_UEnum_ESettingsDOF.OuterSingleton;
}
template<> ENGINE_NON_ATTRIBUTED_API UEnum* StaticEnum<ESettingsDOF::Type>()
{
	return ESettingsDOF_StaticEnum();
}
struct Z_Construct_UEnum_Engine_ESettingsDOF_Statics
{
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
		{ "Full3D.Comment", "/** Allows for full 3D movement and rotation. */" },
		{ "Full3D.Name", "ESettingsDOF::Full3D" },
		{ "Full3D.ToolTip", "Allows for full 3D movement and rotation." },
		{ "ModuleRelativePath", "Classes/PhysicsEngine/PhysicsSettings.h" },
		{ "XYPlane.Comment", "/** Allows 2D movement along the X-Y plane. */" },
		{ "XYPlane.Name", "ESettingsDOF::XYPlane" },
		{ "XYPlane.ToolTip", "Allows 2D movement along the X-Y plane." },
		{ "XZPlane.Comment", "/** Allows 2D movement along the X-Z plane. */" },
		{ "XZPlane.Name", "ESettingsDOF::XZPlane" },
		{ "XZPlane.ToolTip", "Allows 2D movement along the X-Z plane." },
		{ "YZPlane.Comment", "/** Allows 2D movement along the Y-Z plane. */" },
		{ "YZPlane.Name", "ESettingsDOF::YZPlane" },
		{ "YZPlane.ToolTip", "Allows 2D movement along the Y-Z plane." },
	};
#endif // WITH_METADATA
	static constexpr UECodeGen_Private::FEnumeratorParam Enumerators[] = {
		{ "ESettingsDOF::Full3D", (int64)ESettingsDOF::Full3D },
		{ "ESettingsDOF::YZPlane", (int64)ESettingsDOF::YZPlane },
		{ "ESettingsDOF::XZPlane", (int64)ESettingsDOF::XZPlane },
		{ "ESettingsDOF::XYPlane", (int64)ESettingsDOF::XYPlane },
	};
	static const UECodeGen_Private::FEnumParams EnumParams;
}; // struct Z_Construct_UEnum_Engine_ESettingsDOF_Statics 
const UECodeGen_Private::FEnumParams Z_Construct_UEnum_Engine_ESettingsDOF_Statics::EnumParams = {
	(UObject*(*)())Z_Construct_UPackage__Script_Engine,
	nullptr,
	"ESettingsDOF",
	"ESettingsDOF::Type",
	Z_Construct_UEnum_Engine_ESettingsDOF_Statics::Enumerators,
	RF_Public|RF_Transient|RF_MarkAsNative,
	UE_ARRAY_COUNT(Z_Construct_UEnum_Engine_ESettingsDOF_Statics::Enumerators),
	EEnumFlags::None,
	(uint8)UEnum::ECppForm::Namespaced,
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UEnum_Engine_ESettingsDOF_Statics::Enum_MetaDataParams), Z_Construct_UEnum_Engine_ESettingsDOF_Statics::Enum_MetaDataParams)
};
UEnum* Z_Construct_UEnum_Engine_ESettingsDOF()
{
	if (!Z_Registration_Info_UEnum_ESettingsDOF.InnerSingleton)
	{
		UECodeGen_Private::ConstructUEnum(Z_Registration_Info_UEnum_ESettingsDOF.InnerSingleton, Z_Construct_UEnum_Engine_ESettingsDOF_Statics::EnumParams);
	}
	return Z_Registration_Info_UEnum_ESettingsDOF.InnerSingleton;
}
// ********** End Enum ESettingsDOF ****************************************************************

// ********** Begin ScriptStruct FPhysicsReplicationResimulationSettings ***************************
struct Z_Construct_UScriptStruct_FPhysicsReplicationResimulationSettings_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FPhysicsReplicationResimulationSettings); }
	static inline consteval int16 GetStructAlignment() { return alignof(FPhysicsReplicationResimulationSettings); }
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
		{ "Comment", "/** Default settings for physics replication using EPhysicsReplicationMode::Resimulation */" },
		{ "ModuleRelativePath", "Classes/PhysicsEngine/PhysicsSettings.h" },
		{ "ToolTip", "Default settings for physics replication using EPhysicsReplicationMode::Resimulation" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_bEnableResimulationErrorPositionThreshold_MetaData[] = {
		{ "Category", "Replication" },
		{ "Comment", "/** Enable positional error threshold to trigger resimulation */" },
		{ "InlineEditConditionToggle", "" },
		{ "ModuleRelativePath", "Classes/PhysicsEngine/PhysicsSettings.h" },
		{ "ToolTip", "Enable positional error threshold to trigger resimulation" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_ResimulationErrorPositionThreshold_MetaData[] = {
		{ "Category", "Replication" },
		{ "Comment", "/** Enable positional error threshold to trigger resimulation and set distance in centimeters before a state discrepancy triggers a resimulation */" },
		{ "editcondition", "bEnableResimulationErrorPositionThreshold" },
		{ "ModuleRelativePath", "Classes/PhysicsEngine/PhysicsSettings.h" },
		{ "ToolTip", "Enable positional error threshold to trigger resimulation and set distance in centimeters before a state discrepancy triggers a resimulation" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_bEnableResimulationErrorRotationThreshold_MetaData[] = {
		{ "Category", "Replication" },
		{ "Comment", "/** Enable rotational error threshold to trigger resimulation */" },
		{ "InlineEditConditionToggle", "" },
		{ "ModuleRelativePath", "Classes/PhysicsEngine/PhysicsSettings.h" },
		{ "ToolTip", "Enable rotational error threshold to trigger resimulation" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_ResimulationErrorRotationThreshold_MetaData[] = {
		{ "Category", "Replication" },
		{ "Comment", "/** Enable rotational error threshold to trigger resimulation and set rotation difference in degrees before a state discrepancy triggers a resimulation */" },
		{ "editcondition", "bEnableResimulationErrorRotationThreshold" },
		{ "ModuleRelativePath", "Classes/PhysicsEngine/PhysicsSettings.h" },
		{ "ToolTip", "Enable rotational error threshold to trigger resimulation and set rotation difference in degrees before a state discrepancy triggers a resimulation" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_bEnableResimulationErrorLinearVelocityThreshold_MetaData[] = {
		{ "Category", "Replication" },
		{ "Comment", "/** Enable linear velocity error threshold to trigger resimulation */" },
		{ "InlineEditConditionToggle", "" },
		{ "ModuleRelativePath", "Classes/PhysicsEngine/PhysicsSettings.h" },
		{ "ToolTip", "Enable linear velocity error threshold to trigger resimulation" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_ResimulationErrorLinearVelocityThreshold_MetaData[] = {
		{ "Category", "Replication" },
		{ "Comment", "/** Enable linear velocity error threshold to trigger resimulation and set velocity difference in centimeters / second before a state discrepancy triggers a resimulation */" },
		{ "editcondition", "bEnableResimulationErrorLinearVelocityThreshold" },
		{ "ModuleRelativePath", "Classes/PhysicsEngine/PhysicsSettings.h" },
		{ "ToolTip", "Enable linear velocity error threshold to trigger resimulation and set velocity difference in centimeters / second before a state discrepancy triggers a resimulation" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_bEnableResimulationErrorAngularVelocityThreshold_MetaData[] = {
		{ "Category", "Replication" },
		{ "Comment", "/** Enable angular velocity error threshold to trigger resimulation */" },
		{ "InlineEditConditionToggle", "" },
		{ "ModuleRelativePath", "Classes/PhysicsEngine/PhysicsSettings.h" },
		{ "ToolTip", "Enable angular velocity error threshold to trigger resimulation" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_ResimulationErrorAngularVelocityThreshold_MetaData[] = {
		{ "Category", "Replication" },
		{ "Comment", "/** Enable angular velocity error threshold to trigger resimulation and set velocity degrees / second before a state discrepancy triggers a resimulation */" },
		{ "editcondition", "bEnableResimulationErrorAngularVelocityThreshold" },
		{ "ModuleRelativePath", "Classes/PhysicsEngine/PhysicsSettings.h" },
		{ "ToolTip", "Enable angular velocity error threshold to trigger resimulation and set velocity degrees / second before a state discrepancy triggers a resimulation" },
	};
#endif // WITH_METADATA

// ********** Begin ScriptStruct FPhysicsReplicationResimulationSettings constinit property declarations 
	static void NewProp_bEnableResimulationErrorPositionThreshold_SetBit(void* Obj);
	static const UECodeGen_Private::FBoolPropertyParams NewProp_bEnableResimulationErrorPositionThreshold;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_ResimulationErrorPositionThreshold;
	static void NewProp_bEnableResimulationErrorRotationThreshold_SetBit(void* Obj);
	static const UECodeGen_Private::FBoolPropertyParams NewProp_bEnableResimulationErrorRotationThreshold;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_ResimulationErrorRotationThreshold;
	static void NewProp_bEnableResimulationErrorLinearVelocityThreshold_SetBit(void* Obj);
	static const UECodeGen_Private::FBoolPropertyParams NewProp_bEnableResimulationErrorLinearVelocityThreshold;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_ResimulationErrorLinearVelocityThreshold;
	static void NewProp_bEnableResimulationErrorAngularVelocityThreshold_SetBit(void* Obj);
	static const UECodeGen_Private::FBoolPropertyParams NewProp_bEnableResimulationErrorAngularVelocityThreshold;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_ResimulationErrorAngularVelocityThreshold;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End ScriptStruct FPhysicsReplicationResimulationSettings constinit property declarations 
	static void* NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FPhysicsReplicationResimulationSettings>();
	}
	static const UECodeGen_Private::FStructParams StructParams;
}; // struct Z_Construct_UScriptStruct_FPhysicsReplicationResimulationSettings_Statics
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FPhysicsReplicationResimulationSettings;
class UScriptStruct* FPhysicsReplicationResimulationSettings::StaticStruct()
{
	if (!Z_Registration_Info_UScriptStruct_FPhysicsReplicationResimulationSettings.OuterSingleton)
	{
		Z_Registration_Info_UScriptStruct_FPhysicsReplicationResimulationSettings.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FPhysicsReplicationResimulationSettings, (UObject*)Z_Construct_UPackage__Script_Engine(), TEXT("PhysicsReplicationResimulationSettings"));
	}
	return Z_Registration_Info_UScriptStruct_FPhysicsReplicationResimulationSettings.OuterSingleton;
	}

// ********** Begin ScriptStruct FPhysicsReplicationResimulationSettings Property Definitions ******
void Z_Construct_UScriptStruct_FPhysicsReplicationResimulationSettings_Statics::NewProp_bEnableResimulationErrorPositionThreshold_SetBit(void* Obj)
{
	((FPhysicsReplicationResimulationSettings*)Obj)->bEnableResimulationErrorPositionThreshold = 1;
}
const UECodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FPhysicsReplicationResimulationSettings_Statics::NewProp_bEnableResimulationErrorPositionThreshold = { "bEnableResimulationErrorPositionThreshold", nullptr, (EPropertyFlags)0x0010000000014001, UECodeGen_Private::EPropertyGenFlags::Bool | UECodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, sizeof(bool), sizeof(FPhysicsReplicationResimulationSettings), &Z_Construct_UScriptStruct_FPhysicsReplicationResimulationSettings_Statics::NewProp_bEnableResimulationErrorPositionThreshold_SetBit, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_bEnableResimulationErrorPositionThreshold_MetaData), NewProp_bEnableResimulationErrorPositionThreshold_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FPhysicsReplicationResimulationSettings_Statics::NewProp_ResimulationErrorPositionThreshold = { "ResimulationErrorPositionThreshold", nullptr, (EPropertyFlags)0x0010000000000001, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FPhysicsReplicationResimulationSettings, ResimulationErrorPositionThreshold), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_ResimulationErrorPositionThreshold_MetaData), NewProp_ResimulationErrorPositionThreshold_MetaData) };
void Z_Construct_UScriptStruct_FPhysicsReplicationResimulationSettings_Statics::NewProp_bEnableResimulationErrorRotationThreshold_SetBit(void* Obj)
{
	((FPhysicsReplicationResimulationSettings*)Obj)->bEnableResimulationErrorRotationThreshold = 1;
}
const UECodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FPhysicsReplicationResimulationSettings_Statics::NewProp_bEnableResimulationErrorRotationThreshold = { "bEnableResimulationErrorRotationThreshold", nullptr, (EPropertyFlags)0x0010000000014001, UECodeGen_Private::EPropertyGenFlags::Bool | UECodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, sizeof(bool), sizeof(FPhysicsReplicationResimulationSettings), &Z_Construct_UScriptStruct_FPhysicsReplicationResimulationSettings_Statics::NewProp_bEnableResimulationErrorRotationThreshold_SetBit, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_bEnableResimulationErrorRotationThreshold_MetaData), NewProp_bEnableResimulationErrorRotationThreshold_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FPhysicsReplicationResimulationSettings_Statics::NewProp_ResimulationErrorRotationThreshold = { "ResimulationErrorRotationThreshold", nullptr, (EPropertyFlags)0x0010000000000001, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FPhysicsReplicationResimulationSettings, ResimulationErrorRotationThreshold), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_ResimulationErrorRotationThreshold_MetaData), NewProp_ResimulationErrorRotationThreshold_MetaData) };
void Z_Construct_UScriptStruct_FPhysicsReplicationResimulationSettings_Statics::NewProp_bEnableResimulationErrorLinearVelocityThreshold_SetBit(void* Obj)
{
	((FPhysicsReplicationResimulationSettings*)Obj)->bEnableResimulationErrorLinearVelocityThreshold = 1;
}
const UECodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FPhysicsReplicationResimulationSettings_Statics::NewProp_bEnableResimulationErrorLinearVelocityThreshold = { "bEnableResimulationErrorLinearVelocityThreshold", nullptr, (EPropertyFlags)0x0010000000014001, UECodeGen_Private::EPropertyGenFlags::Bool | UECodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, sizeof(bool), sizeof(FPhysicsReplicationResimulationSettings), &Z_Construct_UScriptStruct_FPhysicsReplicationResimulationSettings_Statics::NewProp_bEnableResimulationErrorLinearVelocityThreshold_SetBit, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_bEnableResimulationErrorLinearVelocityThreshold_MetaData), NewProp_bEnableResimulationErrorLinearVelocityThreshold_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FPhysicsReplicationResimulationSettings_Statics::NewProp_ResimulationErrorLinearVelocityThreshold = { "ResimulationErrorLinearVelocityThreshold", nullptr, (EPropertyFlags)0x0010000000000001, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FPhysicsReplicationResimulationSettings, ResimulationErrorLinearVelocityThreshold), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_ResimulationErrorLinearVelocityThreshold_MetaData), NewProp_ResimulationErrorLinearVelocityThreshold_MetaData) };
void Z_Construct_UScriptStruct_FPhysicsReplicationResimulationSettings_Statics::NewProp_bEnableResimulationErrorAngularVelocityThreshold_SetBit(void* Obj)
{
	((FPhysicsReplicationResimulationSettings*)Obj)->bEnableResimulationErrorAngularVelocityThreshold = 1;
}
const UECodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FPhysicsReplicationResimulationSettings_Statics::NewProp_bEnableResimulationErrorAngularVelocityThreshold = { "bEnableResimulationErrorAngularVelocityThreshold", nullptr, (EPropertyFlags)0x0010000000014001, UECodeGen_Private::EPropertyGenFlags::Bool | UECodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, sizeof(bool), sizeof(FPhysicsReplicationResimulationSettings), &Z_Construct_UScriptStruct_FPhysicsReplicationResimulationSettings_Statics::NewProp_bEnableResimulationErrorAngularVelocityThreshold_SetBit, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_bEnableResimulationErrorAngularVelocityThreshold_MetaData), NewProp_bEnableResimulationErrorAngularVelocityThreshold_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FPhysicsReplicationResimulationSettings_Statics::NewProp_ResimulationErrorAngularVelocityThreshold = { "ResimulationErrorAngularVelocityThreshold", nullptr, (EPropertyFlags)0x0010000000000001, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FPhysicsReplicationResimulationSettings, ResimulationErrorAngularVelocityThreshold), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_ResimulationErrorAngularVelocityThreshold_MetaData), NewProp_ResimulationErrorAngularVelocityThreshold_MetaData) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FPhysicsReplicationResimulationSettings_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FPhysicsReplicationResimulationSettings_Statics::NewProp_bEnableResimulationErrorPositionThreshold,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FPhysicsReplicationResimulationSettings_Statics::NewProp_ResimulationErrorPositionThreshold,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FPhysicsReplicationResimulationSettings_Statics::NewProp_bEnableResimulationErrorRotationThreshold,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FPhysicsReplicationResimulationSettings_Statics::NewProp_ResimulationErrorRotationThreshold,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FPhysicsReplicationResimulationSettings_Statics::NewProp_bEnableResimulationErrorLinearVelocityThreshold,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FPhysicsReplicationResimulationSettings_Statics::NewProp_ResimulationErrorLinearVelocityThreshold,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FPhysicsReplicationResimulationSettings_Statics::NewProp_bEnableResimulationErrorAngularVelocityThreshold,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FPhysicsReplicationResimulationSettings_Statics::NewProp_ResimulationErrorAngularVelocityThreshold,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FPhysicsReplicationResimulationSettings_Statics::PropPointers) < 2048);
// ********** End ScriptStruct FPhysicsReplicationResimulationSettings Property Definitions ********
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FPhysicsReplicationResimulationSettings_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_Engine,
	nullptr,
	&NewStructOps,
	"PhysicsReplicationResimulationSettings",
	Z_Construct_UScriptStruct_FPhysicsReplicationResimulationSettings_Statics::PropPointers,
	UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FPhysicsReplicationResimulationSettings_Statics::PropPointers),
	sizeof(FPhysicsReplicationResimulationSettings),
	alignof(FPhysicsReplicationResimulationSettings),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FPhysicsReplicationResimulationSettings_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FPhysicsReplicationResimulationSettings_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FPhysicsReplicationResimulationSettings()
{
	if (!Z_Registration_Info_UScriptStruct_FPhysicsReplicationResimulationSettings.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FPhysicsReplicationResimulationSettings.InnerSingleton, Z_Construct_UScriptStruct_FPhysicsReplicationResimulationSettings_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FPhysicsReplicationResimulationSettings.InnerSingleton);
}
// ********** End ScriptStruct FPhysicsReplicationResimulationSettings *****************************

// ********** Begin ScriptStruct FPhysicsReplicationLODSettings ************************************
struct Z_Construct_UScriptStruct_FPhysicsReplicationLODSettings_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FPhysicsReplicationLODSettings); }
	static inline consteval int16 GetStructAlignment() { return alignof(FPhysicsReplicationLODSettings); }
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
		{ "Comment", "/** Default settings for physics replication LOD */" },
		{ "ModuleRelativePath", "Classes/PhysicsEngine/PhysicsSettings.h" },
		{ "ToolTip", "Default settings for physics replication LOD" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_bEnablePhysicsReplicationLOD_MetaData[] = {
		{ "Category", "Replication" },
		{ "Comment", "/** Enable physics replication LOD */" },
		{ "ModuleRelativePath", "Classes/PhysicsEngine/PhysicsSettings.h" },
		{ "ToolTip", "Enable physics replication LOD" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_MinimumBaseDistance_MetaData[] = {
		{ "Category", "Replication" },
		{ "ClampMin", "0.0" },
		{ "Comment", "/** Minimum distance in the physics replication LODs Base Distance. */" },
		{ "ModuleRelativePath", "Classes/PhysicsEngine/PhysicsSettings.h" },
		{ "ToolTip", "Minimum distance in the physics replication LODs Base Distance." },
		{ "UIMin", "0.0" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_BaseDistanceRadiusMultiplier_MetaData[] = {
		{ "Category", "Replication" },
		{ "ClampMin", "0.0" },
		{ "Comment", "/** Multiplier for adding focal particles bounding box radius to the physics replication LODs Base Distance. Value of 0.75 adds 75% of the radius on top of MinimumBaseDistance. */" },
		{ "ModuleRelativePath", "Classes/PhysicsEngine/PhysicsSettings.h" },
		{ "ToolTip", "Multiplier for adding focal particles bounding box radius to the physics replication LODs Base Distance. Value of 0.75 adds 75% of the radius on top of MinimumBaseDistance." },
		{ "UIMin", "0.0" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_BaseDistancesForResimulationMode_MetaData[] = {
		{ "Category", "Replication" },
		{ "ClampMin", "0.0" },
		{ "Comment", "/** 'BaseDistance' is a result of MinimumBaseDistance + (the focal particles radius * BaseDistanceRadiusMultiplier)\n\x09* Set how many BaseDistance's from the focal particle where within physics replicated objects will use EPhysicsReplicationMode::Resimulation.\n\x09* Resimulation is a fully forward predicted physics replication, for a seamless LOD transition this should be equal to or lower than BaseDistancesForFullPrediction, read that property for information.\n\x09* NOTE: The resulting distance will be added on top of the focal particles radius. */" },
		{ "ModuleRelativePath", "Classes/PhysicsEngine/PhysicsSettings.h" },
		{ "ToolTip", "'BaseDistance' is a result of MinimumBaseDistance + (the focal particles radius * BaseDistanceRadiusMultiplier)\nSet how many BaseDistance's from the focal particle where within physics replicated objects will use EPhysicsReplicationMode::Resimulation.\nResimulation is a fully forward predicted physics replication, for a seamless LOD transition this should be equal to or lower than BaseDistancesForFullPrediction, read that property for information.\nNOTE: The resulting distance will be added on top of the focal particles radius." },
		{ "UIMin", "0.0" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_BaseDistancesForFullPrediction_MetaData[] = {
		{ "Category", "Replication" },
		{ "ClampMin", "0.0" },
		{ "Comment", "/** 'BaseDistance' is a result of MinimumBaseDistance + (the focal particles radius * BaseDistanceRadiusMultiplier)\n\x09* Set how many BaseDistance's from the focal particle where within physics replicated objects will be in the clients forward predicted timeline.\n\x09* Physics replication LOD gradually forward predicts the physics replication when objects get closer to focal points in LOD.\n\x09* Read the TimeOverDistance property for details on how forward prediction is gradually applied up until the distance of DistanceForFullPrediction. \n\x09* NOTE: The local player is typically forward predicted (and should then be a focal particle in LOD), while other physics replicated objects are typically replicated without forward prediction.\n\x09* NOTE: The resulting distance will be added on top of the focal particles radius. */" },
		{ "ModuleRelativePath", "Classes/PhysicsEngine/PhysicsSettings.h" },
		{ "ToolTip", "'BaseDistance' is a result of MinimumBaseDistance + (the focal particles radius * BaseDistanceRadiusMultiplier)\nSet how many BaseDistance's from the focal particle where within physics replicated objects will be in the clients forward predicted timeline.\nPhysics replication LOD gradually forward predicts the physics replication when objects get closer to focal points in LOD.\nRead the TimeOverDistance property for details on how forward prediction is gradually applied up until the distance of DistanceForFullPrediction.\nNOTE: The local player is typically forward predicted (and should then be a focal particle in LOD), while other physics replicated objects are typically replicated without forward prediction.\nNOTE: The resulting distance will be added on top of the focal particles radius." },
		{ "UIMin", "0.0" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_TimeOverDistance_MetaData[] = {
		{ "Category", "Replication" },
		{ "ClampMin", "0.0" },
		{ "Comment", "/** Time/Distance alignment value, used as Distance * TimeOverDistance = Time\n\x09* Time is how far behind the current (forward predicted) timeline replication should run\n\x09* Starts outside of DistanceForFullPrediction (calculated from BaseDistancesForFullPrediction) and gets clamped by the received states timeline.\n\x09* Lower value = Slower timeline transition which produces a larger LOD radius.\n\x09* EXAMPLE: At 500cm away an object should be 37,5ms behind the clients timeline if DistanceForFullPrediction is 250cm and TimeOverDistance is 0.15ms/cm. (500cm - 250cm) * 0.15ms/cm = 37,5ms */" },
		{ "ModuleRelativePath", "Classes/PhysicsEngine/PhysicsSettings.h" },
		{ "ToolTip", "Time/Distance alignment value, used as Distance * TimeOverDistance = Time\nTime is how far behind the current (forward predicted) timeline replication should run\nStarts outside of DistanceForFullPrediction (calculated from BaseDistancesForFullPrediction) and gets clamped by the received states timeline.\nLower value = Slower timeline transition which produces a larger LOD radius.\nEXAMPLE: At 500cm away an object should be 37,5ms behind the clients timeline if DistanceForFullPrediction is 250cm and TimeOverDistance is 0.15ms/cm. (500cm - 250cm) * 0.15ms/cm = 37,5ms" },
		{ "UIMin", "0.0" },
	};
#endif // WITH_METADATA

// ********** Begin ScriptStruct FPhysicsReplicationLODSettings constinit property declarations ****
	static void NewProp_bEnablePhysicsReplicationLOD_SetBit(void* Obj);
	static const UECodeGen_Private::FBoolPropertyParams NewProp_bEnablePhysicsReplicationLOD;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_MinimumBaseDistance;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_BaseDistanceRadiusMultiplier;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_BaseDistancesForResimulationMode;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_BaseDistancesForFullPrediction;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_TimeOverDistance;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End ScriptStruct FPhysicsReplicationLODSettings constinit property declarations ******
	static void* NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FPhysicsReplicationLODSettings>();
	}
	static const UECodeGen_Private::FStructParams StructParams;
}; // struct Z_Construct_UScriptStruct_FPhysicsReplicationLODSettings_Statics
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FPhysicsReplicationLODSettings;
class UScriptStruct* FPhysicsReplicationLODSettings::StaticStruct()
{
	if (!Z_Registration_Info_UScriptStruct_FPhysicsReplicationLODSettings.OuterSingleton)
	{
		Z_Registration_Info_UScriptStruct_FPhysicsReplicationLODSettings.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FPhysicsReplicationLODSettings, (UObject*)Z_Construct_UPackage__Script_Engine(), TEXT("PhysicsReplicationLODSettings"));
	}
	return Z_Registration_Info_UScriptStruct_FPhysicsReplicationLODSettings.OuterSingleton;
	}

// ********** Begin ScriptStruct FPhysicsReplicationLODSettings Property Definitions ***************
void Z_Construct_UScriptStruct_FPhysicsReplicationLODSettings_Statics::NewProp_bEnablePhysicsReplicationLOD_SetBit(void* Obj)
{
	((FPhysicsReplicationLODSettings*)Obj)->bEnablePhysicsReplicationLOD = 1;
}
const UECodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FPhysicsReplicationLODSettings_Statics::NewProp_bEnablePhysicsReplicationLOD = { "bEnablePhysicsReplicationLOD", nullptr, (EPropertyFlags)0x0010000000014001, UECodeGen_Private::EPropertyGenFlags::Bool | UECodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, sizeof(bool), sizeof(FPhysicsReplicationLODSettings), &Z_Construct_UScriptStruct_FPhysicsReplicationLODSettings_Statics::NewProp_bEnablePhysicsReplicationLOD_SetBit, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_bEnablePhysicsReplicationLOD_MetaData), NewProp_bEnablePhysicsReplicationLOD_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FPhysicsReplicationLODSettings_Statics::NewProp_MinimumBaseDistance = { "MinimumBaseDistance", nullptr, (EPropertyFlags)0x0010000000000001, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FPhysicsReplicationLODSettings, MinimumBaseDistance), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_MinimumBaseDistance_MetaData), NewProp_MinimumBaseDistance_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FPhysicsReplicationLODSettings_Statics::NewProp_BaseDistanceRadiusMultiplier = { "BaseDistanceRadiusMultiplier", nullptr, (EPropertyFlags)0x0010000000000001, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FPhysicsReplicationLODSettings, BaseDistanceRadiusMultiplier), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_BaseDistanceRadiusMultiplier_MetaData), NewProp_BaseDistanceRadiusMultiplier_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FPhysicsReplicationLODSettings_Statics::NewProp_BaseDistancesForResimulationMode = { "BaseDistancesForResimulationMode", nullptr, (EPropertyFlags)0x0010000000000001, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FPhysicsReplicationLODSettings, BaseDistancesForResimulationMode), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_BaseDistancesForResimulationMode_MetaData), NewProp_BaseDistancesForResimulationMode_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FPhysicsReplicationLODSettings_Statics::NewProp_BaseDistancesForFullPrediction = { "BaseDistancesForFullPrediction", nullptr, (EPropertyFlags)0x0010000000000001, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FPhysicsReplicationLODSettings, BaseDistancesForFullPrediction), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_BaseDistancesForFullPrediction_MetaData), NewProp_BaseDistancesForFullPrediction_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FPhysicsReplicationLODSettings_Statics::NewProp_TimeOverDistance = { "TimeOverDistance", nullptr, (EPropertyFlags)0x0010000000000001, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FPhysicsReplicationLODSettings, TimeOverDistance), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_TimeOverDistance_MetaData), NewProp_TimeOverDistance_MetaData) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FPhysicsReplicationLODSettings_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FPhysicsReplicationLODSettings_Statics::NewProp_bEnablePhysicsReplicationLOD,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FPhysicsReplicationLODSettings_Statics::NewProp_MinimumBaseDistance,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FPhysicsReplicationLODSettings_Statics::NewProp_BaseDistanceRadiusMultiplier,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FPhysicsReplicationLODSettings_Statics::NewProp_BaseDistancesForResimulationMode,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FPhysicsReplicationLODSettings_Statics::NewProp_BaseDistancesForFullPrediction,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FPhysicsReplicationLODSettings_Statics::NewProp_TimeOverDistance,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FPhysicsReplicationLODSettings_Statics::PropPointers) < 2048);
// ********** End ScriptStruct FPhysicsReplicationLODSettings Property Definitions *****************
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FPhysicsReplicationLODSettings_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_Engine,
	nullptr,
	&NewStructOps,
	"PhysicsReplicationLODSettings",
	Z_Construct_UScriptStruct_FPhysicsReplicationLODSettings_Statics::PropPointers,
	UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FPhysicsReplicationLODSettings_Statics::PropPointers),
	sizeof(FPhysicsReplicationLODSettings),
	alignof(FPhysicsReplicationLODSettings),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FPhysicsReplicationLODSettings_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FPhysicsReplicationLODSettings_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FPhysicsReplicationLODSettings()
{
	if (!Z_Registration_Info_UScriptStruct_FPhysicsReplicationLODSettings.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FPhysicsReplicationLODSettings.InnerSingleton, Z_Construct_UScriptStruct_FPhysicsReplicationLODSettings_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FPhysicsReplicationLODSettings.InnerSingleton);
}
// ********** End ScriptStruct FPhysicsReplicationLODSettings **************************************

// ********** Begin ScriptStruct FPhysicsPredictionSettings ****************************************
struct Z_Construct_UScriptStruct_FPhysicsPredictionSettings_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FPhysicsPredictionSettings); }
	static inline consteval int16 GetStructAlignment() { return alignof(FPhysicsPredictionSettings); }
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
		{ "Comment", "/** Physics Prediction Settings */" },
		{ "ModuleRelativePath", "Classes/PhysicsEngine/PhysicsSettings.h" },
		{ "ToolTip", "Physics Prediction Settings" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_bEnablePhysicsResimulation_MetaData[] = {
		{ "Comment", "/** bEnablePhysicsResimulation has been renamed, please use bEnablePhysicsHistoryCapture*/" },
		{ "ModuleRelativePath", "Classes/PhysicsEngine/PhysicsSettings.h" },
		{ "ToolTip", "bEnablePhysicsResimulation has been renamed, please use bEnablePhysicsHistoryCapture" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_ResimulationErrorThreshold_MetaData[] = {
		{ "Comment", "/** ResimulationErrorThreshold has been renamed and moved, please use FPhysicsReplicationResimulationSettings.ResimulationErrorPositionThreshold*/" },
		{ "ModuleRelativePath", "Classes/PhysicsEngine/PhysicsSettings.h" },
		{ "ToolTip", "ResimulationErrorThreshold has been renamed and moved, please use FPhysicsReplicationResimulationSettings.ResimulationErrorPositionThreshold" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_bEnablePhysicsPrediction_MetaData[] = {
		{ "Category", "Replication" },
		{ "Comment", "/** Enable networked physics prediction (experimental)\n\x09* This syncs the physics tick number between client and server and keeps it in sync via time dilation performed on the client, see APlayerController::GetPhysicsTimestamp().\n\x09* If an AActor::PhysicsReplicationMode is set to use Resimulation this will also enable RewindData to cache physics history on the client which is required by resimulation replication.\n\x09* IMPORTANT: Physics Prediction needs Physics -> Framerate -> Tick Physics Async enabled to function as intended. */" },
		{ "ModuleRelativePath", "Classes/PhysicsEngine/PhysicsSettings.h" },
		{ "ToolTip", "Enable networked physics prediction (experimental)\nThis syncs the physics tick number between client and server and keeps it in sync via time dilation performed on the client, see APlayerController::GetPhysicsTimestamp().\nIf an AActor::PhysicsReplicationMode is set to use Resimulation this will also enable RewindData to cache physics history on the client which is required by resimulation replication.\nIMPORTANT: Physics Prediction needs Physics -> Framerate -> Tick Physics Async enabled to function as intended." },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_bEnablePhysicsHistoryCapture_MetaData[] = {
		{ "Category", "Replication" },
		{ "Comment", "/** Enables FRewindData to cache physics history\n\x09* Note: This is not recommended for networked physics unless developing a custom resimulation solution since this starts caching physics on both client and server, \n\x09 instead only enable bEnablePhysicsPrediction which will automatically enable FRewindData caching on the client if needed by the chosen replication mode. */" },
		{ "ModuleRelativePath", "Classes/PhysicsEngine/PhysicsSettings.h" },
		{ "ToolTip", "Enables FRewindData to cache physics history\nNote: This is not recommended for networked physics unless developing a custom resimulation solution since this starts caching physics on both client and server,\n       instead only enable bEnablePhysicsPrediction which will automatically enable FRewindData caching on the client if needed by the chosen replication mode." },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_MaxSupportedLatencyPrediction_MetaData[] = {
		{ "Category", "Replication" },
		{ "Comment", "/** Amount of RTT (Round Trip Time) latency for the prediction to support in milliseconds. */" },
		{ "ModuleRelativePath", "Classes/PhysicsEngine/PhysicsSettings.h" },
		{ "ToolTip", "Amount of RTT (Round Trip Time) latency for the prediction to support in milliseconds." },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_ResimulationSettings_MetaData[] = {
		{ "Category", "Replication" },
		{ "Comment", "/** Default settings for physics replication using EPhysicsReplicationMode::Resimulation. */" },
		{ "DisplayName", "Default Resimulation Replication Settings (EPhysicsReplicationMode::Resimulation)" },
		{ "ModuleRelativePath", "Classes/PhysicsEngine/PhysicsSettings.h" },
		{ "ToolTip", "Default settings for physics replication using EPhysicsReplicationMode::Resimulation." },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_PhysicsReplicationLODSettings_MetaData[] = {
		{ "Category", "Replication" },
		{ "Comment", "/** Default settings for physics replication LOD. */" },
		{ "DisplayName", "Default settings for physics replication LOD" },
		{ "ModuleRelativePath", "Classes/PhysicsEngine/PhysicsSettings.h" },
		{ "ToolTip", "Default settings for physics replication LOD." },
	};
#endif // WITH_METADATA

// ********** Begin ScriptStruct FPhysicsPredictionSettings constinit property declarations ********
	static void NewProp_bEnablePhysicsResimulation_SetBit(void* Obj);
	static const UECodeGen_Private::FBoolPropertyParams NewProp_bEnablePhysicsResimulation;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_ResimulationErrorThreshold;
	static void NewProp_bEnablePhysicsPrediction_SetBit(void* Obj);
	static const UECodeGen_Private::FBoolPropertyParams NewProp_bEnablePhysicsPrediction;
	static void NewProp_bEnablePhysicsHistoryCapture_SetBit(void* Obj);
	static const UECodeGen_Private::FBoolPropertyParams NewProp_bEnablePhysicsHistoryCapture;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_MaxSupportedLatencyPrediction;
	static const UECodeGen_Private::FStructPropertyParams NewProp_ResimulationSettings;
	static const UECodeGen_Private::FStructPropertyParams NewProp_PhysicsReplicationLODSettings;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End ScriptStruct FPhysicsPredictionSettings constinit property declarations **********
	static void* NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FPhysicsPredictionSettings>();
	}
	static const UECodeGen_Private::FStructParams StructParams;
}; // struct Z_Construct_UScriptStruct_FPhysicsPredictionSettings_Statics
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FPhysicsPredictionSettings;
class UScriptStruct* FPhysicsPredictionSettings::StaticStruct()
{
	if (!Z_Registration_Info_UScriptStruct_FPhysicsPredictionSettings.OuterSingleton)
	{
		Z_Registration_Info_UScriptStruct_FPhysicsPredictionSettings.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FPhysicsPredictionSettings, (UObject*)Z_Construct_UPackage__Script_Engine(), TEXT("PhysicsPredictionSettings"));
	}
	return Z_Registration_Info_UScriptStruct_FPhysicsPredictionSettings.OuterSingleton;
	}

// ********** Begin ScriptStruct FPhysicsPredictionSettings Property Definitions *******************
void Z_Construct_UScriptStruct_FPhysicsPredictionSettings_Statics::NewProp_bEnablePhysicsResimulation_SetBit(void* Obj)
{
	((FPhysicsPredictionSettings*)Obj)->bEnablePhysicsResimulation_DEPRECATED = 1;
}
const UECodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FPhysicsPredictionSettings_Statics::NewProp_bEnablePhysicsResimulation = { "bEnablePhysicsResimulation", nullptr, (EPropertyFlags)0x0010000020004000, UECodeGen_Private::EPropertyGenFlags::Bool | UECodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, sizeof(bool), sizeof(FPhysicsPredictionSettings), &Z_Construct_UScriptStruct_FPhysicsPredictionSettings_Statics::NewProp_bEnablePhysicsResimulation_SetBit, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_bEnablePhysicsResimulation_MetaData), NewProp_bEnablePhysicsResimulation_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FPhysicsPredictionSettings_Statics::NewProp_ResimulationErrorThreshold = { "ResimulationErrorThreshold", nullptr, (EPropertyFlags)0x0010000020004000, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FPhysicsPredictionSettings, ResimulationErrorThreshold_DEPRECATED), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_ResimulationErrorThreshold_MetaData), NewProp_ResimulationErrorThreshold_MetaData) };
void Z_Construct_UScriptStruct_FPhysicsPredictionSettings_Statics::NewProp_bEnablePhysicsPrediction_SetBit(void* Obj)
{
	((FPhysicsPredictionSettings*)Obj)->bEnablePhysicsPrediction = 1;
}
const UECodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FPhysicsPredictionSettings_Statics::NewProp_bEnablePhysicsPrediction = { "bEnablePhysicsPrediction", nullptr, (EPropertyFlags)0x0010000000000001, UECodeGen_Private::EPropertyGenFlags::Bool | UECodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, sizeof(bool), sizeof(FPhysicsPredictionSettings), &Z_Construct_UScriptStruct_FPhysicsPredictionSettings_Statics::NewProp_bEnablePhysicsPrediction_SetBit, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_bEnablePhysicsPrediction_MetaData), NewProp_bEnablePhysicsPrediction_MetaData) };
void Z_Construct_UScriptStruct_FPhysicsPredictionSettings_Statics::NewProp_bEnablePhysicsHistoryCapture_SetBit(void* Obj)
{
	((FPhysicsPredictionSettings*)Obj)->bEnablePhysicsHistoryCapture = 1;
}
const UECodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FPhysicsPredictionSettings_Statics::NewProp_bEnablePhysicsHistoryCapture = { "bEnablePhysicsHistoryCapture", nullptr, (EPropertyFlags)0x0010000000000001, UECodeGen_Private::EPropertyGenFlags::Bool | UECodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, sizeof(bool), sizeof(FPhysicsPredictionSettings), &Z_Construct_UScriptStruct_FPhysicsPredictionSettings_Statics::NewProp_bEnablePhysicsHistoryCapture_SetBit, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_bEnablePhysicsHistoryCapture_MetaData), NewProp_bEnablePhysicsHistoryCapture_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FPhysicsPredictionSettings_Statics::NewProp_MaxSupportedLatencyPrediction = { "MaxSupportedLatencyPrediction", nullptr, (EPropertyFlags)0x0010000000000001, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FPhysicsPredictionSettings, MaxSupportedLatencyPrediction), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_MaxSupportedLatencyPrediction_MetaData), NewProp_MaxSupportedLatencyPrediction_MetaData) };
const UECodeGen_Private::FStructPropertyParams Z_Construct_UScriptStruct_FPhysicsPredictionSettings_Statics::NewProp_ResimulationSettings = { "ResimulationSettings", nullptr, (EPropertyFlags)0x0010000000000001, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FPhysicsPredictionSettings, ResimulationSettings), Z_Construct_UScriptStruct_FPhysicsReplicationResimulationSettings, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_ResimulationSettings_MetaData), NewProp_ResimulationSettings_MetaData) }; // 2262317442
const UECodeGen_Private::FStructPropertyParams Z_Construct_UScriptStruct_FPhysicsPredictionSettings_Statics::NewProp_PhysicsReplicationLODSettings = { "PhysicsReplicationLODSettings", nullptr, (EPropertyFlags)0x0010000000000001, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FPhysicsPredictionSettings, PhysicsReplicationLODSettings), Z_Construct_UScriptStruct_FPhysicsReplicationLODSettings, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_PhysicsReplicationLODSettings_MetaData), NewProp_PhysicsReplicationLODSettings_MetaData) }; // 3427550836
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FPhysicsPredictionSettings_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FPhysicsPredictionSettings_Statics::NewProp_bEnablePhysicsResimulation,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FPhysicsPredictionSettings_Statics::NewProp_ResimulationErrorThreshold,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FPhysicsPredictionSettings_Statics::NewProp_bEnablePhysicsPrediction,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FPhysicsPredictionSettings_Statics::NewProp_bEnablePhysicsHistoryCapture,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FPhysicsPredictionSettings_Statics::NewProp_MaxSupportedLatencyPrediction,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FPhysicsPredictionSettings_Statics::NewProp_ResimulationSettings,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FPhysicsPredictionSettings_Statics::NewProp_PhysicsReplicationLODSettings,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FPhysicsPredictionSettings_Statics::PropPointers) < 2048);
// ********** End ScriptStruct FPhysicsPredictionSettings Property Definitions *********************
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FPhysicsPredictionSettings_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_Engine,
	nullptr,
	&NewStructOps,
	"PhysicsPredictionSettings",
	Z_Construct_UScriptStruct_FPhysicsPredictionSettings_Statics::PropPointers,
	UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FPhysicsPredictionSettings_Statics::PropPointers),
	sizeof(FPhysicsPredictionSettings),
	alignof(FPhysicsPredictionSettings),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FPhysicsPredictionSettings_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FPhysicsPredictionSettings_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FPhysicsPredictionSettings()
{
	if (!Z_Registration_Info_UScriptStruct_FPhysicsPredictionSettings.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FPhysicsPredictionSettings.InnerSingleton, Z_Construct_UScriptStruct_FPhysicsPredictionSettings_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FPhysicsPredictionSettings.InnerSingleton);
}
// ********** End ScriptStruct FPhysicsPredictionSettings ******************************************

// ********** Begin Enum ESettingsLockedAxis *******************************************************
static FEnumRegistrationInfo Z_Registration_Info_UEnum_ESettingsLockedAxis;
static UEnum* ESettingsLockedAxis_StaticEnum()
{
	if (!Z_Registration_Info_UEnum_ESettingsLockedAxis.OuterSingleton)
	{
		Z_Registration_Info_UEnum_ESettingsLockedAxis.OuterSingleton = GetStaticEnum(Z_Construct_UEnum_Engine_ESettingsLockedAxis, (UObject*)Z_Construct_UPackage__Script_Engine(), TEXT("ESettingsLockedAxis"));
	}
	return Z_Registration_Info_UEnum_ESettingsLockedAxis.OuterSingleton;
}
template<> ENGINE_NON_ATTRIBUTED_API UEnum* StaticEnum<ESettingsLockedAxis::Type>()
{
	return ESettingsLockedAxis_StaticEnum();
}
struct Z_Construct_UEnum_Engine_ESettingsLockedAxis_Statics
{
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
		{ "Invalid.Comment", "/** Used for backwards compatibility. Indicates that we've updated into the new struct. */" },
		{ "Invalid.Name", "ESettingsLockedAxis::Invalid" },
		{ "Invalid.ToolTip", "Used for backwards compatibility. Indicates that we've updated into the new struct." },
		{ "ModuleRelativePath", "Classes/PhysicsEngine/PhysicsSettings.h" },
		{ "None.Comment", "/** No axis is locked. */" },
		{ "None.Name", "ESettingsLockedAxis::None" },
		{ "None.ToolTip", "No axis is locked." },
		{ "X.Comment", "/** Lock movement along the x-axis. */" },
		{ "X.Name", "ESettingsLockedAxis::X" },
		{ "X.ToolTip", "Lock movement along the x-axis." },
		{ "Y.Comment", "/** Lock movement along the y-axis. */" },
		{ "Y.Name", "ESettingsLockedAxis::Y" },
		{ "Y.ToolTip", "Lock movement along the y-axis." },
		{ "Z.Comment", "/** Lock movement along the z-axis. */" },
		{ "Z.Name", "ESettingsLockedAxis::Z" },
		{ "Z.ToolTip", "Lock movement along the z-axis." },
	};
#endif // WITH_METADATA
	static constexpr UECodeGen_Private::FEnumeratorParam Enumerators[] = {
		{ "ESettingsLockedAxis::None", (int64)ESettingsLockedAxis::None },
		{ "ESettingsLockedAxis::X", (int64)ESettingsLockedAxis::X },
		{ "ESettingsLockedAxis::Y", (int64)ESettingsLockedAxis::Y },
		{ "ESettingsLockedAxis::Z", (int64)ESettingsLockedAxis::Z },
		{ "ESettingsLockedAxis::Invalid", (int64)ESettingsLockedAxis::Invalid },
	};
	static const UECodeGen_Private::FEnumParams EnumParams;
}; // struct Z_Construct_UEnum_Engine_ESettingsLockedAxis_Statics 
const UECodeGen_Private::FEnumParams Z_Construct_UEnum_Engine_ESettingsLockedAxis_Statics::EnumParams = {
	(UObject*(*)())Z_Construct_UPackage__Script_Engine,
	nullptr,
	"ESettingsLockedAxis",
	"ESettingsLockedAxis::Type",
	Z_Construct_UEnum_Engine_ESettingsLockedAxis_Statics::Enumerators,
	RF_Public|RF_Transient|RF_MarkAsNative,
	UE_ARRAY_COUNT(Z_Construct_UEnum_Engine_ESettingsLockedAxis_Statics::Enumerators),
	EEnumFlags::None,
	(uint8)UEnum::ECppForm::Namespaced,
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UEnum_Engine_ESettingsLockedAxis_Statics::Enum_MetaDataParams), Z_Construct_UEnum_Engine_ESettingsLockedAxis_Statics::Enum_MetaDataParams)
};
UEnum* Z_Construct_UEnum_Engine_ESettingsLockedAxis()
{
	if (!Z_Registration_Info_UEnum_ESettingsLockedAxis.InnerSingleton)
	{
		UECodeGen_Private::ConstructUEnum(Z_Registration_Info_UEnum_ESettingsLockedAxis.InnerSingleton, Z_Construct_UEnum_Engine_ESettingsLockedAxis_Statics::EnumParams);
	}
	return Z_Registration_Info_UEnum_ESettingsLockedAxis.InnerSingleton;
}
// ********** End Enum ESettingsLockedAxis *********************************************************

// ********** Begin Class UPhysicsSettings Function GetPhysicsHistoryCount *************************
struct Z_Construct_UFunction_UPhysicsSettings_GetPhysicsHistoryCount_Statics
{
	struct PhysicsSettings_eventGetPhysicsHistoryCount_Parms
	{
		int32 ReturnValue;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Category", "Physics" },
		{ "ModuleRelativePath", "Classes/PhysicsEngine/PhysicsSettings.h" },
	};
#endif // WITH_METADATA

// ********** Begin Function GetPhysicsHistoryCount constinit property declarations ****************
	static const UECodeGen_Private::FIntPropertyParams NewProp_ReturnValue;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End Function GetPhysicsHistoryCount constinit property declarations ******************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};

// ********** Begin Function GetPhysicsHistoryCount Property Definitions ***************************
const UECodeGen_Private::FIntPropertyParams Z_Construct_UFunction_UPhysicsSettings_GetPhysicsHistoryCount_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UECodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(PhysicsSettings_eventGetPhysicsHistoryCount_Parms, ReturnValue), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UPhysicsSettings_GetPhysicsHistoryCount_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UPhysicsSettings_GetPhysicsHistoryCount_Statics::NewProp_ReturnValue,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UPhysicsSettings_GetPhysicsHistoryCount_Statics::PropPointers) < 2048);
// ********** End Function GetPhysicsHistoryCount Property Definitions *****************************
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UPhysicsSettings_GetPhysicsHistoryCount_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UPhysicsSettings, nullptr, "GetPhysicsHistoryCount", 	Z_Construct_UFunction_UPhysicsSettings_GetPhysicsHistoryCount_Statics::PropPointers, 
	UE_ARRAY_COUNT(Z_Construct_UFunction_UPhysicsSettings_GetPhysicsHistoryCount_Statics::PropPointers), 
sizeof(Z_Construct_UFunction_UPhysicsSettings_GetPhysicsHistoryCount_Statics::PhysicsSettings_eventGetPhysicsHistoryCount_Parms),
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x54020401, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UPhysicsSettings_GetPhysicsHistoryCount_Statics::Function_MetaDataParams), Z_Construct_UFunction_UPhysicsSettings_GetPhysicsHistoryCount_Statics::Function_MetaDataParams)},  };
static_assert(sizeof(Z_Construct_UFunction_UPhysicsSettings_GetPhysicsHistoryCount_Statics::PhysicsSettings_eventGetPhysicsHistoryCount_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UPhysicsSettings_GetPhysicsHistoryCount()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UPhysicsSettings_GetPhysicsHistoryCount_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UPhysicsSettings::execGetPhysicsHistoryCount)
{
	P_FINISH;
	P_NATIVE_BEGIN;
	*(int32*)Z_Param__Result=P_THIS->GetPhysicsHistoryCount();
	P_NATIVE_END;
}
// ********** End Class UPhysicsSettings Function GetPhysicsHistoryCount ***************************

// ********** Begin Class UPhysicsSettings *********************************************************
FClassRegistrationInfo Z_Registration_Info_UClass_UPhysicsSettings;
UClass* UPhysicsSettings::GetPrivateStaticClass()
{
	using TClass = UPhysicsSettings;
	if (!Z_Registration_Info_UClass_UPhysicsSettings.InnerSingleton)
	{
		GetPrivateStaticClassBody(
			TClass::StaticPackage(),
			TEXT("PhysicsSettings"),
			Z_Registration_Info_UClass_UPhysicsSettings.InnerSingleton,
			StaticRegisterNativesUPhysicsSettings,
			sizeof(TClass),
			alignof(TClass),
			TClass::StaticClassFlags,
			TClass::StaticClassCastFlags(),
			TClass::StaticConfigName(),
			(UClass::ClassConstructorType)InternalConstructor<TClass>,
			(UClass::ClassVTableHelperCtorCallerType)InternalVTableHelperCtorCaller<TClass>,
			UOBJECT_CPPCLASS_STATICFUNCTIONS_FORCLASS(TClass),
			&TClass::Super::StaticClass,
			&TClass::WithinClass::StaticClass
		);
	}
	return Z_Registration_Info_UClass_UPhysicsSettings.InnerSingleton;
}
UClass* Z_Construct_UClass_UPhysicsSettings_NoRegister()
{
	return UPhysicsSettings::GetPrivateStaticClass();
}
struct Z_Construct_UClass_UPhysicsSettings_Statics
{
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Class_MetaDataParams[] = {
		{ "Comment", "/**\n * Default physics settings.\n */" },
		{ "DisplayName", "Physics" },
		{ "IncludePath", "PhysicsEngine/PhysicsSettings.h" },
		{ "ModuleRelativePath", "Classes/PhysicsEngine/PhysicsSettings.h" },
		{ "ToolTip", "Default physics settings." },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_PhysicsPrediction_MetaData[] = {
		{ "Category", "Replication" },
		{ "Comment", "/** Settings for Networked Physics Prediction, experimental. */" },
		{ "DisplayName", "Physics Prediction (Experimental)" },
		{ "ModuleRelativePath", "Classes/PhysicsEngine/PhysicsSettings.h" },
		{ "ToolTip", "Settings for Networked Physics Prediction, experimental." },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_PhysicErrorCorrection_MetaData[] = {
		{ "Category", "Replication" },
		{ "Comment", "/** Default settings for physics replication using EPhysicsReplicationMode::Default */" },
		{ "DisplayName", "Default Physics Replication Settings (EPhysicsReplicationMode::Default)" },
		{ "ModuleRelativePath", "Classes/PhysicsEngine/PhysicsSettings.h" },
		{ "ToolTip", "Default settings for physics replication using EPhysicsReplicationMode::Default" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_LockedAxis_MetaData[] = {
		{ "ModuleRelativePath", "Classes/PhysicsEngine/PhysicsSettings.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_DefaultDegreesOfFreedom_MetaData[] = {
		{ "Category", "Simulation" },
		{ "Comment", "/** Useful for constraining all objects in the world, for example if you are making a 2D game using 3D environments.*/" },
		{ "ModuleRelativePath", "Classes/PhysicsEngine/PhysicsSettings.h" },
		{ "ToolTip", "Useful for constraining all objects in the world, for example if you are making a 2D game using 3D environments." },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_bSuppressFaceRemapTable_MetaData[] = {
		{ "Category", "Optimization" },
		{ "Comment", "/**\n\x09*  If true, the internal physx face to UE face mapping will not be generated. This is a memory optimization available if you do not rely on face indices returned by scene queries. */" },
		{ "ModuleRelativePath", "Classes/PhysicsEngine/PhysicsSettings.h" },
		{ "ToolTip", "If true, the internal physx face to UE face mapping will not be generated. This is a memory optimization available if you do not rely on face indices returned by scene queries." },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_bSupportUVFromHitResults_MetaData[] = {
		{ "Category", "Optimization" },
		{ "Comment", "/** If true, store extra information to allow FindCollisionUV to derive UV info from a line trace hit result, using the FindCollisionUV utility */" },
		{ "ConfigRestartRequired", "TRUE" },
		{ "DisplayName", "Support UV From Hit Results" },
		{ "ModuleRelativePath", "Classes/PhysicsEngine/PhysicsSettings.h" },
		{ "ToolTip", "If true, store extra information to allow FindCollisionUV to derive UV info from a line trace hit result, using the FindCollisionUV utility" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_bDisableActiveActors_MetaData[] = {
		{ "Category", "Optimization" },
		{ "Comment", "/**\n\x09* If true, physx will not update unreal with any bodies that have moved during the simulation. This should only be used if you have no physx simulation or you are manually updating the unreal data via polling physx.  */" },
		{ "ModuleRelativePath", "Classes/PhysicsEngine/PhysicsSettings.h" },
		{ "ToolTip", "If true, physx will not update unreal with any bodies that have moved during the simulation. This should only be used if you have no physx simulation or you are manually updating the unreal data via polling physx." },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_bDisableKinematicStaticPairs_MetaData[] = {
		{ "Category", "Optimization" },
		{ "Comment", "/** Whether to disable generating KS pairs, enabling this makes switching between dynamic and static slower for actors - but speeds up contact generation by early rejecting these pairs*/" },
		{ "ModuleRelativePath", "Classes/PhysicsEngine/PhysicsSettings.h" },
		{ "ToolTip", "Whether to disable generating KS pairs, enabling this makes switching between dynamic and static slower for actors - but speeds up contact generation by early rejecting these pairs" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_bDisableKinematicKinematicPairs_MetaData[] = {
		{ "Category", "Optimization" },
		{ "Comment", "/** Whether to disable generating KK pairs, enabling this speeds up contact generation, however it is required when using APEX destruction. */" },
		{ "ModuleRelativePath", "Classes/PhysicsEngine/PhysicsSettings.h" },
		{ "ToolTip", "Whether to disable generating KK pairs, enabling this speeds up contact generation, however it is required when using APEX destruction." },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_bDisableCCD_MetaData[] = {
		{ "Category", "Simulation" },
		{ "Comment", "/**\n\x09*  If true CCD will be ignored. This is an optimization when CCD is never used which removes the need for physx to check it internally. */" },
		{ "ModuleRelativePath", "Classes/PhysicsEngine/PhysicsSettings.h" },
		{ "ToolTip", "If true CCD will be ignored. This is an optimization when CCD is never used which removes the need for physx to check it internally." },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_AnimPhysicsMinDeltaTime_MetaData[] = {
		{ "Category", "Framerate" },
		{ "ClampMax", "1.0" },
		{ "ClampMin", "0.0" },
		{ "Comment", "/** Min Delta Time below which anim dynamics and rigidbody nodes will not simulate. */" },
		{ "ModuleRelativePath", "Classes/PhysicsEngine/PhysicsSettings.h" },
		{ "ToolTip", "Min Delta Time below which anim dynamics and rigidbody nodes will not simulate." },
		{ "UIMax", "1.0" },
		{ "UIMin", "0.0" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_bSimulateAnimPhysicsAfterReset_MetaData[] = {
		{ "Category", "Simulation" },
		{ "Comment", "/** Whether to simulate anim physics nodes in the tick where they're reset. */" },
		{ "ModuleRelativePath", "Classes/PhysicsEngine/PhysicsSettings.h" },
		{ "ToolTip", "Whether to simulate anim physics nodes in the tick where they're reset." },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_MinPhysicsDeltaTime_MetaData[] = {
		{ "Category", "Framerate" },
		{ "ClampMax", "0.0001" },
		{ "ClampMin", "0.0" },
		{ "Comment", "/** Min Physics Delta Time; the simulation will not step if the delta time is below this value */" },
		{ "ModuleRelativePath", "Classes/PhysicsEngine/PhysicsSettings.h" },
		{ "ToolTip", "Min Physics Delta Time; the simulation will not step if the delta time is below this value" },
		{ "UIMax", "0.0001" },
		{ "UIMin", "0.0" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_MaxPhysicsDeltaTime_MetaData[] = {
		{ "Category", "Framerate" },
		{ "ClampMax", "1.0" },
		{ "ClampMin", "0.0013" },
		{ "Comment", "/** Max Physics Delta Time to be clamped. */" },
		{ "ModuleRelativePath", "Classes/PhysicsEngine/PhysicsSettings.h" },
		{ "ToolTip", "Max Physics Delta Time to be clamped." },
		{ "UIMax", "1.0" },
		{ "UIMin", "0.0013" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_bSubstepping_MetaData[] = {
		{ "Category", "Framerate" },
		{ "Comment", "/** Whether to substep the physics simulation. This feature is still experimental. Certain functionality might not work correctly*/" },
		{ "ModuleRelativePath", "Classes/PhysicsEngine/PhysicsSettings.h" },
		{ "ToolTip", "Whether to substep the physics simulation. This feature is still experimental. Certain functionality might not work correctly" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_bSubsteppingAsync_MetaData[] = {
		{ "Category", "Framerate" },
		{ "Comment", "/** Whether to substep the async physics simulation. This feature is still experimental. Certain functionality might not work correctly*/" },
		{ "ModuleRelativePath", "Classes/PhysicsEngine/PhysicsSettings.h" },
		{ "ToolTip", "Whether to substep the async physics simulation. This feature is still experimental. Certain functionality might not work correctly" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_bTickPhysicsAsync_MetaData[] = {
		{ "Category", "Framerate" },
		{ "Comment", "/** Whether to tick physics simulation on an async thread. This feature is still experimental. Certain functionality might not work correctly*/" },
		{ "ModuleRelativePath", "Classes/PhysicsEngine/PhysicsSettings.h" },
		{ "ToolTip", "Whether to tick physics simulation on an async thread. This feature is still experimental. Certain functionality might not work correctly" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_AsyncFixedTimeStepSize_MetaData[] = {
		{ "Category", "Framerate" },
		{ "Comment", "/** If using async, the time step size to tick at. This feature is still experimental. Certain functionality might not work correctly*/" },
		{ "editcondition", "bTickPhysicsAsync" },
		{ "ModuleRelativePath", "Classes/PhysicsEngine/PhysicsSettings.h" },
		{ "ToolTip", "If using async, the time step size to tick at. This feature is still experimental. Certain functionality might not work correctly" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_MaxSubstepDeltaTime_MetaData[] = {
		{ "Category", "Framerate" },
		{ "ClampMax", "1.0" },
		{ "ClampMin", "0.0013" },
		{ "Comment", "/** Max delta time (in seconds) for an individual simulation substep. */" },
		{ "editcondition", "bSubStepping" },
		{ "ModuleRelativePath", "Classes/PhysicsEngine/PhysicsSettings.h" },
		{ "ToolTip", "Max delta time (in seconds) for an individual simulation substep." },
		{ "UIMax", "1.0" },
		{ "UIMin", "0.0013" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_MaxSubsteps_MetaData[] = {
		{ "Category", "Framerate" },
		{ "ClampMax", "16" },
		{ "ClampMin", "1" },
		{ "Comment", "/** Max number of substeps for physics simulation. */" },
		{ "editcondition", "bSubstepping" },
		{ "ModuleRelativePath", "Classes/PhysicsEngine/PhysicsSettings.h" },
		{ "ToolTip", "Max number of substeps for physics simulation." },
		{ "UIMax", "16" },
		{ "UIMin", "1" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_SyncSceneSmoothingFactor_MetaData[] = {
		{ "Category", "Framerate" },
		{ "ClampMax", "1.0" },
		{ "ClampMin", "0.0" },
		{ "Comment", "/** Physics delta time smoothing factor for sync scene. */" },
		{ "ModuleRelativePath", "Classes/PhysicsEngine/PhysicsSettings.h" },
		{ "ToolTip", "Physics delta time smoothing factor for sync scene." },
		{ "UIMax", "1.0" },
		{ "UIMin", "0.0" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_InitialAverageFrameRate_MetaData[] = {
		{ "Category", "Framerate" },
		{ "ClampMax", "1.0" },
		{ "ClampMin", "0.0013" },
		{ "Comment", "/** Physics delta time initial average. */" },
		{ "ModuleRelativePath", "Classes/PhysicsEngine/PhysicsSettings.h" },
		{ "ToolTip", "Physics delta time initial average." },
		{ "UIMax", "1.0" },
		{ "UIMin", "0.0013" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_PhysXTreeRebuildRate_MetaData[] = {
		{ "Category", "Framerate" },
		{ "ClampMin", "4" },
		{ "Comment", "/** The number of frames it takes to rebuild the PhysX scene query AABB tree. The bigger the number, the smaller fetchResults takes per frame, but the more the tree deteriorates until a new tree is built */" },
		{ "ModuleRelativePath", "Classes/PhysicsEngine/PhysicsSettings.h" },
		{ "ToolTip", "The number of frames it takes to rebuild the PhysX scene query AABB tree. The bigger the number, the smaller fetchResults takes per frame, but the more the tree deteriorates until a new tree is built" },
		{ "UIMin", "4" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_PhysicalSurfaces_MetaData[] = {
		{ "Category", "PhysicalSurfaces" },
		{ "Comment", "// PhysicalMaterial Surface Types\n" },
		{ "ModuleRelativePath", "Classes/PhysicsEngine/PhysicsSettings.h" },
		{ "ToolTip", "PhysicalMaterial Surface Types" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_DefaultBroadphaseSettings_MetaData[] = {
		{ "Category", "Broadphase" },
		{ "Comment", "/** If we want to Enable MPB or not globally. This is then overridden by project settings if not enabled. **/" },
		{ "ModuleRelativePath", "Classes/PhysicsEngine/PhysicsSettings.h" },
		{ "ToolTip", "If we want to Enable MPB or not globally. This is then overridden by project settings if not enabled. *" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_MinDeltaVelocityForHitEvents_MetaData[] = {
		{ "Category", "ChaosPhysics" },
		{ "Comment", "/** Minimum velocity delta required on a collinding object for Chaos to send a hit event */" },
		{ "ModuleRelativePath", "Classes/PhysicsEngine/PhysicsSettings.h" },
		{ "ToolTip", "Minimum velocity delta required on a collinding object for Chaos to send a hit event" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_ChaosSettings_MetaData[] = {
		{ "Category", "ChaosPhysics" },
		{ "Comment", "/** Chaos physics engine settings */" },
		{ "ModuleRelativePath", "Classes/PhysicsEngine/PhysicsSettings.h" },
		{ "ToolTip", "Chaos physics engine settings" },
	};
#endif // WITH_METADATA

// ********** Begin Class UPhysicsSettings constinit property declarations *************************
	static const UECodeGen_Private::FStructPropertyParams NewProp_PhysicsPrediction;
	static const UECodeGen_Private::FStructPropertyParams NewProp_PhysicErrorCorrection;
	static const UECodeGen_Private::FBytePropertyParams NewProp_LockedAxis;
	static const UECodeGen_Private::FBytePropertyParams NewProp_DefaultDegreesOfFreedom;
	static void NewProp_bSuppressFaceRemapTable_SetBit(void* Obj);
	static const UECodeGen_Private::FBoolPropertyParams NewProp_bSuppressFaceRemapTable;
	static void NewProp_bSupportUVFromHitResults_SetBit(void* Obj);
	static const UECodeGen_Private::FBoolPropertyParams NewProp_bSupportUVFromHitResults;
	static void NewProp_bDisableActiveActors_SetBit(void* Obj);
	static const UECodeGen_Private::FBoolPropertyParams NewProp_bDisableActiveActors;
	static void NewProp_bDisableKinematicStaticPairs_SetBit(void* Obj);
	static const UECodeGen_Private::FBoolPropertyParams NewProp_bDisableKinematicStaticPairs;
	static void NewProp_bDisableKinematicKinematicPairs_SetBit(void* Obj);
	static const UECodeGen_Private::FBoolPropertyParams NewProp_bDisableKinematicKinematicPairs;
	static void NewProp_bDisableCCD_SetBit(void* Obj);
	static const UECodeGen_Private::FBoolPropertyParams NewProp_bDisableCCD;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_AnimPhysicsMinDeltaTime;
	static void NewProp_bSimulateAnimPhysicsAfterReset_SetBit(void* Obj);
	static const UECodeGen_Private::FBoolPropertyParams NewProp_bSimulateAnimPhysicsAfterReset;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_MinPhysicsDeltaTime;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_MaxPhysicsDeltaTime;
	static void NewProp_bSubstepping_SetBit(void* Obj);
	static const UECodeGen_Private::FBoolPropertyParams NewProp_bSubstepping;
	static void NewProp_bSubsteppingAsync_SetBit(void* Obj);
	static const UECodeGen_Private::FBoolPropertyParams NewProp_bSubsteppingAsync;
	static void NewProp_bTickPhysicsAsync_SetBit(void* Obj);
	static const UECodeGen_Private::FBoolPropertyParams NewProp_bTickPhysicsAsync;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_AsyncFixedTimeStepSize;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_MaxSubstepDeltaTime;
	static const UECodeGen_Private::FIntPropertyParams NewProp_MaxSubsteps;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_SyncSceneSmoothingFactor;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_InitialAverageFrameRate;
	static const UECodeGen_Private::FIntPropertyParams NewProp_PhysXTreeRebuildRate;
	static const UECodeGen_Private::FStructPropertyParams NewProp_PhysicalSurfaces_Inner;
	static const UECodeGen_Private::FArrayPropertyParams NewProp_PhysicalSurfaces;
	static const UECodeGen_Private::FStructPropertyParams NewProp_DefaultBroadphaseSettings;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_MinDeltaVelocityForHitEvents;
	static const UECodeGen_Private::FStructPropertyParams NewProp_ChaosSettings;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End Class UPhysicsSettings constinit property declarations ***************************
	static constexpr UE::CodeGen::FClassNativeFunction Funcs[] = {
		{ .NameUTF8 = UTF8TEXT("GetPhysicsHistoryCount"), .Pointer = &UPhysicsSettings::execGetPhysicsHistoryCount },
	};
	static UObject* (*const DependentSingletons[])();
	static constexpr FClassFunctionLinkInfo FuncInfo[] = {
		{ &Z_Construct_UFunction_UPhysicsSettings_GetPhysicsHistoryCount, "GetPhysicsHistoryCount" }, // 345274491
	};
	static_assert(UE_ARRAY_COUNT(FuncInfo) < 2048);
	static constexpr FCppClassTypeInfoStatic StaticCppClassTypeInfo = {
		TCppClassTypeTraits<UPhysicsSettings>::IsAbstract,
	};
	static const UECodeGen_Private::FClassParams ClassParams;
}; // struct Z_Construct_UClass_UPhysicsSettings_Statics

// ********** Begin Class UPhysicsSettings Property Definitions ************************************
const UECodeGen_Private::FStructPropertyParams Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_PhysicsPrediction = { "PhysicsPrediction", nullptr, (EPropertyFlags)0x0010000000004001, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(UPhysicsSettings, PhysicsPrediction), Z_Construct_UScriptStruct_FPhysicsPredictionSettings, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_PhysicsPrediction_MetaData), NewProp_PhysicsPrediction_MetaData) }; // 3214539364
const UECodeGen_Private::FStructPropertyParams Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_PhysicErrorCorrection = { "PhysicErrorCorrection", nullptr, (EPropertyFlags)0x0010000000004001, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(UPhysicsSettings, PhysicErrorCorrection), Z_Construct_UScriptStruct_FRigidBodyErrorCorrection, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_PhysicErrorCorrection_MetaData), NewProp_PhysicErrorCorrection_MetaData) }; // 1922727968
const UECodeGen_Private::FBytePropertyParams Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_LockedAxis = { "LockedAxis", nullptr, (EPropertyFlags)0x0010000020004000, UECodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(UPhysicsSettings, LockedAxis_DEPRECATED), Z_Construct_UEnum_Engine_ESettingsLockedAxis, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_LockedAxis_MetaData), NewProp_LockedAxis_MetaData) }; // 1696793111
const UECodeGen_Private::FBytePropertyParams Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_DefaultDegreesOfFreedom = { "DefaultDegreesOfFreedom", nullptr, (EPropertyFlags)0x0010000000004001, UECodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(UPhysicsSettings, DefaultDegreesOfFreedom), Z_Construct_UEnum_Engine_ESettingsDOF, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_DefaultDegreesOfFreedom_MetaData), NewProp_DefaultDegreesOfFreedom_MetaData) }; // 1919350231
void Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_bSuppressFaceRemapTable_SetBit(void* Obj)
{
	((UPhysicsSettings*)Obj)->bSuppressFaceRemapTable = 1;
}
const UECodeGen_Private::FBoolPropertyParams Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_bSuppressFaceRemapTable = { "bSuppressFaceRemapTable", nullptr, (EPropertyFlags)0x0010000000004001, UECodeGen_Private::EPropertyGenFlags::Bool | UECodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, sizeof(bool), sizeof(UPhysicsSettings), &Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_bSuppressFaceRemapTable_SetBit, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_bSuppressFaceRemapTable_MetaData), NewProp_bSuppressFaceRemapTable_MetaData) };
void Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_bSupportUVFromHitResults_SetBit(void* Obj)
{
	((UPhysicsSettings*)Obj)->bSupportUVFromHitResults = 1;
}
const UECodeGen_Private::FBoolPropertyParams Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_bSupportUVFromHitResults = { "bSupportUVFromHitResults", nullptr, (EPropertyFlags)0x0010000000004001, UECodeGen_Private::EPropertyGenFlags::Bool | UECodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, sizeof(bool), sizeof(UPhysicsSettings), &Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_bSupportUVFromHitResults_SetBit, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_bSupportUVFromHitResults_MetaData), NewProp_bSupportUVFromHitResults_MetaData) };
void Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_bDisableActiveActors_SetBit(void* Obj)
{
	((UPhysicsSettings*)Obj)->bDisableActiveActors = 1;
}
const UECodeGen_Private::FBoolPropertyParams Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_bDisableActiveActors = { "bDisableActiveActors", nullptr, (EPropertyFlags)0x0010000000004001, UECodeGen_Private::EPropertyGenFlags::Bool | UECodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, sizeof(bool), sizeof(UPhysicsSettings), &Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_bDisableActiveActors_SetBit, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_bDisableActiveActors_MetaData), NewProp_bDisableActiveActors_MetaData) };
void Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_bDisableKinematicStaticPairs_SetBit(void* Obj)
{
	((UPhysicsSettings*)Obj)->bDisableKinematicStaticPairs = 1;
}
const UECodeGen_Private::FBoolPropertyParams Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_bDisableKinematicStaticPairs = { "bDisableKinematicStaticPairs", nullptr, (EPropertyFlags)0x0010000000004001, UECodeGen_Private::EPropertyGenFlags::Bool | UECodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, sizeof(bool), sizeof(UPhysicsSettings), &Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_bDisableKinematicStaticPairs_SetBit, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_bDisableKinematicStaticPairs_MetaData), NewProp_bDisableKinematicStaticPairs_MetaData) };
void Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_bDisableKinematicKinematicPairs_SetBit(void* Obj)
{
	((UPhysicsSettings*)Obj)->bDisableKinematicKinematicPairs = 1;
}
const UECodeGen_Private::FBoolPropertyParams Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_bDisableKinematicKinematicPairs = { "bDisableKinematicKinematicPairs", nullptr, (EPropertyFlags)0x0010000000004001, UECodeGen_Private::EPropertyGenFlags::Bool | UECodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, sizeof(bool), sizeof(UPhysicsSettings), &Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_bDisableKinematicKinematicPairs_SetBit, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_bDisableKinematicKinematicPairs_MetaData), NewProp_bDisableKinematicKinematicPairs_MetaData) };
void Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_bDisableCCD_SetBit(void* Obj)
{
	((UPhysicsSettings*)Obj)->bDisableCCD = 1;
}
const UECodeGen_Private::FBoolPropertyParams Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_bDisableCCD = { "bDisableCCD", nullptr, (EPropertyFlags)0x0010000000004001, UECodeGen_Private::EPropertyGenFlags::Bool | UECodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, sizeof(bool), sizeof(UPhysicsSettings), &Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_bDisableCCD_SetBit, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_bDisableCCD_MetaData), NewProp_bDisableCCD_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_AnimPhysicsMinDeltaTime = { "AnimPhysicsMinDeltaTime", nullptr, (EPropertyFlags)0x0010000000004001, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(UPhysicsSettings, AnimPhysicsMinDeltaTime), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_AnimPhysicsMinDeltaTime_MetaData), NewProp_AnimPhysicsMinDeltaTime_MetaData) };
void Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_bSimulateAnimPhysicsAfterReset_SetBit(void* Obj)
{
	((UPhysicsSettings*)Obj)->bSimulateAnimPhysicsAfterReset = 1;
}
const UECodeGen_Private::FBoolPropertyParams Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_bSimulateAnimPhysicsAfterReset = { "bSimulateAnimPhysicsAfterReset", nullptr, (EPropertyFlags)0x0010000000004001, UECodeGen_Private::EPropertyGenFlags::Bool | UECodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, sizeof(bool), sizeof(UPhysicsSettings), &Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_bSimulateAnimPhysicsAfterReset_SetBit, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_bSimulateAnimPhysicsAfterReset_MetaData), NewProp_bSimulateAnimPhysicsAfterReset_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_MinPhysicsDeltaTime = { "MinPhysicsDeltaTime", nullptr, (EPropertyFlags)0x0010000000004001, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(UPhysicsSettings, MinPhysicsDeltaTime), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_MinPhysicsDeltaTime_MetaData), NewProp_MinPhysicsDeltaTime_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_MaxPhysicsDeltaTime = { "MaxPhysicsDeltaTime", nullptr, (EPropertyFlags)0x0010000000004001, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(UPhysicsSettings, MaxPhysicsDeltaTime), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_MaxPhysicsDeltaTime_MetaData), NewProp_MaxPhysicsDeltaTime_MetaData) };
void Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_bSubstepping_SetBit(void* Obj)
{
	((UPhysicsSettings*)Obj)->bSubstepping = 1;
}
const UECodeGen_Private::FBoolPropertyParams Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_bSubstepping = { "bSubstepping", nullptr, (EPropertyFlags)0x0010000000004001, UECodeGen_Private::EPropertyGenFlags::Bool | UECodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, sizeof(bool), sizeof(UPhysicsSettings), &Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_bSubstepping_SetBit, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_bSubstepping_MetaData), NewProp_bSubstepping_MetaData) };
void Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_bSubsteppingAsync_SetBit(void* Obj)
{
	((UPhysicsSettings*)Obj)->bSubsteppingAsync = 1;
}
const UECodeGen_Private::FBoolPropertyParams Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_bSubsteppingAsync = { "bSubsteppingAsync", nullptr, (EPropertyFlags)0x0010000000004001, UECodeGen_Private::EPropertyGenFlags::Bool | UECodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, sizeof(bool), sizeof(UPhysicsSettings), &Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_bSubsteppingAsync_SetBit, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_bSubsteppingAsync_MetaData), NewProp_bSubsteppingAsync_MetaData) };
void Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_bTickPhysicsAsync_SetBit(void* Obj)
{
	((UPhysicsSettings*)Obj)->bTickPhysicsAsync = 1;
}
const UECodeGen_Private::FBoolPropertyParams Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_bTickPhysicsAsync = { "bTickPhysicsAsync", nullptr, (EPropertyFlags)0x0010000000004001, UECodeGen_Private::EPropertyGenFlags::Bool | UECodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, sizeof(bool), sizeof(UPhysicsSettings), &Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_bTickPhysicsAsync_SetBit, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_bTickPhysicsAsync_MetaData), NewProp_bTickPhysicsAsync_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_AsyncFixedTimeStepSize = { "AsyncFixedTimeStepSize", nullptr, (EPropertyFlags)0x0010000000004001, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(UPhysicsSettings, AsyncFixedTimeStepSize), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_AsyncFixedTimeStepSize_MetaData), NewProp_AsyncFixedTimeStepSize_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_MaxSubstepDeltaTime = { "MaxSubstepDeltaTime", nullptr, (EPropertyFlags)0x0010000000004001, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(UPhysicsSettings, MaxSubstepDeltaTime), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_MaxSubstepDeltaTime_MetaData), NewProp_MaxSubstepDeltaTime_MetaData) };
const UECodeGen_Private::FIntPropertyParams Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_MaxSubsteps = { "MaxSubsteps", nullptr, (EPropertyFlags)0x0010000000004001, UECodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(UPhysicsSettings, MaxSubsteps), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_MaxSubsteps_MetaData), NewProp_MaxSubsteps_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_SyncSceneSmoothingFactor = { "SyncSceneSmoothingFactor", nullptr, (EPropertyFlags)0x0010040000004001, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(UPhysicsSettings, SyncSceneSmoothingFactor), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_SyncSceneSmoothingFactor_MetaData), NewProp_SyncSceneSmoothingFactor_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_InitialAverageFrameRate = { "InitialAverageFrameRate", nullptr, (EPropertyFlags)0x0010040000004001, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(UPhysicsSettings, InitialAverageFrameRate), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_InitialAverageFrameRate_MetaData), NewProp_InitialAverageFrameRate_MetaData) };
const UECodeGen_Private::FIntPropertyParams Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_PhysXTreeRebuildRate = { "PhysXTreeRebuildRate", nullptr, (EPropertyFlags)0x0010040000004001, UECodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(UPhysicsSettings, PhysXTreeRebuildRate), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_PhysXTreeRebuildRate_MetaData), NewProp_PhysXTreeRebuildRate_MetaData) };
const UECodeGen_Private::FStructPropertyParams Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_PhysicalSurfaces_Inner = { "PhysicalSurfaces", nullptr, (EPropertyFlags)0x0000000000004000, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, 0, Z_Construct_UScriptStruct_FPhysicalSurfaceName, METADATA_PARAMS(0, nullptr) }; // 3066006448
const UECodeGen_Private::FArrayPropertyParams Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_PhysicalSurfaces = { "PhysicalSurfaces", nullptr, (EPropertyFlags)0x0010000000004001, UECodeGen_Private::EPropertyGenFlags::Array, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(UPhysicsSettings, PhysicalSurfaces), EArrayPropertyFlags::None, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_PhysicalSurfaces_MetaData), NewProp_PhysicalSurfaces_MetaData) }; // 3066006448
const UECodeGen_Private::FStructPropertyParams Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_DefaultBroadphaseSettings = { "DefaultBroadphaseSettings", nullptr, (EPropertyFlags)0x0010000000004001, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(UPhysicsSettings, DefaultBroadphaseSettings), Z_Construct_UScriptStruct_FBroadphaseSettings, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_DefaultBroadphaseSettings_MetaData), NewProp_DefaultBroadphaseSettings_MetaData) }; // 3483223372
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_MinDeltaVelocityForHitEvents = { "MinDeltaVelocityForHitEvents", nullptr, (EPropertyFlags)0x0010000000004001, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(UPhysicsSettings, MinDeltaVelocityForHitEvents), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_MinDeltaVelocityForHitEvents_MetaData), NewProp_MinDeltaVelocityForHitEvents_MetaData) };
const UECodeGen_Private::FStructPropertyParams Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_ChaosSettings = { "ChaosSettings", nullptr, (EPropertyFlags)0x0010000000004001, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(UPhysicsSettings, ChaosSettings), Z_Construct_UScriptStruct_FChaosPhysicsSettings, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_ChaosSettings_MetaData), NewProp_ChaosSettings_MetaData) }; // 2508495220
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UClass_UPhysicsSettings_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_PhysicsPrediction,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_PhysicErrorCorrection,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_LockedAxis,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_DefaultDegreesOfFreedom,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_bSuppressFaceRemapTable,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_bSupportUVFromHitResults,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_bDisableActiveActors,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_bDisableKinematicStaticPairs,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_bDisableKinematicKinematicPairs,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_bDisableCCD,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_AnimPhysicsMinDeltaTime,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_bSimulateAnimPhysicsAfterReset,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_MinPhysicsDeltaTime,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_MaxPhysicsDeltaTime,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_bSubstepping,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_bSubsteppingAsync,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_bTickPhysicsAsync,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_AsyncFixedTimeStepSize,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_MaxSubstepDeltaTime,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_MaxSubsteps,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_SyncSceneSmoothingFactor,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_InitialAverageFrameRate,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_PhysXTreeRebuildRate,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_PhysicalSurfaces_Inner,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_PhysicalSurfaces,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_DefaultBroadphaseSettings,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_MinDeltaVelocityForHitEvents,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UPhysicsSettings_Statics::NewProp_ChaosSettings,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UClass_UPhysicsSettings_Statics::PropPointers) < 2048);
// ********** End Class UPhysicsSettings Property Definitions **************************************
UObject* (*const Z_Construct_UClass_UPhysicsSettings_Statics::DependentSingletons[])() = {
	(UObject* (*)())Z_Construct_UClass_UPhysicsSettingsCore,
	(UObject* (*)())Z_Construct_UPackage__Script_Engine,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UClass_UPhysicsSettings_Statics::DependentSingletons) < 16);
const UECodeGen_Private::FClassParams Z_Construct_UClass_UPhysicsSettings_Statics::ClassParams = {
	&UPhysicsSettings::StaticClass,
	"Engine",
	&StaticCppClassTypeInfo,
	DependentSingletons,
	FuncInfo,
	Z_Construct_UClass_UPhysicsSettings_Statics::PropPointers,
	nullptr,
	UE_ARRAY_COUNT(DependentSingletons),
	UE_ARRAY_COUNT(FuncInfo),
	UE_ARRAY_COUNT(Z_Construct_UClass_UPhysicsSettings_Statics::PropPointers),
	0,
	0x000800A6u,
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UClass_UPhysicsSettings_Statics::Class_MetaDataParams), Z_Construct_UClass_UPhysicsSettings_Statics::Class_MetaDataParams)
};
void UPhysicsSettings::StaticRegisterNativesUPhysicsSettings()
{
	UClass* Class = UPhysicsSettings::StaticClass();
	FNativeFunctionRegistrar::RegisterFunctions(Class, MakeConstArrayView(Z_Construct_UClass_UPhysicsSettings_Statics::Funcs));
}
UClass* Z_Construct_UClass_UPhysicsSettings()
{
	if (!Z_Registration_Info_UClass_UPhysicsSettings.OuterSingleton)
	{
		UECodeGen_Private::ConstructUClass(Z_Registration_Info_UClass_UPhysicsSettings.OuterSingleton, Z_Construct_UClass_UPhysicsSettings_Statics::ClassParams);
	}
	return Z_Registration_Info_UClass_UPhysicsSettings.OuterSingleton;
}
DEFINE_VTABLE_PTR_HELPER_CTOR_NS(, UPhysicsSettings);
UPhysicsSettings::~UPhysicsSettings() {}
// ********** End Class UPhysicsSettings ***********************************************************

// ********** Begin Registration *******************************************************************
struct Z_CompiledInDeferFile_FID_Engine_Source_Runtime_Engine_Classes_PhysicsEngine_PhysicsSettings_h__Script_Engine_Statics
{
	static constexpr FEnumRegisterCompiledInInfo EnumInfo[] = {
		{ ESettingsDOF_StaticEnum, TEXT("ESettingsDOF"), &Z_Registration_Info_UEnum_ESettingsDOF, CONSTRUCT_RELOAD_VERSION_INFO(FEnumReloadVersionInfo, 1919350231U) },
		{ ESettingsLockedAxis_StaticEnum, TEXT("ESettingsLockedAxis"), &Z_Registration_Info_UEnum_ESettingsLockedAxis, CONSTRUCT_RELOAD_VERSION_INFO(FEnumReloadVersionInfo, 1696793111U) },
	};
	static constexpr FStructRegisterCompiledInInfo ScriptStructInfo[] = {
		{ FPhysicalSurfaceName::StaticStruct, Z_Construct_UScriptStruct_FPhysicalSurfaceName_Statics::NewStructOps, TEXT("PhysicalSurfaceName"),&Z_Registration_Info_UScriptStruct_FPhysicalSurfaceName, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FPhysicalSurfaceName), 3066006448U) },
		{ FChaosPhysicsSettings::StaticStruct, Z_Construct_UScriptStruct_FChaosPhysicsSettings_Statics::NewStructOps, TEXT("ChaosPhysicsSettings"),&Z_Registration_Info_UScriptStruct_FChaosPhysicsSettings, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FChaosPhysicsSettings), 2508495220U) },
		{ FPhysicsReplicationResimulationSettings::StaticStruct, Z_Construct_UScriptStruct_FPhysicsReplicationResimulationSettings_Statics::NewStructOps, TEXT("PhysicsReplicationResimulationSettings"),&Z_Registration_Info_UScriptStruct_FPhysicsReplicationResimulationSettings, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FPhysicsReplicationResimulationSettings), 2262317442U) },
		{ FPhysicsReplicationLODSettings::StaticStruct, Z_Construct_UScriptStruct_FPhysicsReplicationLODSettings_Statics::NewStructOps, TEXT("PhysicsReplicationLODSettings"),&Z_Registration_Info_UScriptStruct_FPhysicsReplicationLODSettings, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FPhysicsReplicationLODSettings), 3427550836U) },
		{ FPhysicsPredictionSettings::StaticStruct, Z_Construct_UScriptStruct_FPhysicsPredictionSettings_Statics::NewStructOps, TEXT("PhysicsPredictionSettings"),&Z_Registration_Info_UScriptStruct_FPhysicsPredictionSettings, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FPhysicsPredictionSettings), 3214539364U) },
	};
	static constexpr FClassRegisterCompiledInInfo ClassInfo[] = {
		{ Z_Construct_UClass_UPhysicsSettings, UPhysicsSettings::StaticClass, TEXT("UPhysicsSettings"), &Z_Registration_Info_UClass_UPhysicsSettings, CONSTRUCT_RELOAD_VERSION_INFO(FClassReloadVersionInfo, sizeof(UPhysicsSettings), 1753173075U) },
	};
}; // Z_CompiledInDeferFile_FID_Engine_Source_Runtime_Engine_Classes_PhysicsEngine_PhysicsSettings_h__Script_Engine_Statics 
static FRegisterCompiledInInfo Z_CompiledInDeferFile_FID_Engine_Source_Runtime_Engine_Classes_PhysicsEngine_PhysicsSettings_h__Script_Engine_1623685925{
	TEXT("/Script/Engine"),
	Z_CompiledInDeferFile_FID_Engine_Source_Runtime_Engine_Classes_PhysicsEngine_PhysicsSettings_h__Script_Engine_Statics::ClassInfo, UE_ARRAY_COUNT(Z_CompiledInDeferFile_FID_Engine_Source_Runtime_Engine_Classes_PhysicsEngine_PhysicsSettings_h__Script_Engine_Statics::ClassInfo),
	Z_CompiledInDeferFile_FID_Engine_Source_Runtime_Engine_Classes_PhysicsEngine_PhysicsSettings_h__Script_Engine_Statics::ScriptStructInfo, UE_ARRAY_COUNT(Z_CompiledInDeferFile_FID_Engine_Source_Runtime_Engine_Classes_PhysicsEngine_PhysicsSettings_h__Script_Engine_Statics::ScriptStructInfo),
	Z_CompiledInDeferFile_FID_Engine_Source_Runtime_Engine_Classes_PhysicsEngine_PhysicsSettings_h__Script_Engine_Statics::EnumInfo, UE_ARRAY_COUNT(Z_CompiledInDeferFile_FID_Engine_Source_Runtime_Engine_Classes_PhysicsEngine_PhysicsSettings_h__Script_Engine_Statics::EnumInfo),
};
// ********** End Registration *********************************************************************

PRAGMA_ENABLE_DEPRECATION_WARNINGS