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

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

#include "UObject/GeneratedCppIncludes.h"
#include "Kismet/BlueprintSpringMathLibrary.h"

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

// ********** Begin Cross Module References ********************************************************
COREUOBJECT_API UScriptStruct* Z_Construct_UScriptStruct_FQuat();
COREUOBJECT_API UScriptStruct* Z_Construct_UScriptStruct_FRotator();
COREUOBJECT_API UScriptStruct* Z_Construct_UScriptStruct_FVector();
COREUOBJECT_API UScriptStruct* Z_Construct_UScriptStruct_FVector2D();
ENGINE_API UClass* Z_Construct_UClass_UBlueprintFunctionLibrary();
ENGINE_API UClass* Z_Construct_UClass_UBlueprintSpringMathLibrary();
ENGINE_API UClass* Z_Construct_UClass_UBlueprintSpringMathLibrary_NoRegister();
UPackage* Z_Construct_UPackage__Script_Engine();
// ********** End Cross Module References **********************************************************

// ********** Begin Class UBlueprintSpringMathLibrary Function ConvertHalfLifeToSmoothingTime ******
struct Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertHalfLifeToSmoothingTime_Statics
{
	struct BlueprintSpringMathLibrary_eventConvertHalfLifeToSmoothingTime_Parms
	{
		float HalfLife;
		float ReturnValue;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Category", "Math|Spring|Experimental" },
		{ "Comment", "/** Convert a halflife to a smoothing time\n \x09* \n \x09* @param HalfLife The half life of the spring. How long it takes the value to get halfway towards the target.\n \x09* @return The smoothing time of the spring in seconds. It is the time by which the output lags the input when critically damped, when the input is changing at a constant rate.\n \x09*/" },
		{ "ModuleRelativePath", "Classes/Kismet/BlueprintSpringMathLibrary.h" },
		{ "ToolTip", "Convert a halflife to a smoothing time\n\n@param HalfLife The half life of the spring. How long it takes the value to get halfway towards the target.\n@return The smoothing time of the spring in seconds. It is the time by which the output lags the input when critically damped, when the input is changing at a constant rate." },
	};
#endif // WITH_METADATA

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

// ********** Begin Function ConvertHalfLifeToSmoothingTime Property Definitions *******************
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertHalfLifeToSmoothingTime_Statics::NewProp_HalfLife = { "HalfLife", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventConvertHalfLifeToSmoothingTime_Parms, HalfLife), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertHalfLifeToSmoothingTime_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventConvertHalfLifeToSmoothingTime_Parms, ReturnValue), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertHalfLifeToSmoothingTime_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertHalfLifeToSmoothingTime_Statics::NewProp_HalfLife,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertHalfLifeToSmoothingTime_Statics::NewProp_ReturnValue,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertHalfLifeToSmoothingTime_Statics::PropPointers) < 2048);
// ********** End Function ConvertHalfLifeToSmoothingTime Property Definitions *********************
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertHalfLifeToSmoothingTime_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UBlueprintSpringMathLibrary, nullptr, "ConvertHalfLifeToSmoothingTime", 	Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertHalfLifeToSmoothingTime_Statics::PropPointers, 
	UE_ARRAY_COUNT(Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertHalfLifeToSmoothingTime_Statics::PropPointers), 
sizeof(Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertHalfLifeToSmoothingTime_Statics::BlueprintSpringMathLibrary_eventConvertHalfLifeToSmoothingTime_Parms),
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x14022403, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertHalfLifeToSmoothingTime_Statics::Function_MetaDataParams), Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertHalfLifeToSmoothingTime_Statics::Function_MetaDataParams)},  };
static_assert(sizeof(Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertHalfLifeToSmoothingTime_Statics::BlueprintSpringMathLibrary_eventConvertHalfLifeToSmoothingTime_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertHalfLifeToSmoothingTime()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertHalfLifeToSmoothingTime_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UBlueprintSpringMathLibrary::execConvertHalfLifeToSmoothingTime)
{
	P_GET_PROPERTY(FFloatProperty,Z_Param_HalfLife);
	P_FINISH;
	P_NATIVE_BEGIN;
	*(float*)Z_Param__Result=UBlueprintSpringMathLibrary::ConvertHalfLifeToSmoothingTime(Z_Param_HalfLife);
	P_NATIVE_END;
}
// ********** End Class UBlueprintSpringMathLibrary Function ConvertHalfLifeToSmoothingTime ********

// ********** Begin Class UBlueprintSpringMathLibrary Function ConvertSmoothingTimeToHalfLife ******
struct Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertSmoothingTimeToHalfLife_Statics
{
	struct BlueprintSpringMathLibrary_eventConvertSmoothingTimeToHalfLife_Parms
	{
		float SmoothingTime;
		float ReturnValue;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Category", "Math|Spring|Experimental" },
		{ "Comment", "/** Convert a smoothing time to a half life\n \x09* \n \x09* @param SmoothingTime The smoothing time of the spring in seconds. It is the time by which the output lags the input when critically damped, when the input is changing at a constant rate. \n \x09* @return The half life of the spring. How long it takes the value to get halfway towards the target. \n \x09*/" },
		{ "ModuleRelativePath", "Classes/Kismet/BlueprintSpringMathLibrary.h" },
		{ "ToolTip", "Convert a smoothing time to a half life\n\n@param SmoothingTime The smoothing time of the spring in seconds. It is the time by which the output lags the input when critically damped, when the input is changing at a constant rate.\n@return The half life of the spring. How long it takes the value to get halfway towards the target." },
	};
#endif // WITH_METADATA

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

// ********** Begin Function ConvertSmoothingTimeToHalfLife Property Definitions *******************
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertSmoothingTimeToHalfLife_Statics::NewProp_SmoothingTime = { "SmoothingTime", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventConvertSmoothingTimeToHalfLife_Parms, SmoothingTime), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertSmoothingTimeToHalfLife_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventConvertSmoothingTimeToHalfLife_Parms, ReturnValue), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertSmoothingTimeToHalfLife_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertSmoothingTimeToHalfLife_Statics::NewProp_SmoothingTime,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertSmoothingTimeToHalfLife_Statics::NewProp_ReturnValue,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertSmoothingTimeToHalfLife_Statics::PropPointers) < 2048);
// ********** End Function ConvertSmoothingTimeToHalfLife Property Definitions *********************
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertSmoothingTimeToHalfLife_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UBlueprintSpringMathLibrary, nullptr, "ConvertSmoothingTimeToHalfLife", 	Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertSmoothingTimeToHalfLife_Statics::PropPointers, 
	UE_ARRAY_COUNT(Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertSmoothingTimeToHalfLife_Statics::PropPointers), 
sizeof(Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertSmoothingTimeToHalfLife_Statics::BlueprintSpringMathLibrary_eventConvertSmoothingTimeToHalfLife_Parms),
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x14022403, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertSmoothingTimeToHalfLife_Statics::Function_MetaDataParams), Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertSmoothingTimeToHalfLife_Statics::Function_MetaDataParams)},  };
static_assert(sizeof(Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertSmoothingTimeToHalfLife_Statics::BlueprintSpringMathLibrary_eventConvertSmoothingTimeToHalfLife_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertSmoothingTimeToHalfLife()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertSmoothingTimeToHalfLife_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UBlueprintSpringMathLibrary::execConvertSmoothingTimeToHalfLife)
{
	P_GET_PROPERTY(FFloatProperty,Z_Param_SmoothingTime);
	P_FINISH;
	P_NATIVE_BEGIN;
	*(float*)Z_Param__Result=UBlueprintSpringMathLibrary::ConvertSmoothingTimeToHalfLife(Z_Param_SmoothingTime);
	P_NATIVE_END;
}
// ********** End Class UBlueprintSpringMathLibrary Function ConvertSmoothingTimeToHalfLife ********

// ********** Begin Class UBlueprintSpringMathLibrary Function ConvertSmoothingTimeToStrength ******
struct Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertSmoothingTimeToStrength_Statics
{
	struct BlueprintSpringMathLibrary_eventConvertSmoothingTimeToStrength_Parms
	{
		float SmoothingTime;
		float ReturnValue;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Category", "Math|Spring|Experimental" },
		{ "Comment", "/** Convert from smoothing time to spring strength.\n\x09* \n\x09* @param SmoothingTime The smoothing time of the spring in seconds. It is the time by which the output lags the input when critically damped, when the input is changing at a constant rate.\n\x09* @return The spring strength. This corresponds to the undamped frequency of the spring in hz.\n\x09*/" },
		{ "ModuleRelativePath", "Classes/Kismet/BlueprintSpringMathLibrary.h" },
		{ "ToolTip", "Convert from smoothing time to spring strength.\n\n@param SmoothingTime The smoothing time of the spring in seconds. It is the time by which the output lags the input when critically damped, when the input is changing at a constant rate.\n@return The spring strength. This corresponds to the undamped frequency of the spring in hz." },
	};
#endif // WITH_METADATA

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

// ********** Begin Function ConvertSmoothingTimeToStrength Property Definitions *******************
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertSmoothingTimeToStrength_Statics::NewProp_SmoothingTime = { "SmoothingTime", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventConvertSmoothingTimeToStrength_Parms, SmoothingTime), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertSmoothingTimeToStrength_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventConvertSmoothingTimeToStrength_Parms, ReturnValue), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertSmoothingTimeToStrength_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertSmoothingTimeToStrength_Statics::NewProp_SmoothingTime,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertSmoothingTimeToStrength_Statics::NewProp_ReturnValue,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertSmoothingTimeToStrength_Statics::PropPointers) < 2048);
// ********** End Function ConvertSmoothingTimeToStrength Property Definitions *********************
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertSmoothingTimeToStrength_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UBlueprintSpringMathLibrary, nullptr, "ConvertSmoothingTimeToStrength", 	Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertSmoothingTimeToStrength_Statics::PropPointers, 
	UE_ARRAY_COUNT(Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertSmoothingTimeToStrength_Statics::PropPointers), 
sizeof(Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertSmoothingTimeToStrength_Statics::BlueprintSpringMathLibrary_eventConvertSmoothingTimeToStrength_Parms),
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x14022403, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertSmoothingTimeToStrength_Statics::Function_MetaDataParams), Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertSmoothingTimeToStrength_Statics::Function_MetaDataParams)},  };
static_assert(sizeof(Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertSmoothingTimeToStrength_Statics::BlueprintSpringMathLibrary_eventConvertSmoothingTimeToStrength_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertSmoothingTimeToStrength()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertSmoothingTimeToStrength_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UBlueprintSpringMathLibrary::execConvertSmoothingTimeToStrength)
{
	P_GET_PROPERTY(FFloatProperty,Z_Param_SmoothingTime);
	P_FINISH;
	P_NATIVE_BEGIN;
	*(float*)Z_Param__Result=UBlueprintSpringMathLibrary::ConvertSmoothingTimeToStrength(Z_Param_SmoothingTime);
	P_NATIVE_END;
}
// ********** End Class UBlueprintSpringMathLibrary Function ConvertSmoothingTimeToStrength ********

// ********** Begin Class UBlueprintSpringMathLibrary Function ConvertStrengthToSmoothingTime ******
struct Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertStrengthToSmoothingTime_Statics
{
	struct BlueprintSpringMathLibrary_eventConvertStrengthToSmoothingTime_Parms
	{
		float Strength;
		float ReturnValue;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Category", "Math|Spring|Experimental" },
		{ "Comment", "/** Convert from spring strength to smoothing time.\n \x09* \n \x09* @param Strength The spring strength. This corresponds to the undamped frequency of the spring in hz.\n \x09* @return The smoothing time of the spring in seconds. It is the time by which the output lags the input when critically damped, when the input is changing at a constant rate.\n \x09*/" },
		{ "ModuleRelativePath", "Classes/Kismet/BlueprintSpringMathLibrary.h" },
		{ "ToolTip", "Convert from spring strength to smoothing time.\n\n@param Strength The spring strength. This corresponds to the undamped frequency of the spring in hz.\n@return The smoothing time of the spring in seconds. It is the time by which the output lags the input when critically damped, when the input is changing at a constant rate." },
	};
#endif // WITH_METADATA

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

// ********** Begin Function ConvertStrengthToSmoothingTime Property Definitions *******************
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertStrengthToSmoothingTime_Statics::NewProp_Strength = { "Strength", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventConvertStrengthToSmoothingTime_Parms, Strength), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertStrengthToSmoothingTime_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventConvertStrengthToSmoothingTime_Parms, ReturnValue), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertStrengthToSmoothingTime_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertStrengthToSmoothingTime_Statics::NewProp_Strength,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertStrengthToSmoothingTime_Statics::NewProp_ReturnValue,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertStrengthToSmoothingTime_Statics::PropPointers) < 2048);
// ********** End Function ConvertStrengthToSmoothingTime Property Definitions *********************
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertStrengthToSmoothingTime_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UBlueprintSpringMathLibrary, nullptr, "ConvertStrengthToSmoothingTime", 	Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertStrengthToSmoothingTime_Statics::PropPointers, 
	UE_ARRAY_COUNT(Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertStrengthToSmoothingTime_Statics::PropPointers), 
