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

#include "GeneratedCppIncludes.h"
#include "Public/FOHEARTBPLibrary.h"
#ifdef _MSC_VER
#pragma warning (push)
#pragma warning (disable : 4883)
#endif
PRAGMA_DISABLE_DEPRECATION_WARNINGS
void EmptyLinkFunctionForGeneratedCodeFOHEARTBPLibrary() {}
// Cross Module References
	FOHEART_API UEnum* Z_Construct_UEnum_FOHEART_EFOHEART_C1BonesEnum();
	UPackage* Z_Construct_UPackage__Script_FOHEART();
	FOHEART_API UEnum* Z_Construct_UEnum_FOHEART_EFOHEARTBoneAxisEnum();
	FOHEART_API UEnum* Z_Construct_UEnum_FOHEART_EFOHEARTChannelNumberEnum();
	FOHEART_API UEnum* Z_Construct_UEnum_FOHEART_EFOHEARTRotOrderEnum();
	FOHEART_API UEnum* Z_Construct_UEnum_FOHEART_EFOHEARTXYZEnum();
	FOHEART_API UEnum* Z_Construct_UEnum_FOHEART_EFOHEARTMotionLineFormatEnum();
	FOHEART_API UEnum* Z_Construct_UEnum_FOHEART_EFOHEARTSkeletonEnum();
	FOHEART_API UScriptStruct* Z_Construct_UScriptStruct_FFOHEART_C1BoneMapStruct();
	FOHEART_API UScriptStruct* Z_Construct_UScriptStruct_FFOHEART_BoneAxisMatch();
	FOHEART_API UClass* Z_Construct_UClass_UFOHEART_C1BPLibrary_NoRegister();
	FOHEART_API UClass* Z_Construct_UClass_UFOHEART_C1BPLibrary();
	ENGINE_API UClass* Z_Construct_UClass_UBlueprintFunctionLibrary();
	FOHEART_API UFunction* Z_Construct_UFunction_UFOHEART_C1BPLibrary_FOHEART_C1BoneSetOffset();
	FOHEART_API UClass* Z_Construct_UClass_AFOHEARTController_NoRegister();
	FOHEART_API UFunction* Z_Construct_UFunction_UFOHEART_C1BPLibrary_FOHEART_C1BVHPause();
	FOHEART_API UFunction* Z_Construct_UFunction_UFOHEART_C1BPLibrary_FOHEART_C1BVHPlay();
	FOHEART_API UFunction* Z_Construct_UFunction_UFOHEART_C1BPLibrary_FOHEART_C1BVHRewind();
	FOHEART_API UFunction* Z_Construct_UFunction_UFOHEART_C1BPLibrary_FOHEART_C1ConnectTCP();
	FOHEART_API UFunction* Z_Construct_UFunction_UFOHEART_C1BPLibrary_FOHEART_C1ConnectUDP();
	FOHEART_API UFunction* Z_Construct_UFunction_UFOHEART_C1BPLibrary_FOHEART_C1Disconnect();
	FOHEART_API UFunction* Z_Construct_UFunction_UFOHEART_C1BPLibrary_FOHEART_C1GetBVHBoneIndex();
	FOHEART_API UFunction* Z_Construct_UFunction_UFOHEART_C1BPLibrary_FOHEART_C1GetLocalBoneLocation();
	COREUOBJECT_API UScriptStruct* Z_Construct_UScriptStruct_FVector();
	ENGINE_API UClass* Z_Construct_UClass_USkeletalMeshComponent_NoRegister();
	FOHEART_API UFunction* Z_Construct_UFunction_UFOHEART_C1BPLibrary_FOHEART_C1GetLocalBoneRotation();
	COREUOBJECT_API UScriptStruct* Z_Construct_UScriptStruct_FRotator();
	FOHEART_API UFunction* Z_Construct_UFunction_UFOHEART_C1BPLibrary_FOHEART_C1GetReferencePoseLocalBoneRotation();
	FOHEART_API UFunction* Z_Construct_UFunction_UFOHEART_C1BPLibrary_FOHEART_C1Init();
	FOHEART_API UFunction* Z_Construct_UFunction_UFOHEART_C1BPLibrary_FOHEART_C1InitBVHFile();
	FOHEART_API UFunction* Z_Construct_UFunction_UFOHEART_C1BPLibrary_FOHEART_C1NegateRotation();
	FOHEART_API UFunction* Z_Construct_UFunction_UFOHEART_C1BPLibrary_FOHEART_C1Read();
	FOHEART_API UFunction* Z_Construct_UFunction_UFOHEART_C1BPLibrary_FOHEART_C1ReadArray();
