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

#include "UObject/GeneratedCppIncludes.h"
#include "MotionCaptureRuntime/Public/MotionCaptureFunctionLibrary.h"
#ifdef _MSC_VER
#pragma warning (push)
#pragma warning (disable : 4883)
#endif
PRAGMA_DISABLE_DEPRECATION_WARNINGS
void EmptyLinkFunctionForGeneratedCodeMotionCaptureFunctionLibrary() {}
// Cross Module References
	MOTIONCAPTURERUNTIME_API UClass* Z_Construct_UClass_UMotionCaptureFunctionLibrary_NoRegister();
	MOTIONCAPTURERUNTIME_API UClass* Z_Construct_UClass_UMotionCaptureFunctionLibrary();
	ENGINE_API UClass* Z_Construct_UClass_UBlueprintFunctionLibrary();
	UPackage* Z_Construct_UPackage__Script_MotionCaptureRuntime();
	MOTIONCAPTURERUNTIME_API UFunction* Z_Construct_UFunction_UMotionCaptureFunctionLibrary_CalibrationGlove();
	MOTIONCAPTURERUNTIME_API UEnum* Z_Construct_UEnum_MotionCaptureRuntime_ECalibrationPose();
	MOTIONCAPTURERUNTIME_API UFunction* Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetCalibrationProgress();
	MOTIONCAPTURERUNTIME_API UFunction* Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetGloveMagneticed();
	MOTIONCAPTURERUNTIME_API UEnum* Z_Construct_UEnum_MotionCaptureRuntime_EGloveMagneticedState();
	MOTIONCAPTURERUNTIME_API UFunction* Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetGlovePositionSource();
	MOTIONCAPTURERUNTIME_API UEnum* Z_Construct_UEnum_MotionCaptureRuntime_EGlovePositionSource();
	MOTIONCAPTURERUNTIME_API UFunction* Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetGlovePowerLevel();
	MOTIONCAPTURERUNTIME_API UEnum* Z_Construct_UEnum_MotionCaptureRuntime_EGlovePowerLevel();
	MOTIONCAPTURERUNTIME_API UFunction* Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointDataByAvatarName();
	COREUOBJECT_API UScriptStruct* Z_Construct_UScriptStruct_FRotator();
	COREUOBJECT_API UScriptStruct* Z_Construct_UScriptStruct_FVector();
	MOTIONCAPTURERUNTIME_API UEnum* Z_Construct_UEnum_MotionCaptureRuntime_EMCBones();
	MOTIONCAPTURERUNTIME_API UEnum* Z_Construct_UEnum_MotionCaptureRuntime_EGloveMod();
	MOTIONCAPTURERUNTIME_API UFunction* Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointDataInLocalMachine();
	MOTIONCAPTURERUNTIME_API UFunction* Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointsDataByAvatarName();
	MOTIONCAPTURERUNTIME_API UFunction* Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointsDataInLocalMachine();
	MOTIONCAPTURERUNTIME_API UFunction* Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetLeftTrackerId();
	MOTIONCAPTURERUNTIME_API UFunction* Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetOptiDeviceBindState();
	MOTIONCAPTURERUNTIME_API UFunction* Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetOptiDeviceSN();
	MOTIONCAPTURERUNTIME_API UFunction* Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetRightTrackerId();
	MOTIONCAPTURERUNTIME_API UFunction* Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetTrackedDeviceDataInUESpace();
	MOTIONCAPTURERUNTIME_API UFunction* Z_Construct_UFunction_UMotionCaptureFunctionLibrary_IsDongleAvailable();
	MOTIONCAPTURERUNTIME_API UFunction* Z_Construct_UFunction_UMotionCaptureFunctionLibrary_IsGloveAvailable();
	MOTIONCAPTURERUNTIME_API UFunction* Z_Construct_UFunction_UMotionCaptureFunctionLibrary_LoadCalibrationData();
	MOTIONCAPTURERUNTIME_API UFunction* Z_Construct_UFunction_UMotionCaptureFunctionLibrary_RotatorToAxisAndAngle();
	MOTIONCAPTURERUNTIME_API UFunction* Z_Construct_UFunction_UMotionCaptureFunctionLibrary_RotatorToAxisAndRadian();
	MOTIONCAPTURERUNTIME_API UFunction* Z_Construct_UFunction_UMotionCaptureFunctionLibrary_SaveCalibrationData();
	MOTIONCAPTURERUNTIME_API UFunction* Z_Construct_UFunction_UMotionCaptureFunctionLibrary_StartMocapService();
	MOTIONCAPTURERUNTIME_API UFunction* Z_Construct_UFunction_UMotionCaptureFunctionLibrary_StopMocapService();
	MOTIONCAPTURERUNTIME_API UFunction* Z_Construct_UFunction_UMotionCaptureFunctionLibrary_VibrateGloves();
	MOTIONCAPTURERUNTIME_API UFunction* Z_Construct_UFunction_UMotionCaptureFunctionLibrary_VibrateLeftGlove();
	MOTIONCAPTURERUNTIME_API UFunction* Z_Construct_UFunction_UMotionCaptureFunctionLibrary_VibrateRightGlove();
// End Cross Module References
	void UMotionCaptureFunctionLibrary::StaticRegisterNativesUMotionCaptureFunctionLibrary()
	{
		UClass* Class = UMotionCaptureFunctionLibrary::StaticClass();
		static const FNameNativePtrPair Funcs[] = {
			{ "CalibrationGlove", &UMotionCaptureFunctionLibrary::execCalibrationGlove },
			{ "GetCalibrationProgress", &UMotionCaptureFunctionLibrary::execGetCalibrationProgress },
			{ "GetGloveMagneticed", &UMotionCaptureFunctionLibrary::execGetGloveMagneticed },
			{ "GetGlovePositionSource", &UMotionCaptureFunctionLibrary::execGetGlovePositionSource },
			{ "GetGlovePowerLevel", &UMotionCaptureFunctionLibrary::execGetGlovePowerLevel },
			{ "GetJointDataByAvatarName", &UMotionCaptureFunctionLibrary::execGetJointDataByAvatarName },
			{ "GetJointDataInLocalMachine", &UMotionCaptureFunctionLibrary::execGetJointDataInLocalMachine },
			{ "GetJointsDataByAvatarName", &UMotionCaptureFunctionLibrary::execGetJointsDataByAvatarName },
			{ "GetJointsDataInLocalMachine", &UMotionCaptureFunctionLibrary::execGetJointsDataInLocalMachine },
			{ "GetLeftTrackerId", &UMotionCaptureFunctionLibrary::execGetLeftTrackerId },
			{ "GetOptiDeviceBindState", &UMotionCaptureFunctionLibrary::execGetOptiDeviceBindState },
			{ "GetOptiDeviceSN", &UMotionCaptureFunctionLibrary::execGetOptiDeviceSN },
			{ "GetRightTrackerId", &UMotionCaptureFunctionLibrary::execGetRightTrackerId },
			{ "GetTrackedDeviceDataInUESpace", &UMotionCaptureFunctionLibrary::execGetTrackedDeviceDataInUESpace },
			{ "IsDongleAvailable", &UMotionCaptureFunctionLibrary::execIsDongleAvailable },
			{ "IsGloveAvailable", &UMotionCaptureFunctionLibrary::execIsGloveAvailable },
			{ "LoadCalibrationData", &UMotionCaptureFunctionLibrary::execLoadCalibrationData },
			{ "RotatorToAxisAndAngle", &UMotionCaptureFunctionLibrary::execRotatorToAxisAndAngle },
			{ "RotatorToAxisAndRadian", &UMotionCaptureFunctionLibrary::execRotatorToAxisAndRadian },
			{ "SaveCalibrationData", &UMotionCaptureFunctionLibrary::execSaveCalibrationData },
			{ "StartMocapService", &UMotionCaptureFunctionLibrary::execStartMocapService },
			{ "StopMocapService", &UMotionCaptureFunctionLibrary::execStopMocapService },
			{ "VibrateGloves", &UMotionCaptureFunctionLibrary::execVibrateGloves },
			{ "VibrateLeftGlove", &UMotionCaptureFunctionLibrary::execVibrateLeftGlove },
			{ "VibrateRightGlove", &UMotionCaptureFunctionLibrary::execVibrateRightGlove },
		};
		FNativeFunctionRegistrar::RegisterFunctions(Class, Funcs, ARRAY_COUNT(Funcs));
	}
	struct Z_Construct_UFunction_UMotionCaptureFunctionLibrary_CalibrationGlove_Statics
	{
		struct MotionCaptureFunctionLibrary_eventCalibrationGlove_Parms
		{
			ECalibrationPose Pose;
			int32 TimeOut;
		};
		static const UE4CodeGen_Private::FIntPropertyParams NewProp_TimeOut;
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_Pose;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_Pose_Underlying;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
		static const UE4CodeGen_Private::FFunctionParams FuncParams;
	};
	const UE4CodeGen_Private::FIntPropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_CalibrationGlove_Statics::NewProp_TimeOut = { "TimeOut", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(MotionCaptureFunctionLibrary_eventCalibrationGlove_Parms, TimeOut), METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_CalibrationGlove_Statics::NewProp_Pose = { "Pose", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(MotionCaptureFunctionLibrary_eventCalibrationGlove_Parms, Pose), Z_Construct_UEnum_MotionCaptureRuntime_ECalibrationPose, METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_CalibrationGlove_Statics::NewProp_Pose_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UMotionCaptureFunctionLibrary_CalibrationGlove_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_CalibrationGlove_Statics::NewProp_TimeOut,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_CalibrationGlove_Statics::NewProp_Pose,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_CalibrationGlove_Statics::NewProp_Pose_Underlying,
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UMotionCaptureFunctionLibrary_CalibrationGlove_Statics::Function_MetaDataParams[] = {
		{ "Category", "Motion Capture|Data Service" },
		{ "CPP_Default_TimeOut", "5000" },
		{ "ModuleRelativePath", "Public/MotionCaptureFunctionLibrary.h" },
		{ "ToolTip", "Calibrate Hi5 glove hardware.\nIn this version, you can use only B and P pose.\n\n@param[in] Pose The motion need to calibrate. May be one of [B, P].\n@param[in] TimeOut (Unit: ms). If the calibration hasn't finished in TimeOut milliseconds, the calibration will stop.\n\n@note For B-Pose, the TimeOut longer than 5 seconds is recommended. And for P-Pose, the recommended TimeOut is 3 seconds. \\\nIf no Hi5 glove is power on, the function do nothing." },
	};
#endif
	const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_CalibrationGlove_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UMotionCaptureFunctionLibrary, nullptr, "CalibrationGlove", sizeof(MotionCaptureFunctionLibrary_eventCalibrationGlove_Parms), Z_Construct_UFunction_UMotionCaptureFunctionLibrary_CalibrationGlove_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_CalibrationGlove_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04022401, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_CalibrationGlove_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_CalibrationGlove_Statics::Function_MetaDataParams)) };
	UFunction* Z_Construct_UFunction_UMotionCaptureFunctionLibrary_CalibrationGlove()
	{
		static UFunction* ReturnFunction = nullptr;
		if (!ReturnFunction)
		{
			UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_UMotionCaptureFunctionLibrary_CalibrationGlove_Statics::FuncParams);
		}
		return ReturnFunction;
	}
	struct Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetCalibrationProgress_Statics
	{
		struct MotionCaptureFunctionLibrary_eventGetCalibrationProgress_Parms
		{
			int32 ReturnValue;
		};
		static const UE4CodeGen_Private::FIntPropertyParams NewProp_ReturnValue;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
		static const UE4CodeGen_Private::FFunctionParams FuncParams;
	};
	const UE4CodeGen_Private::FIntPropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetCalibrationProgress_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(MotionCaptureFunctionLibrary_eventGetCalibrationProgress_Parms, ReturnValue), METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetCalibrationProgress_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetCalibrationProgress_Statics::NewProp_ReturnValue,
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetCalibrationProgress_Statics::Function_MetaDataParams[] = {
		{ "Category", "Motion Capture|Data Service" },
		{ "ModuleRelativePath", "Public/MotionCaptureFunctionLibrary.h" },
		{ "ToolTip", "Query the progress of calibration.\n\n@return The progress of calibration. The value returned is in range [0,100].\n\n@note 100 represent that the calibration of current pose complete." },
	};