sizeof(Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertStrengthToSmoothingTime_Statics::BlueprintSpringMathLibrary_eventConvertStrengthToSmoothingTime_Parms),
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x14022403, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertStrengthToSmoothingTime_Statics::Function_MetaDataParams), Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertStrengthToSmoothingTime_Statics::Function_MetaDataParams)},  };
static_assert(sizeof(Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertStrengthToSmoothingTime_Statics::BlueprintSpringMathLibrary_eventConvertStrengthToSmoothingTime_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertStrengthToSmoothingTime()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertStrengthToSmoothingTime_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UBlueprintSpringMathLibrary::execConvertStrengthToSmoothingTime)
{
	P_GET_PROPERTY(FFloatProperty,Z_Param_Strength);
	P_FINISH;
	P_NATIVE_BEGIN;
	*(float*)Z_Param__Result=UBlueprintSpringMathLibrary::ConvertStrengthToSmoothingTime(Z_Param_Strength);
	P_NATIVE_END;
}
// ********** End Class UBlueprintSpringMathLibrary Function ConvertStrengthToSmoothingTime ********

// ********** Begin Class UBlueprintSpringMathLibrary Function CriticalSpringDampAngle *************
struct Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampAngle_Statics
{
	struct BlueprintSpringMathLibrary_eventCriticalSpringDampAngle_Parms
	{
		float InOutAngle;
		float InOutAngularVelocity;
		float TargetAngle;
		float DeltaTime;
		float SmoothingTime;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Category", "Math|Spring|Experimental" },
		{ "Comment", "/** Interpolates the angle InOutAngle towards TargetAngle with the motion of a critically damped spring. The velocity of InOutAngle is stored in InOutAngularVelocity in deg/s.\n\x09 *\n\x09 * @param InOutAngle The value to be damped in degrees\n\x09 * @param InOutAngularVelocity The speed of the value to be damped in deg/s\n\x09 * @param TargetAngle The goal to damp towards in degrees\n\x09 * @param SmoothingTime The smoothing time to use for the spring. Longer times lead to more damped behaviour. A time of 0 will snap InOutAngle to TargetX\n\x09 * @param DeltaTime Timestep in seconds\n\x09 */" },
		{ "CPP_Default_SmoothingTime", "0.200000" },
		{ "ModuleRelativePath", "Classes/Kismet/BlueprintSpringMathLibrary.h" },
		{ "ToolTip", "Interpolates the angle InOutAngle towards TargetAngle with the motion of a critically damped spring. The velocity of InOutAngle is stored in InOutAngularVelocity in deg/s.\n\n@param InOutAngle The value to be damped in degrees\n@param InOutAngularVelocity The speed of the value to be damped in deg/s\n@param TargetAngle The goal to damp towards in degrees\n@param SmoothingTime The smoothing time to use for the spring. Longer times lead to more damped behaviour. A time of 0 will snap InOutAngle to TargetX\n@param DeltaTime Timestep in seconds" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_TargetAngle_MetaData[] = {
		{ "NativeConst", "" },
	};
#endif // WITH_METADATA

// ********** Begin Function CriticalSpringDampAngle constinit property declarations ***************
	static const UECodeGen_Private::FFloatPropertyParams NewProp_InOutAngle;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_InOutAngularVelocity;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_TargetAngle;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_DeltaTime;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_SmoothingTime;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End Function CriticalSpringDampAngle constinit property declarations *****************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};

// ********** Begin Function CriticalSpringDampAngle Property Definitions **************************
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampAngle_Statics::NewProp_InOutAngle = { "InOutAngle", nullptr, (EPropertyFlags)0x0010000008000180, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventCriticalSpringDampAngle_Parms, InOutAngle), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampAngle_Statics::NewProp_InOutAngularVelocity = { "InOutAngularVelocity", nullptr, (EPropertyFlags)0x0010000008000180, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventCriticalSpringDampAngle_Parms, InOutAngularVelocity), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampAngle_Statics::NewProp_TargetAngle = { "TargetAngle", nullptr, (EPropertyFlags)0x0010000008000182, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventCriticalSpringDampAngle_Parms, TargetAngle), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_TargetAngle_MetaData), NewProp_TargetAngle_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampAngle_Statics::NewProp_DeltaTime = { "DeltaTime", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventCriticalSpringDampAngle_Parms, DeltaTime), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampAngle_Statics::NewProp_SmoothingTime = { "SmoothingTime", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventCriticalSpringDampAngle_Parms, SmoothingTime), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampAngle_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampAngle_Statics::NewProp_InOutAngle,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampAngle_Statics::NewProp_InOutAngularVelocity,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampAngle_Statics::NewProp_TargetAngle,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampAngle_Statics::NewProp_DeltaTime,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampAngle_Statics::NewProp_SmoothingTime,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampAngle_Statics::PropPointers) < 2048);
// ********** End Function CriticalSpringDampAngle Property Definitions ****************************
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampAngle_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UBlueprintSpringMathLibrary, nullptr, "CriticalSpringDampAngle", 	Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampAngle_Statics::PropPointers, 
	UE_ARRAY_COUNT(Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampAngle_Statics::PropPointers), 
sizeof(Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampAngle_Statics::BlueprintSpringMathLibrary_eventCriticalSpringDampAngle_Parms),
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04422403, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampAngle_Statics::Function_MetaDataParams), Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampAngle_Statics::Function_MetaDataParams)},  };
static_assert(sizeof(Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampAngle_Statics::BlueprintSpringMathLibrary_eventCriticalSpringDampAngle_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampAngle()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampAngle_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UBlueprintSpringMathLibrary::execCriticalSpringDampAngle)
{
	P_GET_PROPERTY_REF(FFloatProperty,Z_Param_Out_InOutAngle);
	P_GET_PROPERTY_REF(FFloatProperty,Z_Param_Out_InOutAngularVelocity);
	P_GET_PROPERTY_REF(FFloatProperty,Z_Param_Out_TargetAngle);
	P_GET_PROPERTY(FFloatProperty,Z_Param_DeltaTime);
	P_GET_PROPERTY(FFloatProperty,Z_Param_SmoothingTime);
	P_FINISH;
	P_NATIVE_BEGIN;
	UBlueprintSpringMathLibrary::CriticalSpringDampAngle(Z_Param_Out_InOutAngle,Z_Param_Out_InOutAngularVelocity,Z_Param_Out_TargetAngle,Z_Param_DeltaTime,Z_Param_SmoothingTime);
	P_NATIVE_END;
}
// ********** End Class UBlueprintSpringMathLibrary Function CriticalSpringDampAngle ***************

// ********** Begin Class UBlueprintSpringMathLibrary Function CriticalSpringDampFloat *************
struct Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampFloat_Statics
{
	struct BlueprintSpringMathLibrary_eventCriticalSpringDampFloat_Parms
	{
		float InOutX;
		float InOutV;
		float TargetX;
		float DeltaTime;
		float SmoothingTime;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Category", "Math|Spring|Experimental" },
		{ "Comment", "/** Interpolates the value InOutX towards TargetX with the motion of a critically damped spring. The velocity of X is stored in InOutV.\n\x09 * \n\x09 * @param InOutX The value to be damped\n\x09 * @param InOutV The speed of the value to be damped\n\x09 * @param TargetX The goal to damp towards\n\x09 * @param SmoothingTime The smoothing time to use for the spring. Longer times lead to more damped behaviour. A time of 0 will snap InOutX to TargetX\n\x09 * @param DeltaTime Timestep in seconds\n\x09 */" },
		{ "CPP_Default_SmoothingTime", "0.200000" },
		{ "ModuleRelativePath", "Classes/Kismet/BlueprintSpringMathLibrary.h" },
		{ "ToolTip", "Interpolates the value InOutX towards TargetX with the motion of a critically damped spring. The velocity of X is stored in InOutV.\n\n@param InOutX The value to be damped\n@param InOutV The speed of the value to be damped\n@param TargetX The goal to damp towards\n@param SmoothingTime The smoothing time to use for the spring. Longer times lead to more damped behaviour. A time of 0 will snap InOutX to TargetX\n@param DeltaTime Timestep in seconds" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_TargetX_MetaData[] = {
		{ "NativeConst", "" },
	};
#endif // WITH_METADATA

// ********** Begin Function CriticalSpringDampFloat constinit property declarations ***************
	static const UECodeGen_Private::FFloatPropertyParams NewProp_InOutX;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_InOutV;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_TargetX;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_DeltaTime;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_SmoothingTime;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End Function CriticalSpringDampFloat constinit property declarations *****************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};

// ********** Begin Function CriticalSpringDampFloat Property Definitions **************************
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampFloat_Statics::NewProp_InOutX = { "InOutX", nullptr, (EPropertyFlags)0x0010000008000180, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventCriticalSpringDampFloat_Parms, InOutX), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampFloat_Statics::NewProp_InOutV = { "InOutV", nullptr, (EPropertyFlags)0x0010000008000180, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventCriticalSpringDampFloat_Parms, InOutV), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampFloat_Statics::NewProp_TargetX = { "TargetX", nullptr, (EPropertyFlags)0x0010000008000182, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventCriticalSpringDampFloat_Parms, TargetX), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_TargetX_MetaData), NewProp_TargetX_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampFloat_Statics::NewProp_DeltaTime = { "DeltaTime", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventCriticalSpringDampFloat_Parms, DeltaTime), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampFloat_Statics::NewProp_SmoothingTime = { "SmoothingTime", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventCriticalSpringDampFloat_Parms, SmoothingTime), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampFloat_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampFloat_Statics::NewProp_InOutX,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampFloat_Statics::NewProp_InOutV,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampFloat_Statics::NewProp_TargetX,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampFloat_Statics::NewProp_DeltaTime,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampFloat_Statics::NewProp_SmoothingTime,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampFloat_Statics::PropPointers) < 2048);
// ********** End Function CriticalSpringDampFloat Property Definitions ****************************
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampFloat_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UBlueprintSpringMathLibrary, nullptr, "CriticalSpringDampFloat", 	Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampFloat_Statics::PropPointers, 
	UE_ARRAY_COUNT(Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampFloat_Statics::PropPointers), 
sizeof(Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampFloat_Statics::BlueprintSpringMathLibrary_eventCriticalSpringDampFloat_Parms),
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04422403, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampFloat_Statics::Function_MetaDataParams), Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampFloat_Statics::Function_MetaDataParams)},  };
static_assert(sizeof(Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampFloat_Statics::BlueprintSpringMathLibrary_eventCriticalSpringDampFloat_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampFloat()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampFloat_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UBlueprintSpringMathLibrary::execCriticalSpringDampFloat)
{
	P_GET_PROPERTY_REF(FFloatProperty,Z_Param_Out_InOutX);
	P_GET_PROPERTY_REF(FFloatProperty,Z_Param_Out_InOutV);
	P_GET_PROPERTY_REF(FFloatProperty,Z_Param_Out_TargetX);
	P_GET_PROPERTY(FFloatProperty,Z_Param_DeltaTime);
	P_GET_PROPERTY(FFloatProperty,Z_Param_SmoothingTime);
	P_FINISH;
	P_NATIVE_BEGIN;
	UBlueprintSpringMathLibrary::CriticalSpringDampFloat(Z_Param_Out_InOutX,Z_Param_Out_InOutV,Z_Param_Out_TargetX,Z_Param_DeltaTime,Z_Param_SmoothingTime);
	P_NATIVE_END;
}
// ********** End Class UBlueprintSpringMathLibrary Function CriticalSpringDampFloat ***************

// ********** Begin Class UBlueprintSpringMathLibrary Function CriticalSpringDampQuat **************
struct Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampQuat_Statics
{
	struct BlueprintSpringMathLibrary_eventCriticalSpringDampQuat_Parms
	{
		FQuat InOutRotation;
		FVector InOutAngularVelocity;
		FQuat TargetRotation;
		float DeltaTime;
		float SmoothingTime;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Category", "Math|Spring|Experimental" },
		{ "Comment", "/** Interpolates the value InOutRotation towards TargetRotation with the motion of a critically damped spring. The velocity of InOutRotation is stored in InOutAngularVelocity in deg/s.\n\x09 *\n\x09 * @param InOutRotation The value to be damped\n\x09 * @param InOutAngularVelocity The speed of the value to be damped in deg/s\n\x09 * @param TargetRotation The goal to damp towards\n\x09 * @param SmoothingTime The smoothing time to use for the spring. Longer times lead to more damped behaviour. A time of 0 will snap InOutRotation to TargetRotation\n\x09 * @param DeltaTime Timestep in seconds\n\x09 */" },
		{ "CPP_Default_SmoothingTime", "0.200000" },
		{ "ModuleRelativePath", "Classes/Kismet/BlueprintSpringMathLibrary.h" },
		{ "ToolTip", "Interpolates the value InOutRotation towards TargetRotation with the motion of a critically damped spring. The velocity of InOutRotation is stored in InOutAngularVelocity in deg/s.\n\n@param InOutRotation The value to be damped\n@param InOutAngularVelocity The speed of the value to be damped in deg/s\n@param TargetRotation The goal to damp towards\n@param SmoothingTime The smoothing time to use for the spring. Longer times lead to more damped behaviour. A time of 0 will snap InOutRotation to TargetRotation\n@param DeltaTime Timestep in seconds" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_TargetRotation_MetaData[] = {
		{ "NativeConst", "" },
	};
#endif // WITH_METADATA

// ********** Begin Function CriticalSpringDampQuat constinit property declarations ****************
	static const UECodeGen_Private::FStructPropertyParams NewProp_InOutRotation;
	static const UECodeGen_Private::FStructPropertyParams NewProp_InOutAngularVelocity;
	static const UECodeGen_Private::FStructPropertyParams NewProp_TargetRotation;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_DeltaTime;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_SmoothingTime;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End Function CriticalSpringDampQuat constinit property declarations ******************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};

// ********** Begin Function CriticalSpringDampQuat Property Definitions ***************************
const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampQuat_Statics::NewProp_InOutRotation = { "InOutRotation", nullptr, (EPropertyFlags)0x0010000008000180, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventCriticalSpringDampQuat_Parms, InOutRotation), Z_Construct_UScriptStruct_FQuat, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampQuat_Statics::NewProp_InOutAngularVelocity = { "InOutAngularVelocity", nullptr, (EPropertyFlags)0x0010000008000180, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventCriticalSpringDampQuat_Parms, InOutAngularVelocity), Z_Construct_UScriptStruct_FVector, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampQuat_Statics::NewProp_TargetRotation = { "TargetRotation", nullptr, (EPropertyFlags)0x0010000008000182, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventCriticalSpringDampQuat_Parms, TargetRotation), Z_Construct_UScriptStruct_FQuat, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_TargetRotation_MetaData), NewProp_TargetRotation_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampQuat_Statics::NewProp_DeltaTime = { "DeltaTime", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventCriticalSpringDampQuat_Parms, DeltaTime), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampQuat_Statics::NewProp_SmoothingTime = { "SmoothingTime", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventCriticalSpringDampQuat_Parms, SmoothingTime), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampQuat_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampQuat_Statics::NewProp_InOutRotation,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampQuat_Statics::NewProp_InOutAngularVelocity,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampQuat_Statics::NewProp_TargetRotation,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampQuat_Statics::NewProp_DeltaTime,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampQuat_Statics::NewProp_SmoothingTime,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampQuat_Statics::PropPointers) < 2048);
// ********** End Function CriticalSpringDampQuat Property Definitions *****************************
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampQuat_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UBlueprintSpringMathLibrary, nullptr, "CriticalSpringDampQuat", 	Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampQuat_Statics::PropPointers, 
	UE_ARRAY_COUNT(Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampQuat_Statics::PropPointers), 
