// 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 "AGXUnreal/Public/AGX_Simulation.h"
#include "../../Source/Runtime/Engine/Classes/Engine/GameInstance.h"
#include "AGXUnrealBarrier/Public/Utilities/AGX_Statistics.h"
PRAGMA_DISABLE_DEPRECATION_WARNINGS
void EmptyLinkFunctionForGeneratedCodeAGX_Simulation() {}
// Cross Module References
	AGXUNREAL_API UClass* Z_Construct_UClass_UAGX_Simulation();
	AGXUNREAL_API UClass* Z_Construct_UClass_UAGX_Simulation_NoRegister();
	AGXUNREAL_API UEnum* Z_Construct_UEnum_AGXUnreal_EAGX_GravityModel();
	AGXUNREAL_API UEnum* Z_Construct_UEnum_AGXUnreal_EAGX_StepMode();
	AGXUNREAL_API UFunction* Z_Construct_UDelegateFunction_AGXUnreal_OnPostStepForward__DelegateSignature();
	AGXUNREAL_API UFunction* Z_Construct_UDelegateFunction_AGXUnreal_OnPreStepForward__DelegateSignature();
	AGXUNREALBARRIER_API UScriptStruct* Z_Construct_UScriptStruct_FAGX_Statistics();
	COREUOBJECT_API UScriptStruct* Z_Construct_UScriptStruct_FSoftObjectPath();
	COREUOBJECT_API UScriptStruct* Z_Construct_UScriptStruct_FVector();
	ENGINE_API UClass* Z_Construct_UClass_UGameInstanceSubsystem();
	UPackage* Z_Construct_UPackage__Script_AGXUnreal();
// End Cross Module References
	struct Z_Construct_UDelegateFunction_AGXUnreal_OnPreStepForward__DelegateSignature_Statics
	{
		struct _Script_AGXUnreal_eventOnPreStepForward_Parms
		{
			float Time;
		};
		static const UECodeGen_Private::FFloatPropertyParams NewProp_Time;
		static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
		static const UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
		static const UECodeGen_Private::FFunctionParams FuncParams;
	};
	const UECodeGen_Private::FFloatPropertyParams Z_Construct_UDelegateFunction_AGXUnreal_OnPreStepForward__DelegateSignature_Statics::NewProp_Time = { "Time", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(_Script_AGXUnreal_eventOnPreStepForward_Parms, Time), METADATA_PARAMS(0, nullptr) };
	const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UDelegateFunction_AGXUnreal_OnPreStepForward__DelegateSignature_Statics::PropPointers[] = {
		(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UDelegateFunction_AGXUnreal_OnPreStepForward__DelegateSignature_Statics::NewProp_Time,
	};
#if WITH_METADATA
	const UECodeGen_Private::FMetaDataPairParam Z_Construct_UDelegateFunction_AGXUnreal_OnPreStepForward__DelegateSignature_Statics::Function_MetaDataParams[] = {
		{ "ModuleRelativePath", "Public/AGX_Simulation.h" },
	};
#endif
	const UECodeGen_Private::FFunctionParams Z_Construct_UDelegateFunction_AGXUnreal_OnPreStepForward__DelegateSignature_Statics::FuncParams = { (UObject*(*)())Z_Construct_UPackage__Script_AGXUnreal, nullptr, "OnPreStepForward__DelegateSignature", nullptr, nullptr, Z_Construct_UDelegateFunction_AGXUnreal_OnPreStepForward__DelegateSignature_Statics::PropPointers, UE_ARRAY_COUNT(Z_Construct_UDelegateFunction_AGXUnreal_OnPreStepForward__DelegateSignature_Statics::PropPointers), sizeof(Z_Construct_UDelegateFunction_AGXUnreal_OnPreStepForward__DelegateSignature_Statics::_Script_AGXUnreal_eventOnPreStepForward_Parms), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x00130000, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UDelegateFunction_AGXUnreal_OnPreStepForward__DelegateSignature_Statics::Function_MetaDataParams), Z_Construct_UDelegateFunction_AGXUnreal_OnPreStepForward__DelegateSignature_Statics::Function_MetaDataParams) };
	static_assert(UE_ARRAY_COUNT(Z_Construct_UDelegateFunction_AGXUnreal_OnPreStepForward__DelegateSignature_Statics::PropPointers) < 2048);
	static_assert(sizeof(Z_Construct_UDelegateFunction_AGXUnreal_OnPreStepForward__DelegateSignature_Statics::_Script_AGXUnreal_eventOnPreStepForward_Parms) < MAX_uint16);
	UFunction* Z_Construct_UDelegateFunction_AGXUnreal_OnPreStepForward__DelegateSignature()
	{
		static UFunction* ReturnFunction = nullptr;
		if (!ReturnFunction)
		{
			UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UDelegateFunction_AGXUnreal_OnPreStepForward__DelegateSignature_Statics::FuncParams);
		}
		return ReturnFunction;
	}
void FOnPreStepForward_DelegateWrapper(const FMulticastScriptDelegate& OnPreStepForward, float Time)
{
	struct _Script_AGXUnreal_eventOnPreStepForward_Parms
	{
		float Time;
	};
	_Script_AGXUnreal_eventOnPreStepForward_Parms Parms;
	Parms.Time=Time;
	OnPreStepForward.ProcessMulticastDelegate<UObject>(&Parms);
}
	struct Z_Construct_UDelegateFunction_AGXUnreal_OnPostStepForward__DelegateSignature_Statics
	{
		struct _Script_AGXUnreal_eventOnPostStepForward_Parms
		{
			float Time;
		};
		static const UECodeGen_Private::FFloatPropertyParams NewProp_Time;
		static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
		static const UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
		static const UECodeGen_Private::FFunctionParams FuncParams;
	};
	const UECodeGen_Private::FFloatPropertyParams Z_Construct_UDelegateFunction_AGXUnreal_OnPostStepForward__DelegateSignature_Statics::NewProp_Time = { "Time", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(_Script_AGXUnreal_eventOnPostStepForward_Parms, Time), METADATA_PARAMS(0, nullptr) };
	const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UDelegateFunction_AGXUnreal_OnPostStepForward__DelegateSignature_Statics::PropPointers[] = {
		(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UDelegateFunction_AGXUnreal_OnPostStepForward__DelegateSignature_Statics::NewProp_Time,
	};
#if WITH_METADATA
	const UECodeGen_Private::FMetaDataPairParam Z_Construct_UDelegateFunction_AGXUnreal_OnPostStepForward__DelegateSignature_Statics::Function_MetaDataParams[] = {
		{ "ModuleRelativePath", "Public/AGX_Simulation.h" },
	};
#endif
	const UECodeGen_Private::FFunctionParams Z_Construct_UDelegateFunction_AGXUnreal_OnPostStepForward__DelegateSignature_Statics::FuncParams = { (UObject*(*)())Z_Construct_UPackage__Script_AGXUnreal, nullptr, "OnPostStepForward__DelegateSignature", nullptr, nullptr, Z_Construct_UDelegateFunction_AGXUnreal_OnPostStepForward__DelegateSignature_Statics::PropPointers, UE_ARRAY_COUNT(Z_Construct_UDelegateFunction_AGXUnreal_OnPostStepForward__DelegateSignature_Statics::PropPointers), sizeof(Z_Construct_UDelegateFunction_AGXUnreal_OnPostStepForward__DelegateSignature_Statics::_Script_AGXUnreal_eventOnPostStepForward_Parms), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x00130000, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UDelegateFunction_AGXUnreal_OnPostStepForward__DelegateSignature_Statics::Function_MetaDataParams), Z_Construct_UDelegateFunction_AGXUnreal_OnPostStepForward__DelegateSignature_Statics::Function_MetaDataParams) };
	static_assert(UE_ARRAY_COUNT(Z_Construct_UDelegateFunction_AGXUnreal_OnPostStepForward__DelegateSignature_Statics::PropPointers) < 2048);
	static_assert(sizeof(Z_Construct_UDelegateFunction_AGXUnreal_OnPostStepForward__DelegateSignature_Statics::_Script_AGXUnreal_eventOnPostStepForward_Parms) < MAX_uint16);
	UFunction* Z_Construct_UDelegateFunction_AGXUnreal_OnPostStepForward__DelegateSignature()
	{
		static UFunction* ReturnFunction = nullptr;
		if (!ReturnFunction)
		{
			UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UDelegateFunction_AGXUnreal_OnPostStepForward__DelegateSignature_Statics::FuncParams);
		}
		return ReturnFunction;
	}
