// 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/CommonType.h"
#ifdef _MSC_VER
#pragma warning (push)
#pragma warning (disable : 4883)
#endif
PRAGMA_DISABLE_DEPRECATION_WARNINGS
void EmptyLinkFunctionForGeneratedCodeCommonType() {}
// Cross Module References
	MOTIONCAPTURERUNTIME_API UEnum* Z_Construct_UEnum_MotionCaptureRuntime_EGloveMagneticedState();
	UPackage* Z_Construct_UPackage__Script_MotionCaptureRuntime();
	MOTIONCAPTURERUNTIME_API UEnum* Z_Construct_UEnum_MotionCaptureRuntime_EGlovePowerLevel();
	MOTIONCAPTURERUNTIME_API UEnum* Z_Construct_UEnum_MotionCaptureRuntime_EGlovePositionSource();
	MOTIONCAPTURERUNTIME_API UEnum* Z_Construct_UEnum_MotionCaptureRuntime_EGloveMod();
	MOTIONCAPTURERUNTIME_API UEnum* Z_Construct_UEnum_MotionCaptureRuntime_ECalibrationPose();
// End Cross Module References
	static UEnum* EGloveMagneticedState_StaticEnum()
	{
		static UEnum* Singleton = nullptr;
		if (!Singleton)
		{
			Singleton = GetStaticEnum(Z_Construct_UEnum_MotionCaptureRuntime_EGloveMagneticedState, Z_Construct_UPackage__Script_MotionCaptureRuntime(), TEXT("EGloveMagneticedState"));
		}
		return Singleton;
	}
	template<> MOTIONCAPTURERUNTIME_API UEnum* StaticEnum<EGloveMagneticedState>()
	{
		return EGloveMagneticedState_StaticEnum();
	}
	static FCompiledInDeferEnum Z_CompiledInDeferEnum_UEnum_EGloveMagneticedState(EGloveMagneticedState_StaticEnum, TEXT("/Script/MotionCaptureRuntime"), TEXT("EGloveMagneticedState"), false, nullptr, nullptr);
	uint32 Get_Z_Construct_UEnum_MotionCaptureRuntime_EGloveMagneticedState_Hash() { return 3286850061U; }
	UEnum* Z_Construct_UEnum_MotionCaptureRuntime_EGloveMagneticedState()
	{
#if WITH_HOT_RELOAD
		UPackage* Outer = Z_Construct_UPackage__Script_MotionCaptureRuntime();
		static UEnum* ReturnEnum = FindExistingEnumIfHotReloadOrDynamic(Outer, TEXT("EGloveMagneticedState"), 0, Get_Z_Construct_UEnum_MotionCaptureRuntime_EGloveMagneticedState_Hash(), false);
#else
		static UEnum* ReturnEnum = nullptr;
#endif // WITH_HOT_RELOAD
		if (!ReturnEnum)
		{
			static const UE4CodeGen_Private::FEnumeratorParam Enumerators[] = {
				{ "EGloveMagneticedState::Unknown", (int64)EGloveMagneticedState::Unknown },
				{ "EGloveMagneticedState::Bad", (int64)EGloveMagneticedState::Bad },
				{ "EGloveMagneticedState::Warn", (int64)EGloveMagneticedState::Warn },
				{ "EGloveMagneticedState::Normal", (int64)EGloveMagneticedState::Normal },
			};
#if WITH_METADATA
			const UE4CodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
				{ "BlueprintType", "true" },
				{ "ModuleRelativePath", "Public/CommonType.h" },
				{ "Normal.ToolTip", "< Medium magnetization" },
				{ "ToolTip", "Defines Hi5 Glove's magnetization level." },
				{ "Warn.ToolTip", "< Serious magnetization" },
			};
#endif
			static const UE4CodeGen_Private::FEnumParams EnumParams = {
				(UObject*(*)())Z_Construct_UPackage__Script_MotionCaptureRuntime,
				nullptr,
				"EGloveMagneticedState",
				"EGloveMagneticedState",
				Enumerators,
				ARRAY_COUNT(Enumerators),
				RF_Public|RF_Transient|RF_MarkAsNative,
				UE4CodeGen_Private::EDynamicType::NotDynamic,
				(uint8)UEnum::ECppForm::EnumClass,
				METADATA_PARAMS(Enum_MetaDataParams, ARRAY_COUNT(Enum_MetaDataParams))
			};
			UE4CodeGen_Private::ConstructUEnum(ReturnEnum, EnumParams);
		}
		return ReturnEnum;
	}
	static UEnum* EGlovePowerLevel_StaticEnum()
	{
		static UEnum* Singleton = nullptr;
		if (!Singleton)
		{
			Singleton = GetStaticEnum(Z_Construct_UEnum_MotionCaptureRuntime_EGlovePowerLevel, Z_Construct_UPackage__Script_MotionCaptureRuntime(), TEXT("EGlovePowerLevel"));
		}
		return Singleton;
	}
	template<> MOTIONCAPTURERUNTIME_API UEnum* StaticEnum<EGlovePowerLevel>()
	{
		return EGlovePowerLevel_StaticEnum();
	}
	static FCompiledInDeferEnum Z_CompiledInDeferEnum_UEnum_EGlovePowerLevel(EGlovePowerLevel_StaticEnum, TEXT("/Script/MotionCaptureRuntime"), TEXT("EGlovePowerLevel"), false, nullptr, nullptr);
	uint32 Get_Z_Construct_UEnum_MotionCaptureRuntime_EGlovePowerLevel_Hash() { return 1641364369U; }
	UEnum* Z_Construct_UEnum_MotionCaptureRuntime_EGlovePowerLevel()
	{
#if WITH_HOT_RELOAD
		UPackage* Outer = Z_Construct_UPackage__Script_MotionCaptureRuntime();
		static UEnum* ReturnEnum = FindExistingEnumIfHotReloadOrDynamic(Outer, TEXT("EGlovePowerLevel"), 0, Get_Z_Construct_UEnum_MotionCaptureRuntime_EGlovePowerLevel_Hash(), false);
#else
		static UEnum* ReturnEnum = nullptr;
#endif // WITH_HOT_RELOAD
		if (!ReturnEnum)
		{
			static const UE4CodeGen_Private::FEnumeratorParam Enumerators[] = {
				{ "EGlovePowerLevel::Unknown", (int64)EGlovePowerLevel::Unknown },
				{ "EGlovePowerLevel::Low", (int64)EGlovePowerLevel::Low },
				{ "EGlovePowerLevel::Normal", (int64)EGlovePowerLevel::Normal },
				{ "EGlovePowerLevel::Full", (int64)EGlovePowerLevel::Full },
			};
#if WITH_METADATA
			const UE4CodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
				{ "BlueprintType", "true" },
				{ "Full.ToolTip", "< Battery level is normal and enough for normal use." },
				{ "Low.ToolTip", "< Cannot get battery info" },
				{ "ModuleRelativePath", "Public/CommonType.h" },
				{ "Normal.ToolTip", "< Battery level is low." },
				{ "ToolTip", "Defines Hi5 Glove's battery level." },
			};
#endif
			static const UE4CodeGen_Private::FEnumParams EnumParams = {
				(UObject*(*)())Z_Construct_UPackage__Script_MotionCaptureRuntime,
				nullptr,
				"EGlovePowerLevel",
				"EGlovePowerLevel",
				Enumerators,
				ARRAY_COUNT(Enumerators),
				RF_Public|RF_Transient|RF_MarkAsNative,
				UE4CodeGen_Private::EDynamicType::NotDynamic,
				(uint8)UEnum::ECppForm::EnumClass,
				METADATA_PARAMS(Enum_MetaDataParams, ARRAY_COUNT(Enum_MetaDataParams))
			};
			UE4CodeGen_Private::ConstructUEnum(ReturnEnum, EnumParams);
		}
		return ReturnEnum;
	}
	static UEnum* EGlovePositionSource_StaticEnum()
	{
		static UEnum* Singleton = nullptr;
		if (!Singleton)
		{
			Singleton = GetStaticEnum(Z_Construct_UEnum_MotionCaptureRuntime_EGlovePositionSource, Z_Construct_UPackage__Script_MotionCaptureRuntime(), TEXT("EGlovePositionSource"));
		}
		return Singleton;
	}
	template<> MOTIONCAPTURERUNTIME_API UEnum* StaticEnum<EGlovePositionSource>()
	{
		return EGlovePositionSource_StaticEnum();
	}
	static FCompiledInDeferEnum Z_CompiledInDeferEnum_UEnum_EGlovePositionSource(EGlovePositionSource_StaticEnum, TEXT("/Script/MotionCaptureRuntime"), TEXT("EGlovePositionSource"), false, nullptr, nullptr);
	uint32 Get_Z_Construct_UEnum_MotionCaptureRuntime_EGlovePositionSource_Hash() { return 1110552123U; }
	UEnum* Z_Construct_UEnum_MotionCaptureRuntime_EGlovePositionSource()
	{
#if WITH_HOT_RELOAD
		UPackage* Outer = Z_Construct_UPackage__Script_MotionCaptureRuntime();
		static UEnum* ReturnEnum = FindExistingEnumIfHotReloadOrDynamic(Outer, TEXT("EGlovePositionSource"), 0, Get_Z_Construct_UEnum_MotionCaptureRuntime_EGlovePositionSource_Hash(), false);
#else
		static UEnum* ReturnEnum = nullptr;
#endif // WITH_HOT_RELOAD
		if (!ReturnEnum)
		{
			static const UE4CodeGen_Private::FEnumeratorParam Enumerators[] = {
				{ "EGlovePositionSource::VivePosition", (int64)EGlovePositionSource::VivePosition },
				{ "EGlovePositionSource::AlicePosition", (int64)EGlovePositionSource::AlicePosition },
				{ "EGlovePositionSource::Other", (int64)EGlovePositionSource::Other },
			};
#if WITH_METADATA
			const UE4CodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
				{ "AlicePosition.ToolTip", "< Hi5 Glove's position is supplied by HTC vive." },
				{ "BlueprintType", "true" },
				{ "ModuleRelativePath", "Public/CommonType.h" },
				{ "Other.ToolTip", "< Not used now." },
				{ "ToolTip", "Defines the type of Hi5 Glove's position data source." },
			};
#endif
			static const UE4CodeGen_Private::FEnumParams EnumParams = {
				(UObject*(*)())Z_Construct_UPackage__Script_MotionCaptureRuntime,
				nullptr,
				"EGlovePositionSource",
				"EGlovePositionSource",
				Enumerators,
				ARRAY_COUNT(Enumerators),
				RF_Public|RF_Transient|RF_MarkAsNative,
				UE4CodeGen_Private::EDynamicType::NotDynamic,
				(uint8)UEnum::ECppForm::EnumClass,
				METADATA_PARAMS(Enum_MetaDataParams, ARRAY_COUNT(Enum_MetaDataParams))
			};
			UE4CodeGen_Private::ConstructUEnum(ReturnEnum, EnumParams);
		}
		return ReturnEnum;
	}
	static UEnum* EGloveMod_StaticEnum()
	{
		static UEnum* Singleton = nullptr;
		if (!Singleton)
		{
			Singleton = GetStaticEnum(Z_Construct_UEnum_MotionCaptureRuntime_EGloveMod, Z_Construct_UPackage__Script_MotionCaptureRuntime(), TEXT("EGloveMod"));
		}
		return Singleton;
	}
	template<> MOTIONCAPTURERUNTIME_API UEnum* StaticEnum<EGloveMod>()
	{
		return EGloveMod_StaticEnum();
	}
	static FCompiledInDeferEnum Z_CompiledInDeferEnum_UEnum_EGloveMod(EGloveMod_StaticEnum, TEXT("/Script/MotionCaptureRuntime"), TEXT("EGloveMod"), false, nullptr, nullptr);
	uint32 Get_Z_Construct_UEnum_MotionCaptureRuntime_EGloveMod_Hash() { return 3754165170U; }
	UEnum* Z_Construct_UEnum_MotionCaptureRuntime_EGloveMod()
	{
#if WITH_HOT_RELOAD
		UPackage* Outer = Z_Construct_UPackage__Script_MotionCaptureRuntime();
		static UEnum* ReturnEnum = FindExistingEnumIfHotReloadOrDynamic(Outer, TEXT("EGloveMod"), 0, Get_Z_Construct_UEnum_MotionCaptureRuntime_EGloveMod_Hash(), false);
#else
		static UEnum* ReturnEnum = nullptr;
#endif // WITH_HOT_RELOAD
		if (!ReturnEnum)
		{
			static const UE4CodeGen_Private::FEnumeratorParam Enumerators[] = {
				{ "EGloveMod::GlM_BothGloves", (int64)EGloveMod::GlM_BothGloves },
				{ "EGloveMod::GlM_LeftGlove", (int64)EGloveMod::GlM_LeftGlove },
				{ "EGloveMod::GlM_RightGlove", (int64)EGloveMod::GlM_RightGlove },
			};
#if WITH_METADATA
			const UE4CodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
				{ "BlueprintType", "true" },
				{ "ModuleRelativePath", "Public/CommonType.h" },
				{ "ToolTip", "Defines the hand type." },
			};
#endif
			static const UE4CodeGen_Private::FEnumParams EnumParams = {
				(UObject*(*)())Z_Construct_UPackage__Script_MotionCaptureRuntime,
				nullptr,
				"EGloveMod",
				"EGloveMod",
				Enumerators,
				ARRAY_COUNT(Enumerators),
				RF_Public|RF_Transient|RF_MarkAsNative,
				UE4CodeGen_Private::EDynamicType::NotDynamic,
				(uint8)UEnum::ECppForm::EnumClass,
				METADATA_PARAMS(Enum_MetaDataParams, ARRAY_COUNT(Enum_MetaDataParams))
			};
			UE4CodeGen_Private::ConstructUEnum(ReturnEnum, EnumParams);
		}
		return ReturnEnum;
	}
	static UEnum* ECalibrationPose_StaticEnum()
	{
		static UEnum* Singleton = nullptr;
		if (!Singleton)
		{
			Singleton = GetStaticEnum(Z_Construct_UEnum_MotionCaptureRuntime_ECalibrationPose, Z_Construct_UPackage__Script_MotionCaptureRuntime(), TEXT("ECalibrationPose"));
		}
		return Singleton;
	}
	template<> MOTIONCAPTURERUNTIME_API UEnum* StaticEnum<ECalibrationPose>()
	{
		return ECalibrationPose_StaticEnum();
	}
	static FCompiledInDeferEnum Z_CompiledInDeferEnum_UEnum_ECalibrationPose(ECalibrationPose_StaticEnum, TEXT("/Script/MotionCaptureRuntime"), TEXT("ECalibrationPose"), false, nullptr, nullptr);
	uint32 Get_Z_Construct_UEnum_MotionCaptureRuntime_ECalibrationPose_Hash() { return 3662051975U; }
	UEnum* Z_Construct_UEnum_MotionCaptureRuntime_ECalibrationPose()
	{
#if WITH_HOT_RELOAD
		UPackage* Outer = Z_Construct_UPackage__Script_MotionCaptureRuntime();
		static UEnum* ReturnEnum = FindExistingEnumIfHotReloadOrDynamic(Outer, TEXT("ECalibrationPose"), 0, Get_Z_Construct_UEnum_MotionCaptureRuntime_ECalibrationPose_Hash(), false);
#else
		static UEnum* ReturnEnum = nullptr;
#endif // WITH_HOT_RELOAD
		if (!ReturnEnum)
		{
			static const UE4CodeGen_Private::FEnumeratorParam Enumerators[] = {
				{ "ECalibrationPose::GCP_TPose", (int64)ECalibrationPose::GCP_TPose },
				{ "ECalibrationPose::GCP_APose", (int64)ECalibrationPose::GCP_APose },
				{ "ECalibrationPose::GCP_PPose", (int64)ECalibrationPose::GCP_PPose },
				{ "ECalibrationPose::GCP_BPose", (int64)ECalibrationPose::GCP_BPose },
				{ "ECalibrationPose::GCP_CPose", (int64)ECalibrationPose::GCP_CPose },
			};
#if WITH_METADATA
			const UE4CodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
				{ "BlueprintType", "true" },
				{ "GCP_TPose.ToolTip", "GCP_Unknown = -1," },
				{ "ModuleRelativePath", "Public/CommonType.h" },
				{ "ToolTip", "Defines the calibration pose type." },
			};
#endif
			static const UE4CodeGen_Private::FEnumParams EnumParams = {
				(UObject*(*)())Z_Construct_UPackage__Script_MotionCaptureRuntime,
				nullptr,
				"ECalibrationPose",
				"ECalibrationPose",
				Enumerators,
				ARRAY_COUNT(Enumerators),
				RF_Public|RF_Transient|RF_MarkAsNative,
				UE4CodeGen_Private::EDynamicType::NotDynamic,
				(uint8)UEnum::ECppForm::EnumClass,
				METADATA_PARAMS(Enum_MetaDataParams, ARRAY_COUNT(Enum_MetaDataParams))
			};
			UE4CodeGen_Private::ConstructUEnum(ReturnEnum, EnumParams);
		}
		return ReturnEnum;
	}
PRAGMA_ENABLE_DEPRECATION_WARNINGS
#ifdef _MSC_VER
#pragma warning (pop)
#endif