sizeof(Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampQuat_Statics::BlueprintSpringMathLibrary_eventCriticalSpringDampQuat_Parms),
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04C22403, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampQuat_Statics::Function_MetaDataParams), Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampQuat_Statics::Function_MetaDataParams)},  };
static_assert(sizeof(Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampQuat_Statics::BlueprintSpringMathLibrary_eventCriticalSpringDampQuat_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampQuat()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampQuat_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UBlueprintSpringMathLibrary::execCriticalSpringDampQuat)
{
	P_GET_STRUCT_REF(FQuat,Z_Param_Out_InOutRotation);
	P_GET_STRUCT_REF(FVector,Z_Param_Out_InOutAngularVelocity);
	P_GET_STRUCT_REF(FQuat,Z_Param_Out_TargetRotation);
	P_GET_PROPERTY(FFloatProperty,Z_Param_DeltaTime);
	P_GET_PROPERTY(FFloatProperty,Z_Param_SmoothingTime);
	P_FINISH;
	P_NATIVE_BEGIN;
	UBlueprintSpringMathLibrary::CriticalSpringDampQuat(Z_Param_Out_InOutRotation,Z_Param_Out_InOutAngularVelocity,Z_Param_Out_TargetRotation,Z_Param_DeltaTime,Z_Param_SmoothingTime);
	P_NATIVE_END;
}
// ********** End Class UBlueprintSpringMathLibrary Function CriticalSpringDampQuat ****************

// ********** Begin Class UBlueprintSpringMathLibrary Function CriticalSpringDampRotator ***********
struct Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampRotator_Statics
{
	struct BlueprintSpringMathLibrary_eventCriticalSpringDampRotator_Parms
	{
		FRotator InOutRotation;
		FVector InOutAngularVelocity;
		FRotator TargetRotation;
		float DeltaTime;
		float SmoothingTime;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Category", "Math|Spring|Experimental" },
		{ "Comment", "/** Interpolates the value InOutRotation towards TargetRotation with the motion of a critically damped spring. The velocity of InOutRotation is stored in InOutAngularVelocity in deg/s.\n\x09 *\n\x09 * @param InOutRotation The value to be damped\n\x09 * @param InOutAngularVelocity The speed of the value to be damped in deg/s\n\x09 * @param TargetRotation The goal to damp towards\n\x09 * @param SmoothingTime The smoothing time to use for the spring. Longer times lead to more damped behaviour. A time of 0 will snap InOutRotation to TargetRotation\n\x09 * @param DeltaTime Timestep in seconds\n\x09 */" },
		{ "CPP_Default_SmoothingTime", "0.200000" },
		{ "ModuleRelativePath", "Classes/Kismet/BlueprintSpringMathLibrary.h" },
		{ "ToolTip", "Interpolates the value InOutRotation towards TargetRotation with the motion of a critically damped spring. The velocity of InOutRotation is stored in InOutAngularVelocity in deg/s.\n\n@param InOutRotation The value to be damped\n@param InOutAngularVelocity The speed of the value to be damped in deg/s\n@param TargetRotation The goal to damp towards\n@param SmoothingTime The smoothing time to use for the spring. Longer times lead to more damped behaviour. A time of 0 will snap InOutRotation to TargetRotation\n@param DeltaTime Timestep in seconds" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_TargetRotation_MetaData[] = {
		{ "NativeConst", "" },
	};
#endif // WITH_METADATA

// ********** Begin Function CriticalSpringDampRotator constinit property declarations *************
	static const UECodeGen_Private::FStructPropertyParams NewProp_InOutRotation;
	static const UECodeGen_Private::FStructPropertyParams NewProp_InOutAngularVelocity;
	static const UECodeGen_Private::FStructPropertyParams NewProp_TargetRotation;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_DeltaTime;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_SmoothingTime;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End Function CriticalSpringDampRotator constinit property declarations ***************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};

// ********** Begin Function CriticalSpringDampRotator Property Definitions ************************
const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampRotator_Statics::NewProp_InOutRotation = { "InOutRotation", nullptr, (EPropertyFlags)0x0010000008000180, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventCriticalSpringDampRotator_Parms, InOutRotation), Z_Construct_UScriptStruct_FRotator, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampRotator_Statics::NewProp_InOutAngularVelocity = { "InOutAngularVelocity", nullptr, (EPropertyFlags)0x0010000008000180, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventCriticalSpringDampRotator_Parms, InOutAngularVelocity), Z_Construct_UScriptStruct_FVector, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampRotator_Statics::NewProp_TargetRotation = { "TargetRotation", nullptr, (EPropertyFlags)0x0010000008000182, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventCriticalSpringDampRotator_Parms, TargetRotation), Z_Construct_UScriptStruct_FRotator, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_TargetRotation_MetaData), NewProp_TargetRotation_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampRotator_Statics::NewProp_DeltaTime = { "DeltaTime", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventCriticalSpringDampRotator_Parms, DeltaTime), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampRotator_Statics::NewProp_SmoothingTime = { "SmoothingTime", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventCriticalSpringDampRotator_Parms, SmoothingTime), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampRotator_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampRotator_Statics::NewProp_InOutRotation,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampRotator_Statics::NewProp_InOutAngularVelocity,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampRotator_Statics::NewProp_TargetRotation,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampRotator_Statics::NewProp_DeltaTime,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampRotator_Statics::NewProp_SmoothingTime,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampRotator_Statics::PropPointers) < 2048);
// ********** End Function CriticalSpringDampRotator Property Definitions **************************
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampRotator_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UBlueprintSpringMathLibrary, nullptr, "CriticalSpringDampRotator", 	Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampRotator_Statics::PropPointers, 
	UE_ARRAY_COUNT(Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampRotator_Statics::PropPointers), 
sizeof(Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampRotator_Statics::BlueprintSpringMathLibrary_eventCriticalSpringDampRotator_Parms),
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04C22403, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampRotator_Statics::Function_MetaDataParams), Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampRotator_Statics::Function_MetaDataParams)},  };
static_assert(sizeof(Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampRotator_Statics::BlueprintSpringMathLibrary_eventCriticalSpringDampRotator_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampRotator()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampRotator_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UBlueprintSpringMathLibrary::execCriticalSpringDampRotator)
{
	P_GET_STRUCT_REF(FRotator,Z_Param_Out_InOutRotation);
	P_GET_STRUCT_REF(FVector,Z_Param_Out_InOutAngularVelocity);
	P_GET_STRUCT_REF(FRotator,Z_Param_Out_TargetRotation);
	P_GET_PROPERTY(FFloatProperty,Z_Param_DeltaTime);
	P_GET_PROPERTY(FFloatProperty,Z_Param_SmoothingTime);
	P_FINISH;
	P_NATIVE_BEGIN;
	UBlueprintSpringMathLibrary::CriticalSpringDampRotator(Z_Param_Out_InOutRotation,Z_Param_Out_InOutAngularVelocity,Z_Param_Out_TargetRotation,Z_Param_DeltaTime,Z_Param_SmoothingTime);
	P_NATIVE_END;
}
// ********** End Class UBlueprintSpringMathLibrary Function CriticalSpringDampRotator *************

// ********** Begin Class UBlueprintSpringMathLibrary Function CriticalSpringDampVector ************
struct Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampVector_Statics
{
	struct BlueprintSpringMathLibrary_eventCriticalSpringDampVector_Parms
	{
		FVector InOutX;
		FVector InOutV;
		FVector TargetX;
		float DeltaTime;
		float SmoothingTime;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Category", "Math|Spring|Experimental" },
		{ "Comment", "/** Interpolates the value InOutX towards TargetX with the motion of a critically damped spring. The velocity of X is stored in InOutV.\n\x09 * \n\x09 * @param InOutX The value to be damped\n\x09 * @param InOutV The speed of the value to be damped\n\x09 * @param TargetX The goal to damp towards\n\x09 * @param SmoothingTime The smoothing time to use for the spring. Longer times lead to more damped behaviour. A time of 0 will snap InOutX to TargetX\n\x09 * @param DeltaTime Timestep in seconds\n\x09 */" },
		{ "CPP_Default_SmoothingTime", "0.200000" },
		{ "ModuleRelativePath", "Classes/Kismet/BlueprintSpringMathLibrary.h" },
		{ "ToolTip", "Interpolates the value InOutX towards TargetX with the motion of a critically damped spring. The velocity of X is stored in InOutV.\n\n@param InOutX The value to be damped\n@param InOutV The speed of the value to be damped\n@param TargetX The goal to damp towards\n@param SmoothingTime The smoothing time to use for the spring. Longer times lead to more damped behaviour. A time of 0 will snap InOutX to TargetX\n@param DeltaTime Timestep in seconds" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_TargetX_MetaData[] = {
		{ "NativeConst", "" },
	};
#endif // WITH_METADATA

// ********** Begin Function CriticalSpringDampVector constinit property declarations **************
	static const UECodeGen_Private::FStructPropertyParams NewProp_InOutX;
	static const UECodeGen_Private::FStructPropertyParams NewProp_InOutV;
	static const UECodeGen_Private::FStructPropertyParams NewProp_TargetX;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_DeltaTime;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_SmoothingTime;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End Function CriticalSpringDampVector constinit property declarations ****************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};

// ********** Begin Function CriticalSpringDampVector Property Definitions *************************
const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampVector_Statics::NewProp_InOutX = { "InOutX", nullptr, (EPropertyFlags)0x0010000008000180, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventCriticalSpringDampVector_Parms, InOutX), Z_Construct_UScriptStruct_FVector, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampVector_Statics::NewProp_InOutV = { "InOutV", nullptr, (EPropertyFlags)0x0010000008000180, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventCriticalSpringDampVector_Parms, InOutV), Z_Construct_UScriptStruct_FVector, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampVector_Statics::NewProp_TargetX = { "TargetX", nullptr, (EPropertyFlags)0x0010000008000182, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventCriticalSpringDampVector_Parms, TargetX), Z_Construct_UScriptStruct_FVector, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_TargetX_MetaData), NewProp_TargetX_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampVector_Statics::NewProp_DeltaTime = { "DeltaTime", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventCriticalSpringDampVector_Parms, DeltaTime), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampVector_Statics::NewProp_SmoothingTime = { "SmoothingTime", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventCriticalSpringDampVector_Parms, SmoothingTime), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampVector_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampVector_Statics::NewProp_InOutX,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampVector_Statics::NewProp_InOutV,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampVector_Statics::NewProp_TargetX,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampVector_Statics::NewProp_DeltaTime,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampVector_Statics::NewProp_SmoothingTime,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampVector_Statics::PropPointers) < 2048);
// ********** End Function CriticalSpringDampVector Property Definitions ***************************
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampVector_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UBlueprintSpringMathLibrary, nullptr, "CriticalSpringDampVector", 	Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampVector_Statics::PropPointers, 
	UE_ARRAY_COUNT(Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampVector_Statics::PropPointers), 
sizeof(Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampVector_Statics::BlueprintSpringMathLibrary_eventCriticalSpringDampVector_Parms),
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04C22403, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampVector_Statics::Function_MetaDataParams), Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampVector_Statics::Function_MetaDataParams)},  };
static_assert(sizeof(Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampVector_Statics::BlueprintSpringMathLibrary_eventCriticalSpringDampVector_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampVector()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampVector_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UBlueprintSpringMathLibrary::execCriticalSpringDampVector)
{
	P_GET_STRUCT_REF(FVector,Z_Param_Out_InOutX);
	P_GET_STRUCT_REF(FVector,Z_Param_Out_InOutV);
	P_GET_STRUCT_REF(FVector,Z_Param_Out_TargetX);
	P_GET_PROPERTY(FFloatProperty,Z_Param_DeltaTime);
	P_GET_PROPERTY(FFloatProperty,Z_Param_SmoothingTime);
	P_FINISH;
	P_NATIVE_BEGIN;
	UBlueprintSpringMathLibrary::CriticalSpringDampVector(Z_Param_Out_InOutX,Z_Param_Out_InOutV,Z_Param_Out_TargetX,Z_Param_DeltaTime,Z_Param_SmoothingTime);
	P_NATIVE_END;
}
// ********** End Class UBlueprintSpringMathLibrary Function CriticalSpringDampVector **************

// ********** Begin Class UBlueprintSpringMathLibrary Function CriticalSpringDampVector2D **********
struct Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampVector2D_Statics
{
	struct BlueprintSpringMathLibrary_eventCriticalSpringDampVector2D_Parms
	{
		FVector2D InOutX;
		FVector2D InOutV;
		FVector2D TargetX;
		float DeltaTime;
		float SmoothingTime;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Category", "Math|Spring|Experimental" },
		{ "Comment", "/** Interpolates the value InOutX towards TargetX with the motion of a critically damped spring. The velocity of X is stored in InOutV.\n\x09 * \n\x09 * @param InOutX The value to be damped\n\x09 * @param InOutV The speed of the value to be damped\n\x09 * @param TargetX The goal to damp towards\n\x09 * @param SmoothingTime The smoothing time to use for the spring. Longer times lead to more damped behaviour. A time of 0 will snap InOutX to TargetX\n\x09 * @param DeltaTime Timestep in seconds\n\x09 */" },
		{ "CPP_Default_SmoothingTime", "0.200000" },
		{ "ModuleRelativePath", "Classes/Kismet/BlueprintSpringMathLibrary.h" },
		{ "ToolTip", "Interpolates the value InOutX towards TargetX with the motion of a critically damped spring. The velocity of X is stored in InOutV.\n\n@param InOutX The value to be damped\n@param InOutV The speed of the value to be damped\n@param TargetX The goal to damp towards\n@param SmoothingTime The smoothing time to use for the spring. Longer times lead to more damped behaviour. A time of 0 will snap InOutX to TargetX\n@param DeltaTime Timestep in seconds" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_TargetX_MetaData[] = {
		{ "NativeConst", "" },
	};
#endif // WITH_METADATA

// ********** Begin Function CriticalSpringDampVector2D constinit property declarations ************
	static const UECodeGen_Private::FStructPropertyParams NewProp_InOutX;
	static const UECodeGen_Private::FStructPropertyParams NewProp_InOutV;
	static const UECodeGen_Private::FStructPropertyParams NewProp_TargetX;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_DeltaTime;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_SmoothingTime;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End Function CriticalSpringDampVector2D constinit property declarations **************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};

// ********** Begin Function CriticalSpringDampVector2D Property Definitions ***********************
const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampVector2D_Statics::NewProp_InOutX = { "InOutX", nullptr, (EPropertyFlags)0x0010000008000180, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventCriticalSpringDampVector2D_Parms, InOutX), Z_Construct_UScriptStruct_FVector2D, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampVector2D_Statics::NewProp_InOutV = { "InOutV", nullptr, (EPropertyFlags)0x0010000008000180, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventCriticalSpringDampVector2D_Parms, InOutV), Z_Construct_UScriptStruct_FVector2D, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampVector2D_Statics::NewProp_TargetX = { "TargetX", nullptr, (EPropertyFlags)0x0010000008000182, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventCriticalSpringDampVector2D_Parms, TargetX), Z_Construct_UScriptStruct_FVector2D, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_TargetX_MetaData), NewProp_TargetX_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampVector2D_Statics::NewProp_DeltaTime = { "DeltaTime", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventCriticalSpringDampVector2D_Parms, DeltaTime), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampVector2D_Statics::NewProp_SmoothingTime = { "SmoothingTime", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventCriticalSpringDampVector2D_Parms, SmoothingTime), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampVector2D_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampVector2D_Statics::NewProp_InOutX,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampVector2D_Statics::NewProp_InOutV,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampVector2D_Statics::NewProp_TargetX,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampVector2D_Statics::NewProp_DeltaTime,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampVector2D_Statics::NewProp_SmoothingTime,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampVector2D_Statics::PropPointers) < 2048);
// ********** End Function CriticalSpringDampVector2D Property Definitions *************************
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampVector2D_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UBlueprintSpringMathLibrary, nullptr, "CriticalSpringDampVector2D", 	Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampVector2D_Statics::PropPointers, 
	UE_ARRAY_COUNT(Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampVector2D_Statics::PropPointers), 