// End Cross Module References
	static UEnum* EFOHEART_C1BonesEnum_StaticEnum()
	{
		static UEnum* Singleton = nullptr;
		if (!Singleton)
		{
			Singleton = GetStaticEnum(Z_Construct_UEnum_FOHEART_EFOHEART_C1BonesEnum, Z_Construct_UPackage__Script_FOHEART(), TEXT("EFOHEART_C1BonesEnum"));
		}
		return Singleton;
	}
	static FCompiledInDeferEnum Z_CompiledInDeferEnum_UEnum_EFOHEART_C1BonesEnum(EFOHEART_C1BonesEnum_StaticEnum, TEXT("/Script/FOHEART"), TEXT("EFOHEART_C1BonesEnum"), false, nullptr, nullptr);
	uint32 Get_Z_Construct_UEnum_FOHEART_EFOHEART_C1BonesEnum_CRC() { return 2484247744U; }
	UEnum* Z_Construct_UEnum_FOHEART_EFOHEART_C1BonesEnum()
	{
#if WITH_HOT_RELOAD
		UPackage* Outer = Z_Construct_UPackage__Script_FOHEART();
		static UEnum* ReturnEnum = FindExistingEnumIfHotReloadOrDynamic(Outer, TEXT("EFOHEART_C1BonesEnum"), 0, Get_Z_Construct_UEnum_FOHEART_EFOHEART_C1BonesEnum_CRC(), false);
#else
		static UEnum* ReturnEnum = nullptr;
#endif // WITH_HOT_RELOAD
		if (!ReturnEnum)
		{
			static const UE4CodeGen_Private::FEnumeratorParam Enumerators[] = {
				{ "EFOHEART_C1BonesEnum::VE_Hips", (int64)EFOHEART_C1BonesEnum::VE_Hips },
				{ "EFOHEART_C1BonesEnum::VE_Spine", (int64)EFOHEART_C1BonesEnum::VE_Spine },
				{ "EFOHEART_C1BonesEnum::VE_Spine2", (int64)EFOHEART_C1BonesEnum::VE_Spine2 },
				{ "EFOHEART_C1BonesEnum::VE_Spine3", (int64)EFOHEART_C1BonesEnum::VE_Spine3 },
				{ "EFOHEART_C1BonesEnum::VE_Spine4", (int64)EFOHEART_C1BonesEnum::VE_Spine4 },
				{ "EFOHEART_C1BonesEnum::VE_Neck", (int64)EFOHEART_C1BonesEnum::VE_Neck },
				{ "EFOHEART_C1BonesEnum::VE_Head", (int64)EFOHEART_C1BonesEnum::VE_Head },
				{ "EFOHEART_C1BonesEnum::VE_RightShoulder", (int64)EFOHEART_C1BonesEnum::VE_RightShoulder },
				{ "EFOHEART_C1BonesEnum::VE_RightArm", (int64)EFOHEART_C1BonesEnum::VE_RightArm },
				{ "EFOHEART_C1BonesEnum::VE_RightForeArm", (int64)EFOHEART_C1BonesEnum::VE_RightForeArm },
				{ "EFOHEART_C1BonesEnum::VE_RightHand", (int64)EFOHEART_C1BonesEnum::VE_RightHand },
				{ "EFOHEART_C1BonesEnum::VE_LeftShoulder", (int64)EFOHEART_C1BonesEnum::VE_LeftShoulder },
				{ "EFOHEART_C1BonesEnum::VE_LeftArm", (int64)EFOHEART_C1BonesEnum::VE_LeftArm },
				{ "EFOHEART_C1BonesEnum::VE_LeftForeArm", (int64)EFOHEART_C1BonesEnum::VE_LeftForeArm },
				{ "EFOHEART_C1BonesEnum::VE_LeftHand", (int64)EFOHEART_C1BonesEnum::VE_LeftHand },
				{ "EFOHEART_C1BonesEnum::VE_RightUpLeg", (int64)EFOHEART_C1BonesEnum::VE_RightUpLeg },
				{ "EFOHEART_C1BonesEnum::VE_RightLeg", (int64)EFOHEART_C1BonesEnum::VE_RightLeg },
				{ "EFOHEART_C1BonesEnum::VE_RightFoot", (int64)EFOHEART_C1BonesEnum::VE_RightFoot },
				{ "EFOHEART_C1BonesEnum::VE_RightToeBase", (int64)EFOHEART_C1BonesEnum::VE_RightToeBase },
				{ "EFOHEART_C1BonesEnum::VE_LeftUpLeg", (int64)EFOHEART_C1BonesEnum::VE_LeftUpLeg },
				{ "EFOHEART_C1BonesEnum::VE_LeftLeg", (int64)EFOHEART_C1BonesEnum::VE_LeftLeg },
				{ "EFOHEART_C1BonesEnum::VE_LeftFoot", (int64)EFOHEART_C1BonesEnum::VE_LeftFoot },
				{ "EFOHEART_C1BonesEnum::VE_LeftToeBase", (int64)EFOHEART_C1BonesEnum::VE_LeftToeBase },
			};
#if WITH_METADATA
			static const UE4CodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
				{ "BlueprintType", "true" },
				{ "ModuleRelativePath", "Public/FOHEARTBPLibrary.h" },
				{ "ToolTip", "Bones delivered in the FOHEART_C1 live stream" },
				{ "VE_Head.DisplayName", "Head" },
				{ "VE_Hips.DisplayName", "Hips" },
				{ "VE_LeftArm.DisplayName", "LeftArm" },
				{ "VE_LeftFoot.DisplayName", "LeftFoot" },
				{ "VE_LeftForeArm.DisplayName", "LeftForeArm" },
				{ "VE_LeftHand.DisplayName", "LeftHand" },
				{ "VE_LeftLeg.DisplayName", "LeftLeg" },
				{ "VE_LeftShoulder.DisplayName", "LeftShoulder" },
				{ "VE_LeftToeBase.DisplayName", "LeftToeBase" },
				{ "VE_LeftUpLeg.DisplayName", "LeftUpLeg" },
				{ "VE_Neck.DisplayName", "Neck" },
				{ "VE_RightArm.DisplayName", "RightArm" },
				{ "VE_RightFoot.DisplayName", "RightFoot" },
				{ "VE_RightForeArm.DisplayName", "RightForeArm" },
				{ "VE_RightHand.DisplayName", "RightHand" },
				{ "VE_RightLeg.DisplayName", "RightLeg" },
				{ "VE_RightShoulder.DisplayName", "RightShoulder" },
				{ "VE_RightToeBase.DisplayName", "RightToeBase" },
				{ "VE_RightUpLeg.DisplayName", "RightUpLeg" },
				{ "VE_Spine.DisplayName", "Spine(useless)" },
				{ "VE_Spine2.DisplayName", "Spine2" },
				{ "VE_Spine3.DisplayName", "Spine3" },
				{ "VE_Spine4.DisplayName", "Spine4" },
			};
#endif
			static const UE4CodeGen_Private::FEnumParams EnumParams = {
				(UObject*(*)())Z_Construct_UPackage__Script_FOHEART,
				UE4CodeGen_Private::EDynamicType::NotDynamic,
				"EFOHEART_C1BonesEnum",
				RF_Public|RF_Transient|RF_MarkAsNative,
				nullptr,
				(uint8)UEnum::ECppForm::EnumClass,
				"EFOHEART_C1BonesEnum",
				Enumerators,
				ARRAY_COUNT(Enumerators),
				METADATA_PARAMS(Enum_MetaDataParams, ARRAY_COUNT(Enum_MetaDataParams))
			};
			UE4CodeGen_Private::ConstructUEnum(ReturnEnum, EnumParams);
		}
		return ReturnEnum;
	}
	static UEnum* EFOHEARTBoneAxisEnum_StaticEnum()
	{
		static UEnum* Singleton = nullptr;
		if (!Singleton)
		{
			Singleton = GetStaticEnum(Z_Construct_UEnum_FOHEART_EFOHEARTBoneAxisEnum, Z_Construct_UPackage__Script_FOHEART(), TEXT("EFOHEARTBoneAxisEnum"));
		}
		return Singleton;
	}
	static FCompiledInDeferEnum Z_CompiledInDeferEnum_UEnum_EFOHEARTBoneAxisEnum(EFOHEARTBoneAxisEnum_StaticEnum, TEXT("/Script/FOHEART"), TEXT("EFOHEARTBoneAxisEnum"), false, nullptr, nullptr);
	uint32 Get_Z_Construct_UEnum_FOHEART_EFOHEARTBoneAxisEnum_CRC() { return 1417892862U; }
	UEnum* Z_Construct_UEnum_FOHEART_EFOHEARTBoneAxisEnum()
	{
#if WITH_HOT_RELOAD
		UPackage* Outer = Z_Construct_UPackage__Script_FOHEART();
		static UEnum* ReturnEnum = FindExistingEnumIfHotReloadOrDynamic(Outer, TEXT("EFOHEARTBoneAxisEnum"), 0, Get_Z_Construct_UEnum_FOHEART_EFOHEARTBoneAxisEnum_CRC(), false);
#else
		static UEnum* ReturnEnum = nullptr;
#endif // WITH_HOT_RELOAD
		if (!ReturnEnum)
		{
			static const UE4CodeGen_Private::FEnumeratorParam Enumerators[] = {
				{ "EFOHEARTBoneAxisEnum::VE_Axis_X", (int64)EFOHEARTBoneAxisEnum::VE_Axis_X },
				{ "EFOHEARTBoneAxisEnum::VE_Axis_iX", (int64)EFOHEARTBoneAxisEnum::VE_Axis_iX },
				{ "EFOHEARTBoneAxisEnum::VE_Axis_Y", (int64)EFOHEARTBoneAxisEnum::VE_Axis_Y },
				{ "EFOHEARTBoneAxisEnum::VE_Axis_iY", (int64)EFOHEARTBoneAxisEnum::VE_Axis_iY },
				{ "EFOHEARTBoneAxisEnum::VE_Axis_Z", (int64)EFOHEARTBoneAxisEnum::VE_Axis_Z },
				{ "EFOHEARTBoneAxisEnum::VE_Axis_iZ", (int64)EFOHEARTBoneAxisEnum::VE_Axis_iZ },
			};
#if WITH_METADATA
			static const UE4CodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
				{ "BlueprintType", "true" },
				{ "ModuleRelativePath", "Public/FOHEARTBPLibrary.h" },
				{ "VE_Axis_iX.DisplayName", "-X" },
				{ "VE_Axis_iY.DisplayName", "-Y" },
				{ "VE_Axis_iZ.DisplayName", "-Z" },
				{ "VE_Axis_X.DisplayName", "X" },
				{ "VE_Axis_Y.DisplayName", "Y" },
				{ "VE_Axis_Z.DisplayName", "Z" },
			};
#endif
			static const UE4CodeGen_Private::FEnumParams EnumParams = {
				(UObject*(*)())Z_Construct_UPackage__Script_FOHEART,
				UE4CodeGen_Private::EDynamicType::NotDynamic,
				"EFOHEARTBoneAxisEnum",
				RF_Public|RF_Transient|RF_MarkAsNative,
				nullptr,
				(uint8)UEnum::ECppForm::EnumClass,
				"EFOHEARTBoneAxisEnum",
				Enumerators,
				ARRAY_COUNT(Enumerators),
				METADATA_PARAMS(Enum_MetaDataParams, ARRAY_COUNT(Enum_MetaDataParams))
			};
			UE4CodeGen_Private::ConstructUEnum(ReturnEnum, EnumParams);
		}
		return ReturnEnum;
	}
	static UEnum* EFOHEARTChannelNumberEnum_StaticEnum()
	{
		static UEnum* Singleton = nullptr;
		if (!Singleton)
		{
			Singleton = GetStaticEnum(Z_Construct_UEnum_FOHEART_EFOHEARTChannelNumberEnum, Z_Construct_UPackage__Script_FOHEART(), TEXT("EFOHEARTChannelNumberEnum"));
		}
		return Singleton;
	}
	static FCompiledInDeferEnum Z_CompiledInDeferEnum_UEnum_EFOHEARTChannelNumberEnum(EFOHEARTChannelNumberEnum_StaticEnum, TEXT("/Script/FOHEART"), TEXT("EFOHEARTChannelNumberEnum"), false, nullptr, nullptr);
	uint32 Get_Z_Construct_UEnum_FOHEART_EFOHEARTChannelNumberEnum_CRC() { return 2662922302U; }
	UEnum* Z_Construct_UEnum_FOHEART_EFOHEARTChannelNumberEnum()
	{
#if WITH_HOT_RELOAD
		UPackage* Outer = Z_Construct_UPackage__Script_FOHEART();
		static UEnum* ReturnEnum = FindExistingEnumIfHotReloadOrDynamic(Outer, TEXT("EFOHEARTChannelNumberEnum"), 0, Get_Z_Construct_UEnum_FOHEART_EFOHEARTChannelNumberEnum_CRC(), false);
#else
		static UEnum* ReturnEnum = nullptr;
#endif // WITH_HOT_RELOAD
		if (!ReturnEnum)
		{
			static const UE4CodeGen_Private::FEnumeratorParam Enumerators[] = {
				{ "EFOHEARTChannelNumberEnum::VE_0", (int64)EFOHEARTChannelNumberEnum::VE_0 },
				{ "EFOHEARTChannelNumberEnum::VE_1", (int64)EFOHEARTChannelNumberEnum::VE_1 },
				{ "EFOHEARTChannelNumberEnum::VE_2", (int64)EFOHEARTChannelNumberEnum::VE_2 },
				{ "EFOHEARTChannelNumberEnum::VE_3", (int64)EFOHEARTChannelNumberEnum::VE_3 },
				{ "EFOHEARTChannelNumberEnum::VE_4", (int64)EFOHEARTChannelNumberEnum::VE_4 },
				{ "EFOHEARTChannelNumberEnum::VE_5", (int64)EFOHEARTChannelNumberEnum::VE_5 },
			};
#if WITH_METADATA
			static const UE4CodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
				{ "BlueprintType", "true" },
				{ "ModuleRelativePath", "Public/FOHEARTBPLibrary.h" },
				{ "VE_0.DisplayName", "0" },
				{ "VE_1.DisplayName", "1" },
				{ "VE_2.DisplayName", "2" },
				{ "VE_3.DisplayName", "3" },
				{ "VE_4.DisplayName", "4" },
				{ "VE_5.DisplayName", "5" },
			};
#endif
			static const UE4CodeGen_Private::FEnumParams EnumParams = {
				(UObject*(*)())Z_Construct_UPackage__Script_FOHEART,
				UE4CodeGen_Private::EDynamicType::NotDynamic,
				"EFOHEARTChannelNumberEnum",
				RF_Public|RF_Transient|RF_MarkAsNative,
				nullptr,
				(uint8)UEnum::ECppForm::EnumClass,
				"EFOHEARTChannelNumberEnum",
				Enumerators,
				ARRAY_COUNT(Enumerators),
				METADATA_PARAMS(Enum_MetaDataParams, ARRAY_COUNT(Enum_MetaDataParams))
			};
			UE4CodeGen_Private::ConstructUEnum(ReturnEnum, EnumParams);
		}
		return ReturnEnum;
	}
	static UEnum* EFOHEARTRotOrderEnum_StaticEnum()
	{
		static UEnum* Singleton = nullptr;
		if (!Singleton)
		{
			Singleton = GetStaticEnum(Z_Construct_UEnum_FOHEART_EFOHEARTRotOrderEnum, Z_Construct_UPackage__Script_FOHEART(), TEXT("EFOHEARTRotOrderEnum"));
		}
		return Singleton;
	}
	static FCompiledInDeferEnum Z_CompiledInDeferEnum_UEnum_EFOHEARTRotOrderEnum(EFOHEARTRotOrderEnum_StaticEnum, TEXT("/Script/FOHEART"), TEXT("EFOHEARTRotOrderEnum"), false, nullptr, nullptr);
	uint32 Get_Z_Construct_UEnum_FOHEART_EFOHEARTRotOrderEnum_CRC() { return 2273406567U; }
	UEnum* Z_Construct_UEnum_FOHEART_EFOHEARTRotOrderEnum()
	{
#if WITH_HOT_RELOAD
		UPackage* Outer = Z_Construct_UPackage__Script_FOHEART();
		static UEnum* ReturnEnum = FindExistingEnumIfHotReloadOrDynamic(Outer, TEXT("EFOHEARTRotOrderEnum"), 0, Get_Z_Construct_UEnum_FOHEART_EFOHEARTRotOrderEnum_CRC(), false);
#else
		static UEnum* ReturnEnum = nullptr;
#endif // WITH_HOT_RELOAD
		if (!ReturnEnum)
		{
			static const UE4CodeGen_Private::FEnumeratorParam Enumerators[] = {
				{ "EFOHEARTRotOrderEnum::VE_XYZ", (int64)EFOHEARTRotOrderEnum::VE_XYZ },
				{ "EFOHEARTRotOrderEnum::VE_XZY", (int64)EFOHEARTRotOrderEnum::VE_XZY },
				{ "EFOHEARTRotOrderEnum::VE_YXZ", (int64)EFOHEARTRotOrderEnum::VE_YXZ },
				{ "EFOHEARTRotOrderEnum::VE_YZX", (int64)EFOHEARTRotOrderEnum::VE_YZX },
				{ "EFOHEARTRotOrderEnum::VE_ZXY", (int64)EFOHEARTRotOrderEnum::VE_ZXY },
				{ "EFOHEARTRotOrderEnum::VE_ZYX", (int64)EFOHEARTRotOrderEnum::VE_ZYX },
			};
#if WITH_METADATA
			static const UE4CodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
				{ "BlueprintType", "true" },
				{ "ModuleRelativePath", "Public/FOHEARTBPLibrary.h" },
				{ "VE_XYZ.DisplayName", "XYZ" },
				{ "VE_XZY.DisplayName", "XZY" },
				{ "VE_YXZ.DisplayName", "YXZ" },
				{ "VE_YZX.DisplayName", "YZX" },
				{ "VE_ZXY.DisplayName", "ZXY" },
				{ "VE_ZYX.DisplayName", "ZYX" },
			};
#endif
			static const UE4CodeGen_Private::FEnumParams EnumParams = {
				(UObject*(*)())Z_Construct_UPackage__Script_FOHEART,
				UE4CodeGen_Private::EDynamicType::NotDynamic,
				"EFOHEARTRotOrderEnum",
				RF_Public|RF_Transient|RF_MarkAsNative,
				nullptr,
				(uint8)UEnum::ECppForm::EnumClass,
				"EFOHEARTRotOrderEnum",
				Enumerators,
				ARRAY_COUNT(Enumerators),
				METADATA_PARAMS(Enum_MetaDataParams, ARRAY_COUNT(Enum_MetaDataParams))
			};
			UE4CodeGen_Private::ConstructUEnum(ReturnEnum, EnumParams);
		}
		return ReturnEnum;
	}
	static UEnum* EFOHEARTXYZEnum_StaticEnum()
	{
		static UEnum* Singleton = nullptr;
		if (!Singleton)
		{
			Singleton = GetStaticEnum(Z_Construct_UEnum_FOHEART_EFOHEARTXYZEnum, Z_Construct_UPackage__Script_FOHEART(), TEXT("EFOHEARTXYZEnum"));
		}
		return Singleton;
	}
	static FCompiledInDeferEnum Z_CompiledInDeferEnum_UEnum_EFOHEARTXYZEnum(EFOHEARTXYZEnum_StaticEnum, TEXT("/Script/FOHEART"), TEXT("EFOHEARTXYZEnum"), false, nullptr, nullptr);
	uint32 Get_Z_Construct_UEnum_FOHEART_EFOHEARTXYZEnum_CRC() { return 1223530389U; }
	UEnum* Z_Construct_UEnum_FOHEART_EFOHEARTXYZEnum()
	{
#if WITH_HOT_RELOAD
		UPackage* Outer = Z_Construct_UPackage__Script_FOHEART();
		static UEnum* ReturnEnum = FindExistingEnumIfHotReloadOrDynamic(Outer, TEXT("EFOHEARTXYZEnum"), 0, Get_Z_Construct_UEnum_FOHEART_EFOHEARTXYZEnum_CRC(), false);
#else
		static UEnum* ReturnEnum = nullptr;
#endif // WITH_HOT_RELOAD
		if (!ReturnEnum)
		{
			static const UE4CodeGen_Private::FEnumeratorParam Enumerators[] = {
				{ "EFOHEARTXYZEnum::VE_X", (int64)EFOHEARTXYZEnum::VE_X },
				{ "EFOHEARTXYZEnum::VE_Y", (int64)EFOHEARTXYZEnum::VE_Y },
				{ "EFOHEARTXYZEnum::VE_Z", (int64)EFOHEARTXYZEnum::VE_Z },
				{ "EFOHEARTXYZEnum::VE_NX", (int64)EFOHEARTXYZEnum::VE_NX },
				{ "EFOHEARTXYZEnum::VE_NY", (int64)EFOHEARTXYZEnum::VE_NY },
				{ "EFOHEARTXYZEnum::VE_NZ", (int64)EFOHEARTXYZEnum::VE_NZ },
			};
#if WITH_METADATA
			static const UE4CodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
				{ "BlueprintType", "true" },
				{ "ModuleRelativePath", "Public/FOHEARTBPLibrary.h" },
				{ "VE_NX.DisplayName", "-X" },
				{ "VE_NY.DisplayName", "-Y" },
				{ "VE_NZ.DisplayName", "-Z" },
				{ "VE_X.DisplayName", "X" },
				{ "VE_Y.DisplayName", "Y" },
				{ "VE_Z.DisplayName", "Z" },
			};
#endif
			static const UE4CodeGen_Private::FEnumParams EnumParams = {
				(UObject*(*)())Z_Construct_UPackage__Script_FOHEART,
				UE4CodeGen_Private::EDynamicType::NotDynamic,
				"EFOHEARTXYZEnum",
				RF_Public|RF_Transient|RF_MarkAsNative,
				nullptr,
				(uint8)UEnum::ECppForm::EnumClass,
				"EFOHEARTXYZEnum",
				Enumerators,
				ARRAY_COUNT(Enumerators),
				METADATA_PARAMS(Enum_MetaDataParams, ARRAY_COUNT(Enum_MetaDataParams))
			};
			UE4CodeGen_Private::ConstructUEnum(ReturnEnum, EnumParams);
		}
		return ReturnEnum;
	}
	static UEnum* EFOHEARTMotionLineFormatEnum_StaticEnum()
	{
		static UEnum* Singleton = nullptr;
		if (!Singleton)
		{
			Singleton = GetStaticEnum(Z_Construct_UEnum_FOHEART_EFOHEARTMotionLineFormatEnum, Z_Construct_UPackage__Script_FOHEART(), TEXT("EFOHEARTMotionLineFormatEnum"));
		}
		return Singleton;
	}
	static FCompiledInDeferEnum Z_CompiledInDeferEnum_UEnum_EFOHEARTMotionLineFormatEnum(EFOHEARTMotionLineFormatEnum_StaticEnum, TEXT("/Script/FOHEART"), TEXT("EFOHEARTMotionLineFormatEnum"), false, nullptr, nullptr);
	uint32 Get_Z_Construct_UEnum_FOHEART_EFOHEARTMotionLineFormatEnum_CRC() { return 4105499204U; }
	UEnum* Z_Construct_UEnum_FOHEART_EFOHEARTMotionLineFormatEnum()
	{
#if WITH_HOT_RELOAD
		UPackage* Outer = Z_Construct_UPackage__Script_FOHEART();
		static UEnum* ReturnEnum = FindExistingEnumIfHotReloadOrDynamic(Outer, TEXT("EFOHEARTMotionLineFormatEnum"), 0, Get_Z_Construct_UEnum_FOHEART_EFOHEARTMotionLineFormatEnum_CRC(), false);
#else
		static UEnum* ReturnEnum = nullptr;
#endif // WITH_HOT_RELOAD
		if (!ReturnEnum)
		{
			static const UE4CodeGen_Private::FEnumeratorParam Enumerators[] = {
				{ "EFOHEARTMotionLineFormatEnum::VE_Standard", (int64)EFOHEARTMotionLineFormatEnum::VE_Standard },
				{ "EFOHEARTMotionLineFormatEnum::VE_FOHEART_C1", (int64)EFOHEARTMotionLineFormatEnum::VE_FOHEART_C1 },
				{ "EFOHEARTMotionLineFormatEnum::VE_FOHEART_LEO", (int64)EFOHEARTMotionLineFormatEnum::VE_FOHEART_LEO },
			};
#if WITH_METADATA
			static const UE4CodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
				{ "BlueprintType", "true" },
				{ "ModuleRelativePath", "Public/FOHEARTBPLibrary.h" },
				{ "VE_FOHEART_C1.DisplayName", "FOHEART_C1" },
				{ "VE_FOHEART_C1.ToolTip", "FOHEART C1 BVH live stream format, 23 skeleton." },
				{ "VE_FOHEART_LEO.DisplayName", "FOHEART_LEO" },
				{ "VE_FOHEART_LEO.ToolTip", "FOHEART LEO BVH live stream format, 61 skeleton." },
				{ "VE_Standard.DisplayName", "Standard" },
				{ "VE_Standard.ToolTip", "BVH Standard format (only the float numbers and a CR or LF at line ending)." },
			};
#endif
			static const UE4CodeGen_Private::FEnumParams EnumParams = {
				(UObject*(*)())Z_Construct_UPackage__Script_FOHEART,
				UE4CodeGen_Private::EDynamicType::NotDynamic,
				"EFOHEARTMotionLineFormatEnum",
				RF_Public|RF_Transient|RF_MarkAsNative,
				nullptr,
				(uint8)UEnum::ECppForm::EnumClass,
				"EFOHEARTMotionLineFormatEnum",
				Enumerators,
				ARRAY_COUNT(Enumerators),
				METADATA_PARAMS(Enum_MetaDataParams, ARRAY_COUNT(Enum_MetaDataParams))
			};
			UE4CodeGen_Private::ConstructUEnum(ReturnEnum, EnumParams);
		}
		return ReturnEnum;
	}
	static UEnum* EFOHEARTSkeletonEnum_StaticEnum()
	{
		static UEnum* Singleton = nullptr;
		if (!Singleton)
		{
			Singleton = GetStaticEnum(Z_Construct_UEnum_FOHEART_EFOHEARTSkeletonEnum, Z_Construct_UPackage__Script_FOHEART(), TEXT("EFOHEARTSkeletonEnum"));
		}
		return Singleton;
	}
	static FCompiledInDeferEnum Z_CompiledInDeferEnum_UEnum_EFOHEARTSkeletonEnum(EFOHEARTSkeletonEnum_StaticEnum, TEXT("/Script/FOHEART"), TEXT("EFOHEARTSkeletonEnum"), false, nullptr, nullptr);
	uint32 Get_Z_Construct_UEnum_FOHEART_EFOHEARTSkeletonEnum_CRC() { return 4079009954U; }
	UEnum* Z_Construct_UEnum_FOHEART_EFOHEARTSkeletonEnum()
	{
#if WITH_HOT_RELOAD
		UPackage* Outer = Z_Construct_UPackage__Script_FOHEART();
		static UEnum* ReturnEnum = FindExistingEnumIfHotReloadOrDynamic(Outer, TEXT("EFOHEARTSkeletonEnum"), 0, Get_Z_Construct_UEnum_FOHEART_EFOHEARTSkeletonEnum_CRC(), false);
#else
		static UEnum* ReturnEnum = nullptr;
#endif // WITH_HOT_RELOAD
		if (!ReturnEnum)
		{
			static const UE4CodeGen_Private::FEnumeratorParam Enumerators[] = {
				{ "EFOHEARTSkeletonEnum::VE_None", (int64)EFOHEARTSkeletonEnum::VE_None },
				{ "EFOHEARTSkeletonEnum::VE_FOHEART_C1", (int64)EFOHEARTSkeletonEnum::VE_FOHEART_C1 },
				{ "EFOHEARTSkeletonEnum::VE_FOHEART_LEO", (int64)EFOHEARTSkeletonEnum::VE_FOHEART_LEO },
				{ "EFOHEARTSkeletonEnum::VE_TPP_Hero", (int64)EFOHEARTSkeletonEnum::VE_TPP_Hero },
				{ "EFOHEARTSkeletonEnum::VE_Mannequin", (int64)EFOHEARTSkeletonEnum::VE_Mannequin },
				{ "EFOHEARTSkeletonEnum::VE_Map", (int64)EFOHEARTSkeletonEnum::VE_Map },
				{ "EFOHEARTSkeletonEnum::VE_UE4", (int64)EFOHEARTSkeletonEnum::VE_UE4 },
			};
#if WITH_METADATA
			static const UE4CodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
				{ "BlueprintType", "true" },
				{ "ModuleRelativePath", "Public/FOHEARTBPLibrary.h" },
				{ "ToolTip", "*      Function library class.\n*      Each function in it is expected to be static and represents blueprint node that can be called in any blueprint.\n*\n*      When declaring function you can define metadata for the node. Key function specifiers will be BlueprintPure and BlueprintCallable.\n*      BlueprintPure - means the function does not affect the owning object in any way and thus creates a node without Exec pins.\n*      BlueprintCallable - makes a function which can be executed in Blueprints - Thus it has Exec pins.\n*      DisplayName - full name of the node, shown when you mouse over the node and in the blueprint drop down menu.\n*                              Its lets you name the node using characters not allowed in C++ function names.\n*      CompactNodeTitle - the word(s) that appear on the node.\n*      Keywords -      the list of keywords that helps you to find node when you search for it using Blueprint drop-down menu.\n*                              Good example is \"Print String\" node which you can find also by using keyword \"log\".\n*      Category -      the category your node will be under in the Blueprint drop-down menu.\n*\n*      For more info on custom blueprint nodes visit documentation:\n*      https://wiki.unrealengine.com/Custom_Blueprint_Node_Creation\n// Deprecated" },
				{ "VE_FOHEART_C1.DisplayName", "FOHEART_C1" },
				{ "VE_FOHEART_C1.ToolTip", "Get FOHEART_C1 BVH skeleton coordinates." },
				{ "VE_FOHEART_LEO.DisplayName", "FOHEART_LEO" },
				{ "VE_FOHEART_LEO.ToolTip", "Get FOHEART_LEO BVH skeleton coordinates." },
				{ "VE_Mannequin.DisplayName", "Mannequin" },
				{ "VE_Mannequin.ToolTip", "Get Mannequin skeleton coordinates. New grey Unreal default skeleton with A-Pose." },
				{ "VE_Map.DisplayName", "Map" },
				{ "VE_Map.ToolTip", "Get custom skeleton coordinates with configured bone map." },
				{ "VE_None.DisplayName", "None" },
				{ "VE_None.ToolTip", "Get BVH coordinates. Use translation and rotation as it is." },
				{ "VE_TPP_Hero.DisplayName", "TPP_Hero" },
				{ "VE_TPP_Hero.ToolTip", "Get Hero_TPP skeleton coordinates. Old blue Unreal default skeleton with T-Pose." },
				{ "VE_UE4.DisplayName", "World" },
				{ "VE_UE4.ToolTip", "Get UE4 world skeleton coordinates." },
			};
#endif
			static const UE4CodeGen_Private::FEnumParams EnumParams = {
				(UObject*(*)())Z_Construct_UPackage__Script_FOHEART,
				UE4CodeGen_Private::EDynamicType::NotDynamic,
				"EFOHEARTSkeletonEnum",
				RF_Public|RF_Transient|RF_MarkAsNative,
				nullptr,
				(uint8)UEnum::ECppForm::EnumClass,
				"EFOHEARTSkeletonEnum",
				Enumerators,
				ARRAY_COUNT(Enumerators),
				METADATA_PARAMS(Enum_MetaDataParams, ARRAY_COUNT(Enum_MetaDataParams))
			};
			UE4CodeGen_Private::ConstructUEnum(ReturnEnum, EnumParams);
		}
		return ReturnEnum;
	}