void FOnPostStepForward_DelegateWrapper(const FMulticastScriptDelegate& OnPostStepForward, float Time)
{
	struct _Script_AGXUnreal_eventOnPostStepForward_Parms
	{
		float Time;
	};
	_Script_AGXUnreal_eventOnPostStepForward_Parms Parms;
	Parms.Time=Time;
	OnPostStepForward.ProcessMulticastDelegate<UObject>(&Parms);
}
	DEFINE_FUNCTION(UAGX_Simulation::execStepOnce)
	{
		P_FINISH;
		P_NATIVE_BEGIN;
		P_THIS->StepOnce();
		P_NATIVE_END;
	}
	DEFINE_FUNCTION(UAGX_Simulation::execSetTimeStamp)
	{
		P_GET_PROPERTY(FFloatProperty,Z_Param_NewTimeStamp);
		P_FINISH;
		P_NATIVE_BEGIN;
		P_THIS->SetTimeStamp(Z_Param_NewTimeStamp);
		P_NATIVE_END;
	}
	DEFINE_FUNCTION(UAGX_Simulation::execGetTimeStamp)
	{
		P_FINISH;
		P_NATIVE_BEGIN;
		*(float*)Z_Param__Result=P_THIS->GetTimeStamp();
		P_NATIVE_END;
	}
	DEFINE_FUNCTION(UAGX_Simulation::execGetStatistics)
	{
		P_FINISH;
		P_NATIVE_BEGIN;
		*(FAGX_Statistics*)Z_Param__Result=P_THIS->GetStatistics();
		P_NATIVE_END;
	}
	DEFINE_FUNCTION(UAGX_Simulation::execGetNumPpgsIterations)
	{
		P_FINISH;
		P_NATIVE_BEGIN;
		*(int32*)Z_Param__Result=P_THIS->GetNumPpgsIterations();
		P_NATIVE_END;
	}
	DEFINE_FUNCTION(UAGX_Simulation::execSetNumPpgsIterations)
	{
		P_GET_PROPERTY(FIntProperty,Z_Param_NumIterations);
		P_FINISH;
		P_NATIVE_BEGIN;
		P_THIS->SetNumPpgsIterations(Z_Param_NumIterations);
		P_NATIVE_END;
	}
	DEFINE_FUNCTION(UAGX_Simulation::execGetEnableAMOR)
	{
		P_FINISH;
		P_NATIVE_BEGIN;
		*(bool*)Z_Param__Result=P_THIS->GetEnableAMOR();
		P_NATIVE_END;
	}
	DEFINE_FUNCTION(UAGX_Simulation::execSetEnableAMOR)
	{
		P_GET_UBOOL(Z_Param_bEnable);
		P_FINISH;
		P_NATIVE_BEGIN;
		P_THIS->SetEnableAMOR(Z_Param_bEnable);
		P_NATIVE_END;
	}
	DEFINE_FUNCTION(UAGX_Simulation::execGetEnableContactWarmstarting)
	{
		P_FINISH;
		P_NATIVE_BEGIN;
		*(bool*)Z_Param__Result=P_THIS->GetEnableContactWarmstarting();
		P_NATIVE_END;
	}
	DEFINE_FUNCTION(UAGX_Simulation::execSetEnableContactWarmstarting)
	{
		P_GET_UBOOL(Z_Param_bEnable);
		P_FINISH;
		P_NATIVE_BEGIN;
		P_THIS->SetEnableContactWarmstarting(Z_Param_bEnable);
		P_NATIVE_END;
	}
	DEFINE_FUNCTION(UAGX_Simulation::execSetPointGravity)
	{
		P_GET_STRUCT(FVector,Z_Param_InOrigin);
		P_GET_PROPERTY(FFloatProperty,Z_Param_InMagnitude);
		P_FINISH;
		P_NATIVE_BEGIN;
		P_THIS->SetPointGravity(Z_Param_InOrigin,Z_Param_InMagnitude);
		P_NATIVE_END;
	}
	DEFINE_FUNCTION(UAGX_Simulation::execSetUniformGravity)
	{
		P_GET_STRUCT(FVector,Z_Param_InGravity);
		P_FINISH;
		P_NATIVE_BEGIN;
		P_THIS->SetUniformGravity(Z_Param_InGravity);
		P_NATIVE_END;
	}
	DEFINE_FUNCTION(UAGX_Simulation::execSetGravityModel)
	{
		P_GET_PROPERTY(FByteProperty,Z_Param_InModel);
		P_FINISH;
		P_NATIVE_BEGIN;
		P_THIS->SetGravityModel(EAGX_GravityModel(Z_Param_InModel));
		P_NATIVE_END;
	}
	DEFINE_FUNCTION(UAGX_Simulation::execGetNumThreads)
	{
		P_FINISH;
		P_NATIVE_BEGIN;
		*(int32*)Z_Param__Result=P_THIS->GetNumThreads();
		P_NATIVE_END;
	}
	DEFINE_FUNCTION(UAGX_Simulation::execSetNumThreads)
	{
		P_GET_PROPERTY(FIntProperty,Z_Param_InNumThreads);
		P_FINISH;
		P_NATIVE_BEGIN;
		P_THIS->SetNumThreads(Z_Param_InNumThreads);
		P_NATIVE_END;
	}
	void UAGX_Simulation::StaticRegisterNativesUAGX_Simulation()
	{
		UClass* Class = UAGX_Simulation::StaticClass();
		static const FNameNativePtrPair Funcs[] = {
			{ "GetEnableAMOR", &UAGX_Simulation::execGetEnableAMOR },
			{ "GetEnableContactWarmstarting", &UAGX_Simulation::execGetEnableContactWarmstarting },
			{ "GetNumPpgsIterations", &UAGX_Simulation::execGetNumPpgsIterations },
			{ "GetNumThreads", &UAGX_Simulation::execGetNumThreads },
			{ "GetStatistics", &UAGX_Simulation::execGetStatistics },
			{ "GetTimeStamp", &UAGX_Simulation::execGetTimeStamp },
			{ "SetEnableAMOR", &UAGX_Simulation::execSetEnableAMOR },
			{ "SetEnableContactWarmstarting", &UAGX_Simulation::execSetEnableContactWarmstarting },
			{ "SetGravityModel", &UAGX_Simulation::execSetGravityModel },
			{ "SetNumPpgsIterations", &UAGX_Simulation::execSetNumPpgsIterations },
			{ "SetNumThreads", &UAGX_Simulation::execSetNumThreads },
			{ "SetPointGravity", &UAGX_Simulation::execSetPointGravity },
			{ "SetTimeStamp", &UAGX_Simulation::execSetTimeStamp },
			{ "SetUniformGravity", &UAGX_Simulation::execSetUniformGravity },
			{ "StepOnce", &UAGX_Simulation::execStepOnce },
		};
		FNativeFunctionRegistrar::RegisterFunctions(Class, Funcs, UE_ARRAY_COUNT(Funcs));
	}
	struct Z_Construct_UFunction_UAGX_Simulation_GetEnableAMOR_Statics
	{
		struct AGX_Simulation_eventGetEnableAMOR_Parms
		{
			bool ReturnValue;
		};
		static void NewProp_ReturnValue_SetBit(void* Obj);
		static const UECodeGen_Private::FBoolPropertyParams NewProp_ReturnValue;
		static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
		static const UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
		static const UECodeGen_Private::FFunctionParams FuncParams;
	};
	void Z_Construct_UFunction_UAGX_Simulation_GetEnableAMOR_Statics::NewProp_ReturnValue_SetBit(void* Obj)
	{
		((AGX_Simulation_eventGetEnableAMOR_Parms*)Obj)->ReturnValue = 1;
	}
	const UECodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_UAGX_Simulation_GetEnableAMOR_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UECodeGen_Private::EPropertyGenFlags::Bool | UECodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, sizeof(bool), sizeof(AGX_Simulation_eventGetEnableAMOR_Parms), &Z_Construct_UFunction_UAGX_Simulation_GetEnableAMOR_Statics::NewProp_ReturnValue_SetBit, METADATA_PARAMS(0, nullptr) };
	const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UAGX_Simulation_GetEnableAMOR_Statics::PropPointers[] = {
		(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UAGX_Simulation_GetEnableAMOR_Statics::NewProp_ReturnValue,
	};
#if WITH_METADATA
	const UECodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UAGX_Simulation_GetEnableAMOR_Statics::Function_MetaDataParams[] = {
		{ "Category", "AGX AMOR" },
		{ "ModuleRelativePath", "Public/AGX_Simulation.h" },
	};
#endif
	const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UAGX_Simulation_GetEnableAMOR_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UAGX_Simulation, nullptr, "GetEnableAMOR", nullptr, nullptr, Z_Construct_UFunction_UAGX_Simulation_GetEnableAMOR_Statics::PropPointers, UE_ARRAY_COUNT(Z_Construct_UFunction_UAGX_Simulation_GetEnableAMOR_Statics::PropPointers), sizeof(Z_Construct_UFunction_UAGX_Simulation_GetEnableAMOR_Statics::AGX_Simulation_eventGetEnableAMOR_Parms), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04020401, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UAGX_Simulation_GetEnableAMOR_Statics::Function_MetaDataParams), Z_Construct_UFunction_UAGX_Simulation_GetEnableAMOR_Statics::Function_MetaDataParams) };
	static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UAGX_Simulation_GetEnableAMOR_Statics::PropPointers) < 2048);
	static_assert(sizeof(Z_Construct_UFunction_UAGX_Simulation_GetEnableAMOR_Statics::AGX_Simulation_eventGetEnableAMOR_Parms) < MAX_uint16);
	UFunction* Z_Construct_UFunction_UAGX_Simulation_GetEnableAMOR()
	{
		static UFunction* ReturnFunction = nullptr;
		if (!ReturnFunction)
		{
			UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UAGX_Simulation_GetEnableAMOR_Statics::FuncParams);
		}
		return ReturnFunction;
	}
	struct Z_Construct_UFunction_UAGX_Simulation_GetEnableContactWarmstarting_Statics
	{
		struct AGX_Simulation_eventGetEnableContactWarmstarting_Parms
		{
			bool ReturnValue;
		};
		static void NewProp_ReturnValue_SetBit(void* Obj);
		static const UECodeGen_Private::FBoolPropertyParams NewProp_ReturnValue;
		static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
		static const UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
		static const UECodeGen_Private::FFunctionParams FuncParams;
	};
	void Z_Construct_UFunction_UAGX_Simulation_GetEnableContactWarmstarting_Statics::NewProp_ReturnValue_SetBit(void* Obj)
	{
		((AGX_Simulation_eventGetEnableContactWarmstarting_Parms*)Obj)->ReturnValue = 1;
	}
	const UECodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_UAGX_Simulation_GetEnableContactWarmstarting_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UECodeGen_Private::EPropertyGenFlags::Bool | UECodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, sizeof(bool), sizeof(AGX_Simulation_eventGetEnableContactWarmstarting_Parms), &Z_Construct_UFunction_UAGX_Simulation_GetEnableContactWarmstarting_Statics::NewProp_ReturnValue_SetBit, METADATA_PARAMS(0, nullptr) };
	const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UAGX_Simulation_GetEnableContactWarmstarting_Statics::PropPointers[] = {
		(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UAGX_Simulation_GetEnableContactWarmstarting_Statics::NewProp_ReturnValue,
	};
#if WITH_METADATA
	const UECodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UAGX_Simulation_GetEnableContactWarmstarting_Statics::Function_MetaDataParams[] = {
		{ "Category", "Solver" },
		{ "ModuleRelativePath", "Public/AGX_Simulation.h" },
	};
#endif
	const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UAGX_Simulation_GetEnableContactWarmstarting_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UAGX_Simulation, nullptr, "GetEnableContactWarmstarting", nullptr, nullptr, Z_Construct_UFunction_UAGX_Simulation_GetEnableContactWarmstarting_Statics::PropPointers, UE_ARRAY_COUNT(Z_Construct_UFunction_UAGX_Simulation_GetEnableContactWarmstarting_Statics::PropPointers), sizeof(Z_Construct_UFunction_UAGX_Simulation_GetEnableContactWarmstarting_Statics::AGX_Simulation_eventGetEnableContactWarmstarting_Parms), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x54020401, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UAGX_Simulation_GetEnableContactWarmstarting_Statics::Function_MetaDataParams), Z_Construct_UFunction_UAGX_Simulation_GetEnableContactWarmstarting_Statics::Function_MetaDataParams) };
	static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UAGX_Simulation_GetEnableContactWarmstarting_Statics::PropPointers) < 2048);
	static_assert(sizeof(Z_Construct_UFunction_UAGX_Simulation_GetEnableContactWarmstarting_Statics::AGX_Simulation_eventGetEnableContactWarmstarting_Parms) < MAX_uint16);
	UFunction* Z_Construct_UFunction_UAGX_Simulation_GetEnableContactWarmstarting()
	{
		static UFunction* ReturnFunction = nullptr;
		if (!ReturnFunction)
		{
			UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UAGX_Simulation_GetEnableContactWarmstarting_Statics::FuncParams);
		}
		return ReturnFunction;
	}
	struct Z_Construct_UFunction_UAGX_Simulation_GetNumPpgsIterations_Statics
	{
		struct AGX_Simulation_eventGetNumPpgsIterations_Parms
		{
			int32 ReturnValue;
		};
		static const UECodeGen_Private::FIntPropertyParams NewProp_ReturnValue;
		static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
		static const UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
		static const UECodeGen_Private::FFunctionParams FuncParams;
	};
	const UECodeGen_Private::FIntPropertyParams Z_Construct_UFunction_UAGX_Simulation_GetNumPpgsIterations_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UECodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(AGX_Simulation_eventGetNumPpgsIterations_Parms, ReturnValue), METADATA_PARAMS(0, nullptr) };
	const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UAGX_Simulation_GetNumPpgsIterations_Statics::PropPointers[] = {
		(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UAGX_Simulation_GetNumPpgsIterations_Statics::NewProp_ReturnValue,
	};
#if WITH_METADATA
	const UECodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UAGX_Simulation_GetNumPpgsIterations_Statics::Function_MetaDataParams[] = {
		{ "Category", "Solver" },
		{ "Comment", "/**\n\x09 * \\return The number of Parallel Projected Gauss-Seidel solver iterations to perform per\n\x09 * solve.\n\x09 */" },
		{ "ModuleRelativePath", "Public/AGX_Simulation.h" },
		{ "ToolTip", "\\return The number of Parallel Projected Gauss-Seidel solver iterations to perform per\nsolve." },
	};
#endif
	const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UAGX_Simulation_GetNumPpgsIterations_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UAGX_Simulation, nullptr, "GetNumPpgsIterations", nullptr, nullptr, Z_Construct_UFunction_UAGX_Simulation_GetNumPpgsIterations_Statics::PropPointers, UE_ARRAY_COUNT(Z_Construct_UFunction_UAGX_Simulation_GetNumPpgsIterations_Statics::PropPointers), sizeof(Z_Construct_UFunction_UAGX_Simulation_GetNumPpgsIterations_Statics::AGX_Simulation_eventGetNumPpgsIterations_Parms), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x14020401, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UAGX_Simulation_GetNumPpgsIterations_Statics::Function_MetaDataParams), Z_Construct_UFunction_UAGX_Simulation_GetNumPpgsIterations_Statics::Function_MetaDataParams) };
	static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UAGX_Simulation_GetNumPpgsIterations_Statics::PropPointers) < 2048);
	static_assert(sizeof(Z_Construct_UFunction_UAGX_Simulation_GetNumPpgsIterations_Statics::AGX_Simulation_eventGetNumPpgsIterations_Parms) < MAX_uint16);
	UFunction* Z_Construct_UFunction_UAGX_Simulation_GetNumPpgsIterations()
	{
		static UFunction* ReturnFunction = nullptr;
		if (!ReturnFunction)
		{
			UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UAGX_Simulation_GetNumPpgsIterations_Statics::FuncParams);
		}
		return ReturnFunction;
	}
	struct Z_Construct_UFunction_UAGX_Simulation_GetNumThreads_Statics
	{
		struct AGX_Simulation_eventGetNumThreads_Parms
		{
			int32 ReturnValue;
		};
		static const UECodeGen_Private::FIntPropertyParams NewProp_ReturnValue;
		static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
		static const UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
		static const UECodeGen_Private::FFunctionParams FuncParams;
	};
	const UECodeGen_Private::FIntPropertyParams Z_Construct_UFunction_UAGX_Simulation_GetNumThreads_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UECodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(AGX_Simulation_eventGetNumThreads_Parms, ReturnValue), METADATA_PARAMS(0, nullptr) };
	const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UAGX_Simulation_GetNumThreads_Statics::PropPointers[] = {
		(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UAGX_Simulation_GetNumThreads_Statics::NewProp_ReturnValue,
	};
#if WITH_METADATA
	const UECodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UAGX_Simulation_GetNumThreads_Statics::Function_MetaDataParams[] = {
		{ "Category", "AGX Dynamics" },
		{ "ModuleRelativePath", "Public/AGX_Simulation.h" },
	};
#endif
	const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UAGX_Simulation_GetNumThreads_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UAGX_Simulation, nullptr, "GetNumThreads", nullptr, nullptr, Z_Construct_UFunction_UAGX_Simulation_GetNumThreads_Statics::PropPointers, UE_ARRAY_COUNT(Z_Construct_UFunction_UAGX_Simulation_GetNumThreads_Statics::PropPointers), sizeof(Z_Construct_UFunction_UAGX_Simulation_GetNumThreads_Statics::AGX_Simulation_eventGetNumThreads_Parms), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x54020401, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UAGX_Simulation_GetNumThreads_Statics::Function_MetaDataParams), Z_Construct_UFunction_UAGX_Simulation_GetNumThreads_Statics::Function_MetaDataParams) };
	static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UAGX_Simulation_GetNumThreads_Statics::PropPointers) < 2048);
	static_assert(sizeof(Z_Construct_UFunction_UAGX_Simulation_GetNumThreads_Statics::AGX_Simulation_eventGetNumThreads_Parms) < MAX_uint16);
	UFunction* Z_Construct_UFunction_UAGX_Simulation_GetNumThreads()
	{
		static UFunction* ReturnFunction = nullptr;
		if (!ReturnFunction)
		{
			UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UAGX_Simulation_GetNumThreads_Statics::FuncParams);
		}
		return ReturnFunction;
	}
	struct Z_Construct_UFunction_UAGX_Simulation_GetStatistics_Statics
	{
		struct AGX_Simulation_eventGetStatistics_Parms
		{
			FAGX_Statistics ReturnValue;
		};
		static const UECodeGen_Private::FStructPropertyParams NewProp_ReturnValue;
		static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
		static const UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
		static const UECodeGen_Private::FFunctionParams FuncParams;
	};
	const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UAGX_Simulation_GetStatistics_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(AGX_Simulation_eventGetStatistics_Parms, ReturnValue), Z_Construct_UScriptStruct_FAGX_Statistics, METADATA_PARAMS(0, nullptr) }; // 4139475896
	const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UAGX_Simulation_GetStatistics_Statics::PropPointers[] = {
		(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UAGX_Simulation_GetStatistics_Statics::NewProp_ReturnValue,
	};
#if WITH_METADATA
	const UECodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UAGX_Simulation_GetStatistics_Statics::Function_MetaDataParams[] = {
		{ "Category", "Statistics" },
		{ "Comment", "/**\n\x09 * Get a collection of statistics from the AGX Dynamics simulation.\n\x09 * These will likely be split into several functions in the future.\n\x09 */" },
		{ "ModuleRelativePath", "Public/AGX_Simulation.h" },
		{ "ToolTip", "Get a collection of statistics from the AGX Dynamics simulation.\nThese will likely be split into several functions in the future." },
	};
#endif
	const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UAGX_Simulation_GetStatistics_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UAGX_Simulation, nullptr, "GetStatistics", nullptr, nullptr, Z_Construct_UFunction_UAGX_Simulation_GetStatistics_Statics::PropPointers, UE_ARRAY_COUNT(Z_Construct_UFunction_UAGX_Simulation_GetStatistics_Statics::PropPointers), sizeof(Z_Construct_UFunction_UAGX_Simulation_GetStatistics_Statics::AGX_Simulation_eventGetStatistics_Parms), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04020401, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UAGX_Simulation_GetStatistics_Statics::Function_MetaDataParams), Z_Construct_UFunction_UAGX_Simulation_GetStatistics_Statics::Function_MetaDataParams) };
	static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UAGX_Simulation_GetStatistics_Statics::PropPointers) < 2048);
	static_assert(sizeof(Z_Construct_UFunction_UAGX_Simulation_GetStatistics_Statics::AGX_Simulation_eventGetStatistics_Parms) < MAX_uint16);
	UFunction* Z_Construct_UFunction_UAGX_Simulation_GetStatistics()
	{
		static UFunction* ReturnFunction = nullptr;
		if (!ReturnFunction)
		{
			UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UAGX_Simulation_GetStatistics_Statics::FuncParams);
		}
		return ReturnFunction;
	}
	struct Z_Construct_UFunction_UAGX_Simulation_GetTimeStamp_Statics
	{
		struct AGX_Simulation_eventGetTimeStamp_Parms
		{
			float ReturnValue;
		};
		static const UECodeGen_Private::FFloatPropertyParams NewProp_ReturnValue;
		static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
		static const UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
		static const UECodeGen_Private::FFunctionParams FuncParams;
	};
	const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UAGX_Simulation_GetTimeStamp_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(AGX_Simulation_eventGetTimeStamp_Parms, ReturnValue), METADATA_PARAMS(0, nullptr) };
	const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UAGX_Simulation_GetTimeStamp_Statics::PropPointers[] = {
		(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UAGX_Simulation_GetTimeStamp_Statics::NewProp_ReturnValue,
	};
#if WITH_METADATA
	const UECodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UAGX_Simulation_GetTimeStamp_Statics::Function_MetaDataParams[] = {
		{ "Category", "Simulation" },
		{ "Comment", "/**\n\x09 * Returns the current time within the AGX Dynamics simulation world.\n\x09 *\n\x09 * The returned value is usually the amount of time that has been simulated, but calls to\n\x09 * SetTimeStamp will invalidate this.\n\x09 *\n\x09 * The AGX Dynamics time tries to follow the Unreal Engine world time, using the DeltaTime\n\x09 * values passed to the Tick callbacks, but some of the Step Modes allow for the two times to\n\x09 * diverge.\n\x09 *\n\x09 * @return The current simulation time stamp.\n\x09 */" },
		{ "ModuleRelativePath", "Public/AGX_Simulation.h" },
		{ "ToolTip", "Returns the current time within the AGX Dynamics simulation world.\n\nThe returned value is usually the amount of time that has been simulated, but calls to\nSetTimeStamp will invalidate this.\n\nThe AGX Dynamics time tries to follow the Unreal Engine world time, using the DeltaTime\nvalues passed to the Tick callbacks, but some of the Step Modes allow for the two times to\ndiverge.\n\n@return The current simulation time stamp." },
	};
#endif
	const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UAGX_Simulation_GetTimeStamp_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UAGX_Simulation, nullptr, "GetTimeStamp", nullptr, nullptr, Z_Construct_UFunction_UAGX_Simulation_GetTimeStamp_Statics::PropPointers, UE_ARRAY_COUNT(Z_Construct_UFunction_UAGX_Simulation_GetTimeStamp_Statics::PropPointers), sizeof(Z_Construct_UFunction_UAGX_Simulation_GetTimeStamp_Statics::AGX_Simulation_eventGetTimeStamp_Parms), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x54020401, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UAGX_Simulation_GetTimeStamp_Statics::Function_MetaDataParams), Z_Construct_UFunction_UAGX_Simulation_GetTimeStamp_Statics::Function_MetaDataParams) };
	static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UAGX_Simulation_GetTimeStamp_Statics::PropPointers) < 2048);
	static_assert(sizeof(Z_Construct_UFunction_UAGX_Simulation_GetTimeStamp_Statics::AGX_Simulation_eventGetTimeStamp_Parms) < MAX_uint16);
	UFunction* Z_Construct_UFunction_UAGX_Simulation_GetTimeStamp()
	{
		static UFunction* ReturnFunction = nullptr;
		if (!ReturnFunction)
		{
			UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UAGX_Simulation_GetTimeStamp_Statics::FuncParams);
		}
		return ReturnFunction;
	}
	struct Z_Construct_UFunction_UAGX_Simulation_SetEnableAMOR_Statics
	{
		struct AGX_Simulation_eventSetEnableAMOR_Parms
		{
			bool bEnable;
		};
		static void NewProp_bEnable_SetBit(void* Obj);
		static const UECodeGen_Private::FBoolPropertyParams NewProp_bEnable;
		static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
		static const UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
		static const UECodeGen_Private::FFunctionParams FuncParams;
	};
	void Z_Construct_UFunction_UAGX_Simulation_SetEnableAMOR_Statics::NewProp_bEnable_SetBit(void* Obj)
	{
		((AGX_Simulation_eventSetEnableAMOR_Parms*)Obj)->bEnable = 1;
	}
	const UECodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_UAGX_Simulation_SetEnableAMOR_Statics::NewProp_bEnable = { "bEnable", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Bool | UECodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, sizeof(bool), sizeof(AGX_Simulation_eventSetEnableAMOR_Parms), &Z_Construct_UFunction_UAGX_Simulation_SetEnableAMOR_Statics::NewProp_bEnable_SetBit, METADATA_PARAMS(0, nullptr) };
	const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UAGX_Simulation_SetEnableAMOR_Statics::PropPointers[] = {
		(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UAGX_Simulation_SetEnableAMOR_Statics::NewProp_bEnable,
	};
#if WITH_METADATA
	const UECodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UAGX_Simulation_SetEnableAMOR_Statics::Function_MetaDataParams[] = {
		{ "Category", "AGX AMOR" },
		{ "ModuleRelativePath", "Public/AGX_Simulation.h" },
	};
#endif
	const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UAGX_Simulation_SetEnableAMOR_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UAGX_Simulation, nullptr, "SetEnableAMOR", nullptr, nullptr, Z_Construct_UFunction_UAGX_Simulation_SetEnableAMOR_Statics::PropPointers, UE_ARRAY_COUNT(Z_Construct_UFunction_UAGX_Simulation_SetEnableAMOR_Statics::PropPointers), sizeof(Z_Construct_UFunction_UAGX_Simulation_SetEnableAMOR_Statics::AGX_Simulation_eventSetEnableAMOR_Parms), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04020401, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UAGX_Simulation_SetEnableAMOR_Statics::Function_MetaDataParams), Z_Construct_UFunction_UAGX_Simulation_SetEnableAMOR_Statics::Function_MetaDataParams) };
	static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UAGX_Simulation_SetEnableAMOR_Statics::PropPointers) < 2048);
	static_assert(sizeof(Z_Construct_UFunction_UAGX_Simulation_SetEnableAMOR_Statics::AGX_Simulation_eventSetEnableAMOR_Parms) < MAX_uint16);
	UFunction* Z_Construct_UFunction_UAGX_Simulation_SetEnableAMOR()
	{
		static UFunction* ReturnFunction = nullptr;
		if (!ReturnFunction)
		{
			UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UAGX_Simulation_SetEnableAMOR_Statics::FuncParams);
		}
		return ReturnFunction;
	}
	struct Z_Construct_UFunction_UAGX_Simulation_SetEnableContactWarmstarting_Statics
	{
		struct AGX_Simulation_eventSetEnableContactWarmstarting_Parms
		{
			bool bEnable;
		};
		static void NewProp_bEnable_SetBit(void* Obj);
		static const UECodeGen_Private::FBoolPropertyParams NewProp_bEnable;
		static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
		static const UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
		static const UECodeGen_Private::FFunctionParams FuncParams;
	};
	void Z_Construct_UFunction_UAGX_Simulation_SetEnableContactWarmstarting_Statics::NewProp_bEnable_SetBit(void* Obj)
	{
		((AGX_Simulation_eventSetEnableContactWarmstarting_Parms*)Obj)->bEnable = 1;
	}
	const UECodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_UAGX_Simulation_SetEnableContactWarmstarting_Statics::NewProp_bEnable = { "bEnable", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Bool | UECodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, sizeof(bool), sizeof(AGX_Simulation_eventSetEnableContactWarmstarting_Parms), &Z_Construct_UFunction_UAGX_Simulation_SetEnableContactWarmstarting_Statics::NewProp_bEnable_SetBit, METADATA_PARAMS(0, nullptr) };
	const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UAGX_Simulation_SetEnableContactWarmstarting_Statics::PropPointers[] = {
		(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UAGX_Simulation_SetEnableContactWarmstarting_Statics::NewProp_bEnable,
	};
#if WITH_METADATA
	const UECodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UAGX_Simulation_SetEnableContactWarmstarting_Statics::Function_MetaDataParams[] = {
		{ "Category", "Solver" },
		{ "Comment", "// Member functions.\n" },
		{ "ModuleRelativePath", "Public/AGX_Simulation.h" },
		{ "ToolTip", "Member functions." },
	};
#endif
	const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UAGX_Simulation_SetEnableContactWarmstarting_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UAGX_Simulation, nullptr, "SetEnableContactWarmstarting", nullptr, nullptr, Z_Construct_UFunction_UAGX_Simulation_SetEnableContactWarmstarting_Statics::PropPointers, UE_ARRAY_COUNT(Z_Construct_UFunction_UAGX_Simulation_SetEnableContactWarmstarting_Statics::PropPointers), sizeof(Z_Construct_UFunction_UAGX_Simulation_SetEnableContactWarmstarting_Statics::AGX_Simulation_eventSetEnableContactWarmstarting_Parms), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04020401, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UAGX_Simulation_SetEnableContactWarmstarting_Statics::Function_MetaDataParams), Z_Construct_UFunction_UAGX_Simulation_SetEnableContactWarmstarting_Statics::Function_MetaDataParams) };
	static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UAGX_Simulation_SetEnableContactWarmstarting_Statics::PropPointers) < 2048);
	static_assert(sizeof(Z_Construct_UFunction_UAGX_Simulation_SetEnableContactWarmstarting_Statics::AGX_Simulation_eventSetEnableContactWarmstarting_Parms) < MAX_uint16);
	UFunction* Z_Construct_UFunction_UAGX_Simulation_SetEnableContactWarmstarting()
	{
		static UFunction* ReturnFunction = nullptr;
		if (!ReturnFunction)
		{
			UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UAGX_Simulation_SetEnableContactWarmstarting_Statics::FuncParams);
		}
		return ReturnFunction;
	}
	struct Z_Construct_UFunction_UAGX_Simulation_SetGravityModel_Statics
	{
		struct AGX_Simulation_eventSetGravityModel_Parms
		{
			TEnumAsByte<EAGX_GravityModel> InModel;
		};
		static const UECodeGen_Private::FBytePropertyParams NewProp_InModel;
		static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
		static const UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
		static const UECodeGen_Private::FFunctionParams FuncParams;
	};
	const UECodeGen_Private::FBytePropertyParams Z_Construct_UFunction_UAGX_Simulation_SetGravityModel_Statics::NewProp_InModel = { "InModel", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(AGX_Simulation_eventSetGravityModel_Parms, InModel), Z_Construct_UEnum_AGXUnreal_EAGX_GravityModel, METADATA_PARAMS(0, nullptr) }; // 3622092852
	const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UAGX_Simulation_SetGravityModel_Statics::PropPointers[] = {
		(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UAGX_Simulation_SetGravityModel_Statics::NewProp_InModel,
	};
#if WITH_METADATA
	const UECodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UAGX_Simulation_SetGravityModel_Statics::Function_MetaDataParams[] = {
		{ "Category", "AGX Simulation" },
		{ "ModuleRelativePath", "Public/AGX_Simulation.h" },
	};
#endif
	const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UAGX_Simulation_SetGravityModel_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UAGX_Simulation, nullptr, "SetGravityModel", nullptr, nullptr, Z_Construct_UFunction_UAGX_Simulation_SetGravityModel_Statics::PropPointers, UE_ARRAY_COUNT(Z_Construct_UFunction_UAGX_Simulation_SetGravityModel_Statics::PropPointers), sizeof(Z_Construct_UFunction_UAGX_Simulation_SetGravityModel_Statics::AGX_Simulation_eventSetGravityModel_Parms), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04020401, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UAGX_Simulation_SetGravityModel_Statics::Function_MetaDataParams), Z_Construct_UFunction_UAGX_Simulation_SetGravityModel_Statics::Function_MetaDataParams) };
	static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UAGX_Simulation_SetGravityModel_Statics::PropPointers) < 2048);
	static_assert(sizeof(Z_Construct_UFunction_UAGX_Simulation_SetGravityModel_Statics::AGX_Simulation_eventSetGravityModel_Parms) < MAX_uint16);
	UFunction* Z_Construct_UFunction_UAGX_Simulation_SetGravityModel()
	{
		static UFunction* ReturnFunction = nullptr;
		if (!ReturnFunction)
		{
			UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UAGX_Simulation_SetGravityModel_Statics::FuncParams);
		}
		return ReturnFunction;
	}
	struct Z_Construct_UFunction_UAGX_Simulation_SetNumPpgsIterations_Statics
	{
		struct AGX_Simulation_eventSetNumPpgsIterations_Parms
		{
			int32 NumIterations;
		};
		static const UECodeGen_Private::FIntPropertyParams NewProp_NumIterations;
		static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
		static const UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
		static const UECodeGen_Private::FFunctionParams FuncParams;
	};
	const UECodeGen_Private::FIntPropertyParams Z_Construct_UFunction_UAGX_Simulation_SetNumPpgsIterations_Statics::NewProp_NumIterations = { "NumIterations", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(AGX_Simulation_eventSetNumPpgsIterations_Parms, NumIterations), METADATA_PARAMS(0, nullptr) };
	const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UAGX_Simulation_SetNumPpgsIterations_Statics::PropPointers[] = {
		(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UAGX_Simulation_SetNumPpgsIterations_Statics::NewProp_NumIterations,
	};
#if WITH_METADATA
	const UECodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UAGX_Simulation_SetNumPpgsIterations_Statics::Function_MetaDataParams[] = {
		{ "Category", "Solver" },
		{ "Comment", "/**\n\x09 * Set the number of solver resting iterations to use for the Parallel Projected Gauss-Seidel\n\x09 * (PPGS) solver. This value influences the accuracy and computation cost of e.g. terrain\n\x09 * particles.\n\x09 * @param NumIterations The number of PPGS iterations to perform each solve.\n\x09 */" },
		{ "ModuleRelativePath", "Public/AGX_Simulation.h" },
		{ "ToolTip", "Set the number of solver resting iterations to use for the Parallel Projected Gauss-Seidel\n(PPGS) solver. This value influences the accuracy and computation cost of e.g. terrain\nparticles.\n@param NumIterations The number of PPGS iterations to perform each solve." },
	};
#endif
	const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UAGX_Simulation_SetNumPpgsIterations_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UAGX_Simulation, nullptr, "SetNumPpgsIterations", nullptr, nullptr, Z_Construct_UFunction_UAGX_Simulation_SetNumPpgsIterations_Statics::PropPointers, UE_ARRAY_COUNT(Z_Construct_UFunction_UAGX_Simulation_SetNumPpgsIterations_Statics::PropPointers), sizeof(Z_Construct_UFunction_UAGX_Simulation_SetNumPpgsIterations_Statics::AGX_Simulation_eventSetNumPpgsIterations_Parms), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04020401, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UAGX_Simulation_SetNumPpgsIterations_Statics::Function_MetaDataParams), Z_Construct_UFunction_UAGX_Simulation_SetNumPpgsIterations_Statics::Function_MetaDataParams) };
	static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UAGX_Simulation_SetNumPpgsIterations_Statics::PropPointers) < 2048);
	static_assert(sizeof(Z_Construct_UFunction_UAGX_Simulation_SetNumPpgsIterations_Statics::AGX_Simulation_eventSetNumPpgsIterations_Parms) < MAX_uint16);
	UFunction* Z_Construct_UFunction_UAGX_Simulation_SetNumPpgsIterations()
	{
		static UFunction* ReturnFunction = nullptr;
		if (!ReturnFunction)
		{
			UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UAGX_Simulation_SetNumPpgsIterations_Statics::FuncParams);
		}
		return ReturnFunction;
	}
	struct Z_Construct_UFunction_UAGX_Simulation_SetNumThreads_Statics
	{
		struct AGX_Simulation_eventSetNumThreads_Parms
		{
			int32 InNumThreads;
		};
		static const UECodeGen_Private::FIntPropertyParams NewProp_InNumThreads;
		static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
		static const UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
		static const UECodeGen_Private::FFunctionParams FuncParams;
	};
	const UECodeGen_Private::FIntPropertyParams Z_Construct_UFunction_UAGX_Simulation_SetNumThreads_Statics::NewProp_InNumThreads = { "InNumThreads", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(AGX_Simulation_eventSetNumThreads_Parms, InNumThreads), METADATA_PARAMS(0, nullptr) };
	const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UAGX_Simulation_SetNumThreads_Statics::PropPointers[] = {
		(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UAGX_Simulation_SetNumThreads_Statics::NewProp_InNumThreads,
	};
#if WITH_METADATA
	const UECodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UAGX_Simulation_SetNumThreads_Statics::Function_MetaDataParams[] = {
		{ "Category", "AGX Dynamics" },
		{ "ModuleRelativePath", "Public/AGX_Simulation.h" },
	};
#endif
	const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UAGX_Simulation_SetNumThreads_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UAGX_Simulation, nullptr, "SetNumThreads", nullptr, nullptr, Z_Construct_UFunction_UAGX_Simulation_SetNumThreads_Statics::PropPointers, UE_ARRAY_COUNT(Z_Construct_UFunction_UAGX_Simulation_SetNumThreads_Statics::PropPointers), sizeof(Z_Construct_UFunction_UAGX_Simulation_SetNumThreads_Statics::AGX_Simulation_eventSetNumThreads_Parms), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04020401, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UAGX_Simulation_SetNumThreads_Statics::Function_MetaDataParams), Z_Construct_UFunction_UAGX_Simulation_SetNumThreads_Statics::Function_MetaDataParams) };
	static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UAGX_Simulation_SetNumThreads_Statics::PropPointers) < 2048);
	static_assert(sizeof(Z_Construct_UFunction_UAGX_Simulation_SetNumThreads_Statics::AGX_Simulation_eventSetNumThreads_Parms) < MAX_uint16);
	UFunction* Z_Construct_UFunction_UAGX_Simulation_SetNumThreads()
	{
		static UFunction* ReturnFunction = nullptr;
		if (!ReturnFunction)
		{
			UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UAGX_Simulation_SetNumThreads_Statics::FuncParams);
		}
		return ReturnFunction;
	}
	struct Z_Construct_UFunction_UAGX_Simulation_SetPointGravity_Statics
	{
		struct AGX_Simulation_eventSetPointGravity_Parms
		{
			FVector InOrigin;
			float InMagnitude;
		};
		static const UECodeGen_Private::FStructPropertyParams NewProp_InOrigin;
		static const UECodeGen_Private::FFloatPropertyParams NewProp_InMagnitude;
		static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
		static const UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
		static const UECodeGen_Private::FFunctionParams FuncParams;
	};
	const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UAGX_Simulation_SetPointGravity_Statics::NewProp_InOrigin = { "InOrigin", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(AGX_Simulation_eventSetPointGravity_Parms, InOrigin), Z_Construct_UScriptStruct_FVector, METADATA_PARAMS(0, nullptr) };
	const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UAGX_Simulation_SetPointGravity_Statics::NewProp_InMagnitude = { "InMagnitude", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(AGX_Simulation_eventSetPointGravity_Parms, InMagnitude), METADATA_PARAMS(0, nullptr) };
	const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UAGX_Simulation_SetPointGravity_Statics::PropPointers[] = {
		(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UAGX_Simulation_SetPointGravity_Statics::NewProp_InOrigin,
		(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UAGX_Simulation_SetPointGravity_Statics::NewProp_InMagnitude,
	};
#if WITH_METADATA
	const UECodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UAGX_Simulation_SetPointGravity_Statics::Function_MetaDataParams[] = {
		{ "Category", "AGX Simulation" },
		{ "ModuleRelativePath", "Public/AGX_Simulation.h" },
	};
#endif
	const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UAGX_Simulation_SetPointGravity_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UAGX_Simulation, nullptr, "SetPointGravity", nullptr, nullptr, Z_Construct_UFunction_UAGX_Simulation_SetPointGravity_Statics::PropPointers, UE_ARRAY_COUNT(Z_Construct_UFunction_UAGX_Simulation_SetPointGravity_Statics::PropPointers), sizeof(Z_Construct_UFunction_UAGX_Simulation_SetPointGravity_Statics::AGX_Simulation_eventSetPointGravity_Parms), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04820401, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UAGX_Simulation_SetPointGravity_Statics::Function_MetaDataParams), Z_Construct_UFunction_UAGX_Simulation_SetPointGravity_Statics::Function_MetaDataParams) };
	static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UAGX_Simulation_SetPointGravity_Statics::PropPointers) < 2048);
	static_assert(sizeof(Z_Construct_UFunction_UAGX_Simulation_SetPointGravity_Statics::AGX_Simulation_eventSetPointGravity_Parms) < MAX_uint16);
	UFunction* Z_Construct_UFunction_UAGX_Simulation_SetPointGravity()
	{
		static UFunction* ReturnFunction = nullptr;
		if (!ReturnFunction)
		{
			UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UAGX_Simulation_SetPointGravity_Statics::FuncParams);
		}
		return ReturnFunction;
	}
	struct Z_Construct_UFunction_UAGX_Simulation_SetTimeStamp_Statics
	{
		struct AGX_Simulation_eventSetTimeStamp_Parms
		{
			float NewTimeStamp;
		};
		static const UECodeGen_Private::FFloatPropertyParams NewProp_NewTimeStamp;
		static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
		static const UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
		static const UECodeGen_Private::FFunctionParams FuncParams;
	};
	const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UAGX_Simulation_SetTimeStamp_Statics::NewProp_NewTimeStamp = { "NewTimeStamp", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(AGX_Simulation_eventSetTimeStamp_Parms, NewTimeStamp), METADATA_PARAMS(0, nullptr) };
	const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UAGX_Simulation_SetTimeStamp_Statics::PropPointers[] = {
		(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UAGX_Simulation_SetTimeStamp_Statics::NewProp_NewTimeStamp,
	};
#if WITH_METADATA
	const UECodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UAGX_Simulation_SetTimeStamp_Statics::Function_MetaDataParams[] = {
		{ "Category", "Simulation" },
		{ "Comment", "/**\n\x09 * Set the current simulation time stamp. Does not simulate to that time, just moves the clock\n\x09 * hands.\n\x09 * @param NewTimeStamp The new time stamp.\n\x09 */" },
		{ "ModuleRelativePath", "Public/AGX_Simulation.h" },
		{ "ToolTip", "Set the current simulation time stamp. Does not simulate to that time, just moves the clock\nhands.\n@param NewTimeStamp The new time stamp." },
	};
#endif
	const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UAGX_Simulation_SetTimeStamp_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UAGX_Simulation, nullptr, "SetTimeStamp", nullptr, nullptr, Z_Construct_UFunction_UAGX_Simulation_SetTimeStamp_Statics::PropPointers, UE_ARRAY_COUNT(Z_Construct_UFunction_UAGX_Simulation_SetTimeStamp_Statics::PropPointers), sizeof(Z_Construct_UFunction_UAGX_Simulation_SetTimeStamp_Statics::AGX_Simulation_eventSetTimeStamp_Parms), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04020401, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UAGX_Simulation_SetTimeStamp_Statics::Function_MetaDataParams), Z_Construct_UFunction_UAGX_Simulation_SetTimeStamp_Statics::Function_MetaDataParams) };
	static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UAGX_Simulation_SetTimeStamp_Statics::PropPointers) < 2048);
	static_assert(sizeof(Z_Construct_UFunction_UAGX_Simulation_SetTimeStamp_Statics::AGX_Simulation_eventSetTimeStamp_Parms) < MAX_uint16);
	UFunction* Z_Construct_UFunction_UAGX_Simulation_SetTimeStamp()
	{
		static UFunction* ReturnFunction = nullptr;
		if (!ReturnFunction)
		{
			UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UAGX_Simulation_SetTimeStamp_Statics::FuncParams);
		}
		return ReturnFunction;
	}
	struct Z_Construct_UFunction_UAGX_Simulation_SetUniformGravity_Statics
	{
		struct AGX_Simulation_eventSetUniformGravity_Parms
		{
			FVector InGravity;
		};
		static const UECodeGen_Private::FStructPropertyParams NewProp_InGravity;
		static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
		static const UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
		static const UECodeGen_Private::FFunctionParams FuncParams;
	};
	const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UAGX_Simulation_SetUniformGravity_Statics::NewProp_InGravity = { "InGravity", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(AGX_Simulation_eventSetUniformGravity_Parms, InGravity), Z_Construct_UScriptStruct_FVector, METADATA_PARAMS(0, nullptr) };
	const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UAGX_Simulation_SetUniformGravity_Statics::PropPointers[] = {
		(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UAGX_Simulation_SetUniformGravity_Statics::NewProp_InGravity,
	};
#if WITH_METADATA
	const UECodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UAGX_Simulation_SetUniformGravity_Statics::Function_MetaDataParams[] = {
		{ "Category", "AGX Simulation" },
		{ "ModuleRelativePath", "Public/AGX_Simulation.h" },
	};
#endif
	const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UAGX_Simulation_SetUniformGravity_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UAGX_Simulation, nullptr, "SetUniformGravity", nullptr, nullptr, Z_Construct_UFunction_UAGX_Simulation_SetUniformGravity_Statics::PropPointers, UE_ARRAY_COUNT(Z_Construct_UFunction_UAGX_Simulation_SetUniformGravity_Statics::PropPointers), sizeof(Z_Construct_UFunction_UAGX_Simulation_SetUniformGravity_Statics::AGX_Simulation_eventSetUniformGravity_Parms), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04820401, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UAGX_Simulation_SetUniformGravity_Statics::Function_MetaDataParams), Z_Construct_UFunction_UAGX_Simulation_SetUniformGravity_Statics::Function_MetaDataParams) };
	static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UAGX_Simulation_SetUniformGravity_Statics::PropPointers) < 2048);
	static_assert(sizeof(Z_Construct_UFunction_UAGX_Simulation_SetUniformGravity_Statics::AGX_Simulation_eventSetUniformGravity_Parms) < MAX_uint16);
	UFunction* Z_Construct_UFunction_UAGX_Simulation_SetUniformGravity()
	{
		static UFunction* ReturnFunction = nullptr;
		if (!ReturnFunction)
		{
			UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UAGX_Simulation_SetUniformGravity_Statics::FuncParams);
		}
		return ReturnFunction;
	}
	struct Z_Construct_UFunction_UAGX_Simulation_StepOnce_Statics
	{
#if WITH_METADATA
		static const UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
		static const UECodeGen_Private::FFunctionParams FuncParams;
	};