sizeof(Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampVector2D_Statics::BlueprintSpringMathLibrary_eventCriticalSpringDampVector2D_Parms),
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04C22403, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampVector2D_Statics::Function_MetaDataParams), Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampVector2D_Statics::Function_MetaDataParams)},  };
static_assert(sizeof(Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampVector2D_Statics::BlueprintSpringMathLibrary_eventCriticalSpringDampVector2D_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampVector2D()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampVector2D_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UBlueprintSpringMathLibrary::execCriticalSpringDampVector2D)
{
	P_GET_STRUCT_REF(FVector2D,Z_Param_Out_InOutX);
	P_GET_STRUCT_REF(FVector2D,Z_Param_Out_InOutV);
	P_GET_STRUCT_REF(FVector2D,Z_Param_Out_TargetX);
	P_GET_PROPERTY(FFloatProperty,Z_Param_DeltaTime);
	P_GET_PROPERTY(FFloatProperty,Z_Param_SmoothingTime);
	P_FINISH;
	P_NATIVE_BEGIN;
	UBlueprintSpringMathLibrary::CriticalSpringDampVector2D(Z_Param_Out_InOutX,Z_Param_Out_InOutV,Z_Param_Out_TargetX,Z_Param_DeltaTime,Z_Param_SmoothingTime);
	P_NATIVE_END;
}
// ********** End Class UBlueprintSpringMathLibrary Function CriticalSpringDampVector2D ************

// ********** Begin Class UBlueprintSpringMathLibrary Function DampAngle ***************************
struct Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampAngle_Statics
{
	struct BlueprintSpringMathLibrary_eventDampAngle_Parms
	{
		float Angle;
		float TargetAngle;
		float DeltaTime;
		float SmoothingTime;
		float ReturnValue;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Category", "Math|Spring|Experimental" },
		{ "Comment", "/**\n\x09 * Smooths an angle in degrees using exponential damping towards a target.\n\x09 *\n\x09 *\n\x09 * @param  Angle The angle to be smoothed in degrees\n\x09 * @param  TargetAngle The target to smooth towards in degrees\n\x09 * @param  DeltaTime Time interval\n\x09 * @param  SmoothingTime Timescale over which to smooth. Larger values result in more smoothed behaviour. Can be zero.\n\x09 */" },
		{ "CPP_Default_SmoothingTime", "0.200000" },
		{ "ModuleRelativePath", "Classes/Kismet/BlueprintSpringMathLibrary.h" },
		{ "ToolTip", "Smooths an angle in degrees using exponential damping towards a target.\n\n\n@param  Angle The angle to be smoothed in degrees\n@param  TargetAngle The target to smooth towards in degrees\n@param  DeltaTime Time interval\n@param  SmoothingTime Timescale over which to smooth. Larger values result in more smoothed behaviour. Can be zero." },
	};
#endif // WITH_METADATA

// ********** Begin Function DampAngle constinit property declarations *****************************
	static const UECodeGen_Private::FFloatPropertyParams NewProp_Angle;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_TargetAngle;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_DeltaTime;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_SmoothingTime;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_ReturnValue;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End Function DampAngle constinit property declarations *******************************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};

// ********** Begin Function DampAngle Property Definitions ****************************************
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampAngle_Statics::NewProp_Angle = { "Angle", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventDampAngle_Parms, Angle), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampAngle_Statics::NewProp_TargetAngle = { "TargetAngle", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventDampAngle_Parms, TargetAngle), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampAngle_Statics::NewProp_DeltaTime = { "DeltaTime", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventDampAngle_Parms, DeltaTime), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampAngle_Statics::NewProp_SmoothingTime = { "SmoothingTime", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventDampAngle_Parms, SmoothingTime), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampAngle_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventDampAngle_Parms, ReturnValue), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampAngle_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampAngle_Statics::NewProp_Angle,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampAngle_Statics::NewProp_TargetAngle,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampAngle_Statics::NewProp_DeltaTime,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampAngle_Statics::NewProp_SmoothingTime,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampAngle_Statics::NewProp_ReturnValue,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampAngle_Statics::PropPointers) < 2048);
// ********** End Function DampAngle Property Definitions ******************************************
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampAngle_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UBlueprintSpringMathLibrary, nullptr, "DampAngle", 	Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampAngle_Statics::PropPointers, 
	UE_ARRAY_COUNT(Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampAngle_Statics::PropPointers), 
sizeof(Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampAngle_Statics::BlueprintSpringMathLibrary_eventDampAngle_Parms),
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x14022403, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampAngle_Statics::Function_MetaDataParams), Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampAngle_Statics::Function_MetaDataParams)},  };
static_assert(sizeof(Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampAngle_Statics::BlueprintSpringMathLibrary_eventDampAngle_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampAngle()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampAngle_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UBlueprintSpringMathLibrary::execDampAngle)
{
	P_GET_PROPERTY(FFloatProperty,Z_Param_Angle);
	P_GET_PROPERTY(FFloatProperty,Z_Param_TargetAngle);
	P_GET_PROPERTY(FFloatProperty,Z_Param_DeltaTime);
	P_GET_PROPERTY(FFloatProperty,Z_Param_SmoothingTime);
	P_FINISH;
	P_NATIVE_BEGIN;
	*(float*)Z_Param__Result=UBlueprintSpringMathLibrary::DampAngle(Z_Param_Angle,Z_Param_TargetAngle,Z_Param_DeltaTime,Z_Param_SmoothingTime);
	P_NATIVE_END;
}
// ********** End Class UBlueprintSpringMathLibrary Function DampAngle *****************************

// ********** Begin Class UBlueprintSpringMathLibrary Function DampFloat ***************************
struct Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampFloat_Statics
{
	struct BlueprintSpringMathLibrary_eventDampFloat_Parms
	{
		float Value;
		float Target;
		float DeltaTime;
		float SmoothingTime;
		float ReturnValue;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Category", "Math|Spring|Experimental" },
		{ "Comment", "/**\n\x09 * Smooths a value using exponential damping towards a target.\n\x09 * \n\x09 * \n\x09 * @param  Value The value to be smoothed\n\x09 * @param  Target The target to smooth towards\n\x09 * @param  DeltaTime Time interval\n\x09 * @param  SmoothingTime Timescale over which to smooth. Larger values result in more smoothed behaviour. Can be zero.\n\x09 */" },
		{ "CPP_Default_SmoothingTime", "0.200000" },
		{ "ModuleRelativePath", "Classes/Kismet/BlueprintSpringMathLibrary.h" },
		{ "ToolTip", "Smooths a value using exponential damping towards a target.\n\n\n@param  Value The value to be smoothed\n@param  Target The target to smooth towards\n@param  DeltaTime Time interval\n@param  SmoothingTime Timescale over which to smooth. Larger values result in more smoothed behaviour. Can be zero." },
	};
#endif // WITH_METADATA

// ********** Begin Function DampFloat constinit property declarations *****************************
	static const UECodeGen_Private::FFloatPropertyParams NewProp_Value;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_Target;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_DeltaTime;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_SmoothingTime;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_ReturnValue;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End Function DampFloat constinit property declarations *******************************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};

// ********** Begin Function DampFloat Property Definitions ****************************************
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampFloat_Statics::NewProp_Value = { "Value", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventDampFloat_Parms, Value), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampFloat_Statics::NewProp_Target = { "Target", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventDampFloat_Parms, Target), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampFloat_Statics::NewProp_DeltaTime = { "DeltaTime", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventDampFloat_Parms, DeltaTime), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampFloat_Statics::NewProp_SmoothingTime = { "SmoothingTime", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventDampFloat_Parms, SmoothingTime), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampFloat_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventDampFloat_Parms, ReturnValue), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampFloat_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampFloat_Statics::NewProp_Value,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampFloat_Statics::NewProp_Target,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampFloat_Statics::NewProp_DeltaTime,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampFloat_Statics::NewProp_SmoothingTime,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampFloat_Statics::NewProp_ReturnValue,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampFloat_Statics::PropPointers) < 2048);
// ********** End Function DampFloat Property Definitions ******************************************
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampFloat_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UBlueprintSpringMathLibrary, nullptr, "DampFloat", 	Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampFloat_Statics::PropPointers, 
	UE_ARRAY_COUNT(Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampFloat_Statics::PropPointers), 
sizeof(Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampFloat_Statics::BlueprintSpringMathLibrary_eventDampFloat_Parms),
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x14022403, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampFloat_Statics::Function_MetaDataParams), Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampFloat_Statics::Function_MetaDataParams)},  };
static_assert(sizeof(Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampFloat_Statics::BlueprintSpringMathLibrary_eventDampFloat_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampFloat()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampFloat_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UBlueprintSpringMathLibrary::execDampFloat)
{
	P_GET_PROPERTY(FFloatProperty,Z_Param_Value);
	P_GET_PROPERTY(FFloatProperty,Z_Param_Target);
	P_GET_PROPERTY(FFloatProperty,Z_Param_DeltaTime);
	P_GET_PROPERTY(FFloatProperty,Z_Param_SmoothingTime);
	P_FINISH;
	P_NATIVE_BEGIN;
	*(float*)Z_Param__Result=UBlueprintSpringMathLibrary::DampFloat(Z_Param_Value,Z_Param_Target,Z_Param_DeltaTime,Z_Param_SmoothingTime);
	P_NATIVE_END;
}
// ********** End Class UBlueprintSpringMathLibrary Function DampFloat *****************************

// ********** Begin Class UBlueprintSpringMathLibrary Function DampQuat ****************************
struct Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampQuat_Statics
{
	struct BlueprintSpringMathLibrary_eventDampQuat_Parms
	{
		FQuat Rotation;
		FQuat TargetRotation;
		float DeltaTime;
		float SmoothingTime;
		FQuat ReturnValue;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Category", "Math|Spring|Experimental" },
		{ "Comment", "/**\n\x09 * Smooths a rotation using exponential damping towards a target.\n\x09 * \n\x09 * \n\x09 * @param  Rotation The rotation to be smoothed\n\x09 * @param  TargetRotation The target to smooth towards\n\x09 * @param  DeltaTime Time interval\n\x09 * @param  SmoothingTime Timescale over which to smooth. Larger values result in more smoothed behaviour. Can be zero.\n\x09 */" },
		{ "CPP_Default_SmoothingTime", "0.200000" },
		{ "ModuleRelativePath", "Classes/Kismet/BlueprintSpringMathLibrary.h" },
		{ "ToolTip", "Smooths a rotation using exponential damping towards a target.\n\n\n@param  Rotation The rotation to be smoothed\n@param  TargetRotation The target to smooth towards\n@param  DeltaTime Time interval\n@param  SmoothingTime Timescale over which to smooth. Larger values result in more smoothed behaviour. Can be zero." },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Rotation_MetaData[] = {
		{ "NativeConst", "" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_TargetRotation_MetaData[] = {
		{ "NativeConst", "" },
	};
#endif // WITH_METADATA

// ********** Begin Function DampQuat constinit property declarations ******************************
	static const UECodeGen_Private::FStructPropertyParams NewProp_Rotation;
	static const UECodeGen_Private::FStructPropertyParams NewProp_TargetRotation;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_DeltaTime;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_SmoothingTime;
	static const UECodeGen_Private::FStructPropertyParams NewProp_ReturnValue;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End Function DampQuat constinit property declarations ********************************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};

// ********** Begin Function DampQuat Property Definitions *****************************************
const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampQuat_Statics::NewProp_Rotation = { "Rotation", nullptr, (EPropertyFlags)0x0010000008000182, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventDampQuat_Parms, Rotation), Z_Construct_UScriptStruct_FQuat, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Rotation_MetaData), NewProp_Rotation_MetaData) };
const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampQuat_Statics::NewProp_TargetRotation = { "TargetRotation", nullptr, (EPropertyFlags)0x0010000008000182, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventDampQuat_Parms, TargetRotation), Z_Construct_UScriptStruct_FQuat, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_TargetRotation_MetaData), NewProp_TargetRotation_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampQuat_Statics::NewProp_DeltaTime = { "DeltaTime", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventDampQuat_Parms, DeltaTime), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampQuat_Statics::NewProp_SmoothingTime = { "SmoothingTime", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventDampQuat_Parms, SmoothingTime), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampQuat_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventDampQuat_Parms, ReturnValue), Z_Construct_UScriptStruct_FQuat, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampQuat_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampQuat_Statics::NewProp_Rotation,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampQuat_Statics::NewProp_TargetRotation,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampQuat_Statics::NewProp_DeltaTime,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampQuat_Statics::NewProp_SmoothingTime,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampQuat_Statics::NewProp_ReturnValue,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampQuat_Statics::PropPointers) < 2048);
// ********** End Function DampQuat Property Definitions *******************************************
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampQuat_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UBlueprintSpringMathLibrary, nullptr, "DampQuat", 	Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampQuat_Statics::PropPointers, 
	UE_ARRAY_COUNT(Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampQuat_Statics::PropPointers), 
sizeof(Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampQuat_Statics::BlueprintSpringMathLibrary_eventDampQuat_Parms),
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x14C22403, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampQuat_Statics::Function_MetaDataParams), Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampQuat_Statics::Function_MetaDataParams)},  };
static_assert(sizeof(Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampQuat_Statics::BlueprintSpringMathLibrary_eventDampQuat_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampQuat()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampQuat_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UBlueprintSpringMathLibrary::execDampQuat)
{
	P_GET_STRUCT_REF(FQuat,Z_Param_Out_Rotation);
	P_GET_STRUCT_REF(FQuat,Z_Param_Out_TargetRotation);
	P_GET_PROPERTY(FFloatProperty,Z_Param_DeltaTime);
	P_GET_PROPERTY(FFloatProperty,Z_Param_SmoothingTime);
	P_FINISH;
	P_NATIVE_BEGIN;
	*(FQuat*)Z_Param__Result=UBlueprintSpringMathLibrary::DampQuat(Z_Param_Out_Rotation,Z_Param_Out_TargetRotation,Z_Param_DeltaTime,Z_Param_SmoothingTime);
	P_NATIVE_END;
}
// ********** End Class UBlueprintSpringMathLibrary Function DampQuat ******************************

// ********** Begin Class UBlueprintSpringMathLibrary Function DampRotator *************************
struct Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampRotator_Statics
{
	struct BlueprintSpringMathLibrary_eventDampRotator_Parms
	{
		FRotator Rotation;
		FRotator TargetRotation;
		float DeltaTime;
		float SmoothingTime;
		FRotator ReturnValue;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Category", "Math|Spring|Experimental" },
		{ "Comment", "/**\n\x09 * Smooths a value using exponential damping towards a target.\n\x09 * \n\x09 * \n\x09 * @param  Rotation The rotation to be smoothed\n\x09 * @param  TargetRotation The target to smooth towards\n\x09 * @param  DeltaTime Time interval\n\x09 * @param  SmoothingTime Timescale over which to smooth. Larger values result in more smoothed behaviour. Can be zero.\n\x09 */" },
		{ "CPP_Default_SmoothingTime", "0.200000" },
		{ "ModuleRelativePath", "Classes/Kismet/BlueprintSpringMathLibrary.h" },
		{ "ToolTip", "Smooths a value using exponential damping towards a target.\n\n\n@param  Rotation The rotation to be smoothed\n@param  TargetRotation The target to smooth towards\n@param  DeltaTime Time interval\n@param  SmoothingTime Timescale over which to smooth. Larger values result in more smoothed behaviour. Can be zero." },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Rotation_MetaData[] = {
		{ "NativeConst", "" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_TargetRotation_MetaData[] = {
		{ "NativeConst", "" },
	};
#endif // WITH_METADATA

// ********** Begin Function DampRotator constinit property declarations ***************************
	static const UECodeGen_Private::FStructPropertyParams NewProp_Rotation;
	static const UECodeGen_Private::FStructPropertyParams NewProp_TargetRotation;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_DeltaTime;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_SmoothingTime;
	static const UECodeGen_Private::FStructPropertyParams NewProp_ReturnValue;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End Function DampRotator constinit property declarations *****************************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};

// ********** Begin Function DampRotator Property Definitions **************************************
const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampRotator_Statics::NewProp_Rotation = { "Rotation", nullptr, (EPropertyFlags)0x0010000008000182, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventDampRotator_Parms, Rotation), Z_Construct_UScriptStruct_FRotator, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Rotation_MetaData), NewProp_Rotation_MetaData) };
const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampRotator_Statics::NewProp_TargetRotation = { "TargetRotation", nullptr, (EPropertyFlags)0x0010000008000182, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventDampRotator_Parms, TargetRotation), Z_Construct_UScriptStruct_FRotator, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_TargetRotation_MetaData), NewProp_TargetRotation_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampRotator_Statics::NewProp_DeltaTime = { "DeltaTime", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventDampRotator_Parms, DeltaTime), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampRotator_Statics::NewProp_SmoothingTime = { "SmoothingTime", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventDampRotator_Parms, SmoothingTime), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampRotator_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventDampRotator_Parms, ReturnValue), Z_Construct_UScriptStruct_FRotator, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampRotator_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampRotator_Statics::NewProp_Rotation,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampRotator_Statics::NewProp_TargetRotation,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampRotator_Statics::NewProp_DeltaTime,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampRotator_Statics::NewProp_SmoothingTime,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampRotator_Statics::NewProp_ReturnValue,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampRotator_Statics::PropPointers) < 2048);
// ********** End Function DampRotator Property Definitions ****************************************
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampRotator_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UBlueprintSpringMathLibrary, nullptr, "DampRotator", 	Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampRotator_Statics::PropPointers, 
	UE_ARRAY_COUNT(Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampRotator_Statics::PropPointers), 