#endif
	const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetCalibrationProgress_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UMotionCaptureFunctionLibrary, nullptr, "GetCalibrationProgress", sizeof(MotionCaptureFunctionLibrary_eventGetCalibrationProgress_Parms), Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetCalibrationProgress_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetCalibrationProgress_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04022401, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetCalibrationProgress_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetCalibrationProgress_Statics::Function_MetaDataParams)) };
	UFunction* Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetCalibrationProgress()
	{
		static UFunction* ReturnFunction = nullptr;
		if (!ReturnFunction)
		{
			UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetCalibrationProgress_Statics::FuncParams);
		}
		return ReturnFunction;
	}
	struct Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetGloveMagneticed_Statics
	{
		struct MotionCaptureFunctionLibrary_eventGetGloveMagneticed_Parms
		{
			EGloveMagneticedState LeftGlove;
			EGloveMagneticedState RightGlove;
		};
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_RightGlove;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_RightGlove_Underlying;
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_LeftGlove;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_LeftGlove_Underlying;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
		static const UE4CodeGen_Private::FFunctionParams FuncParams;
	};
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetGloveMagneticed_Statics::NewProp_RightGlove = { "RightGlove", nullptr, (EPropertyFlags)0x0010000000000180, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(MotionCaptureFunctionLibrary_eventGetGloveMagneticed_Parms, RightGlove), Z_Construct_UEnum_MotionCaptureRuntime_EGloveMagneticedState, METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetGloveMagneticed_Statics::NewProp_RightGlove_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetGloveMagneticed_Statics::NewProp_LeftGlove = { "LeftGlove", nullptr, (EPropertyFlags)0x0010000000000180, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(MotionCaptureFunctionLibrary_eventGetGloveMagneticed_Parms, LeftGlove), Z_Construct_UEnum_MotionCaptureRuntime_EGloveMagneticedState, METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetGloveMagneticed_Statics::NewProp_LeftGlove_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetGloveMagneticed_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetGloveMagneticed_Statics::NewProp_RightGlove,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetGloveMagneticed_Statics::NewProp_RightGlove_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetGloveMagneticed_Statics::NewProp_LeftGlove,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetGloveMagneticed_Statics::NewProp_LeftGlove_Underlying,
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetGloveMagneticed_Statics::Function_MetaDataParams[] = {
		{ "Category", "Motion Capture|Data Service" },
		{ "ModuleRelativePath", "Public/MotionCaptureFunctionLibrary.h" },
		{ "ToolTip", "Get glove magnetization state.\n\n@param[out] LeftGlove Left glove magnetization state.\n@param[out] RightGlove Right glove magnetization state." },
	};
#endif
	const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetGloveMagneticed_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UMotionCaptureFunctionLibrary, nullptr, "GetGloveMagneticed", sizeof(MotionCaptureFunctionLibrary_eventGetGloveMagneticed_Parms), Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetGloveMagneticed_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetGloveMagneticed_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04422401, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetGloveMagneticed_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetGloveMagneticed_Statics::Function_MetaDataParams)) };
	UFunction* Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetGloveMagneticed()
	{
		static UFunction* ReturnFunction = nullptr;
		if (!ReturnFunction)
		{
			UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetGloveMagneticed_Statics::FuncParams);
		}
		return ReturnFunction;
	}
	struct Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetGlovePositionSource_Statics
	{
		struct MotionCaptureFunctionLibrary_eventGetGlovePositionSource_Parms
		{
			EGlovePositionSource ReturnValue;
		};
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_ReturnValue;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_ReturnValue_Underlying;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
		static const UE4CodeGen_Private::FFunctionParams FuncParams;
	};
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetGlovePositionSource_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(MotionCaptureFunctionLibrary_eventGetGlovePositionSource_Parms, ReturnValue), Z_Construct_UEnum_MotionCaptureRuntime_EGlovePositionSource, METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetGlovePositionSource_Statics::NewProp_ReturnValue_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetGlovePositionSource_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetGlovePositionSource_Statics::NewProp_ReturnValue,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetGlovePositionSource_Statics::NewProp_ReturnValue_Underlying,
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetGlovePositionSource_Statics::Function_MetaDataParams[] = {
		{ "Category", "Motion Capture|Data Service" },
		{ "ModuleRelativePath", "Public/MotionCaptureFunctionLibrary.h" },
		{ "ToolTip", "Get the source type of the location data of hand.\n\n@return Vive | Alice | Other" },
	};