#if WITH_METADATA
	const UECodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UAGX_Simulation_StepOnce_Statics::Function_MetaDataParams[] = {
		{ "Category", "Simulation" },
		{ "Comment", "/**\n\x09 * Step the AGX Dynamics simulation once. Typically used with the 'None' Step Mode to have full\n\x09 * control over when the simulation is stepped. Does not do any delta time tracking so mixing\n\x09 * automatic frame stepping, i.e. Step Mode != None, and StepOnce may step more than intended.\n\x09 */" },
		{ "ModuleRelativePath", "Public/AGX_Simulation.h" },
		{ "ToolTip", "Step the AGX Dynamics simulation once. Typically used with the 'None' Step Mode to have full\ncontrol over when the simulation is stepped. Does not do any delta time tracking so mixing\nautomatic frame stepping, i.e. Step Mode != None, and StepOnce may step more than intended." },
	};
#endif
	const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UAGX_Simulation_StepOnce_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UAGX_Simulation, nullptr, "StepOnce", nullptr, nullptr, nullptr, 0, 0, RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04020401, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UAGX_Simulation_StepOnce_Statics::Function_MetaDataParams), Z_Construct_UFunction_UAGX_Simulation_StepOnce_Statics::Function_MetaDataParams) };
	UFunction* Z_Construct_UFunction_UAGX_Simulation_StepOnce()
	{
		static UFunction* ReturnFunction = nullptr;
		if (!ReturnFunction)
		{
			UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UAGX_Simulation_StepOnce_Statics::FuncParams);
		}
		return ReturnFunction;
	}
	IMPLEMENT_CLASS_NO_AUTO_REGISTRATION(UAGX_Simulation);
	UClass* Z_Construct_UClass_UAGX_Simulation_NoRegister()
	{
		return UAGX_Simulation::StaticClass();
	}
	struct Z_Construct_UClass_UAGX_Simulation_Statics
	{
		static UObject* (*const DependentSingletons[])();
		static const FClassFunctionLinkInfo FuncInfo[];
#if WITH_METADATA
		static const UECodeGen_Private::FMetaDataPairParam Class_MetaDataParams[];
#endif
#if WITH_METADATA
		static const UECodeGen_Private::FMetaDataPairParam NewProp_NumThreads_MetaData[];
#endif
		static const UECodeGen_Private::FIntPropertyParams NewProp_NumThreads;
#if WITH_METADATA
		static const UECodeGen_Private::FMetaDataPairParam NewProp_TimeStep_MetaData[];
#endif
		static const UECodeGen_Private::FFloatPropertyParams NewProp_TimeStep;
#if WITH_METADATA
		static const UECodeGen_Private::FMetaDataPairParam NewProp_bContactWarmstarting_MetaData[];
#endif
		static void NewProp_bContactWarmstarting_SetBit(void* Obj);
		static const UECodeGen_Private::FBoolPropertyParams NewProp_bContactWarmstarting;
#if WITH_METADATA
		static const UECodeGen_Private::FMetaDataPairParam NewProp_bOverridePPGSIterations_MetaData[];
#endif
		static void NewProp_bOverridePPGSIterations_SetBit(void* Obj);
		static const UECodeGen_Private::FBoolPropertyParams NewProp_bOverridePPGSIterations;
#if WITH_METADATA
		static const UECodeGen_Private::FMetaDataPairParam NewProp_NumPpgsIterations_MetaData[];
#endif
		static const UECodeGen_Private::FIntPropertyParams NewProp_NumPpgsIterations;
#if WITH_METADATA
		static const UECodeGen_Private::FMetaDataPairParam NewProp_GravityModel_MetaData[];
#endif
		static const UECodeGen_Private::FBytePropertyParams NewProp_GravityModel;
#if WITH_METADATA
		static const UECodeGen_Private::FMetaDataPairParam NewProp_UniformGravity_MetaData[];
#endif
		static const UECodeGen_Private::FStructPropertyParams NewProp_UniformGravity;
#if WITH_METADATA
		static const UECodeGen_Private::FMetaDataPairParam NewProp_PointGravityOrigin_MetaData[];
#endif
		static const UECodeGen_Private::FStructPropertyParams NewProp_PointGravityOrigin;
#if WITH_METADATA
		static const UECodeGen_Private::FMetaDataPairParam NewProp_PointGravityMagnitude_MetaData[];
#endif
		static const UECodeGen_Private::FFloatPropertyParams NewProp_PointGravityMagnitude;
#if WITH_METADATA
		static const UECodeGen_Private::FMetaDataPairParam NewProp_StepMode_MetaData[];
#endif
		static const UECodeGen_Private::FBytePropertyParams NewProp_StepMode;
#if WITH_METADATA
		static const UECodeGen_Private::FMetaDataPairParam NewProp_TimeLagCap_MetaData[];
#endif
		static const UECodeGen_Private::FFloatPropertyParams NewProp_TimeLagCap;
#if WITH_METADATA
		static const UECodeGen_Private::FMetaDataPairParam NewProp_bEnableStatistics_MetaData[];
#endif
		static void NewProp_bEnableStatistics_SetBit(void* Obj);
		static const UECodeGen_Private::FBoolPropertyParams NewProp_bEnableStatistics;
#if WITH_METADATA
		static const UECodeGen_Private::FMetaDataPairParam NewProp_bEnableAMOR_MetaData[];
#endif
		static void NewProp_bEnableAMOR_SetBit(void* Obj);
		static const UECodeGen_Private::FBoolPropertyParams NewProp_bEnableAMOR;
#if WITH_METADATA
		static const UECodeGen_Private::FMetaDataPairParam NewProp_GlobalShapeContactMergeSplitThresholds_MetaData[];
#endif
		static const UECodeGen_Private::FStructPropertyParams NewProp_GlobalShapeContactMergeSplitThresholds;
#if WITH_METADATA
		static const UECodeGen_Private::FMetaDataPairParam NewProp_GlobalConstraintMergeSplitThresholds_MetaData[];
#endif
		static const UECodeGen_Private::FStructPropertyParams NewProp_GlobalConstraintMergeSplitThresholds;
#if WITH_METADATA
		static const UECodeGen_Private::FMetaDataPairParam NewProp_GlobalWireMergeSplitThresholds_MetaData[];
#endif
		static const UECodeGen_Private::FStructPropertyParams NewProp_GlobalWireMergeSplitThresholds;
#if WITH_EDITORONLY_DATA
#if WITH_METADATA
		static const UECodeGen_Private::FMetaDataPairParam NewProp_bExportInitialState_MetaData[];
#endif
		static void NewProp_bExportInitialState_SetBit(void* Obj);
		static const UECodeGen_Private::FBoolPropertyParams NewProp_bExportInitialState;
#if WITH_METADATA
		static const UECodeGen_Private::FMetaDataPairParam NewProp_ExportPath_MetaData[];
#endif
		static const UECodeGen_Private::FStrPropertyParams NewProp_ExportPath;
#endif // WITH_EDITORONLY_DATA
#if WITH_METADATA
		static const UECodeGen_Private::FMetaDataPairParam NewProp_bRemoteDebugging_MetaData[];
#endif
		static void NewProp_bRemoteDebugging_SetBit(void* Obj);
		static const UECodeGen_Private::FBoolPropertyParams NewProp_bRemoteDebugging;
#if WITH_METADATA
		static const UECodeGen_Private::FMetaDataPairParam NewProp_RemoteDebuggingPort_MetaData[];
#endif
		static const UECodeGen_Private::FInt16PropertyParams NewProp_RemoteDebuggingPort;
#if WITH_METADATA
		static const UECodeGen_Private::FMetaDataPairParam NewProp_ConstraintVisualizationScalingDistanceMax_MetaData[];
#endif
		static const UECodeGen_Private::FFloatPropertyParams NewProp_ConstraintVisualizationScalingDistanceMax;
#if WITH_METADATA
		static const UECodeGen_Private::FMetaDataPairParam NewProp_PreStepForward_MetaData[];
#endif
		static const UECodeGen_Private::FMulticastDelegatePropertyParams NewProp_PreStepForward;
#if WITH_METADATA
		static const UECodeGen_Private::FMetaDataPairParam NewProp_PostStepForward_MetaData[];
#endif
		static const UECodeGen_Private::FMulticastDelegatePropertyParams NewProp_PostStepForward;
		static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_EDITORONLY_DATA
#endif // WITH_EDITORONLY_DATA
		static const FCppClassTypeInfoStatic StaticCppClassTypeInfo;
		static const UECodeGen_Private::FClassParams ClassParams;
	};
	UObject* (*const Z_Construct_UClass_UAGX_Simulation_Statics::DependentSingletons[])() = {
		(UObject* (*)())Z_Construct_UClass_UGameInstanceSubsystem,
		(UObject* (*)())Z_Construct_UPackage__Script_AGXUnreal,
	};
	static_assert(UE_ARRAY_COUNT(Z_Construct_UClass_UAGX_Simulation_Statics::DependentSingletons) < 16);
	const FClassFunctionLinkInfo Z_Construct_UClass_UAGX_Simulation_Statics::FuncInfo[] = {
		{ &Z_Construct_UFunction_UAGX_Simulation_GetEnableAMOR, "GetEnableAMOR" }, // 3088286275
		{ &Z_Construct_UFunction_UAGX_Simulation_GetEnableContactWarmstarting, "GetEnableContactWarmstarting" }, // 3876957914
		{ &Z_Construct_UFunction_UAGX_Simulation_GetNumPpgsIterations, "GetNumPpgsIterations" }, // 2779104780
		{ &Z_Construct_UFunction_UAGX_Simulation_GetNumThreads, "GetNumThreads" }, // 3383444731
		{ &Z_Construct_UFunction_UAGX_Simulation_GetStatistics, "GetStatistics" }, // 3310827048
		{ &Z_Construct_UFunction_UAGX_Simulation_GetTimeStamp, "GetTimeStamp" }, // 2656303208
		{ &Z_Construct_UFunction_UAGX_Simulation_SetEnableAMOR, "SetEnableAMOR" }, // 3441169622
		{ &Z_Construct_UFunction_UAGX_Simulation_SetEnableContactWarmstarting, "SetEnableContactWarmstarting" }, // 3235342338
		{ &Z_Construct_UFunction_UAGX_Simulation_SetGravityModel, "SetGravityModel" }, // 1434998220
		{ &Z_Construct_UFunction_UAGX_Simulation_SetNumPpgsIterations, "SetNumPpgsIterations" }, // 3982852647
		{ &Z_Construct_UFunction_UAGX_Simulation_SetNumThreads, "SetNumThreads" }, // 3211675839
		{ &Z_Construct_UFunction_UAGX_Simulation_SetPointGravity, "SetPointGravity" }, // 3718480862
		{ &Z_Construct_UFunction_UAGX_Simulation_SetTimeStamp, "SetTimeStamp" }, // 3729296484
		{ &Z_Construct_UFunction_UAGX_Simulation_SetUniformGravity, "SetUniformGravity" }, // 284546816
		{ &Z_Construct_UFunction_UAGX_Simulation_StepOnce, "StepOnce" }, // 2212763984
	};
	static_assert(UE_ARRAY_COUNT(Z_Construct_UClass_UAGX_Simulation_Statics::FuncInfo) < 2048);