sizeof(Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampRotator_Statics::BlueprintSpringMathLibrary_eventDampRotator_Parms),
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x14C22403, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampRotator_Statics::Function_MetaDataParams), Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampRotator_Statics::Function_MetaDataParams)},  };
static_assert(sizeof(Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampRotator_Statics::BlueprintSpringMathLibrary_eventDampRotator_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampRotator()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampRotator_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UBlueprintSpringMathLibrary::execDampRotator)
{
	P_GET_STRUCT_REF(FRotator,Z_Param_Out_Rotation);
	P_GET_STRUCT_REF(FRotator,Z_Param_Out_TargetRotation);
	P_GET_PROPERTY(FFloatProperty,Z_Param_DeltaTime);
	P_GET_PROPERTY(FFloatProperty,Z_Param_SmoothingTime);
	P_FINISH;
	P_NATIVE_BEGIN;
	*(FRotator*)Z_Param__Result=UBlueprintSpringMathLibrary::DampRotator(Z_Param_Out_Rotation,Z_Param_Out_TargetRotation,Z_Param_DeltaTime,Z_Param_SmoothingTime);
	P_NATIVE_END;
}
// ********** End Class UBlueprintSpringMathLibrary Function DampRotator ***************************

// ********** Begin Class UBlueprintSpringMathLibrary Function DampVector **************************
struct Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampVector_Statics
{
	struct BlueprintSpringMathLibrary_eventDampVector_Parms
	{
		FVector Value;
		FVector Target;
		float DeltaTime;
		float SmoothingTime;
		FVector ReturnValue;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Category", "Math|Spring|Experimental" },
		{ "Comment", "/**\n\x09 * Smooths a value using exponential damping towards a target.\n\x09 * \n\x09 * \n\x09 * @param  Value The value to be smoothed\n\x09 * @param  Target The target to smooth towards\n\x09 * @param  DeltaTime Time interval\n\x09 * @param  SmoothingTime Timescale over which to smooth. Larger values result in more smoothed behaviour. Can be zero.\n\x09 */" },
		{ "CPP_Default_SmoothingTime", "0.200000" },
		{ "ModuleRelativePath", "Classes/Kismet/BlueprintSpringMathLibrary.h" },
		{ "ToolTip", "Smooths a value using exponential damping towards a target.\n\n\n@param  Value The value to be smoothed\n@param  Target The target to smooth towards\n@param  DeltaTime Time interval\n@param  SmoothingTime Timescale over which to smooth. Larger values result in more smoothed behaviour. Can be zero." },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Value_MetaData[] = {
		{ "NativeConst", "" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Target_MetaData[] = {
		{ "NativeConst", "" },
	};
#endif // WITH_METADATA

// ********** Begin Function DampVector constinit property declarations ****************************
	static const UECodeGen_Private::FStructPropertyParams NewProp_Value;
	static const UECodeGen_Private::FStructPropertyParams NewProp_Target;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_DeltaTime;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_SmoothingTime;
	static const UECodeGen_Private::FStructPropertyParams NewProp_ReturnValue;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End Function DampVector constinit property declarations ******************************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};

// ********** Begin Function DampVector Property Definitions ***************************************
const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampVector_Statics::NewProp_Value = { "Value", nullptr, (EPropertyFlags)0x0010000008000182, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventDampVector_Parms, Value), Z_Construct_UScriptStruct_FVector, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Value_MetaData), NewProp_Value_MetaData) };
const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampVector_Statics::NewProp_Target = { "Target", nullptr, (EPropertyFlags)0x0010000008000182, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventDampVector_Parms, Target), Z_Construct_UScriptStruct_FVector, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Target_MetaData), NewProp_Target_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampVector_Statics::NewProp_DeltaTime = { "DeltaTime", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventDampVector_Parms, DeltaTime), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampVector_Statics::NewProp_SmoothingTime = { "SmoothingTime", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventDampVector_Parms, SmoothingTime), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampVector_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventDampVector_Parms, ReturnValue), Z_Construct_UScriptStruct_FVector, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampVector_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampVector_Statics::NewProp_Value,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampVector_Statics::NewProp_Target,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampVector_Statics::NewProp_DeltaTime,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampVector_Statics::NewProp_SmoothingTime,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampVector_Statics::NewProp_ReturnValue,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampVector_Statics::PropPointers) < 2048);
// ********** End Function DampVector Property Definitions *****************************************
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampVector_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UBlueprintSpringMathLibrary, nullptr, "DampVector", 	Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampVector_Statics::PropPointers, 
	UE_ARRAY_COUNT(Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampVector_Statics::PropPointers), 
sizeof(Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampVector_Statics::BlueprintSpringMathLibrary_eventDampVector_Parms),
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x14C22403, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampVector_Statics::Function_MetaDataParams), Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampVector_Statics::Function_MetaDataParams)},  };
static_assert(sizeof(Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampVector_Statics::BlueprintSpringMathLibrary_eventDampVector_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampVector()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampVector_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UBlueprintSpringMathLibrary::execDampVector)
{
	P_GET_STRUCT_REF(FVector,Z_Param_Out_Value);
	P_GET_STRUCT_REF(FVector,Z_Param_Out_Target);
	P_GET_PROPERTY(FFloatProperty,Z_Param_DeltaTime);
	P_GET_PROPERTY(FFloatProperty,Z_Param_SmoothingTime);
	P_FINISH;
	P_NATIVE_BEGIN;
	*(FVector*)Z_Param__Result=UBlueprintSpringMathLibrary::DampVector(Z_Param_Out_Value,Z_Param_Out_Target,Z_Param_DeltaTime,Z_Param_SmoothingTime);
	P_NATIVE_END;
}
// ********** End Class UBlueprintSpringMathLibrary Function DampVector ****************************

// ********** Begin Class UBlueprintSpringMathLibrary Function DampVector2D ************************
struct Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampVector2D_Statics
{
	struct BlueprintSpringMathLibrary_eventDampVector2D_Parms
	{
		FVector2D Value;
		FVector2D Target;
		float DeltaTime;
		float SmoothingTime;
		FVector2D ReturnValue;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Category", "Math|Spring|Experimental" },
		{ "Comment", "/**\n\x09 * Smooths a value using exponential damping towards a target.\n\x09 * \n\x09 * \n\x09 * @param  Value The value to be smoothed\n\x09 * @param  Target The target to smooth towards\n\x09 * @param  DeltaTime Time interval\n\x09 * @param  SmoothingTime Timescale over which to smooth. Larger values result in more smoothed behaviour. Can be zero.\n\x09 */" },
		{ "CPP_Default_SmoothingTime", "0.200000" },
		{ "ModuleRelativePath", "Classes/Kismet/BlueprintSpringMathLibrary.h" },
		{ "ToolTip", "Smooths a value using exponential damping towards a target.\n\n\n@param  Value The value to be smoothed\n@param  Target The target to smooth towards\n@param  DeltaTime Time interval\n@param  SmoothingTime Timescale over which to smooth. Larger values result in more smoothed behaviour. Can be zero." },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Value_MetaData[] = {
		{ "NativeConst", "" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Target_MetaData[] = {
		{ "NativeConst", "" },
	};
#endif // WITH_METADATA

// ********** Begin Function DampVector2D constinit property declarations **************************
	static const UECodeGen_Private::FStructPropertyParams NewProp_Value;
	static const UECodeGen_Private::FStructPropertyParams NewProp_Target;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_DeltaTime;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_SmoothingTime;
	static const UECodeGen_Private::FStructPropertyParams NewProp_ReturnValue;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End Function DampVector2D constinit property declarations ****************************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};

// ********** Begin Function DampVector2D Property Definitions *************************************
const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampVector2D_Statics::NewProp_Value = { "Value", nullptr, (EPropertyFlags)0x0010000008000182, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventDampVector2D_Parms, Value), Z_Construct_UScriptStruct_FVector2D, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Value_MetaData), NewProp_Value_MetaData) };
const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampVector2D_Statics::NewProp_Target = { "Target", nullptr, (EPropertyFlags)0x0010000008000182, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventDampVector2D_Parms, Target), Z_Construct_UScriptStruct_FVector2D, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Target_MetaData), NewProp_Target_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampVector2D_Statics::NewProp_DeltaTime = { "DeltaTime", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventDampVector2D_Parms, DeltaTime), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampVector2D_Statics::NewProp_SmoothingTime = { "SmoothingTime", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventDampVector2D_Parms, SmoothingTime), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampVector2D_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventDampVector2D_Parms, ReturnValue), Z_Construct_UScriptStruct_FVector2D, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampVector2D_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampVector2D_Statics::NewProp_Value,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampVector2D_Statics::NewProp_Target,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampVector2D_Statics::NewProp_DeltaTime,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampVector2D_Statics::NewProp_SmoothingTime,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampVector2D_Statics::NewProp_ReturnValue,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampVector2D_Statics::PropPointers) < 2048);
// ********** End Function DampVector2D Property Definitions ***************************************
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampVector2D_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UBlueprintSpringMathLibrary, nullptr, "DampVector2D", 	Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampVector2D_Statics::PropPointers, 
	UE_ARRAY_COUNT(Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampVector2D_Statics::PropPointers), 
sizeof(Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampVector2D_Statics::BlueprintSpringMathLibrary_eventDampVector2D_Parms),
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x14C22403, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampVector2D_Statics::Function_MetaDataParams), Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampVector2D_Statics::Function_MetaDataParams)},  };
static_assert(sizeof(Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampVector2D_Statics::BlueprintSpringMathLibrary_eventDampVector2D_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampVector2D()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampVector2D_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UBlueprintSpringMathLibrary::execDampVector2D)
{
	P_GET_STRUCT_REF(FVector2D,Z_Param_Out_Value);
	P_GET_STRUCT_REF(FVector2D,Z_Param_Out_Target);
	P_GET_PROPERTY(FFloatProperty,Z_Param_DeltaTime);
	P_GET_PROPERTY(FFloatProperty,Z_Param_SmoothingTime);
	P_FINISH;
	P_NATIVE_BEGIN;
	*(FVector2D*)Z_Param__Result=UBlueprintSpringMathLibrary::DampVector2D(Z_Param_Out_Value,Z_Param_Out_Target,Z_Param_DeltaTime,Z_Param_SmoothingTime);
	P_NATIVE_END;
}
// ********** End Class UBlueprintSpringMathLibrary Function DampVector2D **************************

// ********** Begin Class UBlueprintSpringMathLibrary Function SpringCharacterUpdate ***************
struct Z_Construct_UFunction_UBlueprintSpringMathLibrary_SpringCharacterUpdate_Statics
{
	struct BlueprintSpringMathLibrary_eventSpringCharacterUpdate_Parms
	{
		FVector InOutPosition;
		FVector InOutVelocity;
		FVector InOutAcceleration;
		FVector TargetVelocity;
		float DeltaTime;
		float SmoothingTime;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Category", "Math|Spring|Experimental" },
		{ "Comment", "/** Update the position of a character given a target velocity using a simple damped spring\n\x09 * \n\x09 * @param InOutPosition The position of the character\n\x09 * @param InOutVelocity The velocity of the character. Needs to be stored and persisted by the caller. Usually initialized to zero and not modified by the caller.\n\x09 * @param InOutAcceleration The acceleration of the character. Needs to be stored and persisted by the caller. Usually initialized to zero and not modified by the caller.\n\x09 * @param TargetVelocity The target velocity of the character.\n\x09 * @param DeltaTime The delta time to tick the character\n\x09 * @param SmoothingTime The time over which to smooth velocity. It takes roughly the smoothing time in order for the character to reach the target velocity.\n\x09 */" },
		{ "CPP_Default_SmoothingTime", "0.200000" },
		{ "ModuleRelativePath", "Classes/Kismet/BlueprintSpringMathLibrary.h" },
		{ "ToolTip", "Update the position of a character given a target velocity using a simple damped spring\n\n@param InOutPosition The position of the character\n@param InOutVelocity The velocity of the character. Needs to be stored and persisted by the caller. Usually initialized to zero and not modified by the caller.\n@param InOutAcceleration The acceleration of the character. Needs to be stored and persisted by the caller. Usually initialized to zero and not modified by the caller.\n@param TargetVelocity The target velocity of the character.\n@param DeltaTime The delta time to tick the character\n@param SmoothingTime The time over which to smooth velocity. It takes roughly the smoothing time in order for the character to reach the target velocity." },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_TargetVelocity_MetaData[] = {
		{ "NativeConst", "" },
	};
#endif // WITH_METADATA

// ********** Begin Function SpringCharacterUpdate constinit property declarations *****************
	static const UECodeGen_Private::FStructPropertyParams NewProp_InOutPosition;
	static const UECodeGen_Private::FStructPropertyParams NewProp_InOutVelocity;
	static const UECodeGen_Private::FStructPropertyParams NewProp_InOutAcceleration;
	static const UECodeGen_Private::FStructPropertyParams NewProp_TargetVelocity;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_DeltaTime;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_SmoothingTime;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End Function SpringCharacterUpdate constinit property declarations *******************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};

// ********** Begin Function SpringCharacterUpdate Property Definitions ****************************
const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_SpringCharacterUpdate_Statics::NewProp_InOutPosition = { "InOutPosition", nullptr, (EPropertyFlags)0x0010000008000180, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventSpringCharacterUpdate_Parms, InOutPosition), Z_Construct_UScriptStruct_FVector, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_SpringCharacterUpdate_Statics::NewProp_InOutVelocity = { "InOutVelocity", nullptr, (EPropertyFlags)0x0010000008000180, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventSpringCharacterUpdate_Parms, InOutVelocity), Z_Construct_UScriptStruct_FVector, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_SpringCharacterUpdate_Statics::NewProp_InOutAcceleration = { "InOutAcceleration", nullptr, (EPropertyFlags)0x0010000008000180, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventSpringCharacterUpdate_Parms, InOutAcceleration), Z_Construct_UScriptStruct_FVector, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_SpringCharacterUpdate_Statics::NewProp_TargetVelocity = { "TargetVelocity", nullptr, (EPropertyFlags)0x0010000008000182, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventSpringCharacterUpdate_Parms, TargetVelocity), Z_Construct_UScriptStruct_FVector, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_TargetVelocity_MetaData), NewProp_TargetVelocity_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_SpringCharacterUpdate_Statics::NewProp_DeltaTime = { "DeltaTime", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventSpringCharacterUpdate_Parms, DeltaTime), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_SpringCharacterUpdate_Statics::NewProp_SmoothingTime = { "SmoothingTime", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventSpringCharacterUpdate_Parms, SmoothingTime), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UBlueprintSpringMathLibrary_SpringCharacterUpdate_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_SpringCharacterUpdate_Statics::NewProp_InOutPosition,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_SpringCharacterUpdate_Statics::NewProp_InOutVelocity,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_SpringCharacterUpdate_Statics::NewProp_InOutAcceleration,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_SpringCharacterUpdate_Statics::NewProp_TargetVelocity,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_SpringCharacterUpdate_Statics::NewProp_DeltaTime,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_SpringCharacterUpdate_Statics::NewProp_SmoothingTime,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UBlueprintSpringMathLibrary_SpringCharacterUpdate_Statics::PropPointers) < 2048);
// ********** End Function SpringCharacterUpdate Property Definitions ******************************
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_SpringCharacterUpdate_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UBlueprintSpringMathLibrary, nullptr, "SpringCharacterUpdate", 	Z_Construct_UFunction_UBlueprintSpringMathLibrary_SpringCharacterUpdate_Statics::PropPointers, 
	UE_ARRAY_COUNT(Z_Construct_UFunction_UBlueprintSpringMathLibrary_SpringCharacterUpdate_Statics::PropPointers), 