#endif
	const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetGlovePositionSource_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UMotionCaptureFunctionLibrary, nullptr, "GetGlovePositionSource", sizeof(MotionCaptureFunctionLibrary_eventGetGlovePositionSource_Parms), Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetGlovePositionSource_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetGlovePositionSource_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04022401, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetGlovePositionSource_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetGlovePositionSource_Statics::Function_MetaDataParams)) };
	UFunction* Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetGlovePositionSource()
	{
		static UFunction* ReturnFunction = nullptr;
		if (!ReturnFunction)
		{
			UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetGlovePositionSource_Statics::FuncParams);
		}
		return ReturnFunction;
	}
	struct Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetGlovePowerLevel_Statics
	{
		struct MotionCaptureFunctionLibrary_eventGetGlovePowerLevel_Parms
		{
			EGlovePowerLevel LeftGlove;
			EGlovePowerLevel RightGlove;
		};
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_RightGlove;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_RightGlove_Underlying;
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_LeftGlove;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_LeftGlove_Underlying;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
		static const UE4CodeGen_Private::FFunctionParams FuncParams;
	};
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetGlovePowerLevel_Statics::NewProp_RightGlove = { "RightGlove", nullptr, (EPropertyFlags)0x0010000000000180, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(MotionCaptureFunctionLibrary_eventGetGlovePowerLevel_Parms, RightGlove), Z_Construct_UEnum_MotionCaptureRuntime_EGlovePowerLevel, METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetGlovePowerLevel_Statics::NewProp_RightGlove_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetGlovePowerLevel_Statics::NewProp_LeftGlove = { "LeftGlove", nullptr, (EPropertyFlags)0x0010000000000180, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(MotionCaptureFunctionLibrary_eventGetGlovePowerLevel_Parms, LeftGlove), Z_Construct_UEnum_MotionCaptureRuntime_EGlovePowerLevel, METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetGlovePowerLevel_Statics::NewProp_LeftGlove_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetGlovePowerLevel_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetGlovePowerLevel_Statics::NewProp_RightGlove,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetGlovePowerLevel_Statics::NewProp_RightGlove_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetGlovePowerLevel_Statics::NewProp_LeftGlove,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetGlovePowerLevel_Statics::NewProp_LeftGlove_Underlying,
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetGlovePowerLevel_Statics::Function_MetaDataParams[] = {
		{ "Category", "Motion Capture|Data Service" },
		{ "ModuleRelativePath", "Public/MotionCaptureFunctionLibrary.h" },
		{ "ToolTip", "Get glove power level.\n\n@param[out] LeftGlove Left glove power level.\n@param[out] RightGlove Right glove power level.\n\n@see EGlovePowerLevel" },
	};
#endif
	const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetGlovePowerLevel_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UMotionCaptureFunctionLibrary, nullptr, "GetGlovePowerLevel", sizeof(MotionCaptureFunctionLibrary_eventGetGlovePowerLevel_Parms), Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetGlovePowerLevel_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetGlovePowerLevel_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04422401, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetGlovePowerLevel_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetGlovePowerLevel_Statics::Function_MetaDataParams)) };
	UFunction* Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetGlovePowerLevel()
	{
		static UFunction* ReturnFunction = nullptr;
		if (!ReturnFunction)
		{
			UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetGlovePowerLevel_Statics::FuncParams);
		}
		return ReturnFunction;
	}
	struct Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointDataByAvatarName_Statics
	{
		struct MotionCaptureFunctionLibrary_eventGetJointDataByAvatarName_Parms
		{
			EGloveMod Glove;
			FName AvatarName;
			TEnumAsByte<EMCBones::Type> Bone;
			FVector Position;
			FRotator Orientation;
			bool ReturnValue;
		};
		static void NewProp_ReturnValue_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_ReturnValue;
		static const UE4CodeGen_Private::FStructPropertyParams NewProp_Orientation;
		static const UE4CodeGen_Private::FStructPropertyParams NewProp_Position;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_Bone;
		static const UE4CodeGen_Private::FNamePropertyParams NewProp_AvatarName;
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_Glove;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_Glove_Underlying;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
		static const UE4CodeGen_Private::FFunctionParams FuncParams;
	};
	void Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointDataByAvatarName_Statics::NewProp_ReturnValue_SetBit(void* Obj)
	{
		((MotionCaptureFunctionLibrary_eventGetJointDataByAvatarName_Parms*)Obj)->ReturnValue = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointDataByAvatarName_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(MotionCaptureFunctionLibrary_eventGetJointDataByAvatarName_Parms), &Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointDataByAvatarName_Statics::NewProp_ReturnValue_SetBit, METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointDataByAvatarName_Statics::NewProp_Orientation = { "Orientation", nullptr, (EPropertyFlags)0x0010000000000180, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(MotionCaptureFunctionLibrary_eventGetJointDataByAvatarName_Parms, Orientation), Z_Construct_UScriptStruct_FRotator, METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointDataByAvatarName_Statics::NewProp_Position = { "Position", nullptr, (EPropertyFlags)0x0010000000000180, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(MotionCaptureFunctionLibrary_eventGetJointDataByAvatarName_Parms, Position), Z_Construct_UScriptStruct_FVector, METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointDataByAvatarName_Statics::NewProp_Bone = { "Bone", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(MotionCaptureFunctionLibrary_eventGetJointDataByAvatarName_Parms, Bone), Z_Construct_UEnum_MotionCaptureRuntime_EMCBones, METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FNamePropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointDataByAvatarName_Statics::NewProp_AvatarName = { "AvatarName", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Name, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(MotionCaptureFunctionLibrary_eventGetJointDataByAvatarName_Parms, AvatarName), METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointDataByAvatarName_Statics::NewProp_Glove = { "Glove", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(MotionCaptureFunctionLibrary_eventGetJointDataByAvatarName_Parms, Glove), Z_Construct_UEnum_MotionCaptureRuntime_EGloveMod, METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointDataByAvatarName_Statics::NewProp_Glove_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointDataByAvatarName_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointDataByAvatarName_Statics::NewProp_ReturnValue,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointDataByAvatarName_Statics::NewProp_Orientation,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointDataByAvatarName_Statics::NewProp_Position,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointDataByAvatarName_Statics::NewProp_Bone,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointDataByAvatarName_Statics::NewProp_AvatarName,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointDataByAvatarName_Statics::NewProp_Glove,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointDataByAvatarName_Statics::NewProp_Glove_Underlying,
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointDataByAvatarName_Statics::Function_MetaDataParams[] = {
		{ "Category", "Motion Capture|Data Service" },
		{ "ModuleRelativePath", "Public/MotionCaptureFunctionLibrary.h" },
	};
#endif
	const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointDataByAvatarName_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UMotionCaptureFunctionLibrary, nullptr, "GetJointDataByAvatarName", sizeof(MotionCaptureFunctionLibrary_eventGetJointDataByAvatarName_Parms), Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointDataByAvatarName_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointDataByAvatarName_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04C22401, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointDataByAvatarName_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointDataByAvatarName_Statics::Function_MetaDataParams)) };
	UFunction* Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointDataByAvatarName()
	{
		static UFunction* ReturnFunction = nullptr;
		if (!ReturnFunction)
		{
			UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointDataByAvatarName_Statics::FuncParams);
		}
		return ReturnFunction;
	}
	struct Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointDataInLocalMachine_Statics
	{
		struct MotionCaptureFunctionLibrary_eventGetJointDataInLocalMachine_Parms
		{
			EGloveMod Glove;
			TEnumAsByte<EMCBones::Type> Bone;
			FVector Position;
			FRotator Orientation;
			bool ReturnValue;
		};
		static void NewProp_ReturnValue_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_ReturnValue;
		static const UE4CodeGen_Private::FStructPropertyParams NewProp_Orientation;
		static const UE4CodeGen_Private::FStructPropertyParams NewProp_Position;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_Bone;
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_Glove;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_Glove_Underlying;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
		static const UE4CodeGen_Private::FFunctionParams FuncParams;
	};
	void Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointDataInLocalMachine_Statics::NewProp_ReturnValue_SetBit(void* Obj)
	{
		((MotionCaptureFunctionLibrary_eventGetJointDataInLocalMachine_Parms*)Obj)->ReturnValue = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointDataInLocalMachine_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(MotionCaptureFunctionLibrary_eventGetJointDataInLocalMachine_Parms), &Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointDataInLocalMachine_Statics::NewProp_ReturnValue_SetBit, METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointDataInLocalMachine_Statics::NewProp_Orientation = { "Orientation", nullptr, (EPropertyFlags)0x0010000000000180, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(MotionCaptureFunctionLibrary_eventGetJointDataInLocalMachine_Parms, Orientation), Z_Construct_UScriptStruct_FRotator, METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointDataInLocalMachine_Statics::NewProp_Position = { "Position", nullptr, (EPropertyFlags)0x0010000000000180, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(MotionCaptureFunctionLibrary_eventGetJointDataInLocalMachine_Parms, Position), Z_Construct_UScriptStruct_FVector, METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointDataInLocalMachine_Statics::NewProp_Bone = { "Bone", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(MotionCaptureFunctionLibrary_eventGetJointDataInLocalMachine_Parms, Bone), Z_Construct_UEnum_MotionCaptureRuntime_EMCBones, METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointDataInLocalMachine_Statics::NewProp_Glove = { "Glove", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(MotionCaptureFunctionLibrary_eventGetJointDataInLocalMachine_Parms, Glove), Z_Construct_UEnum_MotionCaptureRuntime_EGloveMod, METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointDataInLocalMachine_Statics::NewProp_Glove_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointDataInLocalMachine_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointDataInLocalMachine_Statics::NewProp_ReturnValue,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointDataInLocalMachine_Statics::NewProp_Orientation,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointDataInLocalMachine_Statics::NewProp_Position,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointDataInLocalMachine_Statics::NewProp_Bone,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointDataInLocalMachine_Statics::NewProp_Glove,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointDataInLocalMachine_Statics::NewProp_Glove_Underlying,
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointDataInLocalMachine_Statics::Function_MetaDataParams[] = {
		{ "Category", "Motion Capture|Data Service" },
		{ "ModuleRelativePath", "Public/MotionCaptureFunctionLibrary.h" },
		{ "ToolTip", "Get local position and rotation of specified bone.\n\n@param[in] Glove Left hand or Right hand.\n@param[in] Bone Specify bone.\n@param[out] Position The local position.\n@param[out] Orientation The local rotation.\n\n@retval true Succeeded\n@retval false Failed\n\n@note The ForeArm joint's data is meaningless, don't use it." },
	};
#endif
	const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointDataInLocalMachine_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UMotionCaptureFunctionLibrary, nullptr, "GetJointDataInLocalMachine", sizeof(MotionCaptureFunctionLibrary_eventGetJointDataInLocalMachine_Parms), Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointDataInLocalMachine_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointDataInLocalMachine_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04C22401, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointDataInLocalMachine_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointDataInLocalMachine_Statics::Function_MetaDataParams)) };
	UFunction* Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointDataInLocalMachine()
	{
		static UFunction* ReturnFunction = nullptr;
		if (!ReturnFunction)
		{
			UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointDataInLocalMachine_Statics::FuncParams);
		}
		return ReturnFunction;
	}
	struct Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointsDataByAvatarName_Statics
	{
		struct MotionCaptureFunctionLibrary_eventGetJointsDataByAvatarName_Parms
		{
			EGloveMod Glove;
			FName AvatarName;
			TArray<FVector> Positions;
			TArray<FRotator> Orientations;
			bool ReturnValue;
		};
		static void NewProp_ReturnValue_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_ReturnValue;
		static const UE4CodeGen_Private::FArrayPropertyParams NewProp_Orientations;
		static const UE4CodeGen_Private::FStructPropertyParams NewProp_Orientations_Inner;
		static const UE4CodeGen_Private::FArrayPropertyParams NewProp_Positions;
		static const UE4CodeGen_Private::FStructPropertyParams NewProp_Positions_Inner;
		static const UE4CodeGen_Private::FNamePropertyParams NewProp_AvatarName;
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_Glove;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_Glove_Underlying;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
		static const UE4CodeGen_Private::FFunctionParams FuncParams;
	};
	void Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointsDataByAvatarName_Statics::NewProp_ReturnValue_SetBit(void* Obj)
	{
		((MotionCaptureFunctionLibrary_eventGetJointsDataByAvatarName_Parms*)Obj)->ReturnValue = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointsDataByAvatarName_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(MotionCaptureFunctionLibrary_eventGetJointsDataByAvatarName_Parms), &Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointsDataByAvatarName_Statics::NewProp_ReturnValue_SetBit, METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FArrayPropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointsDataByAvatarName_Statics::NewProp_Orientations = { "Orientations", nullptr, (EPropertyFlags)0x0010000000000180, UE4CodeGen_Private::EPropertyGenFlags::Array, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(MotionCaptureFunctionLibrary_eventGetJointsDataByAvatarName_Parms, Orientations), METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointsDataByAvatarName_Statics::NewProp_Orientations_Inner = { "Orientations", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, Z_Construct_UScriptStruct_FRotator, METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FArrayPropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointsDataByAvatarName_Statics::NewProp_Positions = { "Positions", nullptr, (EPropertyFlags)0x0010000000000180, UE4CodeGen_Private::EPropertyGenFlags::Array, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(MotionCaptureFunctionLibrary_eventGetJointsDataByAvatarName_Parms, Positions), METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointsDataByAvatarName_Statics::NewProp_Positions_Inner = { "Positions", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, Z_Construct_UScriptStruct_FVector, METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FNamePropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointsDataByAvatarName_Statics::NewProp_AvatarName = { "AvatarName", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Name, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(MotionCaptureFunctionLibrary_eventGetJointsDataByAvatarName_Parms, AvatarName), METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointsDataByAvatarName_Statics::NewProp_Glove = { "Glove", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(MotionCaptureFunctionLibrary_eventGetJointsDataByAvatarName_Parms, Glove), Z_Construct_UEnum_MotionCaptureRuntime_EGloveMod, METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointsDataByAvatarName_Statics::NewProp_Glove_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointsDataByAvatarName_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointsDataByAvatarName_Statics::NewProp_ReturnValue,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointsDataByAvatarName_Statics::NewProp_Orientations,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointsDataByAvatarName_Statics::NewProp_Orientations_Inner,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointsDataByAvatarName_Statics::NewProp_Positions,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointsDataByAvatarName_Statics::NewProp_Positions_Inner,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointsDataByAvatarName_Statics::NewProp_AvatarName,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointsDataByAvatarName_Statics::NewProp_Glove,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointsDataByAvatarName_Statics::NewProp_Glove_Underlying,
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointsDataByAvatarName_Statics::Function_MetaDataParams[] = {
		{ "Category", "Motion Capture|Data Service" },
		{ "ModuleRelativePath", "Public/MotionCaptureFunctionLibrary.h" },
	};
#endif
	const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointsDataByAvatarName_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UMotionCaptureFunctionLibrary, nullptr, "GetJointsDataByAvatarName", sizeof(MotionCaptureFunctionLibrary_eventGetJointsDataByAvatarName_Parms), Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointsDataByAvatarName_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointsDataByAvatarName_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04422401, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointsDataByAvatarName_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointsDataByAvatarName_Statics::Function_MetaDataParams)) };
	UFunction* Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointsDataByAvatarName()
	{
		static UFunction* ReturnFunction = nullptr;
		if (!ReturnFunction)
		{
			UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointsDataByAvatarName_Statics::FuncParams);
		}
		return ReturnFunction;
	}
	struct Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointsDataInLocalMachine_Statics
	{
		struct MotionCaptureFunctionLibrary_eventGetJointsDataInLocalMachine_Parms
		{
			EGloveMod Glove;
			TArray<FVector> Positions;
			TArray<FRotator> Orientations;
			bool ReturnValue;
		};
		static void NewProp_ReturnValue_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_ReturnValue;
		static const UE4CodeGen_Private::FArrayPropertyParams NewProp_Orientations;
		static const UE4CodeGen_Private::FStructPropertyParams NewProp_Orientations_Inner;
		static const UE4CodeGen_Private::FArrayPropertyParams NewProp_Positions;
		static const UE4CodeGen_Private::FStructPropertyParams NewProp_Positions_Inner;
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_Glove;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_Glove_Underlying;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
		static const UE4CodeGen_Private::FFunctionParams FuncParams;
	};
	void Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointsDataInLocalMachine_Statics::NewProp_ReturnValue_SetBit(void* Obj)
	{
		((MotionCaptureFunctionLibrary_eventGetJointsDataInLocalMachine_Parms*)Obj)->ReturnValue = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointsDataInLocalMachine_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(MotionCaptureFunctionLibrary_eventGetJointsDataInLocalMachine_Parms), &Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointsDataInLocalMachine_Statics::NewProp_ReturnValue_SetBit, METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FArrayPropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointsDataInLocalMachine_Statics::NewProp_Orientations = { "Orientations", nullptr, (EPropertyFlags)0x0010000000000180, UE4CodeGen_Private::EPropertyGenFlags::Array, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(MotionCaptureFunctionLibrary_eventGetJointsDataInLocalMachine_Parms, Orientations), METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointsDataInLocalMachine_Statics::NewProp_Orientations_Inner = { "Orientations", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, Z_Construct_UScriptStruct_FRotator, METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FArrayPropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointsDataInLocalMachine_Statics::NewProp_Positions = { "Positions", nullptr, (EPropertyFlags)0x0010000000000180, UE4CodeGen_Private::EPropertyGenFlags::Array, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(MotionCaptureFunctionLibrary_eventGetJointsDataInLocalMachine_Parms, Positions), METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointsDataInLocalMachine_Statics::NewProp_Positions_Inner = { "Positions", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, Z_Construct_UScriptStruct_FVector, METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointsDataInLocalMachine_Statics::NewProp_Glove = { "Glove", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(MotionCaptureFunctionLibrary_eventGetJointsDataInLocalMachine_Parms, Glove), Z_Construct_UEnum_MotionCaptureRuntime_EGloveMod, METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointsDataInLocalMachine_Statics::NewProp_Glove_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointsDataInLocalMachine_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointsDataInLocalMachine_Statics::NewProp_ReturnValue,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointsDataInLocalMachine_Statics::NewProp_Orientations,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointsDataInLocalMachine_Statics::NewProp_Orientations_Inner,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointsDataInLocalMachine_Statics::NewProp_Positions,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointsDataInLocalMachine_Statics::NewProp_Positions_Inner,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointsDataInLocalMachine_Statics::NewProp_Glove,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointsDataInLocalMachine_Statics::NewProp_Glove_Underlying,
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointsDataInLocalMachine_Statics::Function_MetaDataParams[] = {
		{ "Category", "Motion Capture|Data Service" },
		{ "ModuleRelativePath", "Public/MotionCaptureFunctionLibrary.h" },
		{ "ToolTip", "Get hand local gesture data in unreal engine space.\n\n@param[in] Glove Left hand or Right hand.\n@param[out] Positions Joints' position.\n@param[out] Orientations Joints' orientation.\n\n@retval true Succeeded\n@retval false Failed.\n\n@note\nIf you want to get RightHandThumb1's local Position and Orientation, you can do as follow:\n@code\nTArray<FVector> Positions;\nTArray<FRotator> Orientations;\nGetJointsDataInLocalMachine(EGloveMod::GlM_LeftGlove, Positions, Orientations);\nFVector pos = Positions[EMCBones::RightHandThumb1];\nFRotator rot = Orientations[EMCBones::RightHandThumb1];\n@endcode\nIn Blueprint, the array index above can be constructed by [Literal enum EMCBones] node.\nThe ForeArm joint's data is meaningless, don't use it.\n\n@warning Glove must be left or right." },
	};
#endif
	const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointsDataInLocalMachine_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UMotionCaptureFunctionLibrary, nullptr, "GetJointsDataInLocalMachine", sizeof(MotionCaptureFunctionLibrary_eventGetJointsDataInLocalMachine_Parms), Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointsDataInLocalMachine_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointsDataInLocalMachine_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04422401, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointsDataInLocalMachine_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointsDataInLocalMachine_Statics::Function_MetaDataParams)) };
	UFunction* Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointsDataInLocalMachine()
	{
		static UFunction* ReturnFunction = nullptr;
		if (!ReturnFunction)
		{
			UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointsDataInLocalMachine_Statics::FuncParams);
		}
		return ReturnFunction;
	}
	struct Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetLeftTrackerId_Statics
	{
		struct MotionCaptureFunctionLibrary_eventGetLeftTrackerId_Parms
		{
			int32 ReturnValue;
		};
		static const UE4CodeGen_Private::FUnsizedIntPropertyParams NewProp_ReturnValue;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
		static const UE4CodeGen_Private::FFunctionParams FuncParams;
	};
	const UE4CodeGen_Private::FUnsizedIntPropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetLeftTrackerId_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(MotionCaptureFunctionLibrary_eventGetLeftTrackerId_Parms, ReturnValue), METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetLeftTrackerId_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetLeftTrackerId_Statics::NewProp_ReturnValue,
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetLeftTrackerId_Statics::Function_MetaDataParams[] = {
		{ "Category", "Motion Capture|Data Service" },
		{ "ModuleRelativePath", "Public/MotionCaptureFunctionLibrary.h" },
		{ "ToolTip", "Get the ID of the tracker binded to left hand.\n\n@retval -1 The returned device id is invalid.\n@retval other The returned device id is valid.\n\n@note The function is meaningless when the glove position source is Alice." },
	};
#endif
	const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetLeftTrackerId_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UMotionCaptureFunctionLibrary, nullptr, "GetLeftTrackerId", sizeof(MotionCaptureFunctionLibrary_eventGetLeftTrackerId_Parms), Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetLeftTrackerId_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetLeftTrackerId_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04022401, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetLeftTrackerId_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetLeftTrackerId_Statics::Function_MetaDataParams)) };
	UFunction* Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetLeftTrackerId()
	{
		static UFunction* ReturnFunction = nullptr;
		if (!ReturnFunction)
		{
			UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetLeftTrackerId_Statics::FuncParams);
		}
		return ReturnFunction;
	}
	struct Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetOptiDeviceBindState_Statics
	{
		struct MotionCaptureFunctionLibrary_eventGetOptiDeviceBindState_Parms
		{
			EGloveMod Hand;
			FString DeviceSN;
			bool ReturnValue;
		};
		static void NewProp_ReturnValue_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_ReturnValue;
		static const UE4CodeGen_Private::FStrPropertyParams NewProp_DeviceSN;
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_Hand;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_Hand_Underlying;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
		static const UE4CodeGen_Private::FFunctionParams FuncParams;
	};
	void Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetOptiDeviceBindState_Statics::NewProp_ReturnValue_SetBit(void* Obj)
	{
		((MotionCaptureFunctionLibrary_eventGetOptiDeviceBindState_Parms*)Obj)->ReturnValue = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetOptiDeviceBindState_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(MotionCaptureFunctionLibrary_eventGetOptiDeviceBindState_Parms), &Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetOptiDeviceBindState_Statics::NewProp_ReturnValue_SetBit, METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FStrPropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetOptiDeviceBindState_Statics::NewProp_DeviceSN = { "DeviceSN", nullptr, (EPropertyFlags)0x0010000000000180, UE4CodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(MotionCaptureFunctionLibrary_eventGetOptiDeviceBindState_Parms, DeviceSN), METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetOptiDeviceBindState_Statics::NewProp_Hand = { "Hand", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(MotionCaptureFunctionLibrary_eventGetOptiDeviceBindState_Parms, Hand), Z_Construct_UEnum_MotionCaptureRuntime_EGloveMod, METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetOptiDeviceBindState_Statics::NewProp_Hand_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetOptiDeviceBindState_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetOptiDeviceBindState_Statics::NewProp_ReturnValue,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetOptiDeviceBindState_Statics::NewProp_DeviceSN,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetOptiDeviceBindState_Statics::NewProp_Hand,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetOptiDeviceBindState_Statics::NewProp_Hand_Underlying,
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetOptiDeviceBindState_Statics::Function_MetaDataParams[] = {
		{ "Category", "Motion Capture|Data Service" },
		{ "ModuleRelativePath", "Public/MotionCaptureFunctionLibrary.h" },
		{ "ToolTip", "Get current binding relationship between glove and optical device.\n\n@param[in] Hand Left or Right hand.\n@param[out] DeviceSN The serial number of optical device which be bound to Hand.\n\n@retval true The hand and optical device are bound together.\n@retval false There isn't any optical device bound to Hand.\n\n@warning Hand must be left or right." },
	};
#endif
	const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetOptiDeviceBindState_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UMotionCaptureFunctionLibrary, nullptr, "GetOptiDeviceBindState", sizeof(MotionCaptureFunctionLibrary_eventGetOptiDeviceBindState_Parms), Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetOptiDeviceBindState_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetOptiDeviceBindState_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04422401, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetOptiDeviceBindState_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetOptiDeviceBindState_Statics::Function_MetaDataParams)) };
	UFunction* Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetOptiDeviceBindState()
	{
		static UFunction* ReturnFunction = nullptr;
		if (!ReturnFunction)
		{
			UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetOptiDeviceBindState_Statics::FuncParams);
		}
		return ReturnFunction;
	}
	struct Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetOptiDeviceSN_Statics
	{
		struct MotionCaptureFunctionLibrary_eventGetOptiDeviceSN_Parms
		{
			int32 Id;
			FString SN;
			bool ReturnValue;
		};
		static void NewProp_ReturnValue_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_ReturnValue;
		static const UE4CodeGen_Private::FStrPropertyParams NewProp_SN;
		static const UE4CodeGen_Private::FIntPropertyParams NewProp_Id;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
		static const UE4CodeGen_Private::FFunctionParams FuncParams;
	};
	void Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetOptiDeviceSN_Statics::NewProp_ReturnValue_SetBit(void* Obj)
	{
		((MotionCaptureFunctionLibrary_eventGetOptiDeviceSN_Parms*)Obj)->ReturnValue = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetOptiDeviceSN_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(MotionCaptureFunctionLibrary_eventGetOptiDeviceSN_Parms), &Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetOptiDeviceSN_Statics::NewProp_ReturnValue_SetBit, METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FStrPropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetOptiDeviceSN_Statics::NewProp_SN = { "SN", nullptr, (EPropertyFlags)0x0010000000000180, UE4CodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(MotionCaptureFunctionLibrary_eventGetOptiDeviceSN_Parms, SN), METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FIntPropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetOptiDeviceSN_Statics::NewProp_Id = { "Id", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(MotionCaptureFunctionLibrary_eventGetOptiDeviceSN_Parms, Id), METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetOptiDeviceSN_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetOptiDeviceSN_Statics::NewProp_ReturnValue,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetOptiDeviceSN_Statics::NewProp_SN,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetOptiDeviceSN_Statics::NewProp_Id,
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetOptiDeviceSN_Statics::Function_MetaDataParams[] = {
		{ "Category", "Motion Capture|Data Service" },
		{ "ModuleRelativePath", "Public/MotionCaptureFunctionLibrary.h" },
		{ "ToolTip", "Get the serial number of optical device via its Id.\n\n@param[in] Id The id of optical device.\n@param[out] SN Receive the returned serial number.\n\n@retval true Succeeded.\n@retval false Failed." },
	};
#endif
	const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetOptiDeviceSN_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UMotionCaptureFunctionLibrary, nullptr, "GetOptiDeviceSN", sizeof(MotionCaptureFunctionLibrary_eventGetOptiDeviceSN_Parms), Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetOptiDeviceSN_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetOptiDeviceSN_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04422401, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetOptiDeviceSN_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetOptiDeviceSN_Statics::Function_MetaDataParams)) };
	UFunction* Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetOptiDeviceSN()
	{
		static UFunction* ReturnFunction = nullptr;
		if (!ReturnFunction)
		{
			UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetOptiDeviceSN_Statics::FuncParams);
		}
		return ReturnFunction;
	}
	struct Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetRightTrackerId_Statics
	{
		struct MotionCaptureFunctionLibrary_eventGetRightTrackerId_Parms
		{
			int32 ReturnValue;
		};
		static const UE4CodeGen_Private::FUnsizedIntPropertyParams NewProp_ReturnValue;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
		static const UE4CodeGen_Private::FFunctionParams FuncParams;
	};
	const UE4CodeGen_Private::FUnsizedIntPropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetRightTrackerId_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(MotionCaptureFunctionLibrary_eventGetRightTrackerId_Parms, ReturnValue), METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetRightTrackerId_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetRightTrackerId_Statics::NewProp_ReturnValue,
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetRightTrackerId_Statics::Function_MetaDataParams[] = {
		{ "Category", "Motion Capture|Data Service" },
		{ "ModuleRelativePath", "Public/MotionCaptureFunctionLibrary.h" },
		{ "ToolTip", "Get the ID of the tracker binded to right hand.\n\n@retval -1 The returned device id is invalid.\n@retval other The returned device id is valid.\n\n@note The function is meaningless when the glove position source is Alice." },
	};
#endif
	const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetRightTrackerId_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UMotionCaptureFunctionLibrary, nullptr, "GetRightTrackerId", sizeof(MotionCaptureFunctionLibrary_eventGetRightTrackerId_Parms), Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetRightTrackerId_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetRightTrackerId_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04022401, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetRightTrackerId_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetRightTrackerId_Statics::Function_MetaDataParams)) };
	UFunction* Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetRightTrackerId()
	{
		static UFunction* ReturnFunction = nullptr;
		if (!ReturnFunction)
		{
			UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetRightTrackerId_Statics::FuncParams);
		}
		return ReturnFunction;
	}
	struct Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetTrackedDeviceDataInUESpace_Statics
	{
		struct MotionCaptureFunctionLibrary_eventGetTrackedDeviceDataInUESpace_Parms
		{
			int32 DeviceId;
			FVector Position;
			FRotator Rotation;
			bool ReturnValue;
		};
		static void NewProp_ReturnValue_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_ReturnValue;
		static const UE4CodeGen_Private::FStructPropertyParams NewProp_Rotation;
		static const UE4CodeGen_Private::FStructPropertyParams NewProp_Position;
		static const UE4CodeGen_Private::FUnsizedIntPropertyParams NewProp_DeviceId;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
		static const UE4CodeGen_Private::FFunctionParams FuncParams;
	};
	void Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetTrackedDeviceDataInUESpace_Statics::NewProp_ReturnValue_SetBit(void* Obj)
	{
		((MotionCaptureFunctionLibrary_eventGetTrackedDeviceDataInUESpace_Parms*)Obj)->ReturnValue = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetTrackedDeviceDataInUESpace_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(MotionCaptureFunctionLibrary_eventGetTrackedDeviceDataInUESpace_Parms), &Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetTrackedDeviceDataInUESpace_Statics::NewProp_ReturnValue_SetBit, METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetTrackedDeviceDataInUESpace_Statics::NewProp_Rotation = { "Rotation", nullptr, (EPropertyFlags)0x0010000000000180, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(MotionCaptureFunctionLibrary_eventGetTrackedDeviceDataInUESpace_Parms, Rotation), Z_Construct_UScriptStruct_FRotator, METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetTrackedDeviceDataInUESpace_Statics::NewProp_Position = { "Position", nullptr, (EPropertyFlags)0x0010000000000180, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(MotionCaptureFunctionLibrary_eventGetTrackedDeviceDataInUESpace_Parms, Position), Z_Construct_UScriptStruct_FVector, METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FUnsizedIntPropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetTrackedDeviceDataInUESpace_Statics::NewProp_DeviceId = { "DeviceId", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(MotionCaptureFunctionLibrary_eventGetTrackedDeviceDataInUESpace_Parms, DeviceId), METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetTrackedDeviceDataInUESpace_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetTrackedDeviceDataInUESpace_Statics::NewProp_ReturnValue,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetTrackedDeviceDataInUESpace_Statics::NewProp_Rotation,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetTrackedDeviceDataInUESpace_Statics::NewProp_Position,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetTrackedDeviceDataInUESpace_Statics::NewProp_DeviceId,
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetTrackedDeviceDataInUESpace_Statics::Function_MetaDataParams[] = {
		{ "Category", "Motion Capture|Data Service" },
		{ "ModuleRelativePath", "Public/MotionCaptureFunctionLibrary.h" },
		{ "ToolTip", "Get the specific vive tracker or controller's position and rotation in UE space.\n\n@param[in] DeviceId The id of vive tracker or controller.\n@param[out] Position Device position\n@param[out] Rotation Device rotation\n\n@retval true The device is connected and normal tracking.\n@retval false The device is not connected or abnormal tracking." },
	};
#endif
	const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetTrackedDeviceDataInUESpace_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UMotionCaptureFunctionLibrary, nullptr, "GetTrackedDeviceDataInUESpace", sizeof(MotionCaptureFunctionLibrary_eventGetTrackedDeviceDataInUESpace_Parms), Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetTrackedDeviceDataInUESpace_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetTrackedDeviceDataInUESpace_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04C22401, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetTrackedDeviceDataInUESpace_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetTrackedDeviceDataInUESpace_Statics::Function_MetaDataParams)) };
	UFunction* Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetTrackedDeviceDataInUESpace()
	{
		static UFunction* ReturnFunction = nullptr;
		if (!ReturnFunction)
		{
			UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetTrackedDeviceDataInUESpace_Statics::FuncParams);
		}
		return ReturnFunction;
	}
	struct Z_Construct_UFunction_UMotionCaptureFunctionLibrary_IsDongleAvailable_Statics
	{
		struct MotionCaptureFunctionLibrary_eventIsDongleAvailable_Parms
		{
			bool ReturnValue;
		};
		static void NewProp_ReturnValue_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_ReturnValue;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
		static const UE4CodeGen_Private::FFunctionParams FuncParams;
	};
	void Z_Construct_UFunction_UMotionCaptureFunctionLibrary_IsDongleAvailable_Statics::NewProp_ReturnValue_SetBit(void* Obj)
	{
		((MotionCaptureFunctionLibrary_eventIsDongleAvailable_Parms*)Obj)->ReturnValue = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_IsDongleAvailable_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(MotionCaptureFunctionLibrary_eventIsDongleAvailable_Parms), &Z_Construct_UFunction_UMotionCaptureFunctionLibrary_IsDongleAvailable_Statics::NewProp_ReturnValue_SetBit, METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UMotionCaptureFunctionLibrary_IsDongleAvailable_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_IsDongleAvailable_Statics::NewProp_ReturnValue,
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UMotionCaptureFunctionLibrary_IsDongleAvailable_Statics::Function_MetaDataParams[] = {
		{ "Category", "Motion Capture|Data Service" },
		{ "ModuleRelativePath", "Public/MotionCaptureFunctionLibrary.h" },
		{ "ToolTip", "Check if the dongle is available.\n\n@retval true Available.\n@retval false Unavailable." },
	};
#endif
	const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_IsDongleAvailable_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UMotionCaptureFunctionLibrary, nullptr, "IsDongleAvailable", sizeof(MotionCaptureFunctionLibrary_eventIsDongleAvailable_Parms), Z_Construct_UFunction_UMotionCaptureFunctionLibrary_IsDongleAvailable_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_IsDongleAvailable_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04022401, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_IsDongleAvailable_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_IsDongleAvailable_Statics::Function_MetaDataParams)) };
	UFunction* Z_Construct_UFunction_UMotionCaptureFunctionLibrary_IsDongleAvailable()
	{
		static UFunction* ReturnFunction = nullptr;
		if (!ReturnFunction)
		{
			UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_UMotionCaptureFunctionLibrary_IsDongleAvailable_Statics::FuncParams);
		}
		return ReturnFunction;
	}
	struct Z_Construct_UFunction_UMotionCaptureFunctionLibrary_IsGloveAvailable_Statics
	{
		struct MotionCaptureFunctionLibrary_eventIsGloveAvailable_Parms
		{
			EGloveMod Mod;
			bool ReturnValue;
		};
		static void NewProp_ReturnValue_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_ReturnValue;
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_Mod;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_Mod_Underlying;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
		static const UE4CodeGen_Private::FFunctionParams FuncParams;
	};
	void Z_Construct_UFunction_UMotionCaptureFunctionLibrary_IsGloveAvailable_Statics::NewProp_ReturnValue_SetBit(void* Obj)
	{
		((MotionCaptureFunctionLibrary_eventIsGloveAvailable_Parms*)Obj)->ReturnValue = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_IsGloveAvailable_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(MotionCaptureFunctionLibrary_eventIsGloveAvailable_Parms), &Z_Construct_UFunction_UMotionCaptureFunctionLibrary_IsGloveAvailable_Statics::NewProp_ReturnValue_SetBit, METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_IsGloveAvailable_Statics::NewProp_Mod = { "Mod", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(MotionCaptureFunctionLibrary_eventIsGloveAvailable_Parms, Mod), Z_Construct_UEnum_MotionCaptureRuntime_EGloveMod, METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_IsGloveAvailable_Statics::NewProp_Mod_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UMotionCaptureFunctionLibrary_IsGloveAvailable_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_IsGloveAvailable_Statics::NewProp_ReturnValue,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_IsGloveAvailable_Statics::NewProp_Mod,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_IsGloveAvailable_Statics::NewProp_Mod_Underlying,
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UMotionCaptureFunctionLibrary_IsGloveAvailable_Statics::Function_MetaDataParams[] = {
		{ "Category", "Motion Capture|Data Service" },
		{ "ModuleRelativePath", "Public/MotionCaptureFunctionLibrary.h" },
		{ "ToolTip", "Check if the specific glove is available.\n\n@param[in] Mod Glove type.\n\n@retval true Available.\n@retval false Unavailable.\n\n@note When Mod is GlM_BothGloves, the returned value will be true if and only if both gloves available." },
	};
#endif
	const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_IsGloveAvailable_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UMotionCaptureFunctionLibrary, nullptr, "IsGloveAvailable", sizeof(MotionCaptureFunctionLibrary_eventIsGloveAvailable_Parms), Z_Construct_UFunction_UMotionCaptureFunctionLibrary_IsGloveAvailable_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_IsGloveAvailable_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04022401, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_IsGloveAvailable_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_IsGloveAvailable_Statics::Function_MetaDataParams)) };
	UFunction* Z_Construct_UFunction_UMotionCaptureFunctionLibrary_IsGloveAvailable()
	{
		static UFunction* ReturnFunction = nullptr;
		if (!ReturnFunction)
		{
			UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_UMotionCaptureFunctionLibrary_IsGloveAvailable_Statics::FuncParams);
		}
		return ReturnFunction;
	}
	struct Z_Construct_UFunction_UMotionCaptureFunctionLibrary_LoadCalibrationData_Statics
	{
		struct MotionCaptureFunctionLibrary_eventLoadCalibrationData_Parms
		{
			bool ReturnValue;
		};
		static void NewProp_ReturnValue_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_ReturnValue;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
		static const UE4CodeGen_Private::FFunctionParams FuncParams;
	};
	void Z_Construct_UFunction_UMotionCaptureFunctionLibrary_LoadCalibrationData_Statics::NewProp_ReturnValue_SetBit(void* Obj)
	{
		((MotionCaptureFunctionLibrary_eventLoadCalibrationData_Parms*)Obj)->ReturnValue = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_LoadCalibrationData_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(MotionCaptureFunctionLibrary_eventLoadCalibrationData_Parms), &Z_Construct_UFunction_UMotionCaptureFunctionLibrary_LoadCalibrationData_Statics::NewProp_ReturnValue_SetBit, METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UMotionCaptureFunctionLibrary_LoadCalibrationData_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_LoadCalibrationData_Statics::NewProp_ReturnValue,
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UMotionCaptureFunctionLibrary_LoadCalibrationData_Statics::Function_MetaDataParams[] = {
		{ "Category", "Motion Capture|Data Service" },
		{ "ModuleRelativePath", "Public/MotionCaptureFunctionLibrary.h" },
		{ "ToolTip", "Load calibration data from default files.\n\n@retval true Succeeded.\n@retval false Failed.\n\n@note The default files are CalibrationData and OpticalDeviceBindInfo.xml\nwhich stored in user-based folder: $FOLDERID_RoamingAppData/Hi5.\nEg: C:/Users/your_name/AppData/Roaming/Hi5/CalibrationData." },
	};
#endif
	const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_LoadCalibrationData_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UMotionCaptureFunctionLibrary, nullptr, "LoadCalibrationData", sizeof(MotionCaptureFunctionLibrary_eventLoadCalibrationData_Parms), Z_Construct_UFunction_UMotionCaptureFunctionLibrary_LoadCalibrationData_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_LoadCalibrationData_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04022401, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_LoadCalibrationData_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_LoadCalibrationData_Statics::Function_MetaDataParams)) };
	UFunction* Z_Construct_UFunction_UMotionCaptureFunctionLibrary_LoadCalibrationData()
	{
		static UFunction* ReturnFunction = nullptr;
		if (!ReturnFunction)
		{
			UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_UMotionCaptureFunctionLibrary_LoadCalibrationData_Statics::FuncParams);
		}
		return ReturnFunction;
	}
	struct Z_Construct_UFunction_UMotionCaptureFunctionLibrary_RotatorToAxisAndAngle_Statics
	{
		struct MotionCaptureFunctionLibrary_eventRotatorToAxisAndAngle_Parms
		{
			FRotator Rotator;
			FVector Axis;
			float Angle;
		};
		static const UE4CodeGen_Private::FFloatPropertyParams NewProp_Angle;
		static const UE4CodeGen_Private::FStructPropertyParams NewProp_Axis;
		static const UE4CodeGen_Private::FStructPropertyParams NewProp_Rotator;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
		static const UE4CodeGen_Private::FFunctionParams FuncParams;
	};
	const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_RotatorToAxisAndAngle_Statics::NewProp_Angle = { "Angle", nullptr, (EPropertyFlags)0x0010000000000180, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(MotionCaptureFunctionLibrary_eventRotatorToAxisAndAngle_Parms, Angle), METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_RotatorToAxisAndAngle_Statics::NewProp_Axis = { "Axis", nullptr, (EPropertyFlags)0x0010000000000180, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(MotionCaptureFunctionLibrary_eventRotatorToAxisAndAngle_Parms, Axis), Z_Construct_UScriptStruct_FVector, METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_RotatorToAxisAndAngle_Statics::NewProp_Rotator = { "Rotator", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(MotionCaptureFunctionLibrary_eventRotatorToAxisAndAngle_Parms, Rotator), Z_Construct_UScriptStruct_FRotator, METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UMotionCaptureFunctionLibrary_RotatorToAxisAndAngle_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_RotatorToAxisAndAngle_Statics::NewProp_Angle,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_RotatorToAxisAndAngle_Statics::NewProp_Axis,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_RotatorToAxisAndAngle_Statics::NewProp_Rotator,
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UMotionCaptureFunctionLibrary_RotatorToAxisAndAngle_Statics::Function_MetaDataParams[] = {
		{ "Category", "Motion Capture|miscellany" },
		{ "ModuleRelativePath", "Public/MotionCaptureFunctionLibrary.h" },
	};
#endif
	const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_RotatorToAxisAndAngle_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UMotionCaptureFunctionLibrary, nullptr, "RotatorToAxisAndAngle", sizeof(MotionCaptureFunctionLibrary_eventRotatorToAxisAndAngle_Parms), Z_Construct_UFunction_UMotionCaptureFunctionLibrary_RotatorToAxisAndAngle_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_RotatorToAxisAndAngle_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04C22401, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_RotatorToAxisAndAngle_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_RotatorToAxisAndAngle_Statics::Function_MetaDataParams)) };
	UFunction* Z_Construct_UFunction_UMotionCaptureFunctionLibrary_RotatorToAxisAndAngle()
	{
		static UFunction* ReturnFunction = nullptr;
		if (!ReturnFunction)
		{
			UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_UMotionCaptureFunctionLibrary_RotatorToAxisAndAngle_Statics::FuncParams);
		}
		return ReturnFunction;
	}
	struct Z_Construct_UFunction_UMotionCaptureFunctionLibrary_RotatorToAxisAndRadian_Statics
	{
		struct MotionCaptureFunctionLibrary_eventRotatorToAxisAndRadian_Parms
		{
			FRotator Rotator;
			FVector Axis;
			float Radian;
		};
		static const UE4CodeGen_Private::FFloatPropertyParams NewProp_Radian;
		static const UE4CodeGen_Private::FStructPropertyParams NewProp_Axis;
		static const UE4CodeGen_Private::FStructPropertyParams NewProp_Rotator;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
		static const UE4CodeGen_Private::FFunctionParams FuncParams;
	};
	const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_RotatorToAxisAndRadian_Statics::NewProp_Radian = { "Radian", nullptr, (EPropertyFlags)0x0010000000000180, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(MotionCaptureFunctionLibrary_eventRotatorToAxisAndRadian_Parms, Radian), METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_RotatorToAxisAndRadian_Statics::NewProp_Axis = { "Axis", nullptr, (EPropertyFlags)0x0010000000000180, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(MotionCaptureFunctionLibrary_eventRotatorToAxisAndRadian_Parms, Axis), Z_Construct_UScriptStruct_FVector, METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_RotatorToAxisAndRadian_Statics::NewProp_Rotator = { "Rotator", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(MotionCaptureFunctionLibrary_eventRotatorToAxisAndRadian_Parms, Rotator), Z_Construct_UScriptStruct_FRotator, METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UMotionCaptureFunctionLibrary_RotatorToAxisAndRadian_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_RotatorToAxisAndRadian_Statics::NewProp_Radian,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_RotatorToAxisAndRadian_Statics::NewProp_Axis,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_RotatorToAxisAndRadian_Statics::NewProp_Rotator,
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UMotionCaptureFunctionLibrary_RotatorToAxisAndRadian_Statics::Function_MetaDataParams[] = {
		{ "Category", "Motion Capture|miscellany" },
		{ "ModuleRelativePath", "Public/MotionCaptureFunctionLibrary.h" },
	};
#endif
	const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_RotatorToAxisAndRadian_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UMotionCaptureFunctionLibrary, nullptr, "RotatorToAxisAndRadian", sizeof(MotionCaptureFunctionLibrary_eventRotatorToAxisAndRadian_Parms), Z_Construct_UFunction_UMotionCaptureFunctionLibrary_RotatorToAxisAndRadian_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_RotatorToAxisAndRadian_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04C22401, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_RotatorToAxisAndRadian_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_RotatorToAxisAndRadian_Statics::Function_MetaDataParams)) };
	UFunction* Z_Construct_UFunction_UMotionCaptureFunctionLibrary_RotatorToAxisAndRadian()
	{
		static UFunction* ReturnFunction = nullptr;
		if (!ReturnFunction)
		{
			UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_UMotionCaptureFunctionLibrary_RotatorToAxisAndRadian_Statics::FuncParams);
		}
		return ReturnFunction;
	}
	struct Z_Construct_UFunction_UMotionCaptureFunctionLibrary_SaveCalibrationData_Statics
	{
		struct MotionCaptureFunctionLibrary_eventSaveCalibrationData_Parms
		{
			bool ReturnValue;
		};
		static void NewProp_ReturnValue_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_ReturnValue;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
		static const UE4CodeGen_Private::FFunctionParams FuncParams;
	};
	void Z_Construct_UFunction_UMotionCaptureFunctionLibrary_SaveCalibrationData_Statics::NewProp_ReturnValue_SetBit(void* Obj)
	{
		((MotionCaptureFunctionLibrary_eventSaveCalibrationData_Parms*)Obj)->ReturnValue = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_SaveCalibrationData_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(MotionCaptureFunctionLibrary_eventSaveCalibrationData_Parms), &Z_Construct_UFunction_UMotionCaptureFunctionLibrary_SaveCalibrationData_Statics::NewProp_ReturnValue_SetBit, METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UMotionCaptureFunctionLibrary_SaveCalibrationData_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_SaveCalibrationData_Statics::NewProp_ReturnValue,
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UMotionCaptureFunctionLibrary_SaveCalibrationData_Statics::Function_MetaDataParams[] = {
		{ "Category", "Motion Capture|Data Service" },
		{ "ModuleRelativePath", "Public/MotionCaptureFunctionLibrary.h" },
		{ "ToolTip", "Save calibration data to default files.\n\n@retval true Succeeded.\n@retval false Failed.\n\n@note The default files are CalibrationData and OpticalDeviceBindInfo.xml\nwhich stored in user-based folder: $FOLDERID_RoamingAppData/Hi5.\nEg: C:/Users/your_name/AppData/Roaming/Hi5/CalibrationData." },
	};
#endif
	const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_SaveCalibrationData_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UMotionCaptureFunctionLibrary, nullptr, "SaveCalibrationData", sizeof(MotionCaptureFunctionLibrary_eventSaveCalibrationData_Parms), Z_Construct_UFunction_UMotionCaptureFunctionLibrary_SaveCalibrationData_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_SaveCalibrationData_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04022401, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_SaveCalibrationData_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_SaveCalibrationData_Statics::Function_MetaDataParams)) };
	UFunction* Z_Construct_UFunction_UMotionCaptureFunctionLibrary_SaveCalibrationData()
	{
		static UFunction* ReturnFunction = nullptr;
		if (!ReturnFunction)
		{
			UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_UMotionCaptureFunctionLibrary_SaveCalibrationData_Statics::FuncParams);
		}
		return ReturnFunction;
	}
	struct Z_Construct_UFunction_UMotionCaptureFunctionLibrary_StartMocapService_Statics
	{
		struct MotionCaptureFunctionLibrary_eventStartMocapService_Parms
		{
			EGlovePositionSource PosSrc;
			bool ReadLocal;
			bool ReturnValue;
		};
		static void NewProp_ReturnValue_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_ReturnValue;
		static void NewProp_ReadLocal_SetBit(void* Obj);
		static const UE4CodeGen_Private::FBoolPropertyParams NewProp_ReadLocal;
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_PosSrc;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_PosSrc_Underlying;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
		static const UE4CodeGen_Private::FFunctionParams FuncParams;
	};
	void Z_Construct_UFunction_UMotionCaptureFunctionLibrary_StartMocapService_Statics::NewProp_ReturnValue_SetBit(void* Obj)
	{
		((MotionCaptureFunctionLibrary_eventStartMocapService_Parms*)Obj)->ReturnValue = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_StartMocapService_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(MotionCaptureFunctionLibrary_eventStartMocapService_Parms), &Z_Construct_UFunction_UMotionCaptureFunctionLibrary_StartMocapService_Statics::NewProp_ReturnValue_SetBit, METADATA_PARAMS(nullptr, 0) };
	void Z_Construct_UFunction_UMotionCaptureFunctionLibrary_StartMocapService_Statics::NewProp_ReadLocal_SetBit(void* Obj)
	{
		((MotionCaptureFunctionLibrary_eventStartMocapService_Parms*)Obj)->ReadLocal = 1;
	}
	const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_StartMocapService_Statics::NewProp_ReadLocal = { "ReadLocal", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(MotionCaptureFunctionLibrary_eventStartMocapService_Parms), &Z_Construct_UFunction_UMotionCaptureFunctionLibrary_StartMocapService_Statics::NewProp_ReadLocal_SetBit, METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_StartMocapService_Statics::NewProp_PosSrc = { "PosSrc", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(MotionCaptureFunctionLibrary_eventStartMocapService_Parms, PosSrc), Z_Construct_UEnum_MotionCaptureRuntime_EGlovePositionSource, METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_StartMocapService_Statics::NewProp_PosSrc_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UMotionCaptureFunctionLibrary_StartMocapService_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_StartMocapService_Statics::NewProp_ReturnValue,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_StartMocapService_Statics::NewProp_ReadLocal,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_StartMocapService_Statics::NewProp_PosSrc,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_StartMocapService_Statics::NewProp_PosSrc_Underlying,
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UMotionCaptureFunctionLibrary_StartMocapService_Statics::Function_MetaDataParams[] = {
		{ "Category", "Motion Capture|Data Service" },
		{ "CPP_Default_PosSrc", "VivePosition" },
		{ "CPP_Default_ReadLocal", "true" },
		{ "ModuleRelativePath", "Public/MotionCaptureFunctionLibrary.h" },
		{ "ToolTip", "Start MocapCapture plugin.\n\n@param[in] PosSrc Specify the source of the location data. The value is one of [Vive, Alice, Other].\n@param[in] ReadLocal If you need read glove data from local Hi5 dongle, pass true. Otherwise, pass false.\n\n@retval true Succeeded.\n@retval false Failed." },
	};
#endif
	const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_StartMocapService_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UMotionCaptureFunctionLibrary, nullptr, "StartMocapService", sizeof(MotionCaptureFunctionLibrary_eventStartMocapService_Parms), Z_Construct_UFunction_UMotionCaptureFunctionLibrary_StartMocapService_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_StartMocapService_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04022401, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_StartMocapService_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_StartMocapService_Statics::Function_MetaDataParams)) };
	UFunction* Z_Construct_UFunction_UMotionCaptureFunctionLibrary_StartMocapService()
	{
		static UFunction* ReturnFunction = nullptr;
		if (!ReturnFunction)
		{
			UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_UMotionCaptureFunctionLibrary_StartMocapService_Statics::FuncParams);
		}
		return ReturnFunction;
	}
	struct Z_Construct_UFunction_UMotionCaptureFunctionLibrary_StopMocapService_Statics
	{
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
		static const UE4CodeGen_Private::FFunctionParams FuncParams;
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UMotionCaptureFunctionLibrary_StopMocapService_Statics::Function_MetaDataParams[] = {
		{ "Category", "Motion Capture|Data Service" },
		{ "ModuleRelativePath", "Public/MotionCaptureFunctionLibrary.h" },
		{ "ToolTip", "Stop the data service" },
	};
#endif
	const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_StopMocapService_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UMotionCaptureFunctionLibrary, nullptr, "StopMocapService", 0, nullptr, 0, RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04022401, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_StopMocapService_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_StopMocapService_Statics::Function_MetaDataParams)) };
	UFunction* Z_Construct_UFunction_UMotionCaptureFunctionLibrary_StopMocapService()
	{
		static UFunction* ReturnFunction = nullptr;
		if (!ReturnFunction)
		{
			UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_UMotionCaptureFunctionLibrary_StopMocapService_Statics::FuncParams);
		}
		return ReturnFunction;
	}
	struct Z_Construct_UFunction_UMotionCaptureFunctionLibrary_VibrateGloves_Statics
	{
		struct MotionCaptureFunctionLibrary_eventVibrateGloves_Parms
		{
			int32 LeftGloveTimeSpan;
			int32 RightGloveTimeSpan;
		};
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_RightGloveTimeSpan_MetaData[];
#endif
		static const UE4CodeGen_Private::FUnsizedIntPropertyParams NewProp_RightGloveTimeSpan;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_LeftGloveTimeSpan_MetaData[];
#endif
		static const UE4CodeGen_Private::FUnsizedIntPropertyParams NewProp_LeftGloveTimeSpan;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
		static const UE4CodeGen_Private::FFunctionParams FuncParams;
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UMotionCaptureFunctionLibrary_VibrateGloves_Statics::NewProp_RightGloveTimeSpan_MetaData[] = {
		{ "NativeConst", "" },
	};
#endif
	const UE4CodeGen_Private::FUnsizedIntPropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_VibrateGloves_Statics::NewProp_RightGloveTimeSpan = { "RightGloveTimeSpan", nullptr, (EPropertyFlags)0x0010000000000082, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(MotionCaptureFunctionLibrary_eventVibrateGloves_Parms, RightGloveTimeSpan), METADATA_PARAMS(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_VibrateGloves_Statics::NewProp_RightGloveTimeSpan_MetaData, ARRAY_COUNT(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_VibrateGloves_Statics::NewProp_RightGloveTimeSpan_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UMotionCaptureFunctionLibrary_VibrateGloves_Statics::NewProp_LeftGloveTimeSpan_MetaData[] = {
		{ "NativeConst", "" },
	};
#endif
	const UE4CodeGen_Private::FUnsizedIntPropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_VibrateGloves_Statics::NewProp_LeftGloveTimeSpan = { "LeftGloveTimeSpan", nullptr, (EPropertyFlags)0x0010000000000082, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(MotionCaptureFunctionLibrary_eventVibrateGloves_Parms, LeftGloveTimeSpan), METADATA_PARAMS(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_VibrateGloves_Statics::NewProp_LeftGloveTimeSpan_MetaData, ARRAY_COUNT(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_VibrateGloves_Statics::NewProp_LeftGloveTimeSpan_MetaData)) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UMotionCaptureFunctionLibrary_VibrateGloves_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_VibrateGloves_Statics::NewProp_RightGloveTimeSpan,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_VibrateGloves_Statics::NewProp_LeftGloveTimeSpan,
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UMotionCaptureFunctionLibrary_VibrateGloves_Statics::Function_MetaDataParams[] = {
		{ "Category", "Motion Capture|Data Service" },
		{ "ModuleRelativePath", "Public/MotionCaptureFunctionLibrary.h" },
		{ "ToolTip", "ms" },
	};
#endif
	const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_VibrateGloves_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UMotionCaptureFunctionLibrary, nullptr, "VibrateGloves", sizeof(MotionCaptureFunctionLibrary_eventVibrateGloves_Parms), Z_Construct_UFunction_UMotionCaptureFunctionLibrary_VibrateGloves_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_VibrateGloves_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04022401, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_VibrateGloves_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_VibrateGloves_Statics::Function_MetaDataParams)) };
	UFunction* Z_Construct_UFunction_UMotionCaptureFunctionLibrary_VibrateGloves()
	{
		static UFunction* ReturnFunction = nullptr;
		if (!ReturnFunction)
		{
			UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_UMotionCaptureFunctionLibrary_VibrateGloves_Statics::FuncParams);
		}
		return ReturnFunction;
	}
	struct Z_Construct_UFunction_UMotionCaptureFunctionLibrary_VibrateLeftGlove_Statics
	{
		struct MotionCaptureFunctionLibrary_eventVibrateLeftGlove_Parms
		{
			int32 GloveTimeSpan;
		};
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_GloveTimeSpan_MetaData[];
#endif
		static const UE4CodeGen_Private::FUnsizedIntPropertyParams NewProp_GloveTimeSpan;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
		static const UE4CodeGen_Private::FFunctionParams FuncParams;
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UMotionCaptureFunctionLibrary_VibrateLeftGlove_Statics::NewProp_GloveTimeSpan_MetaData[] = {
		{ "NativeConst", "" },
	};
#endif
	const UE4CodeGen_Private::FUnsizedIntPropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_VibrateLeftGlove_Statics::NewProp_GloveTimeSpan = { "GloveTimeSpan", nullptr, (EPropertyFlags)0x0010000000000082, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(MotionCaptureFunctionLibrary_eventVibrateLeftGlove_Parms, GloveTimeSpan), METADATA_PARAMS(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_VibrateLeftGlove_Statics::NewProp_GloveTimeSpan_MetaData, ARRAY_COUNT(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_VibrateLeftGlove_Statics::NewProp_GloveTimeSpan_MetaData)) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UMotionCaptureFunctionLibrary_VibrateLeftGlove_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_VibrateLeftGlove_Statics::NewProp_GloveTimeSpan,
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UMotionCaptureFunctionLibrary_VibrateLeftGlove_Statics::Function_MetaDataParams[] = {
		{ "Category", "Motion Capture|Data Service" },
		{ "ModuleRelativePath", "Public/MotionCaptureFunctionLibrary.h" },
		{ "ToolTip", "ms" },
	};
#endif
	const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_VibrateLeftGlove_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UMotionCaptureFunctionLibrary, nullptr, "VibrateLeftGlove", sizeof(MotionCaptureFunctionLibrary_eventVibrateLeftGlove_Parms), Z_Construct_UFunction_UMotionCaptureFunctionLibrary_VibrateLeftGlove_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_VibrateLeftGlove_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04022401, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_VibrateLeftGlove_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_VibrateLeftGlove_Statics::Function_MetaDataParams)) };
	UFunction* Z_Construct_UFunction_UMotionCaptureFunctionLibrary_VibrateLeftGlove()
	{
		static UFunction* ReturnFunction = nullptr;
		if (!ReturnFunction)
		{
			UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_UMotionCaptureFunctionLibrary_VibrateLeftGlove_Statics::FuncParams);
		}
		return ReturnFunction;
	}
	struct Z_Construct_UFunction_UMotionCaptureFunctionLibrary_VibrateRightGlove_Statics
	{
		struct MotionCaptureFunctionLibrary_eventVibrateRightGlove_Parms
		{
			int32 GloveTimeSpan;
		};
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_GloveTimeSpan_MetaData[];
#endif
		static const UE4CodeGen_Private::FUnsizedIntPropertyParams NewProp_GloveTimeSpan;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
		static const UE4CodeGen_Private::FFunctionParams FuncParams;
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UMotionCaptureFunctionLibrary_VibrateRightGlove_Statics::NewProp_GloveTimeSpan_MetaData[] = {
		{ "NativeConst", "" },
	};
#endif
	const UE4CodeGen_Private::FUnsizedIntPropertyParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_VibrateRightGlove_Statics::NewProp_GloveTimeSpan = { "GloveTimeSpan", nullptr, (EPropertyFlags)0x0010000000000082, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(MotionCaptureFunctionLibrary_eventVibrateRightGlove_Parms, GloveTimeSpan), METADATA_PARAMS(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_VibrateRightGlove_Statics::NewProp_GloveTimeSpan_MetaData, ARRAY_COUNT(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_VibrateRightGlove_Statics::NewProp_GloveTimeSpan_MetaData)) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UMotionCaptureFunctionLibrary_VibrateRightGlove_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UMotionCaptureFunctionLibrary_VibrateRightGlove_Statics::NewProp_GloveTimeSpan,
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UMotionCaptureFunctionLibrary_VibrateRightGlove_Statics::Function_MetaDataParams[] = {
		{ "Category", "Motion Capture|Data Service" },
		{ "ModuleRelativePath", "Public/MotionCaptureFunctionLibrary.h" },
		{ "ToolTip", "ms" },
	};
#endif
	const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_UMotionCaptureFunctionLibrary_VibrateRightGlove_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UMotionCaptureFunctionLibrary, nullptr, "VibrateRightGlove", sizeof(MotionCaptureFunctionLibrary_eventVibrateRightGlove_Parms), Z_Construct_UFunction_UMotionCaptureFunctionLibrary_VibrateRightGlove_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_VibrateRightGlove_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04022401, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_VibrateRightGlove_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_UMotionCaptureFunctionLibrary_VibrateRightGlove_Statics::Function_MetaDataParams)) };
	UFunction* Z_Construct_UFunction_UMotionCaptureFunctionLibrary_VibrateRightGlove()
	{
		static UFunction* ReturnFunction = nullptr;
		if (!ReturnFunction)
		{
			UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_UMotionCaptureFunctionLibrary_VibrateRightGlove_Statics::FuncParams);
		}
		return ReturnFunction;
	}
	UClass* Z_Construct_UClass_UMotionCaptureFunctionLibrary_NoRegister()
	{
		return UMotionCaptureFunctionLibrary::StaticClass();
	}
	struct Z_Construct_UClass_UMotionCaptureFunctionLibrary_Statics
	{
		static UObject* (*const DependentSingletons[])();
		static const FClassFunctionLinkInfo FuncInfo[];
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Class_MetaDataParams[];
#endif
		static const FCppClassTypeInfoStatic StaticCppClassTypeInfo;
		static const UE4CodeGen_Private::FClassParams ClassParams;
	};
	UObject* (*const Z_Construct_UClass_UMotionCaptureFunctionLibrary_Statics::DependentSingletons[])() = {
		(UObject* (*)())Z_Construct_UClass_UBlueprintFunctionLibrary,
		(UObject* (*)())Z_Construct_UPackage__Script_MotionCaptureRuntime,
	};
	const FClassFunctionLinkInfo Z_Construct_UClass_UMotionCaptureFunctionLibrary_Statics::FuncInfo[] = {
		{ &Z_Construct_UFunction_UMotionCaptureFunctionLibrary_CalibrationGlove, "CalibrationGlove" }, // 1919482721
		{ &Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetCalibrationProgress, "GetCalibrationProgress" }, // 3504728658
		{ &Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetGloveMagneticed, "GetGloveMagneticed" }, // 3325459555
		{ &Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetGlovePositionSource, "GetGlovePositionSource" }, // 1322878494
		{ &Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetGlovePowerLevel, "GetGlovePowerLevel" }, // 3000202097
		{ &Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointDataByAvatarName, "GetJointDataByAvatarName" }, // 4207347042
		{ &Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointDataInLocalMachine, "GetJointDataInLocalMachine" }, // 88145249
		{ &Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointsDataByAvatarName, "GetJointsDataByAvatarName" }, // 1527696677
		{ &Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetJointsDataInLocalMachine, "GetJointsDataInLocalMachine" }, // 4097953223
		{ &Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetLeftTrackerId, "GetLeftTrackerId" }, // 2471069014
		{ &Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetOptiDeviceBindState, "GetOptiDeviceBindState" }, // 1540910606
		{ &Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetOptiDeviceSN, "GetOptiDeviceSN" }, // 7779568
		{ &Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetRightTrackerId, "GetRightTrackerId" }, // 1720953539
		{ &Z_Construct_UFunction_UMotionCaptureFunctionLibrary_GetTrackedDeviceDataInUESpace, "GetTrackedDeviceDataInUESpace" }, // 982947140
		{ &Z_Construct_UFunction_UMotionCaptureFunctionLibrary_IsDongleAvailable, "IsDongleAvailable" }, // 2703755730
		{ &Z_Construct_UFunction_UMotionCaptureFunctionLibrary_IsGloveAvailable, "IsGloveAvailable" }, // 4290386654
		{ &Z_Construct_UFunction_UMotionCaptureFunctionLibrary_LoadCalibrationData, "LoadCalibrationData" }, // 2991086244
		{ &Z_Construct_UFunction_UMotionCaptureFunctionLibrary_RotatorToAxisAndAngle, "RotatorToAxisAndAngle" }, // 2459515193
		{ &Z_Construct_UFunction_UMotionCaptureFunctionLibrary_RotatorToAxisAndRadian, "RotatorToAxisAndRadian" }, // 808047008
		{ &Z_Construct_UFunction_UMotionCaptureFunctionLibrary_SaveCalibrationData, "SaveCalibrationData" }, // 474922262
		{ &Z_Construct_UFunction_UMotionCaptureFunctionLibrary_StartMocapService, "StartMocapService" }, // 2039463915
		{ &Z_Construct_UFunction_UMotionCaptureFunctionLibrary_StopMocapService, "StopMocapService" }, // 2113570707
		{ &Z_Construct_UFunction_UMotionCaptureFunctionLibrary_VibrateGloves, "VibrateGloves" }, // 290560557
		{ &Z_Construct_UFunction_UMotionCaptureFunctionLibrary_VibrateLeftGlove, "VibrateLeftGlove" }, // 248503790
		{ &Z_Construct_UFunction_UMotionCaptureFunctionLibrary_VibrateRightGlove, "VibrateRightGlove" }, // 1354736008
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_UMotionCaptureFunctionLibrary_Statics::Class_MetaDataParams[] = {
		{ "IncludePath", "MotionCaptureFunctionLibrary.h" },
		{ "ModuleRelativePath", "Public/MotionCaptureFunctionLibrary.h" },
	};
#endif
	const FCppClassTypeInfoStatic Z_Construct_UClass_UMotionCaptureFunctionLibrary_Statics::StaticCppClassTypeInfo = {
		TCppClassTypeTraits<UMotionCaptureFunctionLibrary>::IsAbstract,
	};
	const UE4CodeGen_Private::FClassParams Z_Construct_UClass_UMotionCaptureFunctionLibrary_Statics::ClassParams = {
		&UMotionCaptureFunctionLibrary::StaticClass,
		nullptr,
		&StaticCppClassTypeInfo,
		DependentSingletons,
		FuncInfo,
		nullptr,
		nullptr,
		ARRAY_COUNT(DependentSingletons),
		ARRAY_COUNT(FuncInfo),
		0,
		0,
		0x001000A0u,
		METADATA_PARAMS(Z_Construct_UClass_UMotionCaptureFunctionLibrary_Statics::Class_MetaDataParams, ARRAY_COUNT(Z_Construct_UClass_UMotionCaptureFunctionLibrary_Statics::Class_MetaDataParams))
	};
	UClass* Z_Construct_UClass_UMotionCaptureFunctionLibrary()
	{
		static UClass* OuterClass = nullptr;
		if (!OuterClass)
		{
			UE4CodeGen_Private::ConstructUClass(OuterClass, Z_Construct_UClass_UMotionCaptureFunctionLibrary_Statics::ClassParams);
		}
		return OuterClass;
	}
	IMPLEMENT_CLASS(UMotionCaptureFunctionLibrary, 1154116052);
	template<> MOTIONCAPTURERUNTIME_API UClass* StaticClass<UMotionCaptureFunctionLibrary>()
	{
		return UMotionCaptureFunctionLibrary::StaticClass();
	}
	static FCompiledInDefer Z_CompiledInDefer_UClass_UMotionCaptureFunctionLibrary(Z_Construct_UClass_UMotionCaptureFunctionLibrary, &UMotionCaptureFunctionLibrary::StaticClass, TEXT("/Script/MotionCaptureRuntime"), TEXT("UMotionCaptureFunctionLibrary"), false, nullptr, nullptr, nullptr);
	DEFINE_VTABLE_PTR_HELPER_CTOR(UMotionCaptureFunctionLibrary);
PRAGMA_ENABLE_DEPRECATION_WARNINGS
#ifdef _MSC_VER
#pragma warning (pop)
#endif