#if WITH_METADATA
	const UECodeGen_Private::FMetaDataPairParam Z_Construct_UClass_UAGX_Simulation_Statics::Class_MetaDataParams[] = {
		{ "Category", "AGX" },
		{ "ClassGroupNames", "AGX" },
		{ "Comment", "/**\n * Manages an AGX simulation instance.\n *\n * When an instance of this class exists, native AGX objects relating to the\n * simulation can be created (RigidBody, Constraint, ContactMaterial, etc). When\n * this instance is destroyed, all those native objects must be destroyed.\n *\n * Lifetime is bound to a GameInstance. Therefore, each playing GameInstance\n * will have exactly one UAGX_Simulation instance.\n *\n * When not playing, the CDO (class default object) can be modified through the\n * Editor UI. From the toolbar select Settings -> Project Settings -> Plugins ->\n * AGX Dynamics. This is useful for setting simulation properties like time step\n * and contact materials. When a GameInstance is started, the properties of the\n * CDO will automatically be copied over by Unreal Engine to the GameInstance\n * specific UAGX_Simulation instance.\n *\n */" },
		{ "IncludePath", "AGX_Simulation.h" },
		{ "ModuleRelativePath", "Public/AGX_Simulation.h" },
		{ "ToolTip", "Manages an AGX simulation instance.\n\nWhen an instance of this class exists, native AGX objects relating to the\nsimulation can be created (RigidBody, Constraint, ContactMaterial, etc). When\nthis instance is destroyed, all those native objects must be destroyed.\n\nLifetime is bound to a GameInstance. Therefore, each playing GameInstance\nwill have exactly one UAGX_Simulation instance.\n\nWhen not playing, the CDO (class default object) can be modified through the\nEditor UI. From the toolbar select Settings -> Project Settings -> Plugins ->\nAGX Dynamics. This is useful for setting simulation properties like time step\nand contact materials. When a GameInstance is started, the properties of the\nCDO will automatically be copied over by Unreal Engine to the GameInstance\nspecific UAGX_Simulation instance." },
	};