sizeof(Z_Construct_UFunction_UBlueprintSpringMathLibrary_SpringCharacterUpdate_Statics::BlueprintSpringMathLibrary_eventSpringCharacterUpdate_Parms),
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04C22403, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UBlueprintSpringMathLibrary_SpringCharacterUpdate_Statics::Function_MetaDataParams), Z_Construct_UFunction_UBlueprintSpringMathLibrary_SpringCharacterUpdate_Statics::Function_MetaDataParams)},  };
static_assert(sizeof(Z_Construct_UFunction_UBlueprintSpringMathLibrary_SpringCharacterUpdate_Statics::BlueprintSpringMathLibrary_eventSpringCharacterUpdate_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UBlueprintSpringMathLibrary_SpringCharacterUpdate()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UBlueprintSpringMathLibrary_SpringCharacterUpdate_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UBlueprintSpringMathLibrary::execSpringCharacterUpdate)
{
	P_GET_STRUCT_REF(FVector,Z_Param_Out_InOutPosition);
	P_GET_STRUCT_REF(FVector,Z_Param_Out_InOutVelocity);
	P_GET_STRUCT_REF(FVector,Z_Param_Out_InOutAcceleration);
	P_GET_STRUCT_REF(FVector,Z_Param_Out_TargetVelocity);
	P_GET_PROPERTY(FFloatProperty,Z_Param_DeltaTime);
	P_GET_PROPERTY(FFloatProperty,Z_Param_SmoothingTime);
	P_FINISH;
	P_NATIVE_BEGIN;
	UBlueprintSpringMathLibrary::SpringCharacterUpdate(Z_Param_Out_InOutPosition,Z_Param_Out_InOutVelocity,Z_Param_Out_InOutAcceleration,Z_Param_Out_TargetVelocity,Z_Param_DeltaTime,Z_Param_SmoothingTime);
	P_NATIVE_END;
}
// ********** End Class UBlueprintSpringMathLibrary Function SpringCharacterUpdate *****************

// ********** Begin Class UBlueprintSpringMathLibrary Function VelocitySpringCharacterUpdate *******
struct Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringCharacterUpdate_Statics
{
	struct BlueprintSpringMathLibrary_eventVelocitySpringCharacterUpdate_Parms
	{
		FVector InOutPosition;
		FVector InOutVelocity;
		FVector InOutVelocityIntermediate;
		FVector InOutAcceleration;
		FVector TargetVelocity;
		float DeltaTime;
		float SmoothingTime;
		float MaxAcceleration;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Category", "Math|Spring|Experimental" },
		{ "Comment", "/** Update a position representing a character given a target velocity using a velocity spring.\n\x09 * A velocity spring tracks an intermediate velocity which moves at a maximum acceleration linearly towards a target.\n\x09 * This means unlike the \"SpringCharacterUpdate\", it will take longer to reach a target velocity that is further away from the current velocity.\n\x09 * \n\x09 * @param InOutPosition The position of the character\n\x09 * @param InOutVelocity The velocity of the character. Needs to be stored and persisted by the caller. Usually initialized to zero and not modified by the caller.\n\x09 * @param InOutVelocityIntermediate The intermediate velocity of the character. Needs to be stored and persisted by the caller. Usually initialized to zero and not modified by the caller.\n\x09 * @param InOutAcceleration The acceleration of the character. Needs to be stored and persisted by the caller. Usually initialized to zero and not modified by the caller.\n\x09 * @param TargetVelocity The target velocity of the character.\n\x09 * @param DeltaTime The delta time to tick the character\n\x09 * @param SmoothingTime The time over which to smooth velocity. It takes roughly the smoothing time in order for the character to reach the target velocity.\n\x09 * @param MaxAcceleration Puts a limit on the maximum acceleration that the intermediate velocity can do each frame. If MaxAccel is very large, the behaviour wil lbe the same as SpringCharacterUpdate\n\x09 */" },
		{ "CPP_Default_MaxAcceleration", "1.000000" },
		{ "CPP_Default_SmoothingTime", "0.200000" },
		{ "ModuleRelativePath", "Classes/Kismet/BlueprintSpringMathLibrary.h" },
		{ "ToolTip", "Update a position representing a character given a target velocity using a velocity spring.\nA velocity spring tracks an intermediate velocity which moves at a maximum acceleration linearly towards a target.\nThis means unlike the \"SpringCharacterUpdate\", it will take longer to reach a target velocity that is further away from the current velocity.\n\n@param InOutPosition The position of the character\n@param InOutVelocity The velocity of the character. Needs to be stored and persisted by the caller. Usually initialized to zero and not modified by the caller.\n@param InOutVelocityIntermediate The intermediate velocity of the character. Needs to be stored and persisted by the caller. Usually initialized to zero and not modified by the caller.\n@param InOutAcceleration The acceleration of the character. Needs to be stored and persisted by the caller. Usually initialized to zero and not modified by the caller.\n@param TargetVelocity The target velocity of the character.\n@param DeltaTime The delta time to tick the character\n@param SmoothingTime The time over which to smooth velocity. It takes roughly the smoothing time in order for the character to reach the target velocity.\n@param MaxAcceleration Puts a limit on the maximum acceleration that the intermediate velocity can do each frame. If MaxAccel is very large, the behaviour wil lbe the same as SpringCharacterUpdate" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_TargetVelocity_MetaData[] = {
		{ "NativeConst", "" },
	};
#endif // WITH_METADATA

// ********** Begin Function VelocitySpringCharacterUpdate constinit property declarations *********
	static const UECodeGen_Private::FStructPropertyParams NewProp_InOutPosition;
	static const UECodeGen_Private::FStructPropertyParams NewProp_InOutVelocity;
	static const UECodeGen_Private::FStructPropertyParams NewProp_InOutVelocityIntermediate;
	static const UECodeGen_Private::FStructPropertyParams NewProp_InOutAcceleration;
	static const UECodeGen_Private::FStructPropertyParams NewProp_TargetVelocity;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_DeltaTime;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_SmoothingTime;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_MaxAcceleration;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End Function VelocitySpringCharacterUpdate constinit property declarations ***********
	static const UECodeGen_Private::FFunctionParams FuncParams;
};

// ********** Begin Function VelocitySpringCharacterUpdate Property Definitions ********************
const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringCharacterUpdate_Statics::NewProp_InOutPosition = { "InOutPosition", nullptr, (EPropertyFlags)0x0010000008000180, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventVelocitySpringCharacterUpdate_Parms, InOutPosition), Z_Construct_UScriptStruct_FVector, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringCharacterUpdate_Statics::NewProp_InOutVelocity = { "InOutVelocity", nullptr, (EPropertyFlags)0x0010000008000180, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventVelocitySpringCharacterUpdate_Parms, InOutVelocity), Z_Construct_UScriptStruct_FVector, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringCharacterUpdate_Statics::NewProp_InOutVelocityIntermediate = { "InOutVelocityIntermediate", nullptr, (EPropertyFlags)0x0010000008000180, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventVelocitySpringCharacterUpdate_Parms, InOutVelocityIntermediate), Z_Construct_UScriptStruct_FVector, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringCharacterUpdate_Statics::NewProp_InOutAcceleration = { "InOutAcceleration", nullptr, (EPropertyFlags)0x0010000008000180, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventVelocitySpringCharacterUpdate_Parms, InOutAcceleration), Z_Construct_UScriptStruct_FVector, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringCharacterUpdate_Statics::NewProp_TargetVelocity = { "TargetVelocity", nullptr, (EPropertyFlags)0x0010000008000182, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventVelocitySpringCharacterUpdate_Parms, TargetVelocity), Z_Construct_UScriptStruct_FVector, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_TargetVelocity_MetaData), NewProp_TargetVelocity_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringCharacterUpdate_Statics::NewProp_DeltaTime = { "DeltaTime", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventVelocitySpringCharacterUpdate_Parms, DeltaTime), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringCharacterUpdate_Statics::NewProp_SmoothingTime = { "SmoothingTime", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventVelocitySpringCharacterUpdate_Parms, SmoothingTime), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringCharacterUpdate_Statics::NewProp_MaxAcceleration = { "MaxAcceleration", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventVelocitySpringCharacterUpdate_Parms, MaxAcceleration), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringCharacterUpdate_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringCharacterUpdate_Statics::NewProp_InOutPosition,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringCharacterUpdate_Statics::NewProp_InOutVelocity,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringCharacterUpdate_Statics::NewProp_InOutVelocityIntermediate,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringCharacterUpdate_Statics::NewProp_InOutAcceleration,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringCharacterUpdate_Statics::NewProp_TargetVelocity,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringCharacterUpdate_Statics::NewProp_DeltaTime,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringCharacterUpdate_Statics::NewProp_SmoothingTime,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringCharacterUpdate_Statics::NewProp_MaxAcceleration,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringCharacterUpdate_Statics::PropPointers) < 2048);
// ********** End Function VelocitySpringCharacterUpdate Property Definitions **********************
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringCharacterUpdate_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UBlueprintSpringMathLibrary, nullptr, "VelocitySpringCharacterUpdate", 	Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringCharacterUpdate_Statics::PropPointers, 
	UE_ARRAY_COUNT(Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringCharacterUpdate_Statics::PropPointers), 
sizeof(Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringCharacterUpdate_Statics::BlueprintSpringMathLibrary_eventVelocitySpringCharacterUpdate_Parms),
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04C22403, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringCharacterUpdate_Statics::Function_MetaDataParams), Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringCharacterUpdate_Statics::Function_MetaDataParams)},  };
static_assert(sizeof(Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringCharacterUpdate_Statics::BlueprintSpringMathLibrary_eventVelocitySpringCharacterUpdate_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringCharacterUpdate()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringCharacterUpdate_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UBlueprintSpringMathLibrary::execVelocitySpringCharacterUpdate)
{
	P_GET_STRUCT_REF(FVector,Z_Param_Out_InOutPosition);
	P_GET_STRUCT_REF(FVector,Z_Param_Out_InOutVelocity);
	P_GET_STRUCT_REF(FVector,Z_Param_Out_InOutVelocityIntermediate);
	P_GET_STRUCT_REF(FVector,Z_Param_Out_InOutAcceleration);
	P_GET_STRUCT_REF(FVector,Z_Param_Out_TargetVelocity);
	P_GET_PROPERTY(FFloatProperty,Z_Param_DeltaTime);
	P_GET_PROPERTY(FFloatProperty,Z_Param_SmoothingTime);
	P_GET_PROPERTY(FFloatProperty,Z_Param_MaxAcceleration);
	P_FINISH;
	P_NATIVE_BEGIN;
	UBlueprintSpringMathLibrary::VelocitySpringCharacterUpdate(Z_Param_Out_InOutPosition,Z_Param_Out_InOutVelocity,Z_Param_Out_InOutVelocityIntermediate,Z_Param_Out_InOutAcceleration,Z_Param_Out_TargetVelocity,Z_Param_DeltaTime,Z_Param_SmoothingTime,Z_Param_MaxAcceleration);
	P_NATIVE_END;
}
// ********** End Class UBlueprintSpringMathLibrary Function VelocitySpringCharacterUpdate *********

// ********** Begin Class UBlueprintSpringMathLibrary Function VelocitySpringDampFloat *************
struct Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampFloat_Statics
{
	struct BlueprintSpringMathLibrary_eventVelocitySpringDampFloat_Parms
	{
		float InOutX;
		float InOutV;
		float InOutVi;
		float TargetX;
		float MaxSpeed;
		float DeltaTime;
		float SmoothingTime;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Category", "Math|Spring|Experimental" },
		{ "Comment", "/** A velocity spring will damp towards a target that follows a fixed linear target velocity, allowing control of the interpolation speed\n\x09 * while still giving a smoothed behavior. A SmoothingTime of 0 will give a linear interpolation between X and TargetX\n\x09 * \n\x09 * @param InOutX The value to be damped\n\x09 * @param InOutV The velocity of the value to be damped\n\x09 * @param InOutVi The intermediate target velocity of the value to be damped\n\x09 * @param TargetX The target value of X to damp towards\n\x09 * @param MaxSpeed The desired speed to achieve while damping towards X\n\x09 * @param SmoothingTime The smoothing time to use while damping towards X. Higher values will give more smoothed behaviour. A value of 0 will give a linear interpolation of X to Target\n\x09 * @param DeltaTime The timestep in seconds\n\x09 */" },
		{ "CPP_Default_SmoothingTime", "0.200000" },
		{ "ModuleRelativePath", "Classes/Kismet/BlueprintSpringMathLibrary.h" },
		{ "ToolTip", "A velocity spring will damp towards a target that follows a fixed linear target velocity, allowing control of the interpolation speed\nwhile still giving a smoothed behavior. A SmoothingTime of 0 will give a linear interpolation between X and TargetX\n\n@param InOutX The value to be damped\n@param InOutV The velocity of the value to be damped\n@param InOutVi The intermediate target velocity of the value to be damped\n@param TargetX The target value of X to damp towards\n@param MaxSpeed The desired speed to achieve while damping towards X\n@param SmoothingTime The smoothing time to use while damping towards X. Higher values will give more smoothed behaviour. A value of 0 will give a linear interpolation of X to Target\n@param DeltaTime The timestep in seconds" },
	};
#endif // WITH_METADATA

// ********** Begin Function VelocitySpringDampFloat constinit property declarations ***************
	static const UECodeGen_Private::FFloatPropertyParams NewProp_InOutX;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_InOutV;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_InOutVi;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_TargetX;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_MaxSpeed;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_DeltaTime;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_SmoothingTime;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End Function VelocitySpringDampFloat constinit property declarations *****************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};

// ********** Begin Function VelocitySpringDampFloat Property Definitions **************************
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampFloat_Statics::NewProp_InOutX = { "InOutX", nullptr, (EPropertyFlags)0x0010000008000180, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventVelocitySpringDampFloat_Parms, InOutX), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampFloat_Statics::NewProp_InOutV = { "InOutV", nullptr, (EPropertyFlags)0x0010000008000180, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventVelocitySpringDampFloat_Parms, InOutV), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampFloat_Statics::NewProp_InOutVi = { "InOutVi", nullptr, (EPropertyFlags)0x0010000008000180, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventVelocitySpringDampFloat_Parms, InOutVi), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampFloat_Statics::NewProp_TargetX = { "TargetX", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventVelocitySpringDampFloat_Parms, TargetX), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampFloat_Statics::NewProp_MaxSpeed = { "MaxSpeed", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventVelocitySpringDampFloat_Parms, MaxSpeed), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampFloat_Statics::NewProp_DeltaTime = { "DeltaTime", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventVelocitySpringDampFloat_Parms, DeltaTime), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampFloat_Statics::NewProp_SmoothingTime = { "SmoothingTime", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventVelocitySpringDampFloat_Parms, SmoothingTime), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampFloat_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampFloat_Statics::NewProp_InOutX,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampFloat_Statics::NewProp_InOutV,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampFloat_Statics::NewProp_InOutVi,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampFloat_Statics::NewProp_TargetX,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampFloat_Statics::NewProp_MaxSpeed,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampFloat_Statics::NewProp_DeltaTime,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampFloat_Statics::NewProp_SmoothingTime,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampFloat_Statics::PropPointers) < 2048);
// ********** End Function VelocitySpringDampFloat Property Definitions ****************************
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampFloat_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UBlueprintSpringMathLibrary, nullptr, "VelocitySpringDampFloat", 	Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampFloat_Statics::PropPointers, 
	UE_ARRAY_COUNT(Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampFloat_Statics::PropPointers), 