class UScriptStruct* FFOHEART_C1BoneMapStruct::StaticStruct()
{
	static class UScriptStruct* Singleton = NULL;
	if (!Singleton)
	{
		extern FOHEART_API uint32 Get_Z_Construct_UScriptStruct_FFOHEART_C1BoneMapStruct_CRC();
		Singleton = GetStaticStruct(Z_Construct_UScriptStruct_FFOHEART_C1BoneMapStruct, Z_Construct_UPackage__Script_FOHEART(), TEXT("FOHEART_C1BoneMapStruct"), sizeof(FFOHEART_C1BoneMapStruct), Get_Z_Construct_UScriptStruct_FFOHEART_C1BoneMapStruct_CRC());
	}
	return Singleton;
}
static FCompiledInDeferStruct Z_CompiledInDeferStruct_UScriptStruct_FFOHEART_C1BoneMapStruct(FFOHEART_C1BoneMapStruct::StaticStruct, TEXT("/Script/FOHEART"), TEXT("FOHEART_C1BoneMapStruct"), false, nullptr, nullptr);
static struct FScriptStruct_FOHEART_StaticRegisterNativesFFOHEART_C1BoneMapStruct
{
	FScriptStruct_FOHEART_StaticRegisterNativesFFOHEART_C1BoneMapStruct()
	{
		UScriptStruct::DeferCppStructOps(FName(TEXT("FOHEART_C1BoneMapStruct")),new UScriptStruct::TCppStructOps<FFOHEART_C1BoneMapStruct>);
	}
} ScriptStruct_FOHEART_StaticRegisterNativesFFOHEART_C1BoneMapStruct;
	UScriptStruct* Z_Construct_UScriptStruct_FFOHEART_C1BoneMapStruct()
	{
#if WITH_HOT_RELOAD
		extern uint32 Get_Z_Construct_UScriptStruct_FFOHEART_C1BoneMapStruct_CRC();
		UPackage* Outer = Z_Construct_UPackage__Script_FOHEART();
		static UScriptStruct* ReturnStruct = FindExistingStructIfHotReloadOrDynamic(Outer, TEXT("FOHEART_C1BoneMapStruct"), sizeof(FFOHEART_C1BoneMapStruct), Get_Z_Construct_UScriptStruct_FFOHEART_C1BoneMapStruct_CRC(), false);
#else
		static UScriptStruct* ReturnStruct = nullptr;
#endif
		if (!ReturnStruct)
		{
#if WITH_METADATA
			static const UE4CodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
				{ "BlueprintType", "true" },
				{ "ModuleRelativePath", "Public/FOHEARTBPLibrary.h" },
			};
#endif
			auto NewStructOpsLambda = []() -> void* { return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FFOHEART_C1BoneMapStruct>(); };
#if WITH_METADATA
			static const UE4CodeGen_Private::FMetaDataPairParam NewProp_TargetBoneName_MetaData[] = {
				{ "Category", "FOHEART_C1" },
				{ "ModuleRelativePath", "Public/FOHEARTBPLibrary.h" },
			};
#endif
			static const UE4CodeGen_Private::FNamePropertyParams NewProp_TargetBoneName = { UE4CodeGen_Private::EPropertyClass::Name, "TargetBoneName", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000005, 1, nullptr, STRUCT_OFFSET(FFOHEART_C1BoneMapStruct, TargetBoneName), METADATA_PARAMS(NewProp_TargetBoneName_MetaData, ARRAY_COUNT(NewProp_TargetBoneName_MetaData)) };
#if WITH_METADATA
			static const UE4CodeGen_Private::FMetaDataPairParam NewProp_FoheartBoneName_MetaData[] = {
				{ "Category", "FOHEART_C1" },
				{ "ModuleRelativePath", "Public/FOHEARTBPLibrary.h" },
			};
#endif
			static const UE4CodeGen_Private::FEnumPropertyParams NewProp_FoheartBoneName = { UE4CodeGen_Private::EPropertyClass::Enum, "FoheartBoneName", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000005, 1, nullptr, STRUCT_OFFSET(FFOHEART_C1BoneMapStruct, FoheartBoneName), Z_Construct_UEnum_FOHEART_EFOHEART_C1BonesEnum, METADATA_PARAMS(NewProp_FoheartBoneName_MetaData, ARRAY_COUNT(NewProp_FoheartBoneName_MetaData)) };
			static const UE4CodeGen_Private::FBytePropertyParams NewProp_FoheartBoneName_Underlying = { UE4CodeGen_Private::EPropertyClass::Byte, "UnderlyingType", RF_Public|RF_Transient|RF_MarkAsNative, 0x0000000000000000, 1, nullptr, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[] = {
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_TargetBoneName,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_FoheartBoneName,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_FoheartBoneName_Underlying,
			};
			static const UE4CodeGen_Private::FStructParams ReturnStructParams = {
				(UObject* (*)())Z_Construct_UPackage__Script_FOHEART,
				nullptr,
				&UE4CodeGen_Private::TNewCppStructOpsWrapper<decltype(NewStructOpsLambda)>::NewCppStructOps,
				"FOHEART_C1BoneMapStruct",
				RF_Public|RF_Transient|RF_MarkAsNative,
				EStructFlags(0x00000001),
				sizeof(FFOHEART_C1BoneMapStruct),
				alignof(FFOHEART_C1BoneMapStruct),
				PropPointers, ARRAY_COUNT(PropPointers),
				METADATA_PARAMS(Struct_MetaDataParams, ARRAY_COUNT(Struct_MetaDataParams))
			};
			UE4CodeGen_Private::ConstructUScriptStruct(ReturnStruct, ReturnStructParams);
		}
		return ReturnStruct;
	}
	uint32 Get_Z_Construct_UScriptStruct_FFOHEART_C1BoneMapStruct_CRC() { return 123764753U; }