#endif
#if WITH_METADATA
	const UECodeGen_Private::FMetaDataPairParam Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_NumThreads_MetaData[] = {
		{ "Category", "AGX Dynamics" },
		{ "Comment", "/**\n\x09 * The number of threads AGX Dynamics will use during Play.\n\x09 *\n\x09 * Set to 0 to use all hardware threads.\n\x09 */" },
		{ "DisplayName", "Number of Threads" },
		{ "ModuleRelativePath", "Public/AGX_Simulation.h" },
		{ "ToolTip", "The number of threads AGX Dynamics will use during Play.\n\nSet to 0 to use all hardware threads." },
	};
#endif
	const UECodeGen_Private::FIntPropertyParams Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_NumThreads = { "NumThreads", nullptr, (EPropertyFlags)0x0010000000004001, UECodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(UAGX_Simulation, NumThreads), METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_NumThreads_MetaData), Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_NumThreads_MetaData) };
#if WITH_METADATA
	const UECodeGen_Private::FMetaDataPairParam Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_TimeStep_MetaData[] = {
		{ "Category", "Solver" },
		{ "ClampMax", "1.0" },
		{ "ClampMin", "0.001" },
		{ "Comment", "/**\n\x09 * Step length of the integrator [s].\n\x09 */" },
		{ "ModuleRelativePath", "Public/AGX_Simulation.h" },
		{ "ToolTip", "Step length of the integrator [s]." },
		{ "UIMax", "1.0" },
		{ "UIMin", "0.001" },
	};