sizeof(Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampFloat_Statics::BlueprintSpringMathLibrary_eventVelocitySpringDampFloat_Parms),
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04422403, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampFloat_Statics::Function_MetaDataParams), Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampFloat_Statics::Function_MetaDataParams)},  };
static_assert(sizeof(Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampFloat_Statics::BlueprintSpringMathLibrary_eventVelocitySpringDampFloat_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampFloat()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampFloat_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UBlueprintSpringMathLibrary::execVelocitySpringDampFloat)
{
	P_GET_PROPERTY_REF(FFloatProperty,Z_Param_Out_InOutX);
	P_GET_PROPERTY_REF(FFloatProperty,Z_Param_Out_InOutV);
	P_GET_PROPERTY_REF(FFloatProperty,Z_Param_Out_InOutVi);
	P_GET_PROPERTY(FFloatProperty,Z_Param_TargetX);
	P_GET_PROPERTY(FFloatProperty,Z_Param_MaxSpeed);
	P_GET_PROPERTY(FFloatProperty,Z_Param_DeltaTime);
	P_GET_PROPERTY(FFloatProperty,Z_Param_SmoothingTime);
	P_FINISH;
	P_NATIVE_BEGIN;
	UBlueprintSpringMathLibrary::VelocitySpringDampFloat(Z_Param_Out_InOutX,Z_Param_Out_InOutV,Z_Param_Out_InOutVi,Z_Param_TargetX,Z_Param_MaxSpeed,Z_Param_DeltaTime,Z_Param_SmoothingTime);
	P_NATIVE_END;
}
// ********** End Class UBlueprintSpringMathLibrary Function VelocitySpringDampFloat ***************

// ********** Begin Class UBlueprintSpringMathLibrary Function VelocitySpringDampVector ************
struct Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampVector_Statics
{
	struct BlueprintSpringMathLibrary_eventVelocitySpringDampVector_Parms
	{
		FVector InOutX;
		FVector InOutV;
		FVector InOutVi;
		FVector TargetX;
		float MaxSpeed;
		float DeltaTime;
		float SmoothingTime;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Category", "Math|Spring|Experimental" },
		{ "Comment", "/** A velocity spring will damp towards a target that follows a fixed linear target velocity, allowing control of the interpolation speed\n\x09 * while still giving a smoothed behavior. A SmoothingTime of 0 will give a linear interpolation between X and TargetX\n\x09 * \n\x09 * @param InOutX The value to be damped\n\x09 * @param InOutV The velocity of the value to be damped\n\x09 * @param InOutVi The intermediate target velocity of the value to be damped\n\x09 * @param TargetX The target value of X to damp towards\n\x09 * @param MaxSpeed The desired speed to achieve while damping towards X\n\x09 * @param SmoothingTime The smoothing time to use while damping towards X. Higher values will give more smoothed behaviour. A value of 0 will give a linear interpolation of X to Target\n\x09 * @param DeltaTime The timestep in seconds\n\x09 */" },
		{ "CPP_Default_SmoothingTime", "0.200000" },
		{ "ModuleRelativePath", "Classes/Kismet/BlueprintSpringMathLibrary.h" },
		{ "ToolTip", "A velocity spring will damp towards a target that follows a fixed linear target velocity, allowing control of the interpolation speed\nwhile still giving a smoothed behavior. A SmoothingTime of 0 will give a linear interpolation between X and TargetX\n\n@param InOutX The value to be damped\n@param InOutV The velocity of the value to be damped\n@param InOutVi The intermediate target velocity of the value to be damped\n@param TargetX The target value of X to damp towards\n@param MaxSpeed The desired speed to achieve while damping towards X\n@param SmoothingTime The smoothing time to use while damping towards X. Higher values will give more smoothed behaviour. A value of 0 will give a linear interpolation of X to Target\n@param DeltaTime The timestep in seconds" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_TargetX_MetaData[] = {
		{ "NativeConst", "" },
	};
#endif // WITH_METADATA

// ********** Begin Function VelocitySpringDampVector constinit property declarations **************
	static const UECodeGen_Private::FStructPropertyParams NewProp_InOutX;
	static const UECodeGen_Private::FStructPropertyParams NewProp_InOutV;
	static const UECodeGen_Private::FStructPropertyParams NewProp_InOutVi;
	static const UECodeGen_Private::FStructPropertyParams NewProp_TargetX;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_MaxSpeed;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_DeltaTime;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_SmoothingTime;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End Function VelocitySpringDampVector constinit property declarations ****************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};

// ********** Begin Function VelocitySpringDampVector Property Definitions *************************
const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampVector_Statics::NewProp_InOutX = { "InOutX", nullptr, (EPropertyFlags)0x0010000008000180, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventVelocitySpringDampVector_Parms, InOutX), Z_Construct_UScriptStruct_FVector, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampVector_Statics::NewProp_InOutV = { "InOutV", nullptr, (EPropertyFlags)0x0010000008000180, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventVelocitySpringDampVector_Parms, InOutV), Z_Construct_UScriptStruct_FVector, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampVector_Statics::NewProp_InOutVi = { "InOutVi", nullptr, (EPropertyFlags)0x0010000008000180, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventVelocitySpringDampVector_Parms, InOutVi), Z_Construct_UScriptStruct_FVector, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampVector_Statics::NewProp_TargetX = { "TargetX", nullptr, (EPropertyFlags)0x0010000008000182, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventVelocitySpringDampVector_Parms, TargetX), Z_Construct_UScriptStruct_FVector, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_TargetX_MetaData), NewProp_TargetX_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampVector_Statics::NewProp_MaxSpeed = { "MaxSpeed", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventVelocitySpringDampVector_Parms, MaxSpeed), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampVector_Statics::NewProp_DeltaTime = { "DeltaTime", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventVelocitySpringDampVector_Parms, DeltaTime), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampVector_Statics::NewProp_SmoothingTime = { "SmoothingTime", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventVelocitySpringDampVector_Parms, SmoothingTime), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampVector_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampVector_Statics::NewProp_InOutX,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampVector_Statics::NewProp_InOutV,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampVector_Statics::NewProp_InOutVi,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampVector_Statics::NewProp_TargetX,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampVector_Statics::NewProp_MaxSpeed,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampVector_Statics::NewProp_DeltaTime,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampVector_Statics::NewProp_SmoothingTime,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampVector_Statics::PropPointers) < 2048);
// ********** End Function VelocitySpringDampVector Property Definitions ***************************
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampVector_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UBlueprintSpringMathLibrary, nullptr, "VelocitySpringDampVector", 	Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampVector_Statics::PropPointers, 
	UE_ARRAY_COUNT(Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampVector_Statics::PropPointers), 