class UScriptStruct* FFOHEART_BoneAxisMatch::StaticStruct()
{
	static class UScriptStruct* Singleton = NULL;
	if (!Singleton)
	{
		extern FOHEART_API uint32 Get_Z_Construct_UScriptStruct_FFOHEART_BoneAxisMatch_CRC();
		Singleton = GetStaticStruct(Z_Construct_UScriptStruct_FFOHEART_BoneAxisMatch, Z_Construct_UPackage__Script_FOHEART(), TEXT("FOHEART_BoneAxisMatch"), sizeof(FFOHEART_BoneAxisMatch), Get_Z_Construct_UScriptStruct_FFOHEART_BoneAxisMatch_CRC());
	}
	return Singleton;
}
static FCompiledInDeferStruct Z_CompiledInDeferStruct_UScriptStruct_FFOHEART_BoneAxisMatch(FFOHEART_BoneAxisMatch::StaticStruct, TEXT("/Script/FOHEART"), TEXT("FOHEART_BoneAxisMatch"), false, nullptr, nullptr);
static struct FScriptStruct_FOHEART_StaticRegisterNativesFFOHEART_BoneAxisMatch
{
	FScriptStruct_FOHEART_StaticRegisterNativesFFOHEART_BoneAxisMatch()
	{
		UScriptStruct::DeferCppStructOps(FName(TEXT("FOHEART_BoneAxisMatch")),new UScriptStruct::TCppStructOps<FFOHEART_BoneAxisMatch>);
	}
} ScriptStruct_FOHEART_StaticRegisterNativesFFOHEART_BoneAxisMatch;
	UScriptStruct* Z_Construct_UScriptStruct_FFOHEART_BoneAxisMatch()
	{
#if WITH_HOT_RELOAD
		extern uint32 Get_Z_Construct_UScriptStruct_FFOHEART_BoneAxisMatch_CRC();
		UPackage* Outer = Z_Construct_UPackage__Script_FOHEART();
		static UScriptStruct* ReturnStruct = FindExistingStructIfHotReloadOrDynamic(Outer, TEXT("FOHEART_BoneAxisMatch"), sizeof(FFOHEART_BoneAxisMatch), Get_Z_Construct_UScriptStruct_FFOHEART_BoneAxisMatch_CRC(), false);
#else
		static UScriptStruct* ReturnStruct = nullptr;
#endif
		if (!ReturnStruct)
		{
#if WITH_METADATA
			static const UE4CodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
				{ "BlueprintType", "true" },
				{ "ModuleRelativePath", "Public/FOHEARTBPLibrary.h" },
			};
#endif
			auto NewStructOpsLambda = []() -> void* { return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FFOHEART_BoneAxisMatch>(); };
#if WITH_METADATA
			static const UE4CodeGen_Private::FMetaDataPairParam NewProp_FOHEARTBoneAxis_MetaData[] = {
				{ "Category", "FOHEART_BoneAxisMatch" },
				{ "ModuleRelativePath", "Public/FOHEARTBPLibrary.h" },
			};
#endif
			static const UE4CodeGen_Private::FEnumPropertyParams NewProp_FOHEARTBoneAxis = { UE4CodeGen_Private::EPropertyClass::Enum, "FOHEARTBoneAxis", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000005, 1, nullptr, STRUCT_OFFSET(FFOHEART_BoneAxisMatch, FOHEARTBoneAxis), Z_Construct_UEnum_FOHEART_EFOHEARTBoneAxisEnum, METADATA_PARAMS(NewProp_FOHEARTBoneAxis_MetaData, ARRAY_COUNT(NewProp_FOHEARTBoneAxis_MetaData)) };
			static const UE4CodeGen_Private::FBytePropertyParams NewProp_FOHEARTBoneAxis_Underlying = { UE4CodeGen_Private::EPropertyClass::Byte, "UnderlyingType", RF_Public|RF_Transient|RF_MarkAsNative, 0x0000000000000000, 1, nullptr, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
			static const UE4CodeGen_Private::FMetaDataPairParam NewProp_UE4BoneAxis_MetaData[] = {
				{ "Category", "FOHEART_BoneAxisMatch" },
				{ "ModuleRelativePath", "Public/FOHEARTBPLibrary.h" },
			};
#endif
			static const UE4CodeGen_Private::FStrPropertyParams NewProp_UE4BoneAxis = { UE4CodeGen_Private::EPropertyClass::Str, "UE4BoneAxis", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000015, 1, nullptr, STRUCT_OFFSET(FFOHEART_BoneAxisMatch, UE4BoneAxis), METADATA_PARAMS(NewProp_UE4BoneAxis_MetaData, ARRAY_COUNT(NewProp_UE4BoneAxis_MetaData)) };
			static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[] = {
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_FOHEARTBoneAxis,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_FOHEARTBoneAxis_Underlying,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_UE4BoneAxis,
			};
			static const UE4CodeGen_Private::FStructParams ReturnStructParams = {
				(UObject* (*)())Z_Construct_UPackage__Script_FOHEART,
				nullptr,
				&UE4CodeGen_Private::TNewCppStructOpsWrapper<decltype(NewStructOpsLambda)>::NewCppStructOps,
				"FOHEART_BoneAxisMatch",
				RF_Public|RF_Transient|RF_MarkAsNative,
				EStructFlags(0x00000001),
				sizeof(FFOHEART_BoneAxisMatch),
				alignof(FFOHEART_BoneAxisMatch),
				PropPointers, ARRAY_COUNT(PropPointers),
				METADATA_PARAMS(Struct_MetaDataParams, ARRAY_COUNT(Struct_MetaDataParams))
			};
			UE4CodeGen_Private::ConstructUScriptStruct(ReturnStruct, ReturnStructParams);
		}
		return ReturnStruct;
	}
	uint32 Get_Z_Construct_UScriptStruct_FFOHEART_BoneAxisMatch_CRC() { return 3034275927U; }
	void UFOHEART_C1BPLibrary::StaticRegisterNativesUFOHEART_C1BPLibrary()
	{
		UClass* Class = UFOHEART_C1BPLibrary::StaticClass();
		static const FNameNativePtrPair Funcs[] = {
			{ "FOHEART_C1BoneSetOffset", (Native)&UFOHEART_C1BPLibrary::execFOHEART_C1BoneSetOffset },
			{ "FOHEART_C1BVHPause", (Native)&UFOHEART_C1BPLibrary::execFOHEART_C1BVHPause },
			{ "FOHEART_C1BVHPlay", (Native)&UFOHEART_C1BPLibrary::execFOHEART_C1BVHPlay },
			{ "FOHEART_C1BVHRewind", (Native)&UFOHEART_C1BPLibrary::execFOHEART_C1BVHRewind },
			{ "FOHEART_C1ConnectTCP", (Native)&UFOHEART_C1BPLibrary::execFOHEART_C1ConnectTCP },
			{ "FOHEART_C1ConnectUDP", (Native)&UFOHEART_C1BPLibrary::execFOHEART_C1ConnectUDP },
			{ "FOHEART_C1Disconnect", (Native)&UFOHEART_C1BPLibrary::execFOHEART_C1Disconnect },
			{ "FOHEART_C1GetBVHBoneIndex", (Native)&UFOHEART_C1BPLibrary::execFOHEART_C1GetBVHBoneIndex },
			{ "FOHEART_C1GetLocalBoneLocation", (Native)&UFOHEART_C1BPLibrary::execFOHEART_C1GetLocalBoneLocation },
			{ "FOHEART_C1GetLocalBoneRotation", (Native)&UFOHEART_C1BPLibrary::execFOHEART_C1GetLocalBoneRotation },
			{ "FOHEART_C1GetReferencePoseLocalBoneRotation", (Native)&UFOHEART_C1BPLibrary::execFOHEART_C1GetReferencePoseLocalBoneRotation },
			{ "FOHEART_C1Init", (Native)&UFOHEART_C1BPLibrary::execFOHEART_C1Init },
			{ "FOHEART_C1InitBVHFile", (Native)&UFOHEART_C1BPLibrary::execFOHEART_C1InitBVHFile },
			{ "FOHEART_C1NegateRotation", (Native)&UFOHEART_C1BPLibrary::execFOHEART_C1NegateRotation },
			{ "FOHEART_C1Read", (Native)&UFOHEART_C1BPLibrary::execFOHEART_C1Read },
			{ "FOHEART_C1ReadArray", (Native)&UFOHEART_C1BPLibrary::execFOHEART_C1ReadArray },
		};
		FNativeFunctionRegistrar::RegisterFunctions(Class, Funcs, ARRAY_COUNT(Funcs));
	}
	UFunction* Z_Construct_UFunction_UFOHEART_C1BPLibrary_FOHEART_C1BoneSetOffset()
	{
		struct FOHEART_C1BPLibrary_eventFOHEART_C1BoneSetOffset_Parms
		{
			AFOHEARTController* Controller;
			int32 BoneIndex;
			float X;
			float Y;
			float Z;
			bool ReturnValue;
		};
		static UFunction* ReturnFunction = nullptr;
		if (!ReturnFunction)
		{
			auto NewProp_ReturnValue_SetBit = [](void* Obj){ ((FOHEART_C1BPLibrary_eventFOHEART_C1BoneSetOffset_Parms*)Obj)->ReturnValue = 1; };
			static const UE4CodeGen_Private::FBoolPropertyParams NewProp_ReturnValue = { UE4CodeGen_Private::EPropertyClass::Bool, "ReturnValue", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000580, 1, nullptr, sizeof(bool), UE4CodeGen_Private::ENativeBool::Native, sizeof(FOHEART_C1BPLibrary_eventFOHEART_C1BoneSetOffset_Parms), &UE4CodeGen_Private::TBoolSetBitWrapper<decltype(NewProp_ReturnValue_SetBit)>::SetBit, METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FFloatPropertyParams NewProp_Z = { UE4CodeGen_Private::EPropertyClass::Float, "Z", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000080, 1, nullptr, STRUCT_OFFSET(FOHEART_C1BPLibrary_eventFOHEART_C1BoneSetOffset_Parms, Z), METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FFloatPropertyParams NewProp_Y = { UE4CodeGen_Private::EPropertyClass::Float, "Y", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000080, 1, nullptr, STRUCT_OFFSET(FOHEART_C1BPLibrary_eventFOHEART_C1BoneSetOffset_Parms, Y), METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FFloatPropertyParams NewProp_X = { UE4CodeGen_Private::EPropertyClass::Float, "X", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000080, 1, nullptr, STRUCT_OFFSET(FOHEART_C1BPLibrary_eventFOHEART_C1BoneSetOffset_Parms, X), METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FIntPropertyParams NewProp_BoneIndex = { UE4CodeGen_Private::EPropertyClass::Int, "BoneIndex", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000080, 1, nullptr, STRUCT_OFFSET(FOHEART_C1BPLibrary_eventFOHEART_C1BoneSetOffset_Parms, BoneIndex), METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FObjectPropertyParams NewProp_Controller = { UE4CodeGen_Private::EPropertyClass::Object, "Controller", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000080, 1, nullptr, STRUCT_OFFSET(FOHEART_C1BPLibrary_eventFOHEART_C1BoneSetOffset_Parms, Controller), Z_Construct_UClass_AFOHEARTController_NoRegister, METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[] = {
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_ReturnValue,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_Z,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_Y,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_X,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_BoneIndex,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_Controller,
			};
#if WITH_METADATA
			static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
				{ "Category", "FOHEART_C1" },
				{ "CPP_Default_BoneIndex", "0" },
				{ "CPP_Default_X", "0.000000" },
				{ "CPP_Default_Y", "0.000000" },
				{ "CPP_Default_Z", "0.000000" },
				{ "DisplayName", "Bone Set Offset" },
				{ "ModuleRelativePath", "Public/FOHEARTBPLibrary.h" },
				{ "ToolTip", "Configure BVH bone offset. This offset is removed from the incoming translation before coordinate mapping." },
			};
#endif
			static const UE4CodeGen_Private::FFunctionParams FuncParams = { (UObject*(*)())Z_Construct_UClass_UFOHEART_C1BPLibrary, "FOHEART_C1BoneSetOffset", RF_Public|RF_Transient|RF_MarkAsNative, nullptr, (EFunctionFlags)0x04022401, sizeof(FOHEART_C1BPLibrary_eventFOHEART_C1BoneSetOffset_Parms), PropPointers, ARRAY_COUNT(PropPointers), 0, 0, METADATA_PARAMS(Function_MetaDataParams, ARRAY_COUNT(Function_MetaDataParams)) };
			UE4CodeGen_Private::ConstructUFunction(ReturnFunction, FuncParams);
		}
		return ReturnFunction;
	}
	UFunction* Z_Construct_UFunction_UFOHEART_C1BPLibrary_FOHEART_C1BVHPause()
	{
		struct FOHEART_C1BPLibrary_eventFOHEART_C1BVHPause_Parms
		{
			AFOHEARTController* Controller;
			bool bPause;
			bool ReturnValue;
		};
		static UFunction* ReturnFunction = nullptr;
		if (!ReturnFunction)
		{
			auto NewProp_ReturnValue_SetBit = [](void* Obj){ ((FOHEART_C1BPLibrary_eventFOHEART_C1BVHPause_Parms*)Obj)->ReturnValue = 1; };
			static const UE4CodeGen_Private::FBoolPropertyParams NewProp_ReturnValue = { UE4CodeGen_Private::EPropertyClass::Bool, "ReturnValue", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000580, 1, nullptr, sizeof(bool), UE4CodeGen_Private::ENativeBool::Native, sizeof(FOHEART_C1BPLibrary_eventFOHEART_C1BVHPause_Parms), &UE4CodeGen_Private::TBoolSetBitWrapper<decltype(NewProp_ReturnValue_SetBit)>::SetBit, METADATA_PARAMS(nullptr, 0) };
			auto NewProp_bPause_SetBit = [](void* Obj){ ((FOHEART_C1BPLibrary_eventFOHEART_C1BVHPause_Parms*)Obj)->bPause = 1; };
			static const UE4CodeGen_Private::FBoolPropertyParams NewProp_bPause = { UE4CodeGen_Private::EPropertyClass::Bool, "bPause", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000080, 1, nullptr, sizeof(bool), UE4CodeGen_Private::ENativeBool::Native, sizeof(FOHEART_C1BPLibrary_eventFOHEART_C1BVHPause_Parms), &UE4CodeGen_Private::TBoolSetBitWrapper<decltype(NewProp_bPause_SetBit)>::SetBit, METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FObjectPropertyParams NewProp_Controller = { UE4CodeGen_Private::EPropertyClass::Object, "Controller", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000080, 1, nullptr, STRUCT_OFFSET(FOHEART_C1BPLibrary_eventFOHEART_C1BVHPause_Parms, Controller), Z_Construct_UClass_AFOHEARTController_NoRegister, METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[] = {
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_ReturnValue,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_bPause,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_Controller,
			};
#if WITH_METADATA
			static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
				{ "Category", "FOHEART_C1" },
				{ "CPP_Default_bPause", "false" },
				{ "DisplayName", "Pause playing BVH File" },
				{ "ModuleRelativePath", "Public/FOHEARTBPLibrary.h" },
				{ "ToolTip", "Pause playing a local stored BVH file" },
			};
#endif
			static const UE4CodeGen_Private::FFunctionParams FuncParams = { (UObject*(*)())Z_Construct_UClass_UFOHEART_C1BPLibrary, "FOHEART_C1BVHPause", RF_Public|RF_Transient|RF_MarkAsNative, nullptr, (EFunctionFlags)0x04022401, sizeof(FOHEART_C1BPLibrary_eventFOHEART_C1BVHPause_Parms), PropPointers, ARRAY_COUNT(PropPointers), 0, 0, METADATA_PARAMS(Function_MetaDataParams, ARRAY_COUNT(Function_MetaDataParams)) };
			UE4CodeGen_Private::ConstructUFunction(ReturnFunction, FuncParams);
		}
		return ReturnFunction;
	}
	UFunction* Z_Construct_UFunction_UFOHEART_C1BPLibrary_FOHEART_C1BVHPlay()
	{
		struct FOHEART_C1BPLibrary_eventFOHEART_C1BVHPlay_Parms
		{
			AFOHEARTController* Controller;
			FString BVHFileNa;
			bool bEndless;
			bool bReference;
			bool bDisplacement;
			EFOHEARTMotionLineFormatEnum MotionLineFormat;
			bool ReturnValue;
		};
		static UFunction* ReturnFunction = nullptr;
		if (!ReturnFunction)
		{
			auto NewProp_ReturnValue_SetBit = [](void* Obj){ ((FOHEART_C1BPLibrary_eventFOHEART_C1BVHPlay_Parms*)Obj)->ReturnValue = 1; };
			static const UE4CodeGen_Private::FBoolPropertyParams NewProp_ReturnValue = { UE4CodeGen_Private::EPropertyClass::Bool, "ReturnValue", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000580, 1, nullptr, sizeof(bool), UE4CodeGen_Private::ENativeBool::Native, sizeof(FOHEART_C1BPLibrary_eventFOHEART_C1BVHPlay_Parms), &UE4CodeGen_Private::TBoolSetBitWrapper<decltype(NewProp_ReturnValue_SetBit)>::SetBit, METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FEnumPropertyParams NewProp_MotionLineFormat = { UE4CodeGen_Private::EPropertyClass::Enum, "MotionLineFormat", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000080, 1, nullptr, STRUCT_OFFSET(FOHEART_C1BPLibrary_eventFOHEART_C1BVHPlay_Parms, MotionLineFormat), Z_Construct_UEnum_FOHEART_EFOHEARTMotionLineFormatEnum, METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FBytePropertyParams NewProp_MotionLineFormat_Underlying = { UE4CodeGen_Private::EPropertyClass::Byte, "UnderlyingType", RF_Public|RF_Transient|RF_MarkAsNative, 0x0000000000000000, 1, nullptr, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
			auto NewProp_bDisplacement_SetBit = [](void* Obj){ ((FOHEART_C1BPLibrary_eventFOHEART_C1BVHPlay_Parms*)Obj)->bDisplacement = 1; };
			static const UE4CodeGen_Private::FBoolPropertyParams NewProp_bDisplacement = { UE4CodeGen_Private::EPropertyClass::Bool, "bDisplacement", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000080, 1, nullptr, sizeof(bool), UE4CodeGen_Private::ENativeBool::Native, sizeof(FOHEART_C1BPLibrary_eventFOHEART_C1BVHPlay_Parms), &UE4CodeGen_Private::TBoolSetBitWrapper<decltype(NewProp_bDisplacement_SetBit)>::SetBit, METADATA_PARAMS(nullptr, 0) };
			auto NewProp_bReference_SetBit = [](void* Obj){ ((FOHEART_C1BPLibrary_eventFOHEART_C1BVHPlay_Parms*)Obj)->bReference = 1; };
			static const UE4CodeGen_Private::FBoolPropertyParams NewProp_bReference = { UE4CodeGen_Private::EPropertyClass::Bool, "bReference", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000080, 1, nullptr, sizeof(bool), UE4CodeGen_Private::ENativeBool::Native, sizeof(FOHEART_C1BPLibrary_eventFOHEART_C1BVHPlay_Parms), &UE4CodeGen_Private::TBoolSetBitWrapper<decltype(NewProp_bReference_SetBit)>::SetBit, METADATA_PARAMS(nullptr, 0) };
			auto NewProp_bEndless_SetBit = [](void* Obj){ ((FOHEART_C1BPLibrary_eventFOHEART_C1BVHPlay_Parms*)Obj)->bEndless = 1; };
			static const UE4CodeGen_Private::FBoolPropertyParams NewProp_bEndless = { UE4CodeGen_Private::EPropertyClass::Bool, "bEndless", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000080, 1, nullptr, sizeof(bool), UE4CodeGen_Private::ENativeBool::Native, sizeof(FOHEART_C1BPLibrary_eventFOHEART_C1BVHPlay_Parms), &UE4CodeGen_Private::TBoolSetBitWrapper<decltype(NewProp_bEndless_SetBit)>::SetBit, METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FStrPropertyParams NewProp_BVHFileNa = { UE4CodeGen_Private::EPropertyClass::Str, "BVHFileNa", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000080, 1, nullptr, STRUCT_OFFSET(FOHEART_C1BPLibrary_eventFOHEART_C1BVHPlay_Parms, BVHFileNa), METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FObjectPropertyParams NewProp_Controller = { UE4CodeGen_Private::EPropertyClass::Object, "Controller", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000080, 1, nullptr, STRUCT_OFFSET(FOHEART_C1BPLibrary_eventFOHEART_C1BVHPlay_Parms, Controller), Z_Construct_UClass_AFOHEARTController_NoRegister, METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[] = {
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_ReturnValue,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_MotionLineFormat,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_MotionLineFormat_Underlying,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_bDisplacement,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_bReference,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_bEndless,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_BVHFileNa,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_Controller,
			};
#if WITH_METADATA
			static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
				{ "Category", "FOHEART_C1" },
				{ "CPP_Default_bDisplacement", "true" },
				{ "CPP_Default_bEndless", "true" },
				{ "CPP_Default_bReference", "false" },
				{ "CPP_Default_BVHFileNa", "test.bvh" },
				{ "CPP_Default_MotionLineFormat", "VE_Standard" },
				{ "DisplayName", "Play BVH File" },
				{ "ModuleRelativePath", "Public/FOHEARTBPLibrary.h" },
				{ "ToolTip", "Play a local stored BVH file." },
			};
#endif
			static const UE4CodeGen_Private::FFunctionParams FuncParams = { (UObject*(*)())Z_Construct_UClass_UFOHEART_C1BPLibrary, "FOHEART_C1BVHPlay", RF_Public|RF_Transient|RF_MarkAsNative, nullptr, (EFunctionFlags)0x04022401, sizeof(FOHEART_C1BPLibrary_eventFOHEART_C1BVHPlay_Parms), PropPointers, ARRAY_COUNT(PropPointers), 0, 0, METADATA_PARAMS(Function_MetaDataParams, ARRAY_COUNT(Function_MetaDataParams)) };
			UE4CodeGen_Private::ConstructUFunction(ReturnFunction, FuncParams);
		}
		return ReturnFunction;
	}
	UFunction* Z_Construct_UFunction_UFOHEART_C1BPLibrary_FOHEART_C1BVHRewind()
	{
		struct FOHEART_C1BPLibrary_eventFOHEART_C1BVHRewind_Parms
		{
			AFOHEARTController* Controller;
			bool ReturnValue;
		};
		static UFunction* ReturnFunction = nullptr;
		if (!ReturnFunction)
		{
			auto NewProp_ReturnValue_SetBit = [](void* Obj){ ((FOHEART_C1BPLibrary_eventFOHEART_C1BVHRewind_Parms*)Obj)->ReturnValue = 1; };
			static const UE4CodeGen_Private::FBoolPropertyParams NewProp_ReturnValue = { UE4CodeGen_Private::EPropertyClass::Bool, "ReturnValue", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000580, 1, nullptr, sizeof(bool), UE4CodeGen_Private::ENativeBool::Native, sizeof(FOHEART_C1BPLibrary_eventFOHEART_C1BVHRewind_Parms), &UE4CodeGen_Private::TBoolSetBitWrapper<decltype(NewProp_ReturnValue_SetBit)>::SetBit, METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FObjectPropertyParams NewProp_Controller = { UE4CodeGen_Private::EPropertyClass::Object, "Controller", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000080, 1, nullptr, STRUCT_OFFSET(FOHEART_C1BPLibrary_eventFOHEART_C1BVHRewind_Parms, Controller), Z_Construct_UClass_AFOHEARTController_NoRegister, METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[] = {
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_ReturnValue,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_Controller,
			};
#if WITH_METADATA
			static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
				{ "Category", "FOHEART_C1" },
				{ "DisplayName", "Rewind BVH File Player" },
				{ "ModuleRelativePath", "Public/FOHEARTBPLibrary.h" },
				{ "ToolTip", "Rewind BVH file player." },
			};
#endif
			static const UE4CodeGen_Private::FFunctionParams FuncParams = { (UObject*(*)())Z_Construct_UClass_UFOHEART_C1BPLibrary, "FOHEART_C1BVHRewind", RF_Public|RF_Transient|RF_MarkAsNative, nullptr, (EFunctionFlags)0x04022401, sizeof(FOHEART_C1BPLibrary_eventFOHEART_C1BVHRewind_Parms), PropPointers, ARRAY_COUNT(PropPointers), 0, 0, METADATA_PARAMS(Function_MetaDataParams, ARRAY_COUNT(Function_MetaDataParams)) };
			UE4CodeGen_Private::ConstructUFunction(ReturnFunction, FuncParams);
		}
		return ReturnFunction;
	}
	UFunction* Z_Construct_UFunction_UFOHEART_C1BPLibrary_FOHEART_C1ConnectTCP()
	{
		struct FOHEART_C1BPLibrary_eventFOHEART_C1ConnectTCP_Parms
		{
			AFOHEARTController* Controller;
			FString HostName;
			int32 Port;
			bool bReference;
			bool bDisplacement;
			EFOHEARTMotionLineFormatEnum MotionLineFormat;
			bool ReturnValue;
		};
		static UFunction* ReturnFunction = nullptr;
		if (!ReturnFunction)
		{
			auto NewProp_ReturnValue_SetBit = [](void* Obj){ ((FOHEART_C1BPLibrary_eventFOHEART_C1ConnectTCP_Parms*)Obj)->ReturnValue = 1; };
			static const UE4CodeGen_Private::FBoolPropertyParams NewProp_ReturnValue = { UE4CodeGen_Private::EPropertyClass::Bool, "ReturnValue", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000580, 1, nullptr, sizeof(bool), UE4CodeGen_Private::ENativeBool::Native, sizeof(FOHEART_C1BPLibrary_eventFOHEART_C1ConnectTCP_Parms), &UE4CodeGen_Private::TBoolSetBitWrapper<decltype(NewProp_ReturnValue_SetBit)>::SetBit, METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FEnumPropertyParams NewProp_MotionLineFormat = { UE4CodeGen_Private::EPropertyClass::Enum, "MotionLineFormat", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000080, 1, nullptr, STRUCT_OFFSET(FOHEART_C1BPLibrary_eventFOHEART_C1ConnectTCP_Parms, MotionLineFormat), Z_Construct_UEnum_FOHEART_EFOHEARTMotionLineFormatEnum, METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FBytePropertyParams NewProp_MotionLineFormat_Underlying = { UE4CodeGen_Private::EPropertyClass::Byte, "UnderlyingType", RF_Public|RF_Transient|RF_MarkAsNative, 0x0000000000000000, 1, nullptr, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
			auto NewProp_bDisplacement_SetBit = [](void* Obj){ ((FOHEART_C1BPLibrary_eventFOHEART_C1ConnectTCP_Parms*)Obj)->bDisplacement = 1; };
			static const UE4CodeGen_Private::FBoolPropertyParams NewProp_bDisplacement = { UE4CodeGen_Private::EPropertyClass::Bool, "bDisplacement", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000080, 1, nullptr, sizeof(bool), UE4CodeGen_Private::ENativeBool::Native, sizeof(FOHEART_C1BPLibrary_eventFOHEART_C1ConnectTCP_Parms), &UE4CodeGen_Private::TBoolSetBitWrapper<decltype(NewProp_bDisplacement_SetBit)>::SetBit, METADATA_PARAMS(nullptr, 0) };
			auto NewProp_bReference_SetBit = [](void* Obj){ ((FOHEART_C1BPLibrary_eventFOHEART_C1ConnectTCP_Parms*)Obj)->bReference = 1; };
			static const UE4CodeGen_Private::FBoolPropertyParams NewProp_bReference = { UE4CodeGen_Private::EPropertyClass::Bool, "bReference", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000080, 1, nullptr, sizeof(bool), UE4CodeGen_Private::ENativeBool::Native, sizeof(FOHEART_C1BPLibrary_eventFOHEART_C1ConnectTCP_Parms), &UE4CodeGen_Private::TBoolSetBitWrapper<decltype(NewProp_bReference_SetBit)>::SetBit, METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FIntPropertyParams NewProp_Port = { UE4CodeGen_Private::EPropertyClass::Int, "Port", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000080, 1, nullptr, STRUCT_OFFSET(FOHEART_C1BPLibrary_eventFOHEART_C1ConnectTCP_Parms, Port), METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
			static const UE4CodeGen_Private::FMetaDataPairParam NewProp_HostName_MetaData[] = {
				{ "NativeConst", "" },
			};
#endif
			static const UE4CodeGen_Private::FStrPropertyParams NewProp_HostName = { UE4CodeGen_Private::EPropertyClass::Str, "HostName", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000082, 1, nullptr, STRUCT_OFFSET(FOHEART_C1BPLibrary_eventFOHEART_C1ConnectTCP_Parms, HostName), METADATA_PARAMS(NewProp_HostName_MetaData, ARRAY_COUNT(NewProp_HostName_MetaData)) };
			static const UE4CodeGen_Private::FObjectPropertyParams NewProp_Controller = { UE4CodeGen_Private::EPropertyClass::Object, "Controller", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000080, 1, nullptr, STRUCT_OFFSET(FOHEART_C1BPLibrary_eventFOHEART_C1ConnectTCP_Parms, Controller), Z_Construct_UClass_AFOHEARTController_NoRegister, METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[] = {
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_ReturnValue,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_MotionLineFormat,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_MotionLineFormat_Underlying,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_bDisplacement,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_bReference,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_Port,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_HostName,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_Controller,
			};
#if WITH_METADATA
			static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
				{ "Category", "FOHEART_C1" },
				{ "CPP_Default_bDisplacement", "true" },
				{ "CPP_Default_bReference", "false" },
				{ "CPP_Default_HostName", "127.0.0.1" },
				{ "CPP_Default_MotionLineFormat", "VE_FOHEART_C1" },
				{ "CPP_Default_Port", "7001" },
				{ "DisplayName", "Connect MotionVenus using TCP" },
				{ "ModuleRelativePath", "Public/FOHEARTBPLibrary.h" },
				{ "ToolTip", "Connect MotionVenus with given IP&Port" },
			};
#endif
			static const UE4CodeGen_Private::FFunctionParams FuncParams = { (UObject*(*)())Z_Construct_UClass_UFOHEART_C1BPLibrary, "FOHEART_C1ConnectTCP", RF_Public|RF_Transient|RF_MarkAsNative, nullptr, (EFunctionFlags)0x04022401, sizeof(FOHEART_C1BPLibrary_eventFOHEART_C1ConnectTCP_Parms), PropPointers, ARRAY_COUNT(PropPointers), 0, 0, METADATA_PARAMS(Function_MetaDataParams, ARRAY_COUNT(Function_MetaDataParams)) };
			UE4CodeGen_Private::ConstructUFunction(ReturnFunction, FuncParams);
		}
		return ReturnFunction;
	}
	UFunction* Z_Construct_UFunction_UFOHEART_C1BPLibrary_FOHEART_C1ConnectUDP()
	{
		struct FOHEART_C1BPLibrary_eventFOHEART_C1ConnectUDP_Parms
		{
			AFOHEARTController* Controller;
			FString HostName;
			int32 Port;
			bool bReference;
			bool bDisplacement;
			EFOHEARTMotionLineFormatEnum MotionLineFormat;
			bool ReturnValue;
		};
		static UFunction* ReturnFunction = nullptr;
		if (!ReturnFunction)
		{
			auto NewProp_ReturnValue_SetBit = [](void* Obj){ ((FOHEART_C1BPLibrary_eventFOHEART_C1ConnectUDP_Parms*)Obj)->ReturnValue = 1; };
			static const UE4CodeGen_Private::FBoolPropertyParams NewProp_ReturnValue = { UE4CodeGen_Private::EPropertyClass::Bool, "ReturnValue", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000580, 1, nullptr, sizeof(bool), UE4CodeGen_Private::ENativeBool::Native, sizeof(FOHEART_C1BPLibrary_eventFOHEART_C1ConnectUDP_Parms), &UE4CodeGen_Private::TBoolSetBitWrapper<decltype(NewProp_ReturnValue_SetBit)>::SetBit, METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FEnumPropertyParams NewProp_MotionLineFormat = { UE4CodeGen_Private::EPropertyClass::Enum, "MotionLineFormat", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000080, 1, nullptr, STRUCT_OFFSET(FOHEART_C1BPLibrary_eventFOHEART_C1ConnectUDP_Parms, MotionLineFormat), Z_Construct_UEnum_FOHEART_EFOHEARTMotionLineFormatEnum, METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FBytePropertyParams NewProp_MotionLineFormat_Underlying = { UE4CodeGen_Private::EPropertyClass::Byte, "UnderlyingType", RF_Public|RF_Transient|RF_MarkAsNative, 0x0000000000000000, 1, nullptr, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
			auto NewProp_bDisplacement_SetBit = [](void* Obj){ ((FOHEART_C1BPLibrary_eventFOHEART_C1ConnectUDP_Parms*)Obj)->bDisplacement = 1; };
			static const UE4CodeGen_Private::FBoolPropertyParams NewProp_bDisplacement = { UE4CodeGen_Private::EPropertyClass::Bool, "bDisplacement", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000080, 1, nullptr, sizeof(bool), UE4CodeGen_Private::ENativeBool::Native, sizeof(FOHEART_C1BPLibrary_eventFOHEART_C1ConnectUDP_Parms), &UE4CodeGen_Private::TBoolSetBitWrapper<decltype(NewProp_bDisplacement_SetBit)>::SetBit, METADATA_PARAMS(nullptr, 0) };
			auto NewProp_bReference_SetBit = [](void* Obj){ ((FOHEART_C1BPLibrary_eventFOHEART_C1ConnectUDP_Parms*)Obj)->bReference = 1; };
			static const UE4CodeGen_Private::FBoolPropertyParams NewProp_bReference = { UE4CodeGen_Private::EPropertyClass::Bool, "bReference", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000080, 1, nullptr, sizeof(bool), UE4CodeGen_Private::ENativeBool::Native, sizeof(FOHEART_C1BPLibrary_eventFOHEART_C1ConnectUDP_Parms), &UE4CodeGen_Private::TBoolSetBitWrapper<decltype(NewProp_bReference_SetBit)>::SetBit, METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FIntPropertyParams NewProp_Port = { UE4CodeGen_Private::EPropertyClass::Int, "Port", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000080, 1, nullptr, STRUCT_OFFSET(FOHEART_C1BPLibrary_eventFOHEART_C1ConnectUDP_Parms, Port), METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
			static const UE4CodeGen_Private::FMetaDataPairParam NewProp_HostName_MetaData[] = {
				{ "NativeConst", "" },
			};
#endif
			static const UE4CodeGen_Private::FStrPropertyParams NewProp_HostName = { UE4CodeGen_Private::EPropertyClass::Str, "HostName", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000082, 1, nullptr, STRUCT_OFFSET(FOHEART_C1BPLibrary_eventFOHEART_C1ConnectUDP_Parms, HostName), METADATA_PARAMS(NewProp_HostName_MetaData, ARRAY_COUNT(NewProp_HostName_MetaData)) };
			static const UE4CodeGen_Private::FObjectPropertyParams NewProp_Controller = { UE4CodeGen_Private::EPropertyClass::Object, "Controller", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000080, 1, nullptr, STRUCT_OFFSET(FOHEART_C1BPLibrary_eventFOHEART_C1ConnectUDP_Parms, Controller), Z_Construct_UClass_AFOHEARTController_NoRegister, METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[] = {
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_ReturnValue,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_MotionLineFormat,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_MotionLineFormat_Underlying,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_bDisplacement,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_bReference,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_Port,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_HostName,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_Controller,
			};
#if WITH_METADATA
			static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
				{ "Category", "FOHEART_C1" },
				{ "CPP_Default_bDisplacement", "true" },
				{ "CPP_Default_bReference", "false" },
				{ "CPP_Default_HostName", "127.0.0.1" },
				{ "CPP_Default_MotionLineFormat", "VE_FOHEART_C1" },
				{ "CPP_Default_Port", "5001" },
				{ "DisplayName", "Read from MotionVenus using UDP" },
				{ "ModuleRelativePath", "Public/FOHEARTBPLibrary.h" },
				{ "ToolTip", "Rec from MotionVenus UDP proto" },
			};
#endif
			static const UE4CodeGen_Private::FFunctionParams FuncParams = { (UObject*(*)())Z_Construct_UClass_UFOHEART_C1BPLibrary, "FOHEART_C1ConnectUDP", RF_Public|RF_Transient|RF_MarkAsNative, nullptr, (EFunctionFlags)0x04022401, sizeof(FOHEART_C1BPLibrary_eventFOHEART_C1ConnectUDP_Parms), PropPointers, ARRAY_COUNT(PropPointers), 0, 0, METADATA_PARAMS(Function_MetaDataParams, ARRAY_COUNT(Function_MetaDataParams)) };
			UE4CodeGen_Private::ConstructUFunction(ReturnFunction, FuncParams);
		}
		return ReturnFunction;
	}
	UFunction* Z_Construct_UFunction_UFOHEART_C1BPLibrary_FOHEART_C1Disconnect()
	{
		struct FOHEART_C1BPLibrary_eventFOHEART_C1Disconnect_Parms
		{
			AFOHEARTController* Controller;
			bool ReturnValue;
		};
		static UFunction* ReturnFunction = nullptr;
		if (!ReturnFunction)
		{
			auto NewProp_ReturnValue_SetBit = [](void* Obj){ ((FOHEART_C1BPLibrary_eventFOHEART_C1Disconnect_Parms*)Obj)->ReturnValue = 1; };
			static const UE4CodeGen_Private::FBoolPropertyParams NewProp_ReturnValue = { UE4CodeGen_Private::EPropertyClass::Bool, "ReturnValue", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000580, 1, nullptr, sizeof(bool), UE4CodeGen_Private::ENativeBool::Native, sizeof(FOHEART_C1BPLibrary_eventFOHEART_C1Disconnect_Parms), &UE4CodeGen_Private::TBoolSetBitWrapper<decltype(NewProp_ReturnValue_SetBit)>::SetBit, METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FObjectPropertyParams NewProp_Controller = { UE4CodeGen_Private::EPropertyClass::Object, "Controller", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000080, 1, nullptr, STRUCT_OFFSET(FOHEART_C1BPLibrary_eventFOHEART_C1Disconnect_Parms, Controller), Z_Construct_UClass_AFOHEARTController_NoRegister, METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[] = {
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_ReturnValue,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_Controller,
			};
#if WITH_METADATA
			static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
				{ "Category", "FOHEART_C1" },
				{ "DisplayName", "Disconnect MotionVenus" },
				{ "ModuleRelativePath", "Public/FOHEARTBPLibrary.h" },
				{ "ToolTip", "Disconnect from MotionVenus." },
			};
#endif
			static const UE4CodeGen_Private::FFunctionParams FuncParams = { (UObject*(*)())Z_Construct_UClass_UFOHEART_C1BPLibrary, "FOHEART_C1Disconnect", RF_Public|RF_Transient|RF_MarkAsNative, nullptr, (EFunctionFlags)0x04022401, sizeof(FOHEART_C1BPLibrary_eventFOHEART_C1Disconnect_Parms), PropPointers, ARRAY_COUNT(PropPointers), 0, 0, METADATA_PARAMS(Function_MetaDataParams, ARRAY_COUNT(Function_MetaDataParams)) };
			UE4CodeGen_Private::ConstructUFunction(ReturnFunction, FuncParams);
		}
		return ReturnFunction;
	}
	UFunction* Z_Construct_UFunction_UFOHEART_C1BPLibrary_FOHEART_C1GetBVHBoneIndex()
	{
		struct FOHEART_C1BPLibrary_eventFOHEART_C1GetBVHBoneIndex_Parms
		{
			EFOHEART_C1BonesEnum FoheartBoneName;
			int32 ReturnValue;
		};
		static UFunction* ReturnFunction = nullptr;
		if (!ReturnFunction)
		{
			static const UE4CodeGen_Private::FIntPropertyParams NewProp_ReturnValue = { UE4CodeGen_Private::EPropertyClass::Int, "ReturnValue", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000580, 1, nullptr, STRUCT_OFFSET(FOHEART_C1BPLibrary_eventFOHEART_C1GetBVHBoneIndex_Parms, ReturnValue), METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FEnumPropertyParams NewProp_FoheartBoneName = { UE4CodeGen_Private::EPropertyClass::Enum, "FoheartBoneName", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000080, 1, nullptr, STRUCT_OFFSET(FOHEART_C1BPLibrary_eventFOHEART_C1GetBVHBoneIndex_Parms, FoheartBoneName), Z_Construct_UEnum_FOHEART_EFOHEART_C1BonesEnum, METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FBytePropertyParams NewProp_FoheartBoneName_Underlying = { UE4CodeGen_Private::EPropertyClass::Byte, "UnderlyingType", RF_Public|RF_Transient|RF_MarkAsNative, 0x0000000000000000, 1, nullptr, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[] = {
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_ReturnValue,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_FoheartBoneName,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_FoheartBoneName_Underlying,
			};
#if WITH_METADATA
			static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
				{ "Category", "FOHEART_C1" },
				{ "CompactNodeTitle", "Index" },
				{ "CPP_Default_FoheartBoneName", "VE_Hips" },
				{ "DisplayName", "Get BVH Bone Index" },
				{ "ModuleRelativePath", "Public/FOHEARTBPLibrary.h" },
				{ "ToolTip", "Return BVH Bone Index from Enum." },
			};
#endif
			static const UE4CodeGen_Private::FFunctionParams FuncParams = { (UObject*(*)())Z_Construct_UClass_UFOHEART_C1BPLibrary, "FOHEART_C1GetBVHBoneIndex", RF_Public|RF_Transient|RF_MarkAsNative, nullptr, (EFunctionFlags)0x14022401, sizeof(FOHEART_C1BPLibrary_eventFOHEART_C1GetBVHBoneIndex_Parms), PropPointers, ARRAY_COUNT(PropPointers), 0, 0, METADATA_PARAMS(Function_MetaDataParams, ARRAY_COUNT(Function_MetaDataParams)) };
			UE4CodeGen_Private::ConstructUFunction(ReturnFunction, FuncParams);
		}
		return ReturnFunction;
	}
	UFunction* Z_Construct_UFunction_UFOHEART_C1BPLibrary_FOHEART_C1GetLocalBoneLocation()
	{
		struct FOHEART_C1BPLibrary_eventFOHEART_C1GetLocalBoneLocation_Parms
		{
			USkeletalMeshComponent* Mesh;
			FVector Location;
			int32 BoneIndex;
			bool ReturnValue;
		};
		static UFunction* ReturnFunction = nullptr;
		if (!ReturnFunction)
		{
			auto NewProp_ReturnValue_SetBit = [](void* Obj){ ((FOHEART_C1BPLibrary_eventFOHEART_C1GetLocalBoneLocation_Parms*)Obj)->ReturnValue = 1; };
			static const UE4CodeGen_Private::FBoolPropertyParams NewProp_ReturnValue = { UE4CodeGen_Private::EPropertyClass::Bool, "ReturnValue", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000580, 1, nullptr, sizeof(bool), UE4CodeGen_Private::ENativeBool::Native, sizeof(FOHEART_C1BPLibrary_eventFOHEART_C1GetLocalBoneLocation_Parms), &UE4CodeGen_Private::TBoolSetBitWrapper<decltype(NewProp_ReturnValue_SetBit)>::SetBit, METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FIntPropertyParams NewProp_BoneIndex = { UE4CodeGen_Private::EPropertyClass::Int, "BoneIndex", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000080, 1, nullptr, STRUCT_OFFSET(FOHEART_C1BPLibrary_eventFOHEART_C1GetLocalBoneLocation_Parms, BoneIndex), METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FStructPropertyParams NewProp_Location = { UE4CodeGen_Private::EPropertyClass::Struct, "Location", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000180, 1, nullptr, STRUCT_OFFSET(FOHEART_C1BPLibrary_eventFOHEART_C1GetLocalBoneLocation_Parms, Location), Z_Construct_UScriptStruct_FVector, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
			static const UE4CodeGen_Private::FMetaDataPairParam NewProp_Mesh_MetaData[] = {
				{ "EditInline", "true" },
			};
#endif
			static const UE4CodeGen_Private::FObjectPropertyParams NewProp_Mesh = { UE4CodeGen_Private::EPropertyClass::Object, "Mesh", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000080080, 1, nullptr, STRUCT_OFFSET(FOHEART_C1BPLibrary_eventFOHEART_C1GetLocalBoneLocation_Parms, Mesh), Z_Construct_UClass_USkeletalMeshComponent_NoRegister, METADATA_PARAMS(NewProp_Mesh_MetaData, ARRAY_COUNT(NewProp_Mesh_MetaData)) };
			static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[] = {
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_ReturnValue,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_BoneIndex,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_Location,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_Mesh,
			};
#if WITH_METADATA
			static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
				{ "Category", "FOHEART_C1" },
				{ "CPP_Default_BoneIndex", "0" },
				{ "DisplayName", "Get Local Bone Location" },
				{ "Keywords", "Get local bone location from mesh." },
				{ "ModuleRelativePath", "Public/FOHEARTBPLibrary.h" },
			};
#endif
			static const UE4CodeGen_Private::FFunctionParams FuncParams = { (UObject*(*)())Z_Construct_UClass_UFOHEART_C1BPLibrary, "FOHEART_C1GetLocalBoneLocation", RF_Public|RF_Transient|RF_MarkAsNative, nullptr, (EFunctionFlags)0x04C22401, sizeof(FOHEART_C1BPLibrary_eventFOHEART_C1GetLocalBoneLocation_Parms), PropPointers, ARRAY_COUNT(PropPointers), 0, 0, METADATA_PARAMS(Function_MetaDataParams, ARRAY_COUNT(Function_MetaDataParams)) };
			UE4CodeGen_Private::ConstructUFunction(ReturnFunction, FuncParams);
		}
		return ReturnFunction;
	}
	UFunction* Z_Construct_UFunction_UFOHEART_C1BPLibrary_FOHEART_C1GetLocalBoneRotation()
	{
		struct FOHEART_C1BPLibrary_eventFOHEART_C1GetLocalBoneRotation_Parms
		{
			USkeletalMeshComponent* Mesh;
			FRotator Rotation;
			int32 BoneIndex;
			bool ReturnValue;
		};
		static UFunction* ReturnFunction = nullptr;
		if (!ReturnFunction)
		{
			auto NewProp_ReturnValue_SetBit = [](void* Obj){ ((FOHEART_C1BPLibrary_eventFOHEART_C1GetLocalBoneRotation_Parms*)Obj)->ReturnValue = 1; };
			static const UE4CodeGen_Private::FBoolPropertyParams NewProp_ReturnValue = { UE4CodeGen_Private::EPropertyClass::Bool, "ReturnValue", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000580, 1, nullptr, sizeof(bool), UE4CodeGen_Private::ENativeBool::Native, sizeof(FOHEART_C1BPLibrary_eventFOHEART_C1GetLocalBoneRotation_Parms), &UE4CodeGen_Private::TBoolSetBitWrapper<decltype(NewProp_ReturnValue_SetBit)>::SetBit, METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FIntPropertyParams NewProp_BoneIndex = { UE4CodeGen_Private::EPropertyClass::Int, "BoneIndex", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000080, 1, nullptr, STRUCT_OFFSET(FOHEART_C1BPLibrary_eventFOHEART_C1GetLocalBoneRotation_Parms, BoneIndex), METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FStructPropertyParams NewProp_Rotation = { UE4CodeGen_Private::EPropertyClass::Struct, "Rotation", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000180, 1, nullptr, STRUCT_OFFSET(FOHEART_C1BPLibrary_eventFOHEART_C1GetLocalBoneRotation_Parms, Rotation), Z_Construct_UScriptStruct_FRotator, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
			static const UE4CodeGen_Private::FMetaDataPairParam NewProp_Mesh_MetaData[] = {
				{ "EditInline", "true" },
			};
#endif
			static const UE4CodeGen_Private::FObjectPropertyParams NewProp_Mesh = { UE4CodeGen_Private::EPropertyClass::Object, "Mesh", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000080080, 1, nullptr, STRUCT_OFFSET(FOHEART_C1BPLibrary_eventFOHEART_C1GetLocalBoneRotation_Parms, Mesh), Z_Construct_UClass_USkeletalMeshComponent_NoRegister, METADATA_PARAMS(NewProp_Mesh_MetaData, ARRAY_COUNT(NewProp_Mesh_MetaData)) };
			static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[] = {
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_ReturnValue,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_BoneIndex,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_Rotation,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_Mesh,
			};
#if WITH_METADATA
			static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
				{ "Category", "FOHEART_C1" },
				{ "CPP_Default_BoneIndex", "0" },
				{ "DisplayName", "Get Local Bone Rotation" },
				{ "ModuleRelativePath", "Public/FOHEARTBPLibrary.h" },
				{ "ToolTip", "Get local bone rotation from mesh." },
			};
#endif
			static const UE4CodeGen_Private::FFunctionParams FuncParams = { (UObject*(*)())Z_Construct_UClass_UFOHEART_C1BPLibrary, "FOHEART_C1GetLocalBoneRotation", RF_Public|RF_Transient|RF_MarkAsNative, nullptr, (EFunctionFlags)0x04C22401, sizeof(FOHEART_C1BPLibrary_eventFOHEART_C1GetLocalBoneRotation_Parms), PropPointers, ARRAY_COUNT(PropPointers), 0, 0, METADATA_PARAMS(Function_MetaDataParams, ARRAY_COUNT(Function_MetaDataParams)) };
			UE4CodeGen_Private::ConstructUFunction(ReturnFunction, FuncParams);
		}
		return ReturnFunction;
	}
	UFunction* Z_Construct_UFunction_UFOHEART_C1BPLibrary_FOHEART_C1GetReferencePoseLocalBoneRotation()
	{
		struct FOHEART_C1BPLibrary_eventFOHEART_C1GetReferencePoseLocalBoneRotation_Parms
		{
			USkeletalMeshComponent* Mesh;
			FRotator Rotation;
			int32 BoneIndex;
			bool ReturnValue;
		};
		static UFunction* ReturnFunction = nullptr;
		if (!ReturnFunction)
		{
			auto NewProp_ReturnValue_SetBit = [](void* Obj){ ((FOHEART_C1BPLibrary_eventFOHEART_C1GetReferencePoseLocalBoneRotation_Parms*)Obj)->ReturnValue = 1; };
			static const UE4CodeGen_Private::FBoolPropertyParams NewProp_ReturnValue = { UE4CodeGen_Private::EPropertyClass::Bool, "ReturnValue", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000580, 1, nullptr, sizeof(bool), UE4CodeGen_Private::ENativeBool::Native, sizeof(FOHEART_C1BPLibrary_eventFOHEART_C1GetReferencePoseLocalBoneRotation_Parms), &UE4CodeGen_Private::TBoolSetBitWrapper<decltype(NewProp_ReturnValue_SetBit)>::SetBit, METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FIntPropertyParams NewProp_BoneIndex = { UE4CodeGen_Private::EPropertyClass::Int, "BoneIndex", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000080, 1, nullptr, STRUCT_OFFSET(FOHEART_C1BPLibrary_eventFOHEART_C1GetReferencePoseLocalBoneRotation_Parms, BoneIndex), METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FStructPropertyParams NewProp_Rotation = { UE4CodeGen_Private::EPropertyClass::Struct, "Rotation", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000180, 1, nullptr, STRUCT_OFFSET(FOHEART_C1BPLibrary_eventFOHEART_C1GetReferencePoseLocalBoneRotation_Parms, Rotation), Z_Construct_UScriptStruct_FRotator, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
			static const UE4CodeGen_Private::FMetaDataPairParam NewProp_Mesh_MetaData[] = {
				{ "EditInline", "true" },
			};
#endif
			static const UE4CodeGen_Private::FObjectPropertyParams NewProp_Mesh = { UE4CodeGen_Private::EPropertyClass::Object, "Mesh", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000080080, 1, nullptr, STRUCT_OFFSET(FOHEART_C1BPLibrary_eventFOHEART_C1GetReferencePoseLocalBoneRotation_Parms, Mesh), Z_Construct_UClass_USkeletalMeshComponent_NoRegister, METADATA_PARAMS(NewProp_Mesh_MetaData, ARRAY_COUNT(NewProp_Mesh_MetaData)) };
			static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[] = {
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_ReturnValue,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_BoneIndex,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_Rotation,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_Mesh,
			};
#if WITH_METADATA
			static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
				{ "Category", "FOHEART_C1" },
				{ "CPP_Default_BoneIndex", "0" },
				{ "DisplayName", "Get Refpose Local Bone Rotation" },
				{ "Keywords", "Get local bone rotation from reference pose." },
				{ "ModuleRelativePath", "Public/FOHEARTBPLibrary.h" },
			};
#endif
			static const UE4CodeGen_Private::FFunctionParams FuncParams = { (UObject*(*)())Z_Construct_UClass_UFOHEART_C1BPLibrary, "FOHEART_C1GetReferencePoseLocalBoneRotation", RF_Public|RF_Transient|RF_MarkAsNative, nullptr, (EFunctionFlags)0x04C22401, sizeof(FOHEART_C1BPLibrary_eventFOHEART_C1GetReferencePoseLocalBoneRotation_Parms), PropPointers, ARRAY_COUNT(PropPointers), 0, 0, METADATA_PARAMS(Function_MetaDataParams, ARRAY_COUNT(Function_MetaDataParams)) };
			UE4CodeGen_Private::ConstructUFunction(ReturnFunction, FuncParams);
		}
		return ReturnFunction;
	}
	UFunction* Z_Construct_UFunction_UFOHEART_C1BPLibrary_FOHEART_C1Init()
	{
		struct FOHEART_C1BPLibrary_eventFOHEART_C1Init_Parms
		{
			AFOHEARTController* Controller;
			int32 BoneNumber;
			EFOHEARTRotOrderEnum RotationOrder;
			EFOHEARTChannelNumberEnum XPositionChannel;
			EFOHEARTChannelNumberEnum YPositionChannel;
			EFOHEARTChannelNumberEnum ZPositionChannel;
			EFOHEARTChannelNumberEnum XRotationChannel;
			EFOHEARTChannelNumberEnum YRotationChannel;
			EFOHEARTChannelNumberEnum ZRotationChannel;
			bool ReturnValue;
		};
		static UFunction* ReturnFunction = nullptr;
		if (!ReturnFunction)
		{
			auto NewProp_ReturnValue_SetBit = [](void* Obj){ ((FOHEART_C1BPLibrary_eventFOHEART_C1Init_Parms*)Obj)->ReturnValue = 1; };
			static const UE4CodeGen_Private::FBoolPropertyParams NewProp_ReturnValue = { UE4CodeGen_Private::EPropertyClass::Bool, "ReturnValue", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000580, 1, nullptr, sizeof(bool), UE4CodeGen_Private::ENativeBool::Native, sizeof(FOHEART_C1BPLibrary_eventFOHEART_C1Init_Parms), &UE4CodeGen_Private::TBoolSetBitWrapper<decltype(NewProp_ReturnValue_SetBit)>::SetBit, METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FEnumPropertyParams NewProp_ZRotationChannel = { UE4CodeGen_Private::EPropertyClass::Enum, "ZRotationChannel", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000080, 1, nullptr, STRUCT_OFFSET(FOHEART_C1BPLibrary_eventFOHEART_C1Init_Parms, ZRotationChannel), Z_Construct_UEnum_FOHEART_EFOHEARTChannelNumberEnum, METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FBytePropertyParams NewProp_ZRotationChannel_Underlying = { UE4CodeGen_Private::EPropertyClass::Byte, "UnderlyingType", RF_Public|RF_Transient|RF_MarkAsNative, 0x0000000000000000, 1, nullptr, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FEnumPropertyParams NewProp_YRotationChannel = { UE4CodeGen_Private::EPropertyClass::Enum, "YRotationChannel", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000080, 1, nullptr, STRUCT_OFFSET(FOHEART_C1BPLibrary_eventFOHEART_C1Init_Parms, YRotationChannel), Z_Construct_UEnum_FOHEART_EFOHEARTChannelNumberEnum, METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FBytePropertyParams NewProp_YRotationChannel_Underlying = { UE4CodeGen_Private::EPropertyClass::Byte, "UnderlyingType", RF_Public|RF_Transient|RF_MarkAsNative, 0x0000000000000000, 1, nullptr, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FEnumPropertyParams NewProp_XRotationChannel = { UE4CodeGen_Private::EPropertyClass::Enum, "XRotationChannel", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000080, 1, nullptr, STRUCT_OFFSET(FOHEART_C1BPLibrary_eventFOHEART_C1Init_Parms, XRotationChannel), Z_Construct_UEnum_FOHEART_EFOHEARTChannelNumberEnum, METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FBytePropertyParams NewProp_XRotationChannel_Underlying = { UE4CodeGen_Private::EPropertyClass::Byte, "UnderlyingType", RF_Public|RF_Transient|RF_MarkAsNative, 0x0000000000000000, 1, nullptr, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FEnumPropertyParams NewProp_ZPositionChannel = { UE4CodeGen_Private::EPropertyClass::Enum, "ZPositionChannel", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000080, 1, nullptr, STRUCT_OFFSET(FOHEART_C1BPLibrary_eventFOHEART_C1Init_Parms, ZPositionChannel), Z_Construct_UEnum_FOHEART_EFOHEARTChannelNumberEnum, METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FBytePropertyParams NewProp_ZPositionChannel_Underlying = { UE4CodeGen_Private::EPropertyClass::Byte, "UnderlyingType", RF_Public|RF_Transient|RF_MarkAsNative, 0x0000000000000000, 1, nullptr, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FEnumPropertyParams NewProp_YPositionChannel = { UE4CodeGen_Private::EPropertyClass::Enum, "YPositionChannel", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000080, 1, nullptr, STRUCT_OFFSET(FOHEART_C1BPLibrary_eventFOHEART_C1Init_Parms, YPositionChannel), Z_Construct_UEnum_FOHEART_EFOHEARTChannelNumberEnum, METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FBytePropertyParams NewProp_YPositionChannel_Underlying = { UE4CodeGen_Private::EPropertyClass::Byte, "UnderlyingType", RF_Public|RF_Transient|RF_MarkAsNative, 0x0000000000000000, 1, nullptr, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FEnumPropertyParams NewProp_XPositionChannel = { UE4CodeGen_Private::EPropertyClass::Enum, "XPositionChannel", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000080, 1, nullptr, STRUCT_OFFSET(FOHEART_C1BPLibrary_eventFOHEART_C1Init_Parms, XPositionChannel), Z_Construct_UEnum_FOHEART_EFOHEARTChannelNumberEnum, METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FBytePropertyParams NewProp_XPositionChannel_Underlying = { UE4CodeGen_Private::EPropertyClass::Byte, "UnderlyingType", RF_Public|RF_Transient|RF_MarkAsNative, 0x0000000000000000, 1, nullptr, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FEnumPropertyParams NewProp_RotationOrder = { UE4CodeGen_Private::EPropertyClass::Enum, "RotationOrder", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000080, 1, nullptr, STRUCT_OFFSET(FOHEART_C1BPLibrary_eventFOHEART_C1Init_Parms, RotationOrder), Z_Construct_UEnum_FOHEART_EFOHEARTRotOrderEnum, METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FBytePropertyParams NewProp_RotationOrder_Underlying = { UE4CodeGen_Private::EPropertyClass::Byte, "UnderlyingType", RF_Public|RF_Transient|RF_MarkAsNative, 0x0000000000000000, 1, nullptr, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FIntPropertyParams NewProp_BoneNumber = { UE4CodeGen_Private::EPropertyClass::Int, "BoneNumber", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000080, 1, nullptr, STRUCT_OFFSET(FOHEART_C1BPLibrary_eventFOHEART_C1Init_Parms, BoneNumber), METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FObjectPropertyParams NewProp_Controller = { UE4CodeGen_Private::EPropertyClass::Object, "Controller", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000080, 1, nullptr, STRUCT_OFFSET(FOHEART_C1BPLibrary_eventFOHEART_C1Init_Parms, Controller), Z_Construct_UClass_AFOHEARTController_NoRegister, METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[] = {
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_ReturnValue,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_ZRotationChannel,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_ZRotationChannel_Underlying,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_YRotationChannel,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_YRotationChannel_Underlying,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_XRotationChannel,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_XRotationChannel_Underlying,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_ZPositionChannel,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_ZPositionChannel_Underlying,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_YPositionChannel,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_YPositionChannel_Underlying,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_XPositionChannel,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_XPositionChannel_Underlying,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_RotationOrder,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_RotationOrder_Underlying,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_BoneNumber,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_Controller,
			};
#if WITH_METADATA
			static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
				{ "Category", "FOHEART_C1" },
				{ "CPP_Default_BoneNumber", "23" },
				{ "CPP_Default_RotationOrder", "VE_ZXY" },
				{ "CPP_Default_XPositionChannel", "VE_0" },
				{ "CPP_Default_XRotationChannel", "VE_3" },
				{ "CPP_Default_YPositionChannel", "VE_1" },
				{ "CPP_Default_YRotationChannel", "VE_4" },
				{ "CPP_Default_ZPositionChannel", "VE_2" },
				{ "CPP_Default_ZRotationChannel", "VE_5" },
				{ "DisplayName", "Init FOHEART C1" },
				{ "ModuleRelativePath", "Public/FOHEARTBPLibrary.h" },
				{ "ToolTip", "Init BVH reference skeleton manually." },
			};
#endif
			static const UE4CodeGen_Private::FFunctionParams FuncParams = { (UObject*(*)())Z_Construct_UClass_UFOHEART_C1BPLibrary, "FOHEART_C1Init", RF_Public|RF_Transient|RF_MarkAsNative, nullptr, (EFunctionFlags)0x04022401, sizeof(FOHEART_C1BPLibrary_eventFOHEART_C1Init_Parms), PropPointers, ARRAY_COUNT(PropPointers), 0, 0, METADATA_PARAMS(Function_MetaDataParams, ARRAY_COUNT(Function_MetaDataParams)) };
			UE4CodeGen_Private::ConstructUFunction(ReturnFunction, FuncParams);
		}
		return ReturnFunction;
	}
	UFunction* Z_Construct_UFunction_UFOHEART_C1BPLibrary_FOHEART_C1InitBVHFile()
	{
		struct FOHEART_C1BPLibrary_eventFOHEART_C1InitBVHFile_Parms
		{
			AFOHEARTController* Controller;
			FString BVHFileName;
			bool ReturnValue;
		};
		static UFunction* ReturnFunction = nullptr;
		if (!ReturnFunction)
		{
			auto NewProp_ReturnValue_SetBit = [](void* Obj){ ((FOHEART_C1BPLibrary_eventFOHEART_C1InitBVHFile_Parms*)Obj)->ReturnValue = 1; };
			static const UE4CodeGen_Private::FBoolPropertyParams NewProp_ReturnValue = { UE4CodeGen_Private::EPropertyClass::Bool, "ReturnValue", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000580, 1, nullptr, sizeof(bool), UE4CodeGen_Private::ENativeBool::Native, sizeof(FOHEART_C1BPLibrary_eventFOHEART_C1InitBVHFile_Parms), &UE4CodeGen_Private::TBoolSetBitWrapper<decltype(NewProp_ReturnValue_SetBit)>::SetBit, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
			static const UE4CodeGen_Private::FMetaDataPairParam NewProp_BVHFileName_MetaData[] = {
				{ "NativeConst", "" },
			};
#endif
			static const UE4CodeGen_Private::FStrPropertyParams NewProp_BVHFileName = { UE4CodeGen_Private::EPropertyClass::Str, "BVHFileName", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000082, 1, nullptr, STRUCT_OFFSET(FOHEART_C1BPLibrary_eventFOHEART_C1InitBVHFile_Parms, BVHFileName), METADATA_PARAMS(NewProp_BVHFileName_MetaData, ARRAY_COUNT(NewProp_BVHFileName_MetaData)) };
			static const UE4CodeGen_Private::FObjectPropertyParams NewProp_Controller = { UE4CodeGen_Private::EPropertyClass::Object, "Controller", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000080, 1, nullptr, STRUCT_OFFSET(FOHEART_C1BPLibrary_eventFOHEART_C1InitBVHFile_Parms, Controller), Z_Construct_UClass_AFOHEARTController_NoRegister, METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[] = {
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_ReturnValue,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_BVHFileName,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_Controller,
			};
#if WITH_METADATA
			static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
				{ "Category", "FOHEART_C1" },
				{ "CPP_Default_BVHFileName", "demo.bvh" },
				{ "DisplayName", "Init BVH Replay File" },
				{ "ModuleRelativePath", "Public/FOHEARTBPLibrary.h" },
				{ "ToolTip", "Init BVH reference skeleton with a BVH file." },
			};
#endif
			static const UE4CodeGen_Private::FFunctionParams FuncParams = { (UObject*(*)())Z_Construct_UClass_UFOHEART_C1BPLibrary, "FOHEART_C1InitBVHFile", RF_Public|RF_Transient|RF_MarkAsNative, nullptr, (EFunctionFlags)0x04022401, sizeof(FOHEART_C1BPLibrary_eventFOHEART_C1InitBVHFile_Parms), PropPointers, ARRAY_COUNT(PropPointers), 0, 0, METADATA_PARAMS(Function_MetaDataParams, ARRAY_COUNT(Function_MetaDataParams)) };
			UE4CodeGen_Private::ConstructUFunction(ReturnFunction, FuncParams);
		}
		return ReturnFunction;
	}
	UFunction* Z_Construct_UFunction_UFOHEART_C1BPLibrary_FOHEART_C1NegateRotation()
	{
		struct FOHEART_C1BPLibrary_eventFOHEART_C1NegateRotation_Parms
		{
			FRotator Rotation;
			FRotator ReturnValue;
		};
		static UFunction* ReturnFunction = nullptr;
		if (!ReturnFunction)
		{
			static const UE4CodeGen_Private::FStructPropertyParams NewProp_ReturnValue = { UE4CodeGen_Private::EPropertyClass::Struct, "ReturnValue", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000580, 1, nullptr, STRUCT_OFFSET(FOHEART_C1BPLibrary_eventFOHEART_C1NegateRotation_Parms, ReturnValue), Z_Construct_UScriptStruct_FRotator, METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FStructPropertyParams NewProp_Rotation = { UE4CodeGen_Private::EPropertyClass::Struct, "Rotation", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000080, 1, nullptr, STRUCT_OFFSET(FOHEART_C1BPLibrary_eventFOHEART_C1NegateRotation_Parms, Rotation), Z_Construct_UScriptStruct_FRotator, METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[] = {
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_ReturnValue,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_Rotation,
			};
#if WITH_METADATA
			static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
				{ "Category", "FOHEART_C1" },
				{ "CompactNodeTitle", "Neg" },
				{ "DisplayName", "Negate Rotation" },
				{ "ModuleRelativePath", "Public/FOHEARTBPLibrary.h" },
				{ "ToolTip", "Negate Yaw, Pitch and Roll in rotation vector." },
			};
#endif
			static const UE4CodeGen_Private::FFunctionParams FuncParams = { (UObject*(*)())Z_Construct_UClass_UFOHEART_C1BPLibrary, "FOHEART_C1NegateRotation", RF_Public|RF_Transient|RF_MarkAsNative, nullptr, (EFunctionFlags)0x14822401, sizeof(FOHEART_C1BPLibrary_eventFOHEART_C1NegateRotation_Parms), PropPointers, ARRAY_COUNT(PropPointers), 0, 0, METADATA_PARAMS(Function_MetaDataParams, ARRAY_COUNT(Function_MetaDataParams)) };
			UE4CodeGen_Private::ConstructUFunction(ReturnFunction, FuncParams);
		}
		return ReturnFunction;
	}
	UFunction* Z_Construct_UFunction_UFOHEART_C1BPLibrary_FOHEART_C1Read()
	{
		struct FOHEART_C1BPLibrary_eventFOHEART_C1Read_Parms
		{
			AFOHEARTController* Controller;
			FString ActorName;
			USkeletalMeshComponent* Mesh;
			FVector Translation;
			FRotator Rotation;
			FVector AdditionalTranslation;
			FRotator AdditionalRotation;
			EFOHEART_C1BonesEnum FoheartBoneName;
			FName TargetBoneName;
			FFOHEART_BoneAxisMatch MatchAxis_X;
			FFOHEART_BoneAxisMatch MatchAxis_Y;
			FFOHEART_BoneAxisMatch MatchAxis_Z;
			bool InverseForward;
			bool ReturnValue;
		};
		static UFunction* ReturnFunction = nullptr;
		if (!ReturnFunction)
		{
			auto NewProp_ReturnValue_SetBit = [](void* Obj){ ((FOHEART_C1BPLibrary_eventFOHEART_C1Read_Parms*)Obj)->ReturnValue = 1; };
			static const UE4CodeGen_Private::FBoolPropertyParams NewProp_ReturnValue = { UE4CodeGen_Private::EPropertyClass::Bool, "ReturnValue", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000580, 1, nullptr, sizeof(bool), UE4CodeGen_Private::ENativeBool::Native, sizeof(FOHEART_C1BPLibrary_eventFOHEART_C1Read_Parms), &UE4CodeGen_Private::TBoolSetBitWrapper<decltype(NewProp_ReturnValue_SetBit)>::SetBit, METADATA_PARAMS(nullptr, 0) };
			auto NewProp_InverseForward_SetBit = [](void* Obj){ ((FOHEART_C1BPLibrary_eventFOHEART_C1Read_Parms*)Obj)->InverseForward = 1; };
			static const UE4CodeGen_Private::FBoolPropertyParams NewProp_InverseForward = { UE4CodeGen_Private::EPropertyClass::Bool, "InverseForward", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000080, 1, nullptr, sizeof(bool), UE4CodeGen_Private::ENativeBool::Native, sizeof(FOHEART_C1BPLibrary_eventFOHEART_C1Read_Parms), &UE4CodeGen_Private::TBoolSetBitWrapper<decltype(NewProp_InverseForward_SetBit)>::SetBit, METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FStructPropertyParams NewProp_MatchAxis_Z = { UE4CodeGen_Private::EPropertyClass::Struct, "MatchAxis_Z", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000080, 1, nullptr, STRUCT_OFFSET(FOHEART_C1BPLibrary_eventFOHEART_C1Read_Parms, MatchAxis_Z), Z_Construct_UScriptStruct_FFOHEART_BoneAxisMatch, METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FStructPropertyParams NewProp_MatchAxis_Y = { UE4CodeGen_Private::EPropertyClass::Struct, "MatchAxis_Y", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000080, 1, nullptr, STRUCT_OFFSET(FOHEART_C1BPLibrary_eventFOHEART_C1Read_Parms, MatchAxis_Y), Z_Construct_UScriptStruct_FFOHEART_BoneAxisMatch, METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FStructPropertyParams NewProp_MatchAxis_X = { UE4CodeGen_Private::EPropertyClass::Struct, "MatchAxis_X", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000080, 1, nullptr, STRUCT_OFFSET(FOHEART_C1BPLibrary_eventFOHEART_C1Read_Parms, MatchAxis_X), Z_Construct_UScriptStruct_FFOHEART_BoneAxisMatch, METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FNamePropertyParams NewProp_TargetBoneName = { UE4CodeGen_Private::EPropertyClass::Name, "TargetBoneName", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000080, 1, nullptr, STRUCT_OFFSET(FOHEART_C1BPLibrary_eventFOHEART_C1Read_Parms, TargetBoneName), METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FEnumPropertyParams NewProp_FoheartBoneName = { UE4CodeGen_Private::EPropertyClass::Enum, "FoheartBoneName", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000080, 1, nullptr, STRUCT_OFFSET(FOHEART_C1BPLibrary_eventFOHEART_C1Read_Parms, FoheartBoneName), Z_Construct_UEnum_FOHEART_EFOHEART_C1BonesEnum, METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FBytePropertyParams NewProp_FoheartBoneName_Underlying = { UE4CodeGen_Private::EPropertyClass::Byte, "UnderlyingType", RF_Public|RF_Transient|RF_MarkAsNative, 0x0000000000000000, 1, nullptr, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FStructPropertyParams NewProp_AdditionalRotation = { UE4CodeGen_Private::EPropertyClass::Struct, "AdditionalRotation", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000080, 1, nullptr, STRUCT_OFFSET(FOHEART_C1BPLibrary_eventFOHEART_C1Read_Parms, AdditionalRotation), Z_Construct_UScriptStruct_FRotator, METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FStructPropertyParams NewProp_AdditionalTranslation = { UE4CodeGen_Private::EPropertyClass::Struct, "AdditionalTranslation", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000080, 1, nullptr, STRUCT_OFFSET(FOHEART_C1BPLibrary_eventFOHEART_C1Read_Parms, AdditionalTranslation), Z_Construct_UScriptStruct_FVector, METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FStructPropertyParams NewProp_Rotation = { UE4CodeGen_Private::EPropertyClass::Struct, "Rotation", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000180, 1, nullptr, STRUCT_OFFSET(FOHEART_C1BPLibrary_eventFOHEART_C1Read_Parms, Rotation), Z_Construct_UScriptStruct_FRotator, METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FStructPropertyParams NewProp_Translation = { UE4CodeGen_Private::EPropertyClass::Struct, "Translation", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000180, 1, nullptr, STRUCT_OFFSET(FOHEART_C1BPLibrary_eventFOHEART_C1Read_Parms, Translation), Z_Construct_UScriptStruct_FVector, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
			static const UE4CodeGen_Private::FMetaDataPairParam NewProp_Mesh_MetaData[] = {
				{ "EditInline", "true" },
			};
#endif
			static const UE4CodeGen_Private::FObjectPropertyParams NewProp_Mesh = { UE4CodeGen_Private::EPropertyClass::Object, "Mesh", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000080080, 1, nullptr, STRUCT_OFFSET(FOHEART_C1BPLibrary_eventFOHEART_C1Read_Parms, Mesh), Z_Construct_UClass_USkeletalMeshComponent_NoRegister, METADATA_PARAMS(NewProp_Mesh_MetaData, ARRAY_COUNT(NewProp_Mesh_MetaData)) };
			static const UE4CodeGen_Private::FStrPropertyParams NewProp_ActorName = { UE4CodeGen_Private::EPropertyClass::Str, "ActorName", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000080, 1, nullptr, STRUCT_OFFSET(FOHEART_C1BPLibrary_eventFOHEART_C1Read_Parms, ActorName), METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FObjectPropertyParams NewProp_Controller = { UE4CodeGen_Private::EPropertyClass::Object, "Controller", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000080, 1, nullptr, STRUCT_OFFSET(FOHEART_C1BPLibrary_eventFOHEART_C1Read_Parms, Controller), Z_Construct_UClass_AFOHEARTController_NoRegister, METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[] = {
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_ReturnValue,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_InverseForward,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_MatchAxis_Z,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_MatchAxis_Y,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_MatchAxis_X,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_TargetBoneName,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_FoheartBoneName,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_FoheartBoneName_Underlying,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_AdditionalRotation,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_AdditionalTranslation,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_Rotation,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_Translation,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_Mesh,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_ActorName,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_Controller,
			};
#if WITH_METADATA
			static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
				{ "Category", "FOHEART_C1" },
				{ "CPP_Default_InverseForward", "false" },
				{ "DisplayName", "Read Motion" },
				{ "ModuleRelativePath", "Public/FOHEARTBPLibrary.h" },
				{ "ToolTip", "Read incoming motion data for all bones." },
			};
#endif
			static const UE4CodeGen_Private::FFunctionParams FuncParams = { (UObject*(*)())Z_Construct_UClass_UFOHEART_C1BPLibrary, "FOHEART_C1Read", RF_Public|RF_Transient|RF_MarkAsNative, nullptr, (EFunctionFlags)0x04C22401, sizeof(FOHEART_C1BPLibrary_eventFOHEART_C1Read_Parms), PropPointers, ARRAY_COUNT(PropPointers), 0, 0, METADATA_PARAMS(Function_MetaDataParams, ARRAY_COUNT(Function_MetaDataParams)) };
			UE4CodeGen_Private::ConstructUFunction(ReturnFunction, FuncParams);
		}
		return ReturnFunction;
	}
	UFunction* Z_Construct_UFunction_UFOHEART_C1BPLibrary_FOHEART_C1ReadArray()
	{
		struct FOHEART_C1BPLibrary_eventFOHEART_C1ReadArray_Parms
		{
			AFOHEARTController* Controller;
			FString ActorName;
			USkeletalMeshComponent* Mesh;
			TArray<FVector> Translation;
			TArray<FRotator> Rotation;
			TArray<FVector> AdditionalTranslation;
			TArray<FRotator> AdditionalRotation;
			TArray<FFOHEART_C1BoneMapStruct> BoneMap;
			bool InverseForward;
			bool ReturnValue;
		};
		static UFunction* ReturnFunction = nullptr;
		if (!ReturnFunction)
		{
			auto NewProp_ReturnValue_SetBit = [](void* Obj){ ((FOHEART_C1BPLibrary_eventFOHEART_C1ReadArray_Parms*)Obj)->ReturnValue = 1; };
			static const UE4CodeGen_Private::FBoolPropertyParams NewProp_ReturnValue = { UE4CodeGen_Private::EPropertyClass::Bool, "ReturnValue", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000580, 1, nullptr, sizeof(bool), UE4CodeGen_Private::ENativeBool::Native, sizeof(FOHEART_C1BPLibrary_eventFOHEART_C1ReadArray_Parms), &UE4CodeGen_Private::TBoolSetBitWrapper<decltype(NewProp_ReturnValue_SetBit)>::SetBit, METADATA_PARAMS(nullptr, 0) };
			auto NewProp_InverseForward_SetBit = [](void* Obj){ ((FOHEART_C1BPLibrary_eventFOHEART_C1ReadArray_Parms*)Obj)->InverseForward = 1; };
			static const UE4CodeGen_Private::FBoolPropertyParams NewProp_InverseForward = { UE4CodeGen_Private::EPropertyClass::Bool, "InverseForward", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000080, 1, nullptr, sizeof(bool), UE4CodeGen_Private::ENativeBool::Native, sizeof(FOHEART_C1BPLibrary_eventFOHEART_C1ReadArray_Parms), &UE4CodeGen_Private::TBoolSetBitWrapper<decltype(NewProp_InverseForward_SetBit)>::SetBit, METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FArrayPropertyParams NewProp_BoneMap = { UE4CodeGen_Private::EPropertyClass::Array, "BoneMap", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000080, 1, nullptr, STRUCT_OFFSET(FOHEART_C1BPLibrary_eventFOHEART_C1ReadArray_Parms, BoneMap), METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FStructPropertyParams NewProp_BoneMap_Inner = { UE4CodeGen_Private::EPropertyClass::Struct, "BoneMap", RF_Public|RF_Transient|RF_MarkAsNative, 0x0000000000000000, 1, nullptr, 0, Z_Construct_UScriptStruct_FFOHEART_C1BoneMapStruct, METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FArrayPropertyParams NewProp_AdditionalRotation = { UE4CodeGen_Private::EPropertyClass::Array, "AdditionalRotation", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000080, 1, nullptr, STRUCT_OFFSET(FOHEART_C1BPLibrary_eventFOHEART_C1ReadArray_Parms, AdditionalRotation), METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FStructPropertyParams NewProp_AdditionalRotation_Inner = { UE4CodeGen_Private::EPropertyClass::Struct, "AdditionalRotation", RF_Public|RF_Transient|RF_MarkAsNative, 0x0000000000000000, 1, nullptr, 0, Z_Construct_UScriptStruct_FRotator, METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FArrayPropertyParams NewProp_AdditionalTranslation = { UE4CodeGen_Private::EPropertyClass::Array, "AdditionalTranslation", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000080, 1, nullptr, STRUCT_OFFSET(FOHEART_C1BPLibrary_eventFOHEART_C1ReadArray_Parms, AdditionalTranslation), METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FStructPropertyParams NewProp_AdditionalTranslation_Inner = { UE4CodeGen_Private::EPropertyClass::Struct, "AdditionalTranslation", RF_Public|RF_Transient|RF_MarkAsNative, 0x0000000000000000, 1, nullptr, 0, Z_Construct_UScriptStruct_FVector, METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FArrayPropertyParams NewProp_Rotation = { UE4CodeGen_Private::EPropertyClass::Array, "Rotation", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000180, 1, nullptr, STRUCT_OFFSET(FOHEART_C1BPLibrary_eventFOHEART_C1ReadArray_Parms, Rotation), METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FStructPropertyParams NewProp_Rotation_Inner = { UE4CodeGen_Private::EPropertyClass::Struct, "Rotation", RF_Public|RF_Transient|RF_MarkAsNative, 0x0000000000000000, 1, nullptr, 0, Z_Construct_UScriptStruct_FRotator, METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FArrayPropertyParams NewProp_Translation = { UE4CodeGen_Private::EPropertyClass::Array, "Translation", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000180, 1, nullptr, STRUCT_OFFSET(FOHEART_C1BPLibrary_eventFOHEART_C1ReadArray_Parms, Translation), METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FStructPropertyParams NewProp_Translation_Inner = { UE4CodeGen_Private::EPropertyClass::Struct, "Translation", RF_Public|RF_Transient|RF_MarkAsNative, 0x0000000000000000, 1, nullptr, 0, Z_Construct_UScriptStruct_FVector, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
			static const UE4CodeGen_Private::FMetaDataPairParam NewProp_Mesh_MetaData[] = {
				{ "EditInline", "true" },
			};
#endif
			static const UE4CodeGen_Private::FObjectPropertyParams NewProp_Mesh = { UE4CodeGen_Private::EPropertyClass::Object, "Mesh", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000080080, 1, nullptr, STRUCT_OFFSET(FOHEART_C1BPLibrary_eventFOHEART_C1ReadArray_Parms, Mesh), Z_Construct_UClass_USkeletalMeshComponent_NoRegister, METADATA_PARAMS(NewProp_Mesh_MetaData, ARRAY_COUNT(NewProp_Mesh_MetaData)) };
			static const UE4CodeGen_Private::FStrPropertyParams NewProp_ActorName = { UE4CodeGen_Private::EPropertyClass::Str, "ActorName", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000080, 1, nullptr, STRUCT_OFFSET(FOHEART_C1BPLibrary_eventFOHEART_C1ReadArray_Parms, ActorName), METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FObjectPropertyParams NewProp_Controller = { UE4CodeGen_Private::EPropertyClass::Object, "Controller", RF_Public|RF_Transient|RF_MarkAsNative, 0x0010000000000080, 1, nullptr, STRUCT_OFFSET(FOHEART_C1BPLibrary_eventFOHEART_C1ReadArray_Parms, Controller), Z_Construct_UClass_AFOHEARTController_NoRegister, METADATA_PARAMS(nullptr, 0) };
			static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[] = {
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_ReturnValue,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_InverseForward,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_BoneMap,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_BoneMap_Inner,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_AdditionalRotation,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_AdditionalRotation_Inner,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_AdditionalTranslation,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_AdditionalTranslation_Inner,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_Rotation,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_Rotation_Inner,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_Translation,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_Translation_Inner,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_Mesh,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_ActorName,
				(const UE4CodeGen_Private::FPropertyParamsBase*)&NewProp_Controller,
			};
#if WITH_METADATA
			static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
				{ "Category", "FOHEART_C1" },
				{ "CPP_Default_InverseForward", "false" },
				{ "DisplayName", "Read Motion Array" },
				{ "ModuleRelativePath", "Public/FOHEARTBPLibrary.h" },
				{ "ToolTip", "Read incoming motion data for all bones." },
			};
#endif
			static const UE4CodeGen_Private::FFunctionParams FuncParams = { (UObject*(*)())Z_Construct_UClass_UFOHEART_C1BPLibrary, "FOHEART_C1ReadArray", RF_Public|RF_Transient|RF_MarkAsNative, nullptr, (EFunctionFlags)0x04422401, sizeof(FOHEART_C1BPLibrary_eventFOHEART_C1ReadArray_Parms), PropPointers, ARRAY_COUNT(PropPointers), 0, 0, METADATA_PARAMS(Function_MetaDataParams, ARRAY_COUNT(Function_MetaDataParams)) };
			UE4CodeGen_Private::ConstructUFunction(ReturnFunction, FuncParams);
		}
		return ReturnFunction;
	}
	UClass* Z_Construct_UClass_UFOHEART_C1BPLibrary_NoRegister()
	{
		return UFOHEART_C1BPLibrary::StaticClass();
	}
	UClass* Z_Construct_UClass_UFOHEART_C1BPLibrary()
	{
		static UClass* OuterClass = nullptr;
		if (!OuterClass)
		{
			static UObject* (*const DependentSingletons[])() = {
				(UObject* (*)())Z_Construct_UClass_UBlueprintFunctionLibrary,
				(UObject* (*)())Z_Construct_UPackage__Script_FOHEART,
			};
			static const FClassFunctionLinkInfo FuncInfo[] = {
				{ &Z_Construct_UFunction_UFOHEART_C1BPLibrary_FOHEART_C1BoneSetOffset, "FOHEART_C1BoneSetOffset" }, // 2660027659
				{ &Z_Construct_UFunction_UFOHEART_C1BPLibrary_FOHEART_C1BVHPause, "FOHEART_C1BVHPause" }, // 721617037
				{ &Z_Construct_UFunction_UFOHEART_C1BPLibrary_FOHEART_C1BVHPlay, "FOHEART_C1BVHPlay" }, // 2245657154
				{ &Z_Construct_UFunction_UFOHEART_C1BPLibrary_FOHEART_C1BVHRewind, "FOHEART_C1BVHRewind" }, // 2699209653
				{ &Z_Construct_UFunction_UFOHEART_C1BPLibrary_FOHEART_C1ConnectTCP, "FOHEART_C1ConnectTCP" }, // 3334710045
				{ &Z_Construct_UFunction_UFOHEART_C1BPLibrary_FOHEART_C1ConnectUDP, "FOHEART_C1ConnectUDP" }, // 2917113946
				{ &Z_Construct_UFunction_UFOHEART_C1BPLibrary_FOHEART_C1Disconnect, "FOHEART_C1Disconnect" }, // 596335103
				{ &Z_Construct_UFunction_UFOHEART_C1BPLibrary_FOHEART_C1GetBVHBoneIndex, "FOHEART_C1GetBVHBoneIndex" }, // 2936495098
				{ &Z_Construct_UFunction_UFOHEART_C1BPLibrary_FOHEART_C1GetLocalBoneLocation, "FOHEART_C1GetLocalBoneLocation" }, // 1172815886
				{ &Z_Construct_UFunction_UFOHEART_C1BPLibrary_FOHEART_C1GetLocalBoneRotation, "FOHEART_C1GetLocalBoneRotation" }, // 61797
				{ &Z_Construct_UFunction_UFOHEART_C1BPLibrary_FOHEART_C1GetReferencePoseLocalBoneRotation, "FOHEART_C1GetReferencePoseLocalBoneRotation" }, // 379244981
				{ &Z_Construct_UFunction_UFOHEART_C1BPLibrary_FOHEART_C1Init, "FOHEART_C1Init" }, // 4244879728
				{ &Z_Construct_UFunction_UFOHEART_C1BPLibrary_FOHEART_C1InitBVHFile, "FOHEART_C1InitBVHFile" }, // 2205172801
				{ &Z_Construct_UFunction_UFOHEART_C1BPLibrary_FOHEART_C1NegateRotation, "FOHEART_C1NegateRotation" }, // 2288311632
				{ &Z_Construct_UFunction_UFOHEART_C1BPLibrary_FOHEART_C1Read, "FOHEART_C1Read" }, // 2938426198
				{ &Z_Construct_UFunction_UFOHEART_C1BPLibrary_FOHEART_C1ReadArray, "FOHEART_C1ReadArray" }, // 2860524163
			};
#if WITH_METADATA
			static const UE4CodeGen_Private::FMetaDataPairParam Class_MetaDataParams[] = {
				{ "IncludePath", "FOHEARTBPLibrary.h" },
				{ "ModuleRelativePath", "Public/FOHEARTBPLibrary.h" },
			};
#endif
			static const FCppClassTypeInfoStatic StaticCppClassTypeInfo = {
				TCppClassTypeTraits<UFOHEART_C1BPLibrary>::IsAbstract,
			};
			static const UE4CodeGen_Private::FClassParams ClassParams = {
				&UFOHEART_C1BPLibrary::StaticClass,
				DependentSingletons, ARRAY_COUNT(DependentSingletons),
				0x00000080u,
				FuncInfo, ARRAY_COUNT(FuncInfo),
				nullptr, 0,
				nullptr,
				&StaticCppClassTypeInfo,
				nullptr, 0,
				METADATA_PARAMS(Class_MetaDataParams, ARRAY_COUNT(Class_MetaDataParams))
			};
			UE4CodeGen_Private::ConstructUClass(OuterClass, ClassParams);
		}
		return OuterClass;
	}
	IMPLEMENT_CLASS(UFOHEART_C1BPLibrary, 3148773934);
	static FCompiledInDefer Z_CompiledInDefer_UClass_UFOHEART_C1BPLibrary(Z_Construct_UClass_UFOHEART_C1BPLibrary, &UFOHEART_C1BPLibrary::StaticClass, TEXT("/Script/FOHEART"), TEXT("UFOHEART_C1BPLibrary"), false, nullptr, nullptr, nullptr);
	DEFINE_VTABLE_PTR_HELPER_CTOR(UFOHEART_C1BPLibrary);
PRAGMA_ENABLE_DEPRECATION_WARNINGS
#ifdef _MSC_VER
#pragma warning (pop)
#endif