#endif
	const UECodeGen_Private::FFloatPropertyParams Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_TimeStep = { "TimeStep", nullptr, (EPropertyFlags)0x0010000000004015, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(UAGX_Simulation, TimeStep), METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_TimeStep_MetaData), Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_TimeStep_MetaData) };
#if WITH_METADATA
	const UECodeGen_Private::FMetaDataPairParam Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_bContactWarmstarting_MetaData[] = {
		{ "Category", "Solver" },
		{ "Comment", "/**\n\x09 * Contact warmstarting adds an extra step to the solver where the previous timesteps contact\n\x09 * data is matched to the current timesteps data so the previous forces can be used by the\n\x09 * solver to find a solution faster when direct friction is used.\n\x09 *\n\x09 * If using auto-generated ContactMaterials and default settings, enabling this is not\n\x09 * recommended and will just add some overhead. But if a FrictionModel with DIRECT solvetype is\n\x09 * used, enabling this is recommended.\n\x09 *\n\x09 * The state data used to match contacts for warmstarting is not serialized. This means that\n\x09 * storing and then restoring the simulation can give slightly different trajectories compared\n\x09 * to running the simulation non-stop.\n\x09 */" },
		{ "ModuleRelativePath", "Public/AGX_Simulation.h" },
		{ "ToolTip", "Contact warmstarting adds an extra step to the solver where the previous timesteps contact\ndata is matched to the current timesteps data so the previous forces can be used by the\nsolver to find a solution faster when direct friction is used.\n\nIf using auto-generated ContactMaterials and default settings, enabling this is not\nrecommended and will just add some overhead. But if a FrictionModel with DIRECT solvetype is\nused, enabling this is recommended.\n\nThe state data used to match contacts for warmstarting is not serialized. This means that\nstoring and then restoring the simulation can give slightly different trajectories compared\nto running the simulation non-stop." },
	};
#endif
	void Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_bContactWarmstarting_SetBit(void* Obj)
	{
		((UAGX_Simulation*)Obj)->bContactWarmstarting = 1;
	}
	const UECodeGen_Private::FBoolPropertyParams Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_bContactWarmstarting = { "bContactWarmstarting", nullptr, (EPropertyFlags)0x0010000000004015, UECodeGen_Private::EPropertyGenFlags::Bool | UECodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, sizeof(bool), sizeof(UAGX_Simulation), &Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_bContactWarmstarting_SetBit, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_bContactWarmstarting_MetaData), Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_bContactWarmstarting_MetaData) };
#if WITH_METADATA
	const UECodeGen_Private::FMetaDataPairParam Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_bOverridePPGSIterations_MetaData[] = {
		{ "Category", "Solver" },
		{ "Comment", "/**\n\x09 * Set to true to override the AGX Dynamics default value for the number of Parallel Projected\n\x09 * Gauss-Seidel (PPGS) solver iterations. The number of iterations to use is set with Num PPGS\n\x09 * Iterations.\n\x09 */" },
		{ "DisplayName", "Override PPGS Iterations" },
		{ "ModuleRelativePath", "Public/AGX_Simulation.h" },
		{ "ToolTip", "Set to true to override the AGX Dynamics default value for the number of Parallel Projected\nGauss-Seidel (PPGS) solver iterations. The number of iterations to use is set with Num PPGS\nIterations." },
	};
#endif
	void Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_bOverridePPGSIterations_SetBit(void* Obj)
	{
		((UAGX_Simulation*)Obj)->bOverridePPGSIterations = 1;
	}
	const UECodeGen_Private::FBoolPropertyParams Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_bOverridePPGSIterations = { "bOverridePPGSIterations", nullptr, (EPropertyFlags)0x0010000000004001, UECodeGen_Private::EPropertyGenFlags::Bool | UECodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, sizeof(bool), sizeof(UAGX_Simulation), &Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_bOverridePPGSIterations_SetBit, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_bOverridePPGSIterations_MetaData), Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_bOverridePPGSIterations_MetaData) };
#if WITH_METADATA
	const UECodeGen_Private::FMetaDataPairParam Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_NumPpgsIterations_MetaData[] = {
		{ "Category", "Solver" },
		{ "ClampMin", "1" },
		{ "Comment", "/**\n\x09 * The number of solver resting iterations to use for the Parallel Projected Gauss-Seidel (PPGS)\n\x09 * solver. This value influences the accuracy and computation cost of e.g. terrain particles.\n\x09 */" },
		{ "DisplayName", "Num PPGS Iterations" },
		{ "EditCondition", "bOverridePPGSIterations" },
		{ "ModuleRelativePath", "Public/AGX_Simulation.h" },
		{ "ToolTip", "The number of solver resting iterations to use for the Parallel Projected Gauss-Seidel (PPGS)\nsolver. This value influences the accuracy and computation cost of e.g. terrain particles." },
		{ "UIMin", "1" },
	};
#endif
	const UECodeGen_Private::FIntPropertyParams Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_NumPpgsIterations = { "NumPpgsIterations", nullptr, (EPropertyFlags)0x0010000000004001, UECodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(UAGX_Simulation, NumPpgsIterations), METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_NumPpgsIterations_MetaData), Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_NumPpgsIterations_MetaData) };
#if WITH_METADATA
	const UECodeGen_Private::FMetaDataPairParam Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_GravityModel_MetaData[] = {
		{ "Category", "Gravity" },
		{ "Comment", "/** Specifies the gravity model used by the simulation. */" },
		{ "ModuleRelativePath", "Public/AGX_Simulation.h" },
		{ "ToolTip", "Specifies the gravity model used by the simulation." },
	};