sizeof(Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampVector_Statics::BlueprintSpringMathLibrary_eventVelocitySpringDampVector_Parms),
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04C22403, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampVector_Statics::Function_MetaDataParams), Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampVector_Statics::Function_MetaDataParams)},  };
static_assert(sizeof(Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampVector_Statics::BlueprintSpringMathLibrary_eventVelocitySpringDampVector_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampVector()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampVector_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UBlueprintSpringMathLibrary::execVelocitySpringDampVector)
{
	P_GET_STRUCT_REF(FVector,Z_Param_Out_InOutX);
	P_GET_STRUCT_REF(FVector,Z_Param_Out_InOutV);
	P_GET_STRUCT_REF(FVector,Z_Param_Out_InOutVi);
	P_GET_STRUCT_REF(FVector,Z_Param_Out_TargetX);
	P_GET_PROPERTY(FFloatProperty,Z_Param_MaxSpeed);
	P_GET_PROPERTY(FFloatProperty,Z_Param_DeltaTime);
	P_GET_PROPERTY(FFloatProperty,Z_Param_SmoothingTime);
	P_FINISH;
	P_NATIVE_BEGIN;
	UBlueprintSpringMathLibrary::VelocitySpringDampVector(Z_Param_Out_InOutX,Z_Param_Out_InOutV,Z_Param_Out_InOutVi,Z_Param_Out_TargetX,Z_Param_MaxSpeed,Z_Param_DeltaTime,Z_Param_SmoothingTime);
	P_NATIVE_END;
}
// ********** End Class UBlueprintSpringMathLibrary Function VelocitySpringDampVector **************

// ********** Begin Class UBlueprintSpringMathLibrary Function VelocitySpringDampVector2D **********
struct Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampVector2D_Statics
{
	struct BlueprintSpringMathLibrary_eventVelocitySpringDampVector2D_Parms
	{
		FVector2D InOutX;
		FVector2D InOutV;
		FVector2D InOutVi;
		FVector2D TargetX;
		float MaxSpeed;
		float DeltaTime;
		float SmoothingTime;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Category", "Math|Spring|Experimental" },
		{ "Comment", "/** A velocity spring will damp towards a target that follows a fixed linear target velocity, allowing control of the interpolation speed\n\x09 * while still giving a smoothed behavior. A SmoothingTime of 0 will give a linear interpolation between X and TargetX\n\x09 * \n\x09 * @param InOutX The value to be damped\n\x09 * @param InOutV The velocity of the value to be damped\n\x09 * @param InOutVi The intermediate target velocity of the value to be damped\n\x09 * @param TargetX The target value of X to damp towards\n\x09 * @param MaxSpeed The desired speed to achieve while damping towards X\n\x09 * @param SmoothingTime The smoothing time to use while damping towards X. Higher values will give more smoothed behaviour. A value of 0 will give a linear interpolation of X to Target\n\x09 * @param DeltaTime The timestep in seconds\n\x09 */" },
		{ "CPP_Default_SmoothingTime", "0.200000" },
		{ "ModuleRelativePath", "Classes/Kismet/BlueprintSpringMathLibrary.h" },
		{ "ToolTip", "A velocity spring will damp towards a target that follows a fixed linear target velocity, allowing control of the interpolation speed\nwhile still giving a smoothed behavior. A SmoothingTime of 0 will give a linear interpolation between X and TargetX\n\n@param InOutX The value to be damped\n@param InOutV The velocity of the value to be damped\n@param InOutVi The intermediate target velocity of the value to be damped\n@param TargetX The target value of X to damp towards\n@param MaxSpeed The desired speed to achieve while damping towards X\n@param SmoothingTime The smoothing time to use while damping towards X. Higher values will give more smoothed behaviour. A value of 0 will give a linear interpolation of X to Target\n@param DeltaTime The timestep in seconds" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_TargetX_MetaData[] = {
		{ "NativeConst", "" },
	};
#endif // WITH_METADATA

// ********** Begin Function VelocitySpringDampVector2D constinit property declarations ************
	static const UECodeGen_Private::FStructPropertyParams NewProp_InOutX;
	static const UECodeGen_Private::FStructPropertyParams NewProp_InOutV;
	static const UECodeGen_Private::FStructPropertyParams NewProp_InOutVi;
	static const UECodeGen_Private::FStructPropertyParams NewProp_TargetX;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_MaxSpeed;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_DeltaTime;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_SmoothingTime;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End Function VelocitySpringDampVector2D constinit property declarations **************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};

// ********** Begin Function VelocitySpringDampVector2D Property Definitions ***********************
const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampVector2D_Statics::NewProp_InOutX = { "InOutX", nullptr, (EPropertyFlags)0x0010000008000180, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventVelocitySpringDampVector2D_Parms, InOutX), Z_Construct_UScriptStruct_FVector2D, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampVector2D_Statics::NewProp_InOutV = { "InOutV", nullptr, (EPropertyFlags)0x0010000008000180, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventVelocitySpringDampVector2D_Parms, InOutV), Z_Construct_UScriptStruct_FVector2D, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampVector2D_Statics::NewProp_InOutVi = { "InOutVi", nullptr, (EPropertyFlags)0x0010000008000180, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventVelocitySpringDampVector2D_Parms, InOutVi), Z_Construct_UScriptStruct_FVector2D, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampVector2D_Statics::NewProp_TargetX = { "TargetX", nullptr, (EPropertyFlags)0x0010000008000182, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventVelocitySpringDampVector2D_Parms, TargetX), Z_Construct_UScriptStruct_FVector2D, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_TargetX_MetaData), NewProp_TargetX_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampVector2D_Statics::NewProp_MaxSpeed = { "MaxSpeed", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventVelocitySpringDampVector2D_Parms, MaxSpeed), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampVector2D_Statics::NewProp_DeltaTime = { "DeltaTime", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventVelocitySpringDampVector2D_Parms, DeltaTime), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampVector2D_Statics::NewProp_SmoothingTime = { "SmoothingTime", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(BlueprintSpringMathLibrary_eventVelocitySpringDampVector2D_Parms, SmoothingTime), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampVector2D_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampVector2D_Statics::NewProp_InOutX,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampVector2D_Statics::NewProp_InOutV,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampVector2D_Statics::NewProp_InOutVi,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampVector2D_Statics::NewProp_TargetX,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampVector2D_Statics::NewProp_MaxSpeed,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampVector2D_Statics::NewProp_DeltaTime,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampVector2D_Statics::NewProp_SmoothingTime,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampVector2D_Statics::PropPointers) < 2048);
// ********** End Function VelocitySpringDampVector2D Property Definitions *************************
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampVector2D_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UBlueprintSpringMathLibrary, nullptr, "VelocitySpringDampVector2D", 	Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampVector2D_Statics::PropPointers, 
	UE_ARRAY_COUNT(Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampVector2D_Statics::PropPointers), 
sizeof(Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampVector2D_Statics::BlueprintSpringMathLibrary_eventVelocitySpringDampVector2D_Parms),
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04C22403, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampVector2D_Statics::Function_MetaDataParams), Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampVector2D_Statics::Function_MetaDataParams)},  };
static_assert(sizeof(Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampVector2D_Statics::BlueprintSpringMathLibrary_eventVelocitySpringDampVector2D_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampVector2D()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampVector2D_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UBlueprintSpringMathLibrary::execVelocitySpringDampVector2D)
{
	P_GET_STRUCT_REF(FVector2D,Z_Param_Out_InOutX);
	P_GET_STRUCT_REF(FVector2D,Z_Param_Out_InOutV);
	P_GET_STRUCT_REF(FVector2D,Z_Param_Out_InOutVi);
	P_GET_STRUCT_REF(FVector2D,Z_Param_Out_TargetX);
	P_GET_PROPERTY(FFloatProperty,Z_Param_MaxSpeed);
	P_GET_PROPERTY(FFloatProperty,Z_Param_DeltaTime);
	P_GET_PROPERTY(FFloatProperty,Z_Param_SmoothingTime);
	P_FINISH;
	P_NATIVE_BEGIN;
	UBlueprintSpringMathLibrary::VelocitySpringDampVector2D(Z_Param_Out_InOutX,Z_Param_Out_InOutV,Z_Param_Out_InOutVi,Z_Param_Out_TargetX,Z_Param_MaxSpeed,Z_Param_DeltaTime,Z_Param_SmoothingTime);
	P_NATIVE_END;
}
// ********** End Class UBlueprintSpringMathLibrary Function VelocitySpringDampVector2D ************

// ********** Begin Class UBlueprintSpringMathLibrary **********************************************
FClassRegistrationInfo Z_Registration_Info_UClass_UBlueprintSpringMathLibrary;
UClass* UBlueprintSpringMathLibrary::GetPrivateStaticClass()
{
	using TClass = UBlueprintSpringMathLibrary;
	if (!Z_Registration_Info_UClass_UBlueprintSpringMathLibrary.InnerSingleton)
	{
		GetPrivateStaticClassBody(
			TClass::StaticPackage(),
			TEXT("BlueprintSpringMathLibrary"),
			Z_Registration_Info_UClass_UBlueprintSpringMathLibrary.InnerSingleton,
			StaticRegisterNativesUBlueprintSpringMathLibrary,
			sizeof(TClass),
			alignof(TClass),
			TClass::StaticClassFlags,
			TClass::StaticClassCastFlags(),
			TClass::StaticConfigName(),
			(UClass::ClassConstructorType)InternalConstructor<TClass>,
			(UClass::ClassVTableHelperCtorCallerType)InternalVTableHelperCtorCaller<TClass>,
			UOBJECT_CPPCLASS_STATICFUNCTIONS_FORCLASS(TClass),
			&TClass::Super::StaticClass,
			&TClass::WithinClass::StaticClass
		);
	}
	return Z_Registration_Info_UClass_UBlueprintSpringMathLibrary.InnerSingleton;
}
UClass* Z_Construct_UClass_UBlueprintSpringMathLibrary_NoRegister()
{
	return UBlueprintSpringMathLibrary::GetPrivateStaticClass();
}
struct Z_Construct_UClass_UBlueprintSpringMathLibrary_Statics
{
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Class_MetaDataParams[] = {
		{ "BlueprintThreadSafe", "" },
		{ "DevelopmentStatus", "Experimental" },
		{ "IncludePath", "Kismet/BlueprintSpringMathLibrary.h" },
		{ "ModuleRelativePath", "Classes/Kismet/BlueprintSpringMathLibrary.h" },
	};
#endif // WITH_METADATA

// ********** Begin Class UBlueprintSpringMathLibrary constinit property declarations **************
// ********** End Class UBlueprintSpringMathLibrary constinit property declarations ****************
	static constexpr UE::CodeGen::FClassNativeFunction Funcs[] = {
		{ .NameUTF8 = UTF8TEXT("ConvertHalfLifeToSmoothingTime"), .Pointer = &UBlueprintSpringMathLibrary::execConvertHalfLifeToSmoothingTime },
		{ .NameUTF8 = UTF8TEXT("ConvertSmoothingTimeToHalfLife"), .Pointer = &UBlueprintSpringMathLibrary::execConvertSmoothingTimeToHalfLife },
		{ .NameUTF8 = UTF8TEXT("ConvertSmoothingTimeToStrength"), .Pointer = &UBlueprintSpringMathLibrary::execConvertSmoothingTimeToStrength },
		{ .NameUTF8 = UTF8TEXT("ConvertStrengthToSmoothingTime"), .Pointer = &UBlueprintSpringMathLibrary::execConvertStrengthToSmoothingTime },
		{ .NameUTF8 = UTF8TEXT("CriticalSpringDampAngle"), .Pointer = &UBlueprintSpringMathLibrary::execCriticalSpringDampAngle },
		{ .NameUTF8 = UTF8TEXT("CriticalSpringDampFloat"), .Pointer = &UBlueprintSpringMathLibrary::execCriticalSpringDampFloat },
		{ .NameUTF8 = UTF8TEXT("CriticalSpringDampQuat"), .Pointer = &UBlueprintSpringMathLibrary::execCriticalSpringDampQuat },
		{ .NameUTF8 = UTF8TEXT("CriticalSpringDampRotator"), .Pointer = &UBlueprintSpringMathLibrary::execCriticalSpringDampRotator },
		{ .NameUTF8 = UTF8TEXT("CriticalSpringDampVector"), .Pointer = &UBlueprintSpringMathLibrary::execCriticalSpringDampVector },
		{ .NameUTF8 = UTF8TEXT("CriticalSpringDampVector2D"), .Pointer = &UBlueprintSpringMathLibrary::execCriticalSpringDampVector2D },
		{ .NameUTF8 = UTF8TEXT("DampAngle"), .Pointer = &UBlueprintSpringMathLibrary::execDampAngle },
		{ .NameUTF8 = UTF8TEXT("DampFloat"), .Pointer = &UBlueprintSpringMathLibrary::execDampFloat },
		{ .NameUTF8 = UTF8TEXT("DampQuat"), .Pointer = &UBlueprintSpringMathLibrary::execDampQuat },
		{ .NameUTF8 = UTF8TEXT("DampRotator"), .Pointer = &UBlueprintSpringMathLibrary::execDampRotator },
		{ .NameUTF8 = UTF8TEXT("DampVector"), .Pointer = &UBlueprintSpringMathLibrary::execDampVector },
		{ .NameUTF8 = UTF8TEXT("DampVector2D"), .Pointer = &UBlueprintSpringMathLibrary::execDampVector2D },
		{ .NameUTF8 = UTF8TEXT("SpringCharacterUpdate"), .Pointer = &UBlueprintSpringMathLibrary::execSpringCharacterUpdate },
		{ .NameUTF8 = UTF8TEXT("VelocitySpringCharacterUpdate"), .Pointer = &UBlueprintSpringMathLibrary::execVelocitySpringCharacterUpdate },
		{ .NameUTF8 = UTF8TEXT("VelocitySpringDampFloat"), .Pointer = &UBlueprintSpringMathLibrary::execVelocitySpringDampFloat },
		{ .NameUTF8 = UTF8TEXT("VelocitySpringDampVector"), .Pointer = &UBlueprintSpringMathLibrary::execVelocitySpringDampVector },
		{ .NameUTF8 = UTF8TEXT("VelocitySpringDampVector2D"), .Pointer = &UBlueprintSpringMathLibrary::execVelocitySpringDampVector2D },
	};
	static UObject* (*const DependentSingletons[])();
	static constexpr FClassFunctionLinkInfo FuncInfo[] = {
		{ &Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertHalfLifeToSmoothingTime, "ConvertHalfLifeToSmoothingTime" }, // 2227004437
		{ &Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertSmoothingTimeToHalfLife, "ConvertSmoothingTimeToHalfLife" }, // 2836663479
		{ &Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertSmoothingTimeToStrength, "ConvertSmoothingTimeToStrength" }, // 307966904
		{ &Z_Construct_UFunction_UBlueprintSpringMathLibrary_ConvertStrengthToSmoothingTime, "ConvertStrengthToSmoothingTime" }, // 4266238540
		{ &Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampAngle, "CriticalSpringDampAngle" }, // 3957701752
		{ &Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampFloat, "CriticalSpringDampFloat" }, // 273366188
		{ &Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampQuat, "CriticalSpringDampQuat" }, // 3958110497
		{ &Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampRotator, "CriticalSpringDampRotator" }, // 938874978
		{ &Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampVector, "CriticalSpringDampVector" }, // 2832051472
		{ &Z_Construct_UFunction_UBlueprintSpringMathLibrary_CriticalSpringDampVector2D, "CriticalSpringDampVector2D" }, // 700927348
		{ &Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampAngle, "DampAngle" }, // 1748341425
		{ &Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampFloat, "DampFloat" }, // 2780258955
		{ &Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampQuat, "DampQuat" }, // 3498067619
		{ &Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampRotator, "DampRotator" }, // 2276970455
		{ &Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampVector, "DampVector" }, // 1123251536
		{ &Z_Construct_UFunction_UBlueprintSpringMathLibrary_DampVector2D, "DampVector2D" }, // 1737063634
		{ &Z_Construct_UFunction_UBlueprintSpringMathLibrary_SpringCharacterUpdate, "SpringCharacterUpdate" }, // 828520679
		{ &Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringCharacterUpdate, "VelocitySpringCharacterUpdate" }, // 3823843666
		{ &Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampFloat, "VelocitySpringDampFloat" }, // 2381258237
		{ &Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampVector, "VelocitySpringDampVector" }, // 3605556957
		{ &Z_Construct_UFunction_UBlueprintSpringMathLibrary_VelocitySpringDampVector2D, "VelocitySpringDampVector2D" }, // 967060316
	};
	static_assert(UE_ARRAY_COUNT(FuncInfo) < 2048);
	static constexpr FCppClassTypeInfoStatic StaticCppClassTypeInfo = {
		TCppClassTypeTraits<UBlueprintSpringMathLibrary>::IsAbstract,
	};
	static const UECodeGen_Private::FClassParams ClassParams;
}; // struct Z_Construct_UClass_UBlueprintSpringMathLibrary_Statics
UObject* (*const Z_Construct_UClass_UBlueprintSpringMathLibrary_Statics::DependentSingletons[])() = {
	(UObject* (*)())Z_Construct_UClass_UBlueprintFunctionLibrary,
	(UObject* (*)())Z_Construct_UPackage__Script_Engine,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UClass_UBlueprintSpringMathLibrary_Statics::DependentSingletons) < 16);
const UECodeGen_Private::FClassParams Z_Construct_UClass_UBlueprintSpringMathLibrary_Statics::ClassParams = {
	&UBlueprintSpringMathLibrary::StaticClass,
	nullptr,
	&StaticCppClassTypeInfo,
	DependentSingletons,
	FuncInfo,
	nullptr,
	nullptr,
	UE_ARRAY_COUNT(DependentSingletons),
	UE_ARRAY_COUNT(FuncInfo),
	0,
	0,
	0x000800A0u,
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UClass_UBlueprintSpringMathLibrary_Statics::Class_MetaDataParams), Z_Construct_UClass_UBlueprintSpringMathLibrary_Statics::Class_MetaDataParams)
};
void UBlueprintSpringMathLibrary::StaticRegisterNativesUBlueprintSpringMathLibrary()
{
	UClass* Class = UBlueprintSpringMathLibrary::StaticClass();
	FNativeFunctionRegistrar::RegisterFunctions(Class, MakeConstArrayView(Z_Construct_UClass_UBlueprintSpringMathLibrary_Statics::Funcs));
}
UClass* Z_Construct_UClass_UBlueprintSpringMathLibrary()
{
	if (!Z_Registration_Info_UClass_UBlueprintSpringMathLibrary.OuterSingleton)
	{
		UECodeGen_Private::ConstructUClass(Z_Registration_Info_UClass_UBlueprintSpringMathLibrary.OuterSingleton, Z_Construct_UClass_UBlueprintSpringMathLibrary_Statics::ClassParams);
	}
	return Z_Registration_Info_UClass_UBlueprintSpringMathLibrary.OuterSingleton;
}
UBlueprintSpringMathLibrary::UBlueprintSpringMathLibrary(const FObjectInitializer& ObjectInitializer) : Super(ObjectInitializer) {}
DEFINE_VTABLE_PTR_HELPER_CTOR_NS(, UBlueprintSpringMathLibrary);
UBlueprintSpringMathLibrary::~UBlueprintSpringMathLibrary() {}
// ********** End Class UBlueprintSpringMathLibrary ************************************************

// ********** Begin Registration *******************************************************************
struct Z_CompiledInDeferFile_FID_Engine_Source_Runtime_Engine_Classes_Kismet_BlueprintSpringMathLibrary_h__Script_Engine_Statics
{
	static constexpr FClassRegisterCompiledInInfo ClassInfo[] = {
		{ Z_Construct_UClass_UBlueprintSpringMathLibrary, UBlueprintSpringMathLibrary::StaticClass, TEXT("UBlueprintSpringMathLibrary"), &Z_Registration_Info_UClass_UBlueprintSpringMathLibrary, CONSTRUCT_RELOAD_VERSION_INFO(FClassReloadVersionInfo, sizeof(UBlueprintSpringMathLibrary), 1287154363U) },
	};
}; // Z_CompiledInDeferFile_FID_Engine_Source_Runtime_Engine_Classes_Kismet_BlueprintSpringMathLibrary_h__Script_Engine_Statics 
static FRegisterCompiledInInfo Z_CompiledInDeferFile_FID_Engine_Source_Runtime_Engine_Classes_Kismet_BlueprintSpringMathLibrary_h__Script_Engine_665002447{
	TEXT("/Script/Engine"),
	Z_CompiledInDeferFile_FID_Engine_Source_Runtime_Engine_Classes_Kismet_BlueprintSpringMathLibrary_h__Script_Engine_Statics::ClassInfo, UE_ARRAY_COUNT(Z_CompiledInDeferFile_FID_Engine_Source_Runtime_Engine_Classes_Kismet_BlueprintSpringMathLibrary_h__Script_Engine_Statics::ClassInfo),
	nullptr, 0,
	nullptr, 0,
};
// ********** End Registration *********************************************************************

PRAGMA_ENABLE_DEPRECATION_WARNINGS