#endif
	const UECodeGen_Private::FBytePropertyParams Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_GravityModel = { "GravityModel", nullptr, (EPropertyFlags)0x0010000000004001, UECodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(UAGX_Simulation, GravityModel), Z_Construct_UEnum_AGXUnreal_EAGX_GravityModel, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_GravityModel_MetaData), Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_GravityModel_MetaData) }; // 3622092852
#if WITH_METADATA
	const UECodeGen_Private::FMetaDataPairParam Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_UniformGravity_MetaData[] = {
		{ "Category", "Gravity" },
		{ "Comment", "/** Specifies the gravity vector when using Uniform Gravity Field with magnitude [cm/s^2]. */" },
		{ "EditCondition", "GravityModel == EAGX_GravityModel::Uniform" },
		{ "ModuleRelativePath", "Public/AGX_Simulation.h" },
		{ "ToolTip", "Specifies the gravity vector when using Uniform Gravity Field with magnitude [cm/s^2]." },
	};
#endif
	const UECodeGen_Private::FStructPropertyParams Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_UniformGravity = { "UniformGravity", nullptr, (EPropertyFlags)0x0010000000004001, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(UAGX_Simulation, UniformGravity), Z_Construct_UScriptStruct_FVector, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_UniformGravity_MetaData), Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_UniformGravity_MetaData) };
#if WITH_METADATA
	const UECodeGen_Private::FMetaDataPairParam Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_PointGravityOrigin_MetaData[] = {
		{ "Category", "Gravity" },
		{ "Comment", "/** Specifies the world location towards which the gravity field is directed when using Point\n\x09 * Gravity Field [cm]. */" },
		{ "EditCondition", "GravityModel == EAGX_GravityModel::Point" },
		{ "ModuleRelativePath", "Public/AGX_Simulation.h" },
		{ "ToolTip", "Specifies the world location towards which the gravity field is directed when using Point\nGravity Field [cm]." },
	};
#endif
	const UECodeGen_Private::FStructPropertyParams Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_PointGravityOrigin = { "PointGravityOrigin", nullptr, (EPropertyFlags)0x0010000000004001, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(UAGX_Simulation, PointGravityOrigin), Z_Construct_UScriptStruct_FVector, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_PointGravityOrigin_MetaData), Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_PointGravityOrigin_MetaData) };
#if WITH_METADATA
	const UECodeGen_Private::FMetaDataPairParam Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_PointGravityMagnitude_MetaData[] = {
		{ "Category", "Gravity" },
		{ "Comment", "/** Specifies the gravity magnitude when using Point Gravity Field [cm/s^2]. */" },
		{ "EditCondition", "GravityModel == EAGX_GravityModel::Point" },
		{ "ModuleRelativePath", "Public/AGX_Simulation.h" },
		{ "ToolTip", "Specifies the gravity magnitude when using Point Gravity Field [cm/s^2]." },
	};
#endif
	const UECodeGen_Private::FFloatPropertyParams Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_PointGravityMagnitude = { "PointGravityMagnitude", nullptr, (EPropertyFlags)0x0010000000004001, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(UAGX_Simulation, PointGravityMagnitude), METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_PointGravityMagnitude_MetaData), Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_PointGravityMagnitude_MetaData) };
#if WITH_METADATA
	const UECodeGen_Private::FMetaDataPairParam Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_StepMode_MetaData[] = {
		{ "Category", "Simulation Stepping Mode" },
		{ "Comment", "/**\n\x09 * Simulation stepping mode. This controls what happens when the simulation is unable to keep\n\x09 * up with real-time.\n\x09 */" },
		{ "ModuleRelativePath", "Public/AGX_Simulation.h" },
		{ "ToolTip", "Simulation stepping mode. This controls what happens when the simulation is unable to keep\nup with real-time." },
	};
#endif
	const UECodeGen_Private::FBytePropertyParams Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_StepMode = { "StepMode", nullptr, (EPropertyFlags)0x0010000000004005, UECodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(UAGX_Simulation, StepMode), Z_Construct_UEnum_AGXUnreal_EAGX_StepMode, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_StepMode_MetaData), Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_StepMode_MetaData) }; // 1709449964
#if WITH_METADATA
	const UECodeGen_Private::FMetaDataPairParam Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_TimeLagCap_MetaData[] = {
		{ "Category", "Simulation Stepping Mode" },
		{ "Comment", "/** Maximum time lag for the Catch up over time Capped step mode before dropping [s]. */" },
		{ "ModuleRelativePath", "Public/AGX_Simulation.h" },
		{ "ToolTip", "Maximum time lag for the Catch up over time Capped step mode before dropping [s]." },
	};
#endif
	const UECodeGen_Private::FFloatPropertyParams Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_TimeLagCap = { "TimeLagCap", nullptr, (EPropertyFlags)0x0010000000004001, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(UAGX_Simulation, TimeLagCap), METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_TimeLagCap_MetaData), Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_TimeLagCap_MetaData) };
#if WITH_METADATA
	const UECodeGen_Private::FMetaDataPairParam Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_bEnableStatistics_MetaData[] = {
		{ "Category", "Statistics" },
		{ "Comment", "/** Set to true to enable statistics gathering in AGX Dynamics. */" },
		{ "ModuleRelativePath", "Public/AGX_Simulation.h" },
		{ "ToolTip", "Set to true to enable statistics gathering in AGX Dynamics." },
	};
#endif
	void Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_bEnableStatistics_SetBit(void* Obj)
	{
		((UAGX_Simulation*)Obj)->bEnableStatistics = 1;
	}
	const UECodeGen_Private::FBoolPropertyParams Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_bEnableStatistics = { "bEnableStatistics", nullptr, (EPropertyFlags)0x0010000000004005, UECodeGen_Private::EPropertyGenFlags::Bool | UECodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, sizeof(bool), sizeof(UAGX_Simulation), &Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_bEnableStatistics_SetBit, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_bEnableStatistics_MetaData), Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_bEnableStatistics_MetaData) };
#if WITH_METADATA
	const UECodeGen_Private::FMetaDataPairParam Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_bEnableAMOR_MetaData[] = {
		{ "Category", "AGX AMOR" },
		{ "Comment", "/**\n\x09 * Globally enable or disable AMOR (Merge Split Handler) in AGX Dynamics.\n\x09 * Note that each RigidBody / Geometry / Wire / Constraint need to enable merge/split\n\x09 * individually for AMOR to be used for those.\n\x09 */" },
		{ "ModuleRelativePath", "Public/AGX_Simulation.h" },
		{ "ToolTip", "Globally enable or disable AMOR (Merge Split Handler) in AGX Dynamics.\nNote that each RigidBody / Geometry / Wire / Constraint need to enable merge/split\nindividually for AMOR to be used for those." },
	};
#endif
	void Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_bEnableAMOR_SetBit(void* Obj)
	{
		((UAGX_Simulation*)Obj)->bEnableAMOR = 1;
	}
	const UECodeGen_Private::FBoolPropertyParams Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_bEnableAMOR = { "bEnableAMOR", nullptr, (EPropertyFlags)0x0010000000004015, UECodeGen_Private::EPropertyGenFlags::Bool | UECodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, sizeof(bool), sizeof(UAGX_Simulation), &Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_bEnableAMOR_SetBit, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_bEnableAMOR_MetaData), Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_bEnableAMOR_MetaData) };
#if WITH_METADATA
	const UECodeGen_Private::FMetaDataPairParam Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_GlobalShapeContactMergeSplitThresholds_MetaData[] = {
		{ "AllowedClasses", "/Script/AGXUnreal.AGX_ShapeContactMergeSplitThresholds" },
		{ "Category", "AGX AMOR" },
		{ "Comment", "/**\n\x09 * Changes the default AMOR Shape Contact Merge Split Thresholds for all Rigid Bodies\n\x09 * and Shapes that does not specify their own.\n\x09 */" },
		{ "ModuleRelativePath", "Public/AGX_Simulation.h" },
		{ "ToolTip", "Changes the default AMOR Shape Contact Merge Split Thresholds for all Rigid Bodies\nand Shapes that does not specify their own." },
	};
#endif
	const UECodeGen_Private::FStructPropertyParams Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_GlobalShapeContactMergeSplitThresholds = { "GlobalShapeContactMergeSplitThresholds", nullptr, (EPropertyFlags)0x0010000000004001, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(UAGX_Simulation, GlobalShapeContactMergeSplitThresholds), Z_Construct_UScriptStruct_FSoftObjectPath, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_GlobalShapeContactMergeSplitThresholds_MetaData), Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_GlobalShapeContactMergeSplitThresholds_MetaData) };
#if WITH_METADATA
	const UECodeGen_Private::FMetaDataPairParam Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_GlobalConstraintMergeSplitThresholds_MetaData[] = {
		{ "AllowedClasses", "/Script/AGXUnreal.AGX_ConstraintMergeSplitThresholds" },
		{ "Category", "AGX AMOR" },
		{ "Comment", "/**\n\x09 * Changes the default AMOR Constraint Merge Split Thresholds for all Constraints\n\x09 * that does not specify their own.\n\x09 */" },
		{ "ModuleRelativePath", "Public/AGX_Simulation.h" },
		{ "ToolTip", "Changes the default AMOR Constraint Merge Split Thresholds for all Constraints\nthat does not specify their own." },
	};
#endif
	const UECodeGen_Private::FStructPropertyParams Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_GlobalConstraintMergeSplitThresholds = { "GlobalConstraintMergeSplitThresholds", nullptr, (EPropertyFlags)0x0010000000004001, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(UAGX_Simulation, GlobalConstraintMergeSplitThresholds), Z_Construct_UScriptStruct_FSoftObjectPath, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_GlobalConstraintMergeSplitThresholds_MetaData), Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_GlobalConstraintMergeSplitThresholds_MetaData) };
#if WITH_METADATA
	const UECodeGen_Private::FMetaDataPairParam Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_GlobalWireMergeSplitThresholds_MetaData[] = {
		{ "AllowedClasses", "/Script/AGXUnreal.AGX_WireMergeSplitThresholds" },
		{ "Category", "AGX AMOR" },
		{ "Comment", "/**\n\x09 * Changes the default AMOR Wire Merge Split Thresholds for all Wires\n\x09 * that does not specify their own.\n\x09 */" },
		{ "ModuleRelativePath", "Public/AGX_Simulation.h" },
		{ "ToolTip", "Changes the default AMOR Wire Merge Split Thresholds for all Wires\nthat does not specify their own." },
	};
#endif
	const UECodeGen_Private::FStructPropertyParams Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_GlobalWireMergeSplitThresholds = { "GlobalWireMergeSplitThresholds", nullptr, (EPropertyFlags)0x0010000000004001, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(UAGX_Simulation, GlobalWireMergeSplitThresholds), Z_Construct_UScriptStruct_FSoftObjectPath, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_GlobalWireMergeSplitThresholds_MetaData), Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_GlobalWireMergeSplitThresholds_MetaData) };
#if WITH_EDITORONLY_DATA
#if WITH_METADATA
	const UECodeGen_Private::FMetaDataPairParam Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_bExportInitialState_MetaData[] = {
		{ "Category", "Startup" },
		{ "Comment", "/**\n\x09 * Set to true to write an AGX Dynamics for Unreal archive of the initial state.\n\x09 * The archive is written to the path set in ExportPath on the first game Tick.\n\x09 */" },
		{ "ModuleRelativePath", "Public/AGX_Simulation.h" },
		{ "ToolTip", "Set to true to write an AGX Dynamics for Unreal archive of the initial state.\nThe archive is written to the path set in ExportPath on the first game Tick." },
	};
#endif
	void Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_bExportInitialState_SetBit(void* Obj)
	{
		((UAGX_Simulation*)Obj)->bExportInitialState = 1;
	}
	const UECodeGen_Private::FBoolPropertyParams Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_bExportInitialState = { "bExportInitialState", nullptr, (EPropertyFlags)0x0010000800004001, UECodeGen_Private::EPropertyGenFlags::Bool | UECodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, sizeof(bool), sizeof(UAGX_Simulation), &Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_bExportInitialState_SetBit, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_bExportInitialState_MetaData), Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_bExportInitialState_MetaData) };
#if WITH_METADATA
	const UECodeGen_Private::FMetaDataPairParam Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_ExportPath_MetaData[] = {
		{ "Category", "Startup" },
		{ "Comment", "/**\n\x09 * Path to the file to which the initial AGX Dynamics state is written if ExportInitialState is\n\x09 * set.\n\x09 */" },
		{ "EditCondition", "bExportInitialState" },
		{ "ModuleRelativePath", "Public/AGX_Simulation.h" },
		{ "ToolTip", "Path to the file to which the initial AGX Dynamics state is written if ExportInitialState is\nset." },
	};
#endif
	const UECodeGen_Private::FStrPropertyParams Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_ExportPath = { "ExportPath", nullptr, (EPropertyFlags)0x0010000800004001, UECodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(UAGX_Simulation, ExportPath), METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_ExportPath_MetaData), Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_ExportPath_MetaData) };
#endif // WITH_EDITORONLY_DATA
#if WITH_METADATA
	const UECodeGen_Private::FMetaDataPairParam Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_bRemoteDebugging_MetaData[] = {
		{ "Category", "Debug" },
		{ "Comment", "/**\n\x09 * Remote debugging allows agxViewer, the default scene viewer in AGX\n\x09 * Dynamics, to connect to the AGX_Simulation running inside Unreal Engine\n\x09 * and render the internal simulation state using its built-in debug\n\x09 * rendering capabilities.\n\x09 *\n\x09 * To connect to a running Unreal Engine instance launch agxViewer with\n\x09 *    agxViewer -p --connect localhost:<PORT>\n\x09 * where <PORT> is the port number configured in Project Settings > Plugins >  AGX Dynamics >\n\x09 * Debug > RemoteDebuggingPort.\n\x09 */" },
		{ "ModuleRelativePath", "Public/AGX_Simulation.h" },
		{ "ToolTip", "Remote debugging allows agxViewer, the default scene viewer in AGX\nDynamics, to connect to the AGX_Simulation running inside Unreal Engine\nand render the internal simulation state using its built-in debug\nrendering capabilities.\n\nTo connect to a running Unreal Engine instance launch agxViewer with\n   agxViewer -p --connect localhost:<PORT>\nwhere <PORT> is the port number configured in Project Settings > Plugins >  AGX Dynamics >\nDebug > RemoteDebuggingPort." },
	};
#endif
	void Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_bRemoteDebugging_SetBit(void* Obj)
	{
		((UAGX_Simulation*)Obj)->bRemoteDebugging = 1;
	}
	const UECodeGen_Private::FBoolPropertyParams Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_bRemoteDebugging = { "bRemoteDebugging", nullptr, (EPropertyFlags)0x0010000000004001, UECodeGen_Private::EPropertyGenFlags::Bool , RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, sizeof(uint8), sizeof(UAGX_Simulation), &Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_bRemoteDebugging_SetBit, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_bRemoteDebugging_MetaData), Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_bRemoteDebugging_MetaData) };
#if WITH_METADATA
	const UECodeGen_Private::FMetaDataPairParam Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_RemoteDebuggingPort_MetaData[] = {
		{ "Category", "Debug" },
		{ "Comment", "/** Network port to use for remote debugging. */" },
		{ "EditCondition", "bRemoteDebugging" },
		{ "ModuleRelativePath", "Public/AGX_Simulation.h" },
		{ "ToolTip", "Network port to use for remote debugging." },
	};
#endif
	const UECodeGen_Private::FInt16PropertyParams Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_RemoteDebuggingPort = { "RemoteDebuggingPort", nullptr, (EPropertyFlags)0x0010000000004001, UECodeGen_Private::EPropertyGenFlags::Int16, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(UAGX_Simulation, RemoteDebuggingPort), METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_RemoteDebuggingPort_MetaData), Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_RemoteDebuggingPort_MetaData) };
#if WITH_METADATA
	const UECodeGen_Private::FMetaDataPairParam Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_ConstraintVisualizationScalingDistanceMax_MetaData[] = {
		{ "Category", "Rendering" },
		{ "ClampMin", "0.0" },
		{ "Comment", "/**\n\x09 * Maximum distance between the active Viewport camera and any AGX Constraint within which\n\x09 * the AGX Constraint graphical representation is scaled such that it's size is constant as\n\x09 * drawn on the screen [cm].\n\x09 *\n\x09 * When moving the camera further away than this distance the on-screen size of the constraint\n\x09 * visualization will start to shrink along with the surrounding geometry.\n\x09 */" },
		{ "ModuleRelativePath", "Public/AGX_Simulation.h" },
		{ "ToolTip", "Maximum distance between the active Viewport camera and any AGX Constraint within which\nthe AGX Constraint graphical representation is scaled such that it's size is constant as\ndrawn on the screen [cm].\n\nWhen moving the camera further away than this distance the on-screen size of the constraint\nvisualization will start to shrink along with the surrounding geometry." },
		{ "UIMin", "0.0" },
	};
#endif
	const UECodeGen_Private::FFloatPropertyParams Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_ConstraintVisualizationScalingDistanceMax = { "ConstraintVisualizationScalingDistanceMax", nullptr, (EPropertyFlags)0x0010000000004001, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(UAGX_Simulation, ConstraintVisualizationScalingDistanceMax), METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_ConstraintVisualizationScalingDistanceMax_MetaData), Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_ConstraintVisualizationScalingDistanceMax_MetaData) };
#if WITH_METADATA
	const UECodeGen_Private::FMetaDataPairParam Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_PreStepForward_MetaData[] = {
		{ "Category", "Simulation" },
		{ "Comment", "/**\n\x09 * Delegate that is executed before each Simulation step forward.\n\x09 * Users may bind to this delegate in order to get a callback before each Simulation step\n\x09 * forward. This may be executed zero, one or several times per Unreal Engine Tick, depending on\n\x09 * the Step Mode and Time Step selected in the AGX Dynamics for Unreal settings.\n\x09 */" },
		{ "ModuleRelativePath", "Public/AGX_Simulation.h" },
		{ "ToolTip", "Delegate that is executed before each Simulation step forward.\nUsers may bind to this delegate in order to get a callback before each Simulation step\nforward. This may be executed zero, one or several times per Unreal Engine Tick, depending on\nthe Step Mode and Time Step selected in the AGX Dynamics for Unreal settings." },
	};
#endif
	const UECodeGen_Private::FMulticastDelegatePropertyParams Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_PreStepForward = { "PreStepForward", nullptr, (EPropertyFlags)0x0010000010080000, UECodeGen_Private::EPropertyGenFlags::InlineMulticastDelegate, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(UAGX_Simulation, PreStepForward), Z_Construct_UDelegateFunction_AGXUnreal_OnPreStepForward__DelegateSignature, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_PreStepForward_MetaData), Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_PreStepForward_MetaData) }; // 4223958529
#if WITH_METADATA
	const UECodeGen_Private::FMetaDataPairParam Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_PostStepForward_MetaData[] = {
		{ "Category", "Simulation" },
		{ "Comment", "/**\n\x09 * Delegate that is executed after each Simulation step forward.\n\x09 * Users may bind to this delegate in order to get a callback after each Simulation step\n\x09 * forward. This may be executed zero, one or several times per Unreal Engine Tick, depending on\n\x09 * the Step Mode and Time Step selected in the AGX Dynamics for Unreal settings.\n\x09 */" },
		{ "ModuleRelativePath", "Public/AGX_Simulation.h" },
		{ "ToolTip", "Delegate that is executed after each Simulation step forward.\nUsers may bind to this delegate in order to get a callback after each Simulation step\nforward. This may be executed zero, one or several times per Unreal Engine Tick, depending on\nthe Step Mode and Time Step selected in the AGX Dynamics for Unreal settings." },
	};
#endif
	const UECodeGen_Private::FMulticastDelegatePropertyParams Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_PostStepForward = { "PostStepForward", nullptr, (EPropertyFlags)0x0010000010080000, UECodeGen_Private::EPropertyGenFlags::InlineMulticastDelegate, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(UAGX_Simulation, PostStepForward), Z_Construct_UDelegateFunction_AGXUnreal_OnPostStepForward__DelegateSignature, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_PostStepForward_MetaData), Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_PostStepForward_MetaData) }; // 3443893351
	const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UClass_UAGX_Simulation_Statics::PropPointers[] = {
		(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_NumThreads,
		(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_TimeStep,
		(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_bContactWarmstarting,
		(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_bOverridePPGSIterations,
		(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_NumPpgsIterations,
		(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_GravityModel,
		(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_UniformGravity,
		(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_PointGravityOrigin,
		(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_PointGravityMagnitude,
		(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_StepMode,
		(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_TimeLagCap,
		(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_bEnableStatistics,
		(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_bEnableAMOR,
		(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_GlobalShapeContactMergeSplitThresholds,
		(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_GlobalConstraintMergeSplitThresholds,
		(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_GlobalWireMergeSplitThresholds,
#if WITH_EDITORONLY_DATA
		(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_bExportInitialState,
		(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_ExportPath,
#endif // WITH_EDITORONLY_DATA
		(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_bRemoteDebugging,
		(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_RemoteDebuggingPort,
		(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_ConstraintVisualizationScalingDistanceMax,
		(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_PreStepForward,
		(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UAGX_Simulation_Statics::NewProp_PostStepForward,
	};
	const FCppClassTypeInfoStatic Z_Construct_UClass_UAGX_Simulation_Statics::StaticCppClassTypeInfo = {
		TCppClassTypeTraits<UAGX_Simulation>::IsAbstract,
	};
	const UECodeGen_Private::FClassParams Z_Construct_UClass_UAGX_Simulation_Statics::ClassParams = {
		&UAGX_Simulation::StaticClass,
		"Engine",
		&StaticCppClassTypeInfo,
		DependentSingletons,
		FuncInfo,
		Z_Construct_UClass_UAGX_Simulation_Statics::PropPointers,
		nullptr,
		UE_ARRAY_COUNT(DependentSingletons),
		UE_ARRAY_COUNT(FuncInfo),
		UE_ARRAY_COUNT(Z_Construct_UClass_UAGX_Simulation_Statics::PropPointers),
		0,
		0x009000A6u,
		METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UClass_UAGX_Simulation_Statics::Class_MetaDataParams), Z_Construct_UClass_UAGX_Simulation_Statics::Class_MetaDataParams)
	};
	static_assert(UE_ARRAY_COUNT(Z_Construct_UClass_UAGX_Simulation_Statics::PropPointers) < 2048);
	UClass* Z_Construct_UClass_UAGX_Simulation()
	{
		if (!Z_Registration_Info_UClass_UAGX_Simulation.OuterSingleton)
		{
			UECodeGen_Private::ConstructUClass(Z_Registration_Info_UClass_UAGX_Simulation.OuterSingleton, Z_Construct_UClass_UAGX_Simulation_Statics::ClassParams);
		}
		return Z_Registration_Info_UClass_UAGX_Simulation.OuterSingleton;
	}
	template<> AGXUNREAL_API UClass* StaticClass<UAGX_Simulation>()
	{
		return UAGX_Simulation::StaticClass();
	}
	UAGX_Simulation::UAGX_Simulation() {}
	DEFINE_VTABLE_PTR_HELPER_CTOR(UAGX_Simulation);
	UAGX_Simulation::~UAGX_Simulation() {}
	struct Z_CompiledInDeferFile_FID_GitLab_Runner_builds_9YzzThLq_0_algoryx_unreal_agxunreal_staging_selfhosted_build_AGXUnreal_HostProject_Plugins_AGXUnreal_Source_AGXUnreal_Public_AGX_Simulation_h_Statics
	{
		static const FClassRegisterCompiledInInfo ClassInfo[];
	};
	const FClassRegisterCompiledInInfo Z_CompiledInDeferFile_FID_GitLab_Runner_builds_9YzzThLq_0_algoryx_unreal_agxunreal_staging_selfhosted_build_AGXUnreal_HostProject_Plugins_AGXUnreal_Source_AGXUnreal_Public_AGX_Simulation_h_Statics::ClassInfo[] = {
		{ Z_Construct_UClass_UAGX_Simulation, UAGX_Simulation::StaticClass, TEXT("UAGX_Simulation"), &Z_Registration_Info_UClass_UAGX_Simulation, CONSTRUCT_RELOAD_VERSION_INFO(FClassReloadVersionInfo, sizeof(UAGX_Simulation), 3905378834U) },
	};
	static FRegisterCompiledInInfo Z_CompiledInDeferFile_FID_GitLab_Runner_builds_9YzzThLq_0_algoryx_unreal_agxunreal_staging_selfhosted_build_AGXUnreal_HostProject_Plugins_AGXUnreal_Source_AGXUnreal_Public_AGX_Simulation_h_3897720167(TEXT("/Script/AGXUnreal"),
		Z_CompiledInDeferFile_FID_GitLab_Runner_builds_9YzzThLq_0_algoryx_unreal_agxunreal_staging_selfhosted_build_AGXUnreal_HostProject_Plugins_AGXUnreal_Source_AGXUnreal_Public_AGX_Simulation_h_Statics::ClassInfo, UE_ARRAY_COUNT(Z_CompiledInDeferFile_FID_GitLab_Runner_builds_9YzzThLq_0_algoryx_unreal_agxunreal_staging_selfhosted_build_AGXUnreal_HostProject_Plugins_AGXUnreal_Source_AGXUnreal_Public_AGX_Simulation_h_Statics::ClassInfo),
		nullptr, 0,
		nullptr, 0);
PRAGMA_ENABLE_DEPRECATION_WARNINGS
