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

#include "UObject/GeneratedCppIncludes.h"
#include "VentuzPlugin/Public/VentuzBPEvent.h"
PRAGMA_DISABLE_DEPRECATION_WARNINGS
void EmptyLinkFunctionForGeneratedCodeVentuzBPEvent() {}

// Begin Cross Module References
COREUOBJECT_API UScriptStruct* Z_Construct_UScriptStruct_FRotator();
COREUOBJECT_API UScriptStruct* Z_Construct_UScriptStruct_FTransform();
COREUOBJECT_API UScriptStruct* Z_Construct_UScriptStruct_FVector();
ENGINE_API UClass* Z_Construct_UClass_UBlueprintFunctionLibrary();
UPackage* Z_Construct_UPackage__Script_VentuzPlugin();
VENTUZPLUGIN_API UClass* Z_Construct_UClass_UVentuzBPFunctionLibrary();
VENTUZPLUGIN_API UClass* Z_Construct_UClass_UVentuzBPFunctionLibrary_NoRegister();
VENTUZPLUGIN_API UEnum* Z_Construct_UEnum_VentuzPlugin_EulerRotationOrder();
VENTUZPLUGIN_API UEnum* Z_Construct_UEnum_VentuzPlugin_LimitedEulerRotationOrder();
VENTUZPLUGIN_API UEnum* Z_Construct_UEnum_VentuzPlugin_VentuzConnectionStatus();
VENTUZPLUGIN_API UFunction* Z_Construct_UDelegateFunction_VentuzPlugin_VentuzEventCallback__DelegateSignature();
// End Cross Module References

// Begin Delegate FVentuzEventCallback
struct Z_Construct_UDelegateFunction_VentuzPlugin_VentuzEventCallback__DelegateSignature_Statics
{
	struct _Script_VentuzPlugin_eventVentuzEventCallback_Parms
	{
		int32 Argument;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "ModuleRelativePath", "Public/VentuzBPEvent.h" },
	};
#endif // WITH_METADATA
	static const UECodeGen_Private::FIntPropertyParams NewProp_Argument;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FIntPropertyParams Z_Construct_UDelegateFunction_VentuzPlugin_VentuzEventCallback__DelegateSignature_Statics::NewProp_Argument = { "Argument", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(_Script_VentuzPlugin_eventVentuzEventCallback_Parms, Argument), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UDelegateFunction_VentuzPlugin_VentuzEventCallback__DelegateSignature_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UDelegateFunction_VentuzPlugin_VentuzEventCallback__DelegateSignature_Statics::NewProp_Argument,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UDelegateFunction_VentuzPlugin_VentuzEventCallback__DelegateSignature_Statics::PropPointers) < 2048);
const UECodeGen_Private::FFunctionParams Z_Construct_UDelegateFunction_VentuzPlugin_VentuzEventCallback__DelegateSignature_Statics::FuncParams = { (UObject*(*)())Z_Construct_UPackage__Script_VentuzPlugin, nullptr, "VentuzEventCallback__DelegateSignature", nullptr, nullptr, Z_Construct_UDelegateFunction_VentuzPlugin_VentuzEventCallback__DelegateSignature_Statics::PropPointers, UE_ARRAY_COUNT(Z_Construct_UDelegateFunction_VentuzPlugin_VentuzEventCallback__DelegateSignature_Statics::PropPointers), sizeof(Z_Construct_UDelegateFunction_VentuzPlugin_VentuzEventCallback__DelegateSignature_Statics::_Script_VentuzPlugin_eventVentuzEventCallback_Parms), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x00120000, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UDelegateFunction_VentuzPlugin_VentuzEventCallback__DelegateSignature_Statics::Function_MetaDataParams), Z_Construct_UDelegateFunction_VentuzPlugin_VentuzEventCallback__DelegateSignature_Statics::Function_MetaDataParams) };
static_assert(sizeof(Z_Construct_UDelegateFunction_VentuzPlugin_VentuzEventCallback__DelegateSignature_Statics::_Script_VentuzPlugin_eventVentuzEventCallback_Parms) < MAX_uint16);
UFunction* Z_Construct_UDelegateFunction_VentuzPlugin_VentuzEventCallback__DelegateSignature()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UDelegateFunction_VentuzPlugin_VentuzEventCallback__DelegateSignature_Statics::FuncParams);
	}
	return ReturnFunction;
}
void FVentuzEventCallback_DelegateWrapper(const FScriptDelegate& VentuzEventCallback, int32 Argument)
{
	struct _Script_VentuzPlugin_eventVentuzEventCallback_Parms
	{
		int32 Argument;
	};
	_Script_VentuzPlugin_eventVentuzEventCallback_Parms Parms;
	Parms.Argument=Argument;
	VentuzEventCallback.ProcessDelegate<UObject>(&Parms);
}
// End Delegate FVentuzEventCallback

// Begin Enum EulerRotationOrder
static FEnumRegistrationInfo Z_Registration_Info_UEnum_EulerRotationOrder;
static UEnum* EulerRotationOrder_StaticEnum()
{
	if (!Z_Registration_Info_UEnum_EulerRotationOrder.OuterSingleton)
	{
		Z_Registration_Info_UEnum_EulerRotationOrder.OuterSingleton = GetStaticEnum(Z_Construct_UEnum_VentuzPlugin_EulerRotationOrder, (UObject*)Z_Construct_UPackage__Script_VentuzPlugin(), TEXT("EulerRotationOrder"));
	}
	return Z_Registration_Info_UEnum_EulerRotationOrder.OuterSingleton;
}
template<> VENTUZPLUGIN_API UEnum* StaticEnum<EulerRotationOrder>()
{
	return EulerRotationOrder_StaticEnum();
}
struct Z_Construct_UEnum_VentuzPlugin_EulerRotationOrder_Statics
{
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
		{ "ModuleRelativePath", "Public/VentuzBPEvent.h" },
		{ "XYZ.DisplayName", "XYZ" },
		{ "XYZ.Name", "EulerRotationOrder::XYZ" },
		{ "XZY.DisplayName", "XZY" },
		{ "XZY.Name", "EulerRotationOrder::XZY" },
		{ "YXZ.DisplayName", "YXZ" },
		{ "YXZ.Name", "EulerRotationOrder::YXZ" },
		{ "YZX.DisplayName", "YZX" },
		{ "YZX.Name", "EulerRotationOrder::YZX" },
		{ "ZXY.DisplayName", "ZXY" },
		{ "ZXY.Name", "EulerRotationOrder::ZXY" },
		{ "ZYX.DisplayName", "ZYX" },
		{ "ZYX.Name", "EulerRotationOrder::ZYX" },
	};
#endif // WITH_METADATA
	static constexpr UECodeGen_Private::FEnumeratorParam Enumerators[] = {
		{ "EulerRotationOrder::ZXY", (int64)EulerRotationOrder::ZXY },
		{ "EulerRotationOrder::ZYX", (int64)EulerRotationOrder::ZYX },
		{ "EulerRotationOrder::YZX", (int64)EulerRotationOrder::YZX },
		{ "EulerRotationOrder::YXZ", (int64)EulerRotationOrder::YXZ },
		{ "EulerRotationOrder::XYZ", (int64)EulerRotationOrder::XYZ },
		{ "EulerRotationOrder::XZY", (int64)EulerRotationOrder::XZY },
	};
	static const UECodeGen_Private::FEnumParams EnumParams;
};
const UECodeGen_Private::FEnumParams Z_Construct_UEnum_VentuzPlugin_EulerRotationOrder_Statics::EnumParams = {
	(UObject*(*)())Z_Construct_UPackage__Script_VentuzPlugin,
	nullptr,
	"EulerRotationOrder",
	"EulerRotationOrder",
	Z_Construct_UEnum_VentuzPlugin_EulerRotationOrder_Statics::Enumerators,
	RF_Public|RF_Transient|RF_MarkAsNative,
	UE_ARRAY_COUNT(Z_Construct_UEnum_VentuzPlugin_EulerRotationOrder_Statics::Enumerators),
	EEnumFlags::None,
	(uint8)UEnum::ECppForm::EnumClass,
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UEnum_VentuzPlugin_EulerRotationOrder_Statics::Enum_MetaDataParams), Z_Construct_UEnum_VentuzPlugin_EulerRotationOrder_Statics::Enum_MetaDataParams)
};
UEnum* Z_Construct_UEnum_VentuzPlugin_EulerRotationOrder()
{
	if (!Z_Registration_Info_UEnum_EulerRotationOrder.InnerSingleton)
	{
		UECodeGen_Private::ConstructUEnum(Z_Registration_Info_UEnum_EulerRotationOrder.InnerSingleton, Z_Construct_UEnum_VentuzPlugin_EulerRotationOrder_Statics::EnumParams);
	}
	return Z_Registration_Info_UEnum_EulerRotationOrder.InnerSingleton;
}
// End Enum EulerRotationOrder

// Begin Enum LimitedEulerRotationOrder
static FEnumRegistrationInfo Z_Registration_Info_UEnum_LimitedEulerRotationOrder;
static UEnum* LimitedEulerRotationOrder_StaticEnum()
{
	if (!Z_Registration_Info_UEnum_LimitedEulerRotationOrder.OuterSingleton)
	{
		Z_Registration_Info_UEnum_LimitedEulerRotationOrder.OuterSingleton = GetStaticEnum(Z_Construct_UEnum_VentuzPlugin_LimitedEulerRotationOrder, (UObject*)Z_Construct_UPackage__Script_VentuzPlugin(), TEXT("LimitedEulerRotationOrder"));
	}
	return Z_Registration_Info_UEnum_LimitedEulerRotationOrder.OuterSingleton;
}
template<> VENTUZPLUGIN_API UEnum* StaticEnum<LimitedEulerRotationOrder>()
{
	return LimitedEulerRotationOrder_StaticEnum();
}
struct Z_Construct_UEnum_VentuzPlugin_LimitedEulerRotationOrder_Statics
{
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
		{ "ModuleRelativePath", "Public/VentuzBPEvent.h" },
		{ "XYZ.DisplayName", "XYZ" },
		{ "XYZ.Name", "LimitedEulerRotationOrder::XYZ" },
	};
#endif // WITH_METADATA
	static constexpr UECodeGen_Private::FEnumeratorParam Enumerators[] = {
		{ "LimitedEulerRotationOrder::XYZ", (int64)LimitedEulerRotationOrder::XYZ },
	};
	static const UECodeGen_Private::FEnumParams EnumParams;
};
const UECodeGen_Private::FEnumParams Z_Construct_UEnum_VentuzPlugin_LimitedEulerRotationOrder_Statics::EnumParams = {
	(UObject*(*)())Z_Construct_UPackage__Script_VentuzPlugin,
	nullptr,
	"LimitedEulerRotationOrder",
	"LimitedEulerRotationOrder",
	Z_Construct_UEnum_VentuzPlugin_LimitedEulerRotationOrder_Statics::Enumerators,
	RF_Public|RF_Transient|RF_MarkAsNative,
	UE_ARRAY_COUNT(Z_Construct_UEnum_VentuzPlugin_LimitedEulerRotationOrder_Statics::Enumerators),
	EEnumFlags::None,
	(uint8)UEnum::ECppForm::EnumClass,
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UEnum_VentuzPlugin_LimitedEulerRotationOrder_Statics::Enum_MetaDataParams), Z_Construct_UEnum_VentuzPlugin_LimitedEulerRotationOrder_Statics::Enum_MetaDataParams)
};
UEnum* Z_Construct_UEnum_VentuzPlugin_LimitedEulerRotationOrder()
{
	if (!Z_Registration_Info_UEnum_LimitedEulerRotationOrder.InnerSingleton)
	{
		UECodeGen_Private::ConstructUEnum(Z_Registration_Info_UEnum_LimitedEulerRotationOrder.InnerSingleton, Z_Construct_UEnum_VentuzPlugin_LimitedEulerRotationOrder_Statics::EnumParams);
	}
	return Z_Registration_Info_UEnum_LimitedEulerRotationOrder.InnerSingleton;
}
// End Enum LimitedEulerRotationOrder

// Begin Enum VentuzConnectionStatus
static FEnumRegistrationInfo Z_Registration_Info_UEnum_VentuzConnectionStatus;
static UEnum* VentuzConnectionStatus_StaticEnum()
{
	if (!Z_Registration_Info_UEnum_VentuzConnectionStatus.OuterSingleton)
	{
		Z_Registration_Info_UEnum_VentuzConnectionStatus.OuterSingleton = GetStaticEnum(Z_Construct_UEnum_VentuzPlugin_VentuzConnectionStatus, (UObject*)Z_Construct_UPackage__Script_VentuzPlugin(), TEXT("VentuzConnectionStatus"));
	}
	return Z_Registration_Info_UEnum_VentuzConnectionStatus.OuterSingleton;
}
template<> VENTUZPLUGIN_API UEnum* StaticEnum<VentuzConnectionStatus>()
{
	return VentuzConnectionStatus_StaticEnum();
}
struct Z_Construct_UEnum_VentuzPlugin_VentuzConnectionStatus_Statics
{
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
		{ "Connected.Name", "VentuzConnectionStatus::Connected" },
		{ "Disconnected.Name", "VentuzConnectionStatus::Disconnected" },
		{ "ModuleRelativePath", "Public/VentuzBPEvent.h" },
	};
#endif // WITH_METADATA
	static constexpr UECodeGen_Private::FEnumeratorParam Enumerators[] = {
		{ "VentuzConnectionStatus::Disconnected", (int64)VentuzConnectionStatus::Disconnected },
		{ "VentuzConnectionStatus::Connected", (int64)VentuzConnectionStatus::Connected },
	};
	static const UECodeGen_Private::FEnumParams EnumParams;
};
const UECodeGen_Private::FEnumParams Z_Construct_UEnum_VentuzPlugin_VentuzConnectionStatus_Statics::EnumParams = {
	(UObject*(*)())Z_Construct_UPackage__Script_VentuzPlugin,
	nullptr,
	"VentuzConnectionStatus",
	"VentuzConnectionStatus",
	Z_Construct_UEnum_VentuzPlugin_VentuzConnectionStatus_Statics::Enumerators,
	RF_Public|RF_Transient|RF_MarkAsNative,
	UE_ARRAY_COUNT(Z_Construct_UEnum_VentuzPlugin_VentuzConnectionStatus_Statics::Enumerators),
	EEnumFlags::None,
	(uint8)UEnum::ECppForm::EnumClass,
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UEnum_VentuzPlugin_VentuzConnectionStatus_Statics::Enum_MetaDataParams), Z_Construct_UEnum_VentuzPlugin_VentuzConnectionStatus_Statics::Enum_MetaDataParams)
};
UEnum* Z_Construct_UEnum_VentuzPlugin_VentuzConnectionStatus()
{
	if (!Z_Registration_Info_UEnum_VentuzConnectionStatus.InnerSingleton)
	{
		UECodeGen_Private::ConstructUEnum(Z_Registration_Info_UEnum_VentuzConnectionStatus.InnerSingleton, Z_Construct_UEnum_VentuzPlugin_VentuzConnectionStatus_Statics::EnumParams);
	}
	return Z_Registration_Info_UEnum_VentuzConnectionStatus.InnerSingleton;
}
// End Enum VentuzConnectionStatus

// Begin Class UVentuzBPFunctionLibrary Function GetVentuzBoolArrayByNodeName
struct Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzBoolArrayByNodeName_Statics
{
	struct VentuzBPFunctionLibrary_eventGetVentuzBoolArrayByNodeName_Parms
	{
		FString nodeName;
		FString fieldName;
		bool isAvailable;
		TArray<bool> ReturnValue;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "BlueprintInternalUseOnly", "true" },
		{ "BlueprintType", "true" },
		{ "Category", "Ventuz" },
		{ "ModuleRelativePath", "Public/VentuzBPEvent.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_nodeName_MetaData[] = {
		{ "NativeConst", "" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_fieldName_MetaData[] = {
		{ "NativeConst", "" },
	};
#endif // WITH_METADATA
	static const UECodeGen_Private::FStrPropertyParams NewProp_nodeName;
	static const UECodeGen_Private::FStrPropertyParams NewProp_fieldName;
	static void NewProp_isAvailable_SetBit(void* Obj);
	static const UECodeGen_Private::FBoolPropertyParams NewProp_isAvailable;
	static const UECodeGen_Private::FBoolPropertyParams NewProp_ReturnValue_Inner;
	static const UECodeGen_Private::FArrayPropertyParams NewProp_ReturnValue;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FStrPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzBoolArrayByNodeName_Statics::NewProp_nodeName = { "nodeName", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventGetVentuzBoolArrayByNodeName_Parms, nodeName), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_nodeName_MetaData), NewProp_nodeName_MetaData) };
const UECodeGen_Private::FStrPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzBoolArrayByNodeName_Statics::NewProp_fieldName = { "fieldName", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventGetVentuzBoolArrayByNodeName_Parms, fieldName), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_fieldName_MetaData), NewProp_fieldName_MetaData) };
void Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzBoolArrayByNodeName_Statics::NewProp_isAvailable_SetBit(void* Obj)
{
	((VentuzBPFunctionLibrary_eventGetVentuzBoolArrayByNodeName_Parms*)Obj)->isAvailable = 1;
}
const UECodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzBoolArrayByNodeName_Statics::NewProp_isAvailable = { "isAvailable", nullptr, (EPropertyFlags)0x0010000000000180, UECodeGen_Private::EPropertyGenFlags::Bool | UECodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, sizeof(bool), sizeof(VentuzBPFunctionLibrary_eventGetVentuzBoolArrayByNodeName_Parms), &Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzBoolArrayByNodeName_Statics::NewProp_isAvailable_SetBit, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzBoolArrayByNodeName_Statics::NewProp_ReturnValue_Inner = { "ReturnValue", nullptr, (EPropertyFlags)0x0000000000000000, UECodeGen_Private::EPropertyGenFlags::Bool | UECodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, sizeof(bool), 0, nullptr, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FArrayPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzBoolArrayByNodeName_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UECodeGen_Private::EPropertyGenFlags::Array, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventGetVentuzBoolArrayByNodeName_Parms, ReturnValue), EArrayPropertyFlags::None, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzBoolArrayByNodeName_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzBoolArrayByNodeName_Statics::NewProp_nodeName,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzBoolArrayByNodeName_Statics::NewProp_fieldName,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzBoolArrayByNodeName_Statics::NewProp_isAvailable,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzBoolArrayByNodeName_Statics::NewProp_ReturnValue_Inner,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzBoolArrayByNodeName_Statics::NewProp_ReturnValue,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzBoolArrayByNodeName_Statics::PropPointers) < 2048);
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzBoolArrayByNodeName_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UVentuzBPFunctionLibrary, nullptr, "GetVentuzBoolArrayByNodeName", nullptr, nullptr, Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzBoolArrayByNodeName_Statics::PropPointers, UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzBoolArrayByNodeName_Statics::PropPointers), sizeof(Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzBoolArrayByNodeName_Statics::VentuzBPFunctionLibrary_eventGetVentuzBoolArrayByNodeName_Parms), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04422401, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzBoolArrayByNodeName_Statics::Function_MetaDataParams), Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzBoolArrayByNodeName_Statics::Function_MetaDataParams) };
static_assert(sizeof(Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzBoolArrayByNodeName_Statics::VentuzBPFunctionLibrary_eventGetVentuzBoolArrayByNodeName_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzBoolArrayByNodeName()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzBoolArrayByNodeName_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UVentuzBPFunctionLibrary::execGetVentuzBoolArrayByNodeName)
{
	P_GET_PROPERTY(FStrProperty,Z_Param_nodeName);
	P_GET_PROPERTY(FStrProperty,Z_Param_fieldName);
	P_GET_UBOOL_REF(Z_Param_Out_isAvailable);
	P_FINISH;
	P_NATIVE_BEGIN;
	*(TArray<bool>*)Z_Param__Result=UVentuzBPFunctionLibrary::GetVentuzBoolArrayByNodeName(Z_Param_nodeName,Z_Param_fieldName,Z_Param_Out_isAvailable);
	P_NATIVE_END;
}
// End Class UVentuzBPFunctionLibrary Function GetVentuzBoolArrayByNodeName

// Begin Class UVentuzBPFunctionLibrary Function GetVentuzBoolValueByNodeName
struct Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzBoolValueByNodeName_Statics
{
	struct VentuzBPFunctionLibrary_eventGetVentuzBoolValueByNodeName_Parms
	{
		FString nodeName;
		FString fieldName;
		bool isAvailable;
		bool ReturnValue;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "BlueprintInternalUseOnly", "true" },
		{ "BlueprintType", "true" },
		{ "Category", "Ventuz" },
		{ "ModuleRelativePath", "Public/VentuzBPEvent.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_nodeName_MetaData[] = {
		{ "NativeConst", "" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_fieldName_MetaData[] = {
		{ "NativeConst", "" },
	};
#endif // WITH_METADATA
	static const UECodeGen_Private::FStrPropertyParams NewProp_nodeName;
	static const UECodeGen_Private::FStrPropertyParams NewProp_fieldName;
	static void NewProp_isAvailable_SetBit(void* Obj);
	static const UECodeGen_Private::FBoolPropertyParams NewProp_isAvailable;
	static void NewProp_ReturnValue_SetBit(void* Obj);
	static const UECodeGen_Private::FBoolPropertyParams NewProp_ReturnValue;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FStrPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzBoolValueByNodeName_Statics::NewProp_nodeName = { "nodeName", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventGetVentuzBoolValueByNodeName_Parms, nodeName), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_nodeName_MetaData), NewProp_nodeName_MetaData) };
const UECodeGen_Private::FStrPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzBoolValueByNodeName_Statics::NewProp_fieldName = { "fieldName", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventGetVentuzBoolValueByNodeName_Parms, fieldName), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_fieldName_MetaData), NewProp_fieldName_MetaData) };
void Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzBoolValueByNodeName_Statics::NewProp_isAvailable_SetBit(void* Obj)
{
	((VentuzBPFunctionLibrary_eventGetVentuzBoolValueByNodeName_Parms*)Obj)->isAvailable = 1;
}
const UECodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzBoolValueByNodeName_Statics::NewProp_isAvailable = { "isAvailable", nullptr, (EPropertyFlags)0x0010000000000180, UECodeGen_Private::EPropertyGenFlags::Bool | UECodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, sizeof(bool), sizeof(VentuzBPFunctionLibrary_eventGetVentuzBoolValueByNodeName_Parms), &Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzBoolValueByNodeName_Statics::NewProp_isAvailable_SetBit, METADATA_PARAMS(0, nullptr) };
void Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzBoolValueByNodeName_Statics::NewProp_ReturnValue_SetBit(void* Obj)
{
	((VentuzBPFunctionLibrary_eventGetVentuzBoolValueByNodeName_Parms*)Obj)->ReturnValue = 1;
}
const UECodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzBoolValueByNodeName_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UECodeGen_Private::EPropertyGenFlags::Bool | UECodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, sizeof(bool), sizeof(VentuzBPFunctionLibrary_eventGetVentuzBoolValueByNodeName_Parms), &Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzBoolValueByNodeName_Statics::NewProp_ReturnValue_SetBit, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzBoolValueByNodeName_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzBoolValueByNodeName_Statics::NewProp_nodeName,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzBoolValueByNodeName_Statics::NewProp_fieldName,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzBoolValueByNodeName_Statics::NewProp_isAvailable,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzBoolValueByNodeName_Statics::NewProp_ReturnValue,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzBoolValueByNodeName_Statics::PropPointers) < 2048);
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzBoolValueByNodeName_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UVentuzBPFunctionLibrary, nullptr, "GetVentuzBoolValueByNodeName", nullptr, nullptr, Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzBoolValueByNodeName_Statics::PropPointers, UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzBoolValueByNodeName_Statics::PropPointers), sizeof(Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzBoolValueByNodeName_Statics::VentuzBPFunctionLibrary_eventGetVentuzBoolValueByNodeName_Parms), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04422401, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzBoolValueByNodeName_Statics::Function_MetaDataParams), Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzBoolValueByNodeName_Statics::Function_MetaDataParams) };
static_assert(sizeof(Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzBoolValueByNodeName_Statics::VentuzBPFunctionLibrary_eventGetVentuzBoolValueByNodeName_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzBoolValueByNodeName()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzBoolValueByNodeName_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UVentuzBPFunctionLibrary::execGetVentuzBoolValueByNodeName)
{
	P_GET_PROPERTY(FStrProperty,Z_Param_nodeName);
	P_GET_PROPERTY(FStrProperty,Z_Param_fieldName);
	P_GET_UBOOL_REF(Z_Param_Out_isAvailable);
	P_FINISH;
	P_NATIVE_BEGIN;
	*(bool*)Z_Param__Result=UVentuzBPFunctionLibrary::GetVentuzBoolValueByNodeName(Z_Param_nodeName,Z_Param_fieldName,Z_Param_Out_isAvailable);
	P_NATIVE_END;
}
// End Class UVentuzBPFunctionLibrary Function GetVentuzBoolValueByNodeName

// Begin Class UVentuzBPFunctionLibrary Function GetVentuzCameraTransform
struct Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzCameraTransform_Statics
{
	struct VentuzBPFunctionLibrary_eventGetVentuzCameraTransform_Parms
	{
		bool isAvailable;
		FTransform ReturnValue;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Category", "Ventuz" },
		{ "Comment", "/**\n     * Get camera transform from Ventuz\n     *\n     * @param\x09isAvailable\x09True if the value transform was read successfully\n     */" },
		{ "ModuleRelativePath", "Public/VentuzBPEvent.h" },
		{ "ToolTip", "Get camera transform from Ventuz\n\n@param  isAvailable     True if the value transform was read successfully" },
	};
#endif // WITH_METADATA
	static void NewProp_isAvailable_SetBit(void* Obj);
	static const UECodeGen_Private::FBoolPropertyParams NewProp_isAvailable;
	static const UECodeGen_Private::FStructPropertyParams NewProp_ReturnValue;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
void Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzCameraTransform_Statics::NewProp_isAvailable_SetBit(void* Obj)
{
	((VentuzBPFunctionLibrary_eventGetVentuzCameraTransform_Parms*)Obj)->isAvailable = 1;
}
const UECodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzCameraTransform_Statics::NewProp_isAvailable = { "isAvailable", nullptr, (EPropertyFlags)0x0010000000000180, UECodeGen_Private::EPropertyGenFlags::Bool | UECodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, sizeof(bool), sizeof(VentuzBPFunctionLibrary_eventGetVentuzCameraTransform_Parms), &Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzCameraTransform_Statics::NewProp_isAvailable_SetBit, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzCameraTransform_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventGetVentuzCameraTransform_Parms, ReturnValue), Z_Construct_UScriptStruct_FTransform, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzCameraTransform_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzCameraTransform_Statics::NewProp_isAvailable,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzCameraTransform_Statics::NewProp_ReturnValue,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzCameraTransform_Statics::PropPointers) < 2048);
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzCameraTransform_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UVentuzBPFunctionLibrary, nullptr, "GetVentuzCameraTransform", nullptr, nullptr, Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzCameraTransform_Statics::PropPointers, UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzCameraTransform_Statics::PropPointers), sizeof(Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzCameraTransform_Statics::VentuzBPFunctionLibrary_eventGetVentuzCameraTransform_Parms), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04C22401, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzCameraTransform_Statics::Function_MetaDataParams), Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzCameraTransform_Statics::Function_MetaDataParams) };
static_assert(sizeof(Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzCameraTransform_Statics::VentuzBPFunctionLibrary_eventGetVentuzCameraTransform_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzCameraTransform()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzCameraTransform_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UVentuzBPFunctionLibrary::execGetVentuzCameraTransform)
{
	P_GET_UBOOL_REF(Z_Param_Out_isAvailable);
	P_FINISH;
	P_NATIVE_BEGIN;
	*(FTransform*)Z_Param__Result=UVentuzBPFunctionLibrary::GetVentuzCameraTransform(Z_Param_Out_isAvailable);
	P_NATIVE_END;
}
// End Class UVentuzBPFunctionLibrary Function GetVentuzCameraTransform

// Begin Class UVentuzBPFunctionLibrary Function GetVentuzFloatArrayByNodeName
struct Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzFloatArrayByNodeName_Statics
{
	struct VentuzBPFunctionLibrary_eventGetVentuzFloatArrayByNodeName_Parms
	{
		FString nodeName;
		FString fieldName;
		bool isAvailable;
		TArray<float> ReturnValue;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "BlueprintInternalUseOnly", "true" },
		{ "BlueprintType", "true" },
		{ "Category", "Ventuz" },
		{ "ModuleRelativePath", "Public/VentuzBPEvent.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_nodeName_MetaData[] = {
		{ "NativeConst", "" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_fieldName_MetaData[] = {
		{ "NativeConst", "" },
	};
#endif // WITH_METADATA
	static const UECodeGen_Private::FStrPropertyParams NewProp_nodeName;
	static const UECodeGen_Private::FStrPropertyParams NewProp_fieldName;
	static void NewProp_isAvailable_SetBit(void* Obj);
	static const UECodeGen_Private::FBoolPropertyParams NewProp_isAvailable;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_ReturnValue_Inner;
	static const UECodeGen_Private::FArrayPropertyParams NewProp_ReturnValue;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FStrPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzFloatArrayByNodeName_Statics::NewProp_nodeName = { "nodeName", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventGetVentuzFloatArrayByNodeName_Parms, nodeName), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_nodeName_MetaData), NewProp_nodeName_MetaData) };
const UECodeGen_Private::FStrPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzFloatArrayByNodeName_Statics::NewProp_fieldName = { "fieldName", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventGetVentuzFloatArrayByNodeName_Parms, fieldName), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_fieldName_MetaData), NewProp_fieldName_MetaData) };
void Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzFloatArrayByNodeName_Statics::NewProp_isAvailable_SetBit(void* Obj)
{
	((VentuzBPFunctionLibrary_eventGetVentuzFloatArrayByNodeName_Parms*)Obj)->isAvailable = 1;
}
const UECodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzFloatArrayByNodeName_Statics::NewProp_isAvailable = { "isAvailable", nullptr, (EPropertyFlags)0x0010000000000180, UECodeGen_Private::EPropertyGenFlags::Bool | UECodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, sizeof(bool), sizeof(VentuzBPFunctionLibrary_eventGetVentuzFloatArrayByNodeName_Parms), &Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzFloatArrayByNodeName_Statics::NewProp_isAvailable_SetBit, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzFloatArrayByNodeName_Statics::NewProp_ReturnValue_Inner = { "ReturnValue", nullptr, (EPropertyFlags)0x0000000000000000, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, 0, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FArrayPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzFloatArrayByNodeName_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UECodeGen_Private::EPropertyGenFlags::Array, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventGetVentuzFloatArrayByNodeName_Parms, ReturnValue), EArrayPropertyFlags::None, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzFloatArrayByNodeName_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzFloatArrayByNodeName_Statics::NewProp_nodeName,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzFloatArrayByNodeName_Statics::NewProp_fieldName,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzFloatArrayByNodeName_Statics::NewProp_isAvailable,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzFloatArrayByNodeName_Statics::NewProp_ReturnValue_Inner,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzFloatArrayByNodeName_Statics::NewProp_ReturnValue,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzFloatArrayByNodeName_Statics::PropPointers) < 2048);
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzFloatArrayByNodeName_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UVentuzBPFunctionLibrary, nullptr, "GetVentuzFloatArrayByNodeName", nullptr, nullptr, Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzFloatArrayByNodeName_Statics::PropPointers, UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzFloatArrayByNodeName_Statics::PropPointers), sizeof(Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzFloatArrayByNodeName_Statics::VentuzBPFunctionLibrary_eventGetVentuzFloatArrayByNodeName_Parms), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04422401, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzFloatArrayByNodeName_Statics::Function_MetaDataParams), Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzFloatArrayByNodeName_Statics::Function_MetaDataParams) };
static_assert(sizeof(Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzFloatArrayByNodeName_Statics::VentuzBPFunctionLibrary_eventGetVentuzFloatArrayByNodeName_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzFloatArrayByNodeName()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzFloatArrayByNodeName_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UVentuzBPFunctionLibrary::execGetVentuzFloatArrayByNodeName)
{
	P_GET_PROPERTY(FStrProperty,Z_Param_nodeName);
	P_GET_PROPERTY(FStrProperty,Z_Param_fieldName);
	P_GET_UBOOL_REF(Z_Param_Out_isAvailable);
	P_FINISH;
	P_NATIVE_BEGIN;
	*(TArray<float>*)Z_Param__Result=UVentuzBPFunctionLibrary::GetVentuzFloatArrayByNodeName(Z_Param_nodeName,Z_Param_fieldName,Z_Param_Out_isAvailable);
	P_NATIVE_END;
}
// End Class UVentuzBPFunctionLibrary Function GetVentuzFloatArrayByNodeName

// Begin Class UVentuzBPFunctionLibrary Function GetVentuzFloatValueByNodeName
struct Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzFloatValueByNodeName_Statics
{
	struct VentuzBPFunctionLibrary_eventGetVentuzFloatValueByNodeName_Parms
	{
		FString nodeName;
		FString fieldName;
		bool isAvailable;
		float ReturnValue;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "BlueprintInternalUseOnly", "true" },
		{ "BlueprintType", "true" },
		{ "Category", "Ventuz" },
		{ "ModuleRelativePath", "Public/VentuzBPEvent.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_nodeName_MetaData[] = {
		{ "NativeConst", "" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_fieldName_MetaData[] = {
		{ "NativeConst", "" },
	};
#endif // WITH_METADATA
	static const UECodeGen_Private::FStrPropertyParams NewProp_nodeName;
	static const UECodeGen_Private::FStrPropertyParams NewProp_fieldName;
	static void NewProp_isAvailable_SetBit(void* Obj);
	static const UECodeGen_Private::FBoolPropertyParams NewProp_isAvailable;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_ReturnValue;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FStrPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzFloatValueByNodeName_Statics::NewProp_nodeName = { "nodeName", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventGetVentuzFloatValueByNodeName_Parms, nodeName), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_nodeName_MetaData), NewProp_nodeName_MetaData) };
const UECodeGen_Private::FStrPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzFloatValueByNodeName_Statics::NewProp_fieldName = { "fieldName", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventGetVentuzFloatValueByNodeName_Parms, fieldName), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_fieldName_MetaData), NewProp_fieldName_MetaData) };
void Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzFloatValueByNodeName_Statics::NewProp_isAvailable_SetBit(void* Obj)
{
	((VentuzBPFunctionLibrary_eventGetVentuzFloatValueByNodeName_Parms*)Obj)->isAvailable = 1;
}
const UECodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzFloatValueByNodeName_Statics::NewProp_isAvailable = { "isAvailable", nullptr, (EPropertyFlags)0x0010000000000180, UECodeGen_Private::EPropertyGenFlags::Bool | UECodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, sizeof(bool), sizeof(VentuzBPFunctionLibrary_eventGetVentuzFloatValueByNodeName_Parms), &Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzFloatValueByNodeName_Statics::NewProp_isAvailable_SetBit, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzFloatValueByNodeName_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventGetVentuzFloatValueByNodeName_Parms, ReturnValue), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzFloatValueByNodeName_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzFloatValueByNodeName_Statics::NewProp_nodeName,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzFloatValueByNodeName_Statics::NewProp_fieldName,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzFloatValueByNodeName_Statics::NewProp_isAvailable,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzFloatValueByNodeName_Statics::NewProp_ReturnValue,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzFloatValueByNodeName_Statics::PropPointers) < 2048);
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzFloatValueByNodeName_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UVentuzBPFunctionLibrary, nullptr, "GetVentuzFloatValueByNodeName", nullptr, nullptr, Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzFloatValueByNodeName_Statics::PropPointers, UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzFloatValueByNodeName_Statics::PropPointers), sizeof(Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzFloatValueByNodeName_Statics::VentuzBPFunctionLibrary_eventGetVentuzFloatValueByNodeName_Parms), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04422401, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzFloatValueByNodeName_Statics::Function_MetaDataParams), Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzFloatValueByNodeName_Statics::Function_MetaDataParams) };
static_assert(sizeof(Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzFloatValueByNodeName_Statics::VentuzBPFunctionLibrary_eventGetVentuzFloatValueByNodeName_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzFloatValueByNodeName()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzFloatValueByNodeName_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UVentuzBPFunctionLibrary::execGetVentuzFloatValueByNodeName)
{
	P_GET_PROPERTY(FStrProperty,Z_Param_nodeName);
	P_GET_PROPERTY(FStrProperty,Z_Param_fieldName);
	P_GET_UBOOL_REF(Z_Param_Out_isAvailable);
	P_FINISH;
	P_NATIVE_BEGIN;
	*(float*)Z_Param__Result=UVentuzBPFunctionLibrary::GetVentuzFloatValueByNodeName(Z_Param_nodeName,Z_Param_fieldName,Z_Param_Out_isAvailable);
	P_NATIVE_END;
}
// End Class UVentuzBPFunctionLibrary Function GetVentuzFloatValueByNodeName

// Begin Class UVentuzBPFunctionLibrary Function GetVentuzIntArrayByNodeName
struct Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzIntArrayByNodeName_Statics
{
	struct VentuzBPFunctionLibrary_eventGetVentuzIntArrayByNodeName_Parms
	{
		FString nodeName;
		FString fieldName;
		bool isAvailable;
		TArray<int32> ReturnValue;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "BlueprintInternalUseOnly", "true" },
		{ "BlueprintType", "true" },
		{ "Category", "Ventuz" },
		{ "ModuleRelativePath", "Public/VentuzBPEvent.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_nodeName_MetaData[] = {
		{ "NativeConst", "" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_fieldName_MetaData[] = {
		{ "NativeConst", "" },
	};
#endif // WITH_METADATA
	static const UECodeGen_Private::FStrPropertyParams NewProp_nodeName;
	static const UECodeGen_Private::FStrPropertyParams NewProp_fieldName;
	static void NewProp_isAvailable_SetBit(void* Obj);
	static const UECodeGen_Private::FBoolPropertyParams NewProp_isAvailable;
	static const UECodeGen_Private::FIntPropertyParams NewProp_ReturnValue_Inner;
	static const UECodeGen_Private::FArrayPropertyParams NewProp_ReturnValue;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FStrPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzIntArrayByNodeName_Statics::NewProp_nodeName = { "nodeName", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventGetVentuzIntArrayByNodeName_Parms, nodeName), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_nodeName_MetaData), NewProp_nodeName_MetaData) };
const UECodeGen_Private::FStrPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzIntArrayByNodeName_Statics::NewProp_fieldName = { "fieldName", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventGetVentuzIntArrayByNodeName_Parms, fieldName), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_fieldName_MetaData), NewProp_fieldName_MetaData) };
void Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzIntArrayByNodeName_Statics::NewProp_isAvailable_SetBit(void* Obj)
{
	((VentuzBPFunctionLibrary_eventGetVentuzIntArrayByNodeName_Parms*)Obj)->isAvailable = 1;
}
const UECodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzIntArrayByNodeName_Statics::NewProp_isAvailable = { "isAvailable", nullptr, (EPropertyFlags)0x0010000000000180, UECodeGen_Private::EPropertyGenFlags::Bool | UECodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, sizeof(bool), sizeof(VentuzBPFunctionLibrary_eventGetVentuzIntArrayByNodeName_Parms), &Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzIntArrayByNodeName_Statics::NewProp_isAvailable_SetBit, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FIntPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzIntArrayByNodeName_Statics::NewProp_ReturnValue_Inner = { "ReturnValue", nullptr, (EPropertyFlags)0x0000000000000000, UECodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, 0, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FArrayPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzIntArrayByNodeName_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UECodeGen_Private::EPropertyGenFlags::Array, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventGetVentuzIntArrayByNodeName_Parms, ReturnValue), EArrayPropertyFlags::None, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzIntArrayByNodeName_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzIntArrayByNodeName_Statics::NewProp_nodeName,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzIntArrayByNodeName_Statics::NewProp_fieldName,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzIntArrayByNodeName_Statics::NewProp_isAvailable,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzIntArrayByNodeName_Statics::NewProp_ReturnValue_Inner,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzIntArrayByNodeName_Statics::NewProp_ReturnValue,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzIntArrayByNodeName_Statics::PropPointers) < 2048);
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzIntArrayByNodeName_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UVentuzBPFunctionLibrary, nullptr, "GetVentuzIntArrayByNodeName", nullptr, nullptr, Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzIntArrayByNodeName_Statics::PropPointers, UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzIntArrayByNodeName_Statics::PropPointers), sizeof(Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzIntArrayByNodeName_Statics::VentuzBPFunctionLibrary_eventGetVentuzIntArrayByNodeName_Parms), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04422401, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzIntArrayByNodeName_Statics::Function_MetaDataParams), Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzIntArrayByNodeName_Statics::Function_MetaDataParams) };
static_assert(sizeof(Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzIntArrayByNodeName_Statics::VentuzBPFunctionLibrary_eventGetVentuzIntArrayByNodeName_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzIntArrayByNodeName()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzIntArrayByNodeName_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UVentuzBPFunctionLibrary::execGetVentuzIntArrayByNodeName)
{
	P_GET_PROPERTY(FStrProperty,Z_Param_nodeName);
	P_GET_PROPERTY(FStrProperty,Z_Param_fieldName);
	P_GET_UBOOL_REF(Z_Param_Out_isAvailable);
	P_FINISH;
	P_NATIVE_BEGIN;
	*(TArray<int32>*)Z_Param__Result=UVentuzBPFunctionLibrary::GetVentuzIntArrayByNodeName(Z_Param_nodeName,Z_Param_fieldName,Z_Param_Out_isAvailable);
	P_NATIVE_END;
}
// End Class UVentuzBPFunctionLibrary Function GetVentuzIntArrayByNodeName

// Begin Class UVentuzBPFunctionLibrary Function GetVentuzIntValueByNodeName
struct Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzIntValueByNodeName_Statics
{
	struct VentuzBPFunctionLibrary_eventGetVentuzIntValueByNodeName_Parms
	{
		FString nodeName;
		FString fieldName;
		bool isAvailable;
		int32 ReturnValue;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "BlueprintInternalUseOnly", "true" },
		{ "BlueprintType", "true" },
		{ "Category", "Ventuz" },
		{ "Comment", "// internal helpers\n" },
		{ "ModuleRelativePath", "Public/VentuzBPEvent.h" },
		{ "ToolTip", "internal helpers" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_nodeName_MetaData[] = {
		{ "NativeConst", "" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_fieldName_MetaData[] = {
		{ "NativeConst", "" },
	};
#endif // WITH_METADATA
	static const UECodeGen_Private::FStrPropertyParams NewProp_nodeName;
	static const UECodeGen_Private::FStrPropertyParams NewProp_fieldName;
	static void NewProp_isAvailable_SetBit(void* Obj);
	static const UECodeGen_Private::FBoolPropertyParams NewProp_isAvailable;
	static const UECodeGen_Private::FIntPropertyParams NewProp_ReturnValue;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FStrPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzIntValueByNodeName_Statics::NewProp_nodeName = { "nodeName", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventGetVentuzIntValueByNodeName_Parms, nodeName), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_nodeName_MetaData), NewProp_nodeName_MetaData) };
const UECodeGen_Private::FStrPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzIntValueByNodeName_Statics::NewProp_fieldName = { "fieldName", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventGetVentuzIntValueByNodeName_Parms, fieldName), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_fieldName_MetaData), NewProp_fieldName_MetaData) };
void Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzIntValueByNodeName_Statics::NewProp_isAvailable_SetBit(void* Obj)
{
	((VentuzBPFunctionLibrary_eventGetVentuzIntValueByNodeName_Parms*)Obj)->isAvailable = 1;
}
const UECodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzIntValueByNodeName_Statics::NewProp_isAvailable = { "isAvailable", nullptr, (EPropertyFlags)0x0010000000000180, UECodeGen_Private::EPropertyGenFlags::Bool | UECodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, sizeof(bool), sizeof(VentuzBPFunctionLibrary_eventGetVentuzIntValueByNodeName_Parms), &Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzIntValueByNodeName_Statics::NewProp_isAvailable_SetBit, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FIntPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzIntValueByNodeName_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UECodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventGetVentuzIntValueByNodeName_Parms, ReturnValue), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzIntValueByNodeName_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzIntValueByNodeName_Statics::NewProp_nodeName,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzIntValueByNodeName_Statics::NewProp_fieldName,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzIntValueByNodeName_Statics::NewProp_isAvailable,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzIntValueByNodeName_Statics::NewProp_ReturnValue,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzIntValueByNodeName_Statics::PropPointers) < 2048);
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzIntValueByNodeName_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UVentuzBPFunctionLibrary, nullptr, "GetVentuzIntValueByNodeName", nullptr, nullptr, Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzIntValueByNodeName_Statics::PropPointers, UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzIntValueByNodeName_Statics::PropPointers), sizeof(Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzIntValueByNodeName_Statics::VentuzBPFunctionLibrary_eventGetVentuzIntValueByNodeName_Parms), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04422401, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzIntValueByNodeName_Statics::Function_MetaDataParams), Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzIntValueByNodeName_Statics::Function_MetaDataParams) };
static_assert(sizeof(Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzIntValueByNodeName_Statics::VentuzBPFunctionLibrary_eventGetVentuzIntValueByNodeName_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzIntValueByNodeName()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzIntValueByNodeName_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UVentuzBPFunctionLibrary::execGetVentuzIntValueByNodeName)
{
	P_GET_PROPERTY(FStrProperty,Z_Param_nodeName);
	P_GET_PROPERTY(FStrProperty,Z_Param_fieldName);
	P_GET_UBOOL_REF(Z_Param_Out_isAvailable);
	P_FINISH;
	P_NATIVE_BEGIN;
	*(int32*)Z_Param__Result=UVentuzBPFunctionLibrary::GetVentuzIntValueByNodeName(Z_Param_nodeName,Z_Param_fieldName,Z_Param_Out_isAvailable);
	P_NATIVE_END;
}
// End Class UVentuzBPFunctionLibrary Function GetVentuzIntValueByNodeName

// Begin Class UVentuzBPFunctionLibrary Function GetVentuzStringArrayByNodeName
struct Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzStringArrayByNodeName_Statics
{
	struct VentuzBPFunctionLibrary_eventGetVentuzStringArrayByNodeName_Parms
	{
		FString nodeName;
		FString fieldName;
		bool isAvailable;
		TArray<FString> ReturnValue;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "BlueprintInternalUseOnly", "true" },
		{ "BlueprintType", "true" },
		{ "Category", "Ventuz" },
		{ "ModuleRelativePath", "Public/VentuzBPEvent.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_nodeName_MetaData[] = {
		{ "NativeConst", "" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_fieldName_MetaData[] = {
		{ "NativeConst", "" },
	};
#endif // WITH_METADATA
	static const UECodeGen_Private::FStrPropertyParams NewProp_nodeName;
	static const UECodeGen_Private::FStrPropertyParams NewProp_fieldName;
	static void NewProp_isAvailable_SetBit(void* Obj);
	static const UECodeGen_Private::FBoolPropertyParams NewProp_isAvailable;
	static const UECodeGen_Private::FStrPropertyParams NewProp_ReturnValue_Inner;
	static const UECodeGen_Private::FArrayPropertyParams NewProp_ReturnValue;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FStrPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzStringArrayByNodeName_Statics::NewProp_nodeName = { "nodeName", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventGetVentuzStringArrayByNodeName_Parms, nodeName), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_nodeName_MetaData), NewProp_nodeName_MetaData) };
const UECodeGen_Private::FStrPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzStringArrayByNodeName_Statics::NewProp_fieldName = { "fieldName", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventGetVentuzStringArrayByNodeName_Parms, fieldName), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_fieldName_MetaData), NewProp_fieldName_MetaData) };
void Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzStringArrayByNodeName_Statics::NewProp_isAvailable_SetBit(void* Obj)
{
	((VentuzBPFunctionLibrary_eventGetVentuzStringArrayByNodeName_Parms*)Obj)->isAvailable = 1;
}
const UECodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzStringArrayByNodeName_Statics::NewProp_isAvailable = { "isAvailable", nullptr, (EPropertyFlags)0x0010000000000180, UECodeGen_Private::EPropertyGenFlags::Bool | UECodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, sizeof(bool), sizeof(VentuzBPFunctionLibrary_eventGetVentuzStringArrayByNodeName_Parms), &Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzStringArrayByNodeName_Statics::NewProp_isAvailable_SetBit, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FStrPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzStringArrayByNodeName_Statics::NewProp_ReturnValue_Inner = { "ReturnValue", nullptr, (EPropertyFlags)0x0000000000000000, UECodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, 0, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FArrayPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzStringArrayByNodeName_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UECodeGen_Private::EPropertyGenFlags::Array, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventGetVentuzStringArrayByNodeName_Parms, ReturnValue), EArrayPropertyFlags::None, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzStringArrayByNodeName_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzStringArrayByNodeName_Statics::NewProp_nodeName,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzStringArrayByNodeName_Statics::NewProp_fieldName,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzStringArrayByNodeName_Statics::NewProp_isAvailable,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzStringArrayByNodeName_Statics::NewProp_ReturnValue_Inner,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzStringArrayByNodeName_Statics::NewProp_ReturnValue,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzStringArrayByNodeName_Statics::PropPointers) < 2048);
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzStringArrayByNodeName_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UVentuzBPFunctionLibrary, nullptr, "GetVentuzStringArrayByNodeName", nullptr, nullptr, Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzStringArrayByNodeName_Statics::PropPointers, UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzStringArrayByNodeName_Statics::PropPointers), sizeof(Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzStringArrayByNodeName_Statics::VentuzBPFunctionLibrary_eventGetVentuzStringArrayByNodeName_Parms), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04422401, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzStringArrayByNodeName_Statics::Function_MetaDataParams), Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzStringArrayByNodeName_Statics::Function_MetaDataParams) };
static_assert(sizeof(Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzStringArrayByNodeName_Statics::VentuzBPFunctionLibrary_eventGetVentuzStringArrayByNodeName_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzStringArrayByNodeName()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzStringArrayByNodeName_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UVentuzBPFunctionLibrary::execGetVentuzStringArrayByNodeName)
{
	P_GET_PROPERTY(FStrProperty,Z_Param_nodeName);
	P_GET_PROPERTY(FStrProperty,Z_Param_fieldName);
	P_GET_UBOOL_REF(Z_Param_Out_isAvailable);
	P_FINISH;
	P_NATIVE_BEGIN;
	*(TArray<FString>*)Z_Param__Result=UVentuzBPFunctionLibrary::GetVentuzStringArrayByNodeName(Z_Param_nodeName,Z_Param_fieldName,Z_Param_Out_isAvailable);
	P_NATIVE_END;
}
// End Class UVentuzBPFunctionLibrary Function GetVentuzStringArrayByNodeName

// Begin Class UVentuzBPFunctionLibrary Function GetVentuzStringValueByNodeName
struct Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzStringValueByNodeName_Statics
{
	struct VentuzBPFunctionLibrary_eventGetVentuzStringValueByNodeName_Parms
	{
		FString nodeName;
		FString fieldName;
		bool isAvailable;
		FString ReturnValue;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "BlueprintInternalUseOnly", "true" },
		{ "BlueprintType", "true" },
		{ "Category", "Ventuz" },
		{ "ModuleRelativePath", "Public/VentuzBPEvent.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_nodeName_MetaData[] = {
		{ "NativeConst", "" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_fieldName_MetaData[] = {
		{ "NativeConst", "" },
	};
#endif // WITH_METADATA
	static const UECodeGen_Private::FStrPropertyParams NewProp_nodeName;
	static const UECodeGen_Private::FStrPropertyParams NewProp_fieldName;
	static void NewProp_isAvailable_SetBit(void* Obj);
	static const UECodeGen_Private::FBoolPropertyParams NewProp_isAvailable;
	static const UECodeGen_Private::FStrPropertyParams NewProp_ReturnValue;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FStrPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzStringValueByNodeName_Statics::NewProp_nodeName = { "nodeName", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventGetVentuzStringValueByNodeName_Parms, nodeName), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_nodeName_MetaData), NewProp_nodeName_MetaData) };
const UECodeGen_Private::FStrPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzStringValueByNodeName_Statics::NewProp_fieldName = { "fieldName", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventGetVentuzStringValueByNodeName_Parms, fieldName), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_fieldName_MetaData), NewProp_fieldName_MetaData) };
void Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzStringValueByNodeName_Statics::NewProp_isAvailable_SetBit(void* Obj)
{
	((VentuzBPFunctionLibrary_eventGetVentuzStringValueByNodeName_Parms*)Obj)->isAvailable = 1;
}
const UECodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzStringValueByNodeName_Statics::NewProp_isAvailable = { "isAvailable", nullptr, (EPropertyFlags)0x0010000000000180, UECodeGen_Private::EPropertyGenFlags::Bool | UECodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, sizeof(bool), sizeof(VentuzBPFunctionLibrary_eventGetVentuzStringValueByNodeName_Parms), &Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzStringValueByNodeName_Statics::NewProp_isAvailable_SetBit, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FStrPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzStringValueByNodeName_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UECodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventGetVentuzStringValueByNodeName_Parms, ReturnValue), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzStringValueByNodeName_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzStringValueByNodeName_Statics::NewProp_nodeName,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzStringValueByNodeName_Statics::NewProp_fieldName,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzStringValueByNodeName_Statics::NewProp_isAvailable,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzStringValueByNodeName_Statics::NewProp_ReturnValue,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzStringValueByNodeName_Statics::PropPointers) < 2048);
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzStringValueByNodeName_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UVentuzBPFunctionLibrary, nullptr, "GetVentuzStringValueByNodeName", nullptr, nullptr, Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzStringValueByNodeName_Statics::PropPointers, UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzStringValueByNodeName_Statics::PropPointers), sizeof(Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzStringValueByNodeName_Statics::VentuzBPFunctionLibrary_eventGetVentuzStringValueByNodeName_Parms), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04422401, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzStringValueByNodeName_Statics::Function_MetaDataParams), Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzStringValueByNodeName_Statics::Function_MetaDataParams) };
static_assert(sizeof(Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzStringValueByNodeName_Statics::VentuzBPFunctionLibrary_eventGetVentuzStringValueByNodeName_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzStringValueByNodeName()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzStringValueByNodeName_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UVentuzBPFunctionLibrary::execGetVentuzStringValueByNodeName)
{
	P_GET_PROPERTY(FStrProperty,Z_Param_nodeName);
	P_GET_PROPERTY(FStrProperty,Z_Param_fieldName);
	P_GET_UBOOL_REF(Z_Param_Out_isAvailable);
	P_FINISH;
	P_NATIVE_BEGIN;
	*(FString*)Z_Param__Result=UVentuzBPFunctionLibrary::GetVentuzStringValueByNodeName(Z_Param_nodeName,Z_Param_fieldName,Z_Param_Out_isAvailable);
	P_NATIVE_END;
}
// End Class UVentuzBPFunctionLibrary Function GetVentuzStringValueByNodeName

// Begin Class UVentuzBPFunctionLibrary Function GetVentuzTransformValue
struct Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzTransformValue_Statics
{
	struct VentuzBPFunctionLibrary_eventGetVentuzTransformValue_Parms
	{
		FString valueName;
		bool isAvailable;
		FTransform ReturnValue;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Category", "Ventuz" },
		{ "Comment", "/**\n     * Get a Transform value from an Axis Unreal node from Ventuz\n     *\n     * @param\x09valueName  The name of the node to read from on the Ventuz side\n     * @param\x09isAvailable\x09True if the value was read successfully\n     * @return\x09The transform read from Ventuz, converted to the Unreal coordinate system\n     */" },
		{ "ModuleRelativePath", "Public/VentuzBPEvent.h" },
		{ "ToolTip", "Get a Transform value from an Axis Unreal node from Ventuz\n\n@param  valueName  The name of the node to read from on the Ventuz side\n@param  isAvailable     True if the value was read successfully\n@return The transform read from Ventuz, converted to the Unreal coordinate system" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_valueName_MetaData[] = {
		{ "NativeConst", "" },
	};
#endif // WITH_METADATA
	static const UECodeGen_Private::FStrPropertyParams NewProp_valueName;
	static void NewProp_isAvailable_SetBit(void* Obj);
	static const UECodeGen_Private::FBoolPropertyParams NewProp_isAvailable;
	static const UECodeGen_Private::FStructPropertyParams NewProp_ReturnValue;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FStrPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzTransformValue_Statics::NewProp_valueName = { "valueName", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventGetVentuzTransformValue_Parms, valueName), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_valueName_MetaData), NewProp_valueName_MetaData) };
void Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzTransformValue_Statics::NewProp_isAvailable_SetBit(void* Obj)
{
	((VentuzBPFunctionLibrary_eventGetVentuzTransformValue_Parms*)Obj)->isAvailable = 1;
}
const UECodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzTransformValue_Statics::NewProp_isAvailable = { "isAvailable", nullptr, (EPropertyFlags)0x0010000000000180, UECodeGen_Private::EPropertyGenFlags::Bool | UECodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, sizeof(bool), sizeof(VentuzBPFunctionLibrary_eventGetVentuzTransformValue_Parms), &Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzTransformValue_Statics::NewProp_isAvailable_SetBit, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzTransformValue_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventGetVentuzTransformValue_Parms, ReturnValue), Z_Construct_UScriptStruct_FTransform, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzTransformValue_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzTransformValue_Statics::NewProp_valueName,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzTransformValue_Statics::NewProp_isAvailable,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzTransformValue_Statics::NewProp_ReturnValue,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzTransformValue_Statics::PropPointers) < 2048);
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzTransformValue_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UVentuzBPFunctionLibrary, nullptr, "GetVentuzTransformValue", nullptr, nullptr, Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzTransformValue_Statics::PropPointers, UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzTransformValue_Statics::PropPointers), sizeof(Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzTransformValue_Statics::VentuzBPFunctionLibrary_eventGetVentuzTransformValue_Parms), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04C22401, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzTransformValue_Statics::Function_MetaDataParams), Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzTransformValue_Statics::Function_MetaDataParams) };
static_assert(sizeof(Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzTransformValue_Statics::VentuzBPFunctionLibrary_eventGetVentuzTransformValue_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzTransformValue()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzTransformValue_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UVentuzBPFunctionLibrary::execGetVentuzTransformValue)
{
	P_GET_PROPERTY(FStrProperty,Z_Param_valueName);
	P_GET_UBOOL_REF(Z_Param_Out_isAvailable);
	P_FINISH;
	P_NATIVE_BEGIN;
	*(FTransform*)Z_Param__Result=UVentuzBPFunctionLibrary::GetVentuzTransformValue(Z_Param_valueName,Z_Param_Out_isAvailable);
	P_NATIVE_END;
}
// End Class UVentuzBPFunctionLibrary Function GetVentuzTransformValue

// Begin Class UVentuzBPFunctionLibrary Function IsVentuzConnected
struct Z_Construct_UFunction_UVentuzBPFunctionLibrary_IsVentuzConnected_Statics
{
	struct VentuzBPFunctionLibrary_eventIsVentuzConnected_Parms
	{
		bool ReturnValue;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Category", "Ventuz" },
		{ "Comment", "/**\n     * Query the status of the Ventuz connection\n     *\n     * @return\x09Returns true if Ventuz is connected\n     */" },
		{ "ModuleRelativePath", "Public/VentuzBPEvent.h" },
		{ "ToolTip", "Query the status of the Ventuz connection\n\n@return Returns true if Ventuz is connected" },
	};
#endif // WITH_METADATA
	static void NewProp_ReturnValue_SetBit(void* Obj);
	static const UECodeGen_Private::FBoolPropertyParams NewProp_ReturnValue;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
void Z_Construct_UFunction_UVentuzBPFunctionLibrary_IsVentuzConnected_Statics::NewProp_ReturnValue_SetBit(void* Obj)
{
	((VentuzBPFunctionLibrary_eventIsVentuzConnected_Parms*)Obj)->ReturnValue = 1;
}
const UECodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_IsVentuzConnected_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UECodeGen_Private::EPropertyGenFlags::Bool | UECodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, sizeof(bool), sizeof(VentuzBPFunctionLibrary_eventIsVentuzConnected_Parms), &Z_Construct_UFunction_UVentuzBPFunctionLibrary_IsVentuzConnected_Statics::NewProp_ReturnValue_SetBit, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UVentuzBPFunctionLibrary_IsVentuzConnected_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_IsVentuzConnected_Statics::NewProp_ReturnValue,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_IsVentuzConnected_Statics::PropPointers) < 2048);
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_IsVentuzConnected_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UVentuzBPFunctionLibrary, nullptr, "IsVentuzConnected", nullptr, nullptr, Z_Construct_UFunction_UVentuzBPFunctionLibrary_IsVentuzConnected_Statics::PropPointers, UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_IsVentuzConnected_Statics::PropPointers), sizeof(Z_Construct_UFunction_UVentuzBPFunctionLibrary_IsVentuzConnected_Statics::VentuzBPFunctionLibrary_eventIsVentuzConnected_Parms), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x14022401, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_IsVentuzConnected_Statics::Function_MetaDataParams), Z_Construct_UFunction_UVentuzBPFunctionLibrary_IsVentuzConnected_Statics::Function_MetaDataParams) };
static_assert(sizeof(Z_Construct_UFunction_UVentuzBPFunctionLibrary_IsVentuzConnected_Statics::VentuzBPFunctionLibrary_eventIsVentuzConnected_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UVentuzBPFunctionLibrary_IsVentuzConnected()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UVentuzBPFunctionLibrary_IsVentuzConnected_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UVentuzBPFunctionLibrary::execIsVentuzConnected)
{
	P_FINISH;
	P_NATIVE_BEGIN;
	*(bool*)Z_Param__Result=UVentuzBPFunctionLibrary::IsVentuzConnected();
	P_NATIVE_END;
}
// End Class UVentuzBPFunctionLibrary Function IsVentuzConnected

// Begin Class UVentuzBPFunctionLibrary Function RegisterVentuzMethod
struct Z_Construct_UFunction_UVentuzBPFunctionLibrary_RegisterVentuzMethod_Statics
{
	struct VentuzBPFunctionLibrary_eventRegisterVentuzMethod_Parms
	{
		FString node;
		FString method;
		FScriptDelegate calledEvent;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Category", "Ventuz" },
		{ "Comment", "/**\n\x09 * Register a custom event to be called whenever a specified Method is called in Ventuz\n\x09 *\n\x09 * @param\x09methodName  The name of the method on the Ventuz side\n\x09 * @param\x09""calledEvent\x09The custom event to be called when the Method is called in Ventuz\n\x09 */" },
		{ "ModuleRelativePath", "Public/VentuzBPEvent.h" },
		{ "ToolTip", "Register a custom event to be called whenever a specified Method is called in Ventuz\n\n@param       methodName  The name of the method on the Ventuz side\n@param       calledEvent     The custom event to be called when the Method is called in Ventuz" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_node_MetaData[] = {
		{ "NativeConst", "" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_method_MetaData[] = {
		{ "NativeConst", "" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_calledEvent_MetaData[] = {
		{ "NativeConst", "" },
	};
#endif // WITH_METADATA
	static const UECodeGen_Private::FStrPropertyParams NewProp_node;
	static const UECodeGen_Private::FStrPropertyParams NewProp_method;
	static const UECodeGen_Private::FDelegatePropertyParams NewProp_calledEvent;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FStrPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_RegisterVentuzMethod_Statics::NewProp_node = { "node", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventRegisterVentuzMethod_Parms, node), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_node_MetaData), NewProp_node_MetaData) };
const UECodeGen_Private::FStrPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_RegisterVentuzMethod_Statics::NewProp_method = { "method", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventRegisterVentuzMethod_Parms, method), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_method_MetaData), NewProp_method_MetaData) };
const UECodeGen_Private::FDelegatePropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_RegisterVentuzMethod_Statics::NewProp_calledEvent = { "calledEvent", nullptr, (EPropertyFlags)0x0010000000000082, UECodeGen_Private::EPropertyGenFlags::Delegate, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventRegisterVentuzMethod_Parms, calledEvent), Z_Construct_UDelegateFunction_VentuzPlugin_VentuzEventCallback__DelegateSignature, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_calledEvent_MetaData), NewProp_calledEvent_MetaData) }; // 1297995755
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UVentuzBPFunctionLibrary_RegisterVentuzMethod_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_RegisterVentuzMethod_Statics::NewProp_node,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_RegisterVentuzMethod_Statics::NewProp_method,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_RegisterVentuzMethod_Statics::NewProp_calledEvent,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_RegisterVentuzMethod_Statics::PropPointers) < 2048);
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_RegisterVentuzMethod_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UVentuzBPFunctionLibrary, nullptr, "RegisterVentuzMethod", nullptr, nullptr, Z_Construct_UFunction_UVentuzBPFunctionLibrary_RegisterVentuzMethod_Statics::PropPointers, UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_RegisterVentuzMethod_Statics::PropPointers), sizeof(Z_Construct_UFunction_UVentuzBPFunctionLibrary_RegisterVentuzMethod_Statics::VentuzBPFunctionLibrary_eventRegisterVentuzMethod_Parms), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04022401, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_RegisterVentuzMethod_Statics::Function_MetaDataParams), Z_Construct_UFunction_UVentuzBPFunctionLibrary_RegisterVentuzMethod_Statics::Function_MetaDataParams) };
static_assert(sizeof(Z_Construct_UFunction_UVentuzBPFunctionLibrary_RegisterVentuzMethod_Statics::VentuzBPFunctionLibrary_eventRegisterVentuzMethod_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UVentuzBPFunctionLibrary_RegisterVentuzMethod()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UVentuzBPFunctionLibrary_RegisterVentuzMethod_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UVentuzBPFunctionLibrary::execRegisterVentuzMethod)
{
	P_GET_PROPERTY(FStrProperty,Z_Param_node);
	P_GET_PROPERTY(FStrProperty,Z_Param_method);
	P_GET_PROPERTY(FDelegateProperty,Z_Param_calledEvent);
	P_FINISH;
	P_NATIVE_BEGIN;
	UVentuzBPFunctionLibrary::RegisterVentuzMethod(Z_Param_node,Z_Param_method,FVentuzEventCallback(Z_Param_calledEvent));
	P_NATIVE_END;
}
// End Class UVentuzBPFunctionLibrary Function RegisterVentuzMethod

// Begin Class UVentuzBPFunctionLibrary Function SendVentuzBoolArrayByNodeName
struct Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzBoolArrayByNodeName_Statics
{
	struct VentuzBPFunctionLibrary_eventSendVentuzBoolArrayByNodeName_Parms
	{
		FString nodeName;
		FString fieldName;
		TArray<bool> value;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "BlueprintInternalUseOnly", "true" },
		{ "BlueprintType", "true" },
		{ "Category", "Ventuz" },
		{ "ModuleRelativePath", "Public/VentuzBPEvent.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_nodeName_MetaData[] = {
		{ "NativeConst", "" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_fieldName_MetaData[] = {
		{ "NativeConst", "" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_value_MetaData[] = {
		{ "NativeConst", "" },
	};
#endif // WITH_METADATA
	static const UECodeGen_Private::FStrPropertyParams NewProp_nodeName;
	static const UECodeGen_Private::FStrPropertyParams NewProp_fieldName;
	static const UECodeGen_Private::FBoolPropertyParams NewProp_value_Inner;
	static const UECodeGen_Private::FArrayPropertyParams NewProp_value;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FStrPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzBoolArrayByNodeName_Statics::NewProp_nodeName = { "nodeName", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventSendVentuzBoolArrayByNodeName_Parms, nodeName), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_nodeName_MetaData), NewProp_nodeName_MetaData) };
const UECodeGen_Private::FStrPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzBoolArrayByNodeName_Statics::NewProp_fieldName = { "fieldName", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventSendVentuzBoolArrayByNodeName_Parms, fieldName), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_fieldName_MetaData), NewProp_fieldName_MetaData) };
const UECodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzBoolArrayByNodeName_Statics::NewProp_value_Inner = { "value", nullptr, (EPropertyFlags)0x0000000000000000, UECodeGen_Private::EPropertyGenFlags::Bool | UECodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, sizeof(bool), 0, nullptr, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FArrayPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzBoolArrayByNodeName_Statics::NewProp_value = { "value", nullptr, (EPropertyFlags)0x0010000000000082, UECodeGen_Private::EPropertyGenFlags::Array, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventSendVentuzBoolArrayByNodeName_Parms, value), EArrayPropertyFlags::None, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_value_MetaData), NewProp_value_MetaData) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzBoolArrayByNodeName_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzBoolArrayByNodeName_Statics::NewProp_nodeName,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzBoolArrayByNodeName_Statics::NewProp_fieldName,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzBoolArrayByNodeName_Statics::NewProp_value_Inner,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzBoolArrayByNodeName_Statics::NewProp_value,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzBoolArrayByNodeName_Statics::PropPointers) < 2048);
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzBoolArrayByNodeName_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UVentuzBPFunctionLibrary, nullptr, "SendVentuzBoolArrayByNodeName", nullptr, nullptr, Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzBoolArrayByNodeName_Statics::PropPointers, UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzBoolArrayByNodeName_Statics::PropPointers), sizeof(Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzBoolArrayByNodeName_Statics::VentuzBPFunctionLibrary_eventSendVentuzBoolArrayByNodeName_Parms), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04022401, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzBoolArrayByNodeName_Statics::Function_MetaDataParams), Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzBoolArrayByNodeName_Statics::Function_MetaDataParams) };
static_assert(sizeof(Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzBoolArrayByNodeName_Statics::VentuzBPFunctionLibrary_eventSendVentuzBoolArrayByNodeName_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzBoolArrayByNodeName()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzBoolArrayByNodeName_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UVentuzBPFunctionLibrary::execSendVentuzBoolArrayByNodeName)
{
	P_GET_PROPERTY(FStrProperty,Z_Param_nodeName);
	P_GET_PROPERTY(FStrProperty,Z_Param_fieldName);
	P_GET_TARRAY(bool,Z_Param_value);
	P_FINISH;
	P_NATIVE_BEGIN;
	UVentuzBPFunctionLibrary::SendVentuzBoolArrayByNodeName(Z_Param_nodeName,Z_Param_fieldName,Z_Param_value);
	P_NATIVE_END;
}
// End Class UVentuzBPFunctionLibrary Function SendVentuzBoolArrayByNodeName

// Begin Class UVentuzBPFunctionLibrary Function SendVentuzBoolValueByNodeName
struct Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzBoolValueByNodeName_Statics
{
	struct VentuzBPFunctionLibrary_eventSendVentuzBoolValueByNodeName_Parms
	{
		FString nodeName;
		FString fieldName;
		bool value;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "BlueprintInternalUseOnly", "true" },
		{ "BlueprintType", "true" },
		{ "Category", "Ventuz" },
		{ "ModuleRelativePath", "Public/VentuzBPEvent.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_nodeName_MetaData[] = {
		{ "NativeConst", "" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_fieldName_MetaData[] = {
		{ "NativeConst", "" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_value_MetaData[] = {
		{ "NativeConst", "" },
	};
#endif // WITH_METADATA
	static const UECodeGen_Private::FStrPropertyParams NewProp_nodeName;
	static const UECodeGen_Private::FStrPropertyParams NewProp_fieldName;
	static void NewProp_value_SetBit(void* Obj);
	static const UECodeGen_Private::FBoolPropertyParams NewProp_value;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FStrPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzBoolValueByNodeName_Statics::NewProp_nodeName = { "nodeName", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventSendVentuzBoolValueByNodeName_Parms, nodeName), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_nodeName_MetaData), NewProp_nodeName_MetaData) };
const UECodeGen_Private::FStrPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzBoolValueByNodeName_Statics::NewProp_fieldName = { "fieldName", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventSendVentuzBoolValueByNodeName_Parms, fieldName), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_fieldName_MetaData), NewProp_fieldName_MetaData) };
void Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzBoolValueByNodeName_Statics::NewProp_value_SetBit(void* Obj)
{
	((VentuzBPFunctionLibrary_eventSendVentuzBoolValueByNodeName_Parms*)Obj)->value = 1;
}
const UECodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzBoolValueByNodeName_Statics::NewProp_value = { "value", nullptr, (EPropertyFlags)0x0010000000000082, UECodeGen_Private::EPropertyGenFlags::Bool | UECodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, sizeof(bool), sizeof(VentuzBPFunctionLibrary_eventSendVentuzBoolValueByNodeName_Parms), &Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzBoolValueByNodeName_Statics::NewProp_value_SetBit, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_value_MetaData), NewProp_value_MetaData) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzBoolValueByNodeName_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzBoolValueByNodeName_Statics::NewProp_nodeName,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzBoolValueByNodeName_Statics::NewProp_fieldName,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzBoolValueByNodeName_Statics::NewProp_value,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzBoolValueByNodeName_Statics::PropPointers) < 2048);
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzBoolValueByNodeName_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UVentuzBPFunctionLibrary, nullptr, "SendVentuzBoolValueByNodeName", nullptr, nullptr, Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzBoolValueByNodeName_Statics::PropPointers, UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzBoolValueByNodeName_Statics::PropPointers), sizeof(Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzBoolValueByNodeName_Statics::VentuzBPFunctionLibrary_eventSendVentuzBoolValueByNodeName_Parms), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04022401, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzBoolValueByNodeName_Statics::Function_MetaDataParams), Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzBoolValueByNodeName_Statics::Function_MetaDataParams) };
static_assert(sizeof(Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzBoolValueByNodeName_Statics::VentuzBPFunctionLibrary_eventSendVentuzBoolValueByNodeName_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzBoolValueByNodeName()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzBoolValueByNodeName_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UVentuzBPFunctionLibrary::execSendVentuzBoolValueByNodeName)
{
	P_GET_PROPERTY(FStrProperty,Z_Param_nodeName);
	P_GET_PROPERTY(FStrProperty,Z_Param_fieldName);
	P_GET_UBOOL(Z_Param_value);
	P_FINISH;
	P_NATIVE_BEGIN;
	UVentuzBPFunctionLibrary::SendVentuzBoolValueByNodeName(Z_Param_nodeName,Z_Param_fieldName,Z_Param_value);
	P_NATIVE_END;
}
// End Class UVentuzBPFunctionLibrary Function SendVentuzBoolValueByNodeName

// Begin Class UVentuzBPFunctionLibrary Function SendVentuzFloatArrayByNodeName
struct Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzFloatArrayByNodeName_Statics
{
	struct VentuzBPFunctionLibrary_eventSendVentuzFloatArrayByNodeName_Parms
	{
		FString nodeName;
		FString fieldName;
		TArray<float> value;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "BlueprintInternalUseOnly", "true" },
		{ "BlueprintType", "true" },
		{ "Category", "Ventuz" },
		{ "ModuleRelativePath", "Public/VentuzBPEvent.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_nodeName_MetaData[] = {
		{ "NativeConst", "" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_fieldName_MetaData[] = {
		{ "NativeConst", "" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_value_MetaData[] = {
		{ "NativeConst", "" },
	};
#endif // WITH_METADATA
	static const UECodeGen_Private::FStrPropertyParams NewProp_nodeName;
	static const UECodeGen_Private::FStrPropertyParams NewProp_fieldName;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_value_Inner;
	static const UECodeGen_Private::FArrayPropertyParams NewProp_value;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FStrPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzFloatArrayByNodeName_Statics::NewProp_nodeName = { "nodeName", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventSendVentuzFloatArrayByNodeName_Parms, nodeName), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_nodeName_MetaData), NewProp_nodeName_MetaData) };
const UECodeGen_Private::FStrPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzFloatArrayByNodeName_Statics::NewProp_fieldName = { "fieldName", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventSendVentuzFloatArrayByNodeName_Parms, fieldName), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_fieldName_MetaData), NewProp_fieldName_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzFloatArrayByNodeName_Statics::NewProp_value_Inner = { "value", nullptr, (EPropertyFlags)0x0000000000000000, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, 0, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FArrayPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzFloatArrayByNodeName_Statics::NewProp_value = { "value", nullptr, (EPropertyFlags)0x0010000000000082, UECodeGen_Private::EPropertyGenFlags::Array, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventSendVentuzFloatArrayByNodeName_Parms, value), EArrayPropertyFlags::None, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_value_MetaData), NewProp_value_MetaData) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzFloatArrayByNodeName_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzFloatArrayByNodeName_Statics::NewProp_nodeName,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzFloatArrayByNodeName_Statics::NewProp_fieldName,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzFloatArrayByNodeName_Statics::NewProp_value_Inner,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzFloatArrayByNodeName_Statics::NewProp_value,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzFloatArrayByNodeName_Statics::PropPointers) < 2048);
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzFloatArrayByNodeName_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UVentuzBPFunctionLibrary, nullptr, "SendVentuzFloatArrayByNodeName", nullptr, nullptr, Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzFloatArrayByNodeName_Statics::PropPointers, UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzFloatArrayByNodeName_Statics::PropPointers), sizeof(Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzFloatArrayByNodeName_Statics::VentuzBPFunctionLibrary_eventSendVentuzFloatArrayByNodeName_Parms), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04022401, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzFloatArrayByNodeName_Statics::Function_MetaDataParams), Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzFloatArrayByNodeName_Statics::Function_MetaDataParams) };
static_assert(sizeof(Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzFloatArrayByNodeName_Statics::VentuzBPFunctionLibrary_eventSendVentuzFloatArrayByNodeName_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzFloatArrayByNodeName()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzFloatArrayByNodeName_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UVentuzBPFunctionLibrary::execSendVentuzFloatArrayByNodeName)
{
	P_GET_PROPERTY(FStrProperty,Z_Param_nodeName);
	P_GET_PROPERTY(FStrProperty,Z_Param_fieldName);
	P_GET_TARRAY(float,Z_Param_value);
	P_FINISH;
	P_NATIVE_BEGIN;
	UVentuzBPFunctionLibrary::SendVentuzFloatArrayByNodeName(Z_Param_nodeName,Z_Param_fieldName,Z_Param_value);
	P_NATIVE_END;
}
// End Class UVentuzBPFunctionLibrary Function SendVentuzFloatArrayByNodeName

// Begin Class UVentuzBPFunctionLibrary Function SendVentuzFloatValueByNodeName
struct Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzFloatValueByNodeName_Statics
{
	struct VentuzBPFunctionLibrary_eventSendVentuzFloatValueByNodeName_Parms
	{
		FString nodeName;
		FString fieldName;
		float value;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "BlueprintInternalUseOnly", "true" },
		{ "BlueprintType", "true" },
		{ "Category", "Ventuz" },
		{ "ModuleRelativePath", "Public/VentuzBPEvent.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_nodeName_MetaData[] = {
		{ "NativeConst", "" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_fieldName_MetaData[] = {
		{ "NativeConst", "" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_value_MetaData[] = {
		{ "NativeConst", "" },
	};
#endif // WITH_METADATA
	static const UECodeGen_Private::FStrPropertyParams NewProp_nodeName;
	static const UECodeGen_Private::FStrPropertyParams NewProp_fieldName;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_value;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FStrPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzFloatValueByNodeName_Statics::NewProp_nodeName = { "nodeName", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventSendVentuzFloatValueByNodeName_Parms, nodeName), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_nodeName_MetaData), NewProp_nodeName_MetaData) };
const UECodeGen_Private::FStrPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzFloatValueByNodeName_Statics::NewProp_fieldName = { "fieldName", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventSendVentuzFloatValueByNodeName_Parms, fieldName), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_fieldName_MetaData), NewProp_fieldName_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzFloatValueByNodeName_Statics::NewProp_value = { "value", nullptr, (EPropertyFlags)0x0010000000000082, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventSendVentuzFloatValueByNodeName_Parms, value), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_value_MetaData), NewProp_value_MetaData) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzFloatValueByNodeName_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzFloatValueByNodeName_Statics::NewProp_nodeName,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzFloatValueByNodeName_Statics::NewProp_fieldName,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzFloatValueByNodeName_Statics::NewProp_value,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzFloatValueByNodeName_Statics::PropPointers) < 2048);
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzFloatValueByNodeName_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UVentuzBPFunctionLibrary, nullptr, "SendVentuzFloatValueByNodeName", nullptr, nullptr, Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzFloatValueByNodeName_Statics::PropPointers, UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzFloatValueByNodeName_Statics::PropPointers), sizeof(Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzFloatValueByNodeName_Statics::VentuzBPFunctionLibrary_eventSendVentuzFloatValueByNodeName_Parms), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04022401, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzFloatValueByNodeName_Statics::Function_MetaDataParams), Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzFloatValueByNodeName_Statics::Function_MetaDataParams) };
static_assert(sizeof(Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzFloatValueByNodeName_Statics::VentuzBPFunctionLibrary_eventSendVentuzFloatValueByNodeName_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzFloatValueByNodeName()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzFloatValueByNodeName_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UVentuzBPFunctionLibrary::execSendVentuzFloatValueByNodeName)
{
	P_GET_PROPERTY(FStrProperty,Z_Param_nodeName);
	P_GET_PROPERTY(FStrProperty,Z_Param_fieldName);
	P_GET_PROPERTY(FFloatProperty,Z_Param_value);
	P_FINISH;
	P_NATIVE_BEGIN;
	UVentuzBPFunctionLibrary::SendVentuzFloatValueByNodeName(Z_Param_nodeName,Z_Param_fieldName,Z_Param_value);
	P_NATIVE_END;
}
// End Class UVentuzBPFunctionLibrary Function SendVentuzFloatValueByNodeName

// Begin Class UVentuzBPFunctionLibrary Function SendVentuzIntArrayByNodeName
struct Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzIntArrayByNodeName_Statics
{
	struct VentuzBPFunctionLibrary_eventSendVentuzIntArrayByNodeName_Parms
	{
		FString nodeName;
		FString fieldName;
		TArray<int32> value;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "BlueprintInternalUseOnly", "true" },
		{ "BlueprintType", "true" },
		{ "Category", "Ventuz" },
		{ "ModuleRelativePath", "Public/VentuzBPEvent.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_nodeName_MetaData[] = {
		{ "NativeConst", "" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_fieldName_MetaData[] = {
		{ "NativeConst", "" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_value_MetaData[] = {
		{ "NativeConst", "" },
	};
#endif // WITH_METADATA
	static const UECodeGen_Private::FStrPropertyParams NewProp_nodeName;
	static const UECodeGen_Private::FStrPropertyParams NewProp_fieldName;
	static const UECodeGen_Private::FIntPropertyParams NewProp_value_Inner;
	static const UECodeGen_Private::FArrayPropertyParams NewProp_value;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FStrPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzIntArrayByNodeName_Statics::NewProp_nodeName = { "nodeName", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventSendVentuzIntArrayByNodeName_Parms, nodeName), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_nodeName_MetaData), NewProp_nodeName_MetaData) };
const UECodeGen_Private::FStrPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzIntArrayByNodeName_Statics::NewProp_fieldName = { "fieldName", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventSendVentuzIntArrayByNodeName_Parms, fieldName), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_fieldName_MetaData), NewProp_fieldName_MetaData) };
const UECodeGen_Private::FIntPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzIntArrayByNodeName_Statics::NewProp_value_Inner = { "value", nullptr, (EPropertyFlags)0x0000000000000000, UECodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, 0, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FArrayPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzIntArrayByNodeName_Statics::NewProp_value = { "value", nullptr, (EPropertyFlags)0x0010000000000082, UECodeGen_Private::EPropertyGenFlags::Array, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventSendVentuzIntArrayByNodeName_Parms, value), EArrayPropertyFlags::None, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_value_MetaData), NewProp_value_MetaData) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzIntArrayByNodeName_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzIntArrayByNodeName_Statics::NewProp_nodeName,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzIntArrayByNodeName_Statics::NewProp_fieldName,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzIntArrayByNodeName_Statics::NewProp_value_Inner,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzIntArrayByNodeName_Statics::NewProp_value,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzIntArrayByNodeName_Statics::PropPointers) < 2048);
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzIntArrayByNodeName_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UVentuzBPFunctionLibrary, nullptr, "SendVentuzIntArrayByNodeName", nullptr, nullptr, Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzIntArrayByNodeName_Statics::PropPointers, UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzIntArrayByNodeName_Statics::PropPointers), sizeof(Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzIntArrayByNodeName_Statics::VentuzBPFunctionLibrary_eventSendVentuzIntArrayByNodeName_Parms), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04022401, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzIntArrayByNodeName_Statics::Function_MetaDataParams), Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzIntArrayByNodeName_Statics::Function_MetaDataParams) };
static_assert(sizeof(Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzIntArrayByNodeName_Statics::VentuzBPFunctionLibrary_eventSendVentuzIntArrayByNodeName_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzIntArrayByNodeName()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzIntArrayByNodeName_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UVentuzBPFunctionLibrary::execSendVentuzIntArrayByNodeName)
{
	P_GET_PROPERTY(FStrProperty,Z_Param_nodeName);
	P_GET_PROPERTY(FStrProperty,Z_Param_fieldName);
	P_GET_TARRAY(int32,Z_Param_value);
	P_FINISH;
	P_NATIVE_BEGIN;
	UVentuzBPFunctionLibrary::SendVentuzIntArrayByNodeName(Z_Param_nodeName,Z_Param_fieldName,Z_Param_value);
	P_NATIVE_END;
}
// End Class UVentuzBPFunctionLibrary Function SendVentuzIntArrayByNodeName

// Begin Class UVentuzBPFunctionLibrary Function SendVentuzIntValueByNodeName
struct Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzIntValueByNodeName_Statics
{
	struct VentuzBPFunctionLibrary_eventSendVentuzIntValueByNodeName_Parms
	{
		FString nodeName;
		FString fieldName;
		int32 value;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "BlueprintInternalUseOnly", "true" },
		{ "BlueprintType", "true" },
		{ "Category", "Ventuz" },
		{ "ModuleRelativePath", "Public/VentuzBPEvent.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_nodeName_MetaData[] = {
		{ "NativeConst", "" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_fieldName_MetaData[] = {
		{ "NativeConst", "" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_value_MetaData[] = {
		{ "NativeConst", "" },
	};
#endif // WITH_METADATA
	static const UECodeGen_Private::FStrPropertyParams NewProp_nodeName;
	static const UECodeGen_Private::FStrPropertyParams NewProp_fieldName;
	static const UECodeGen_Private::FIntPropertyParams NewProp_value;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FStrPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzIntValueByNodeName_Statics::NewProp_nodeName = { "nodeName", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventSendVentuzIntValueByNodeName_Parms, nodeName), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_nodeName_MetaData), NewProp_nodeName_MetaData) };
const UECodeGen_Private::FStrPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzIntValueByNodeName_Statics::NewProp_fieldName = { "fieldName", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventSendVentuzIntValueByNodeName_Parms, fieldName), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_fieldName_MetaData), NewProp_fieldName_MetaData) };
const UECodeGen_Private::FIntPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzIntValueByNodeName_Statics::NewProp_value = { "value", nullptr, (EPropertyFlags)0x0010000000000082, UECodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventSendVentuzIntValueByNodeName_Parms, value), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_value_MetaData), NewProp_value_MetaData) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzIntValueByNodeName_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzIntValueByNodeName_Statics::NewProp_nodeName,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzIntValueByNodeName_Statics::NewProp_fieldName,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzIntValueByNodeName_Statics::NewProp_value,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzIntValueByNodeName_Statics::PropPointers) < 2048);
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzIntValueByNodeName_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UVentuzBPFunctionLibrary, nullptr, "SendVentuzIntValueByNodeName", nullptr, nullptr, Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzIntValueByNodeName_Statics::PropPointers, UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzIntValueByNodeName_Statics::PropPointers), sizeof(Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzIntValueByNodeName_Statics::VentuzBPFunctionLibrary_eventSendVentuzIntValueByNodeName_Parms), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04022401, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzIntValueByNodeName_Statics::Function_MetaDataParams), Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzIntValueByNodeName_Statics::Function_MetaDataParams) };
static_assert(sizeof(Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzIntValueByNodeName_Statics::VentuzBPFunctionLibrary_eventSendVentuzIntValueByNodeName_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzIntValueByNodeName()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzIntValueByNodeName_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UVentuzBPFunctionLibrary::execSendVentuzIntValueByNodeName)
{
	P_GET_PROPERTY(FStrProperty,Z_Param_nodeName);
	P_GET_PROPERTY(FStrProperty,Z_Param_fieldName);
	P_GET_PROPERTY(FIntProperty,Z_Param_value);
	P_FINISH;
	P_NATIVE_BEGIN;
	UVentuzBPFunctionLibrary::SendVentuzIntValueByNodeName(Z_Param_nodeName,Z_Param_fieldName,Z_Param_value);
	P_NATIVE_END;
}
// End Class UVentuzBPFunctionLibrary Function SendVentuzIntValueByNodeName

// Begin Class UVentuzBPFunctionLibrary Function SendVentuzStringArrayByNodeName
struct Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzStringArrayByNodeName_Statics
{
	struct VentuzBPFunctionLibrary_eventSendVentuzStringArrayByNodeName_Parms
	{
		FString nodeName;
		FString fieldName;
		TArray<FString> value;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "BlueprintInternalUseOnly", "true" },
		{ "BlueprintType", "true" },
		{ "Category", "Ventuz" },
		{ "ModuleRelativePath", "Public/VentuzBPEvent.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_nodeName_MetaData[] = {
		{ "NativeConst", "" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_fieldName_MetaData[] = {
		{ "NativeConst", "" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_value_MetaData[] = {
		{ "NativeConst", "" },
	};
#endif // WITH_METADATA
	static const UECodeGen_Private::FStrPropertyParams NewProp_nodeName;
	static const UECodeGen_Private::FStrPropertyParams NewProp_fieldName;
	static const UECodeGen_Private::FStrPropertyParams NewProp_value_Inner;
	static const UECodeGen_Private::FArrayPropertyParams NewProp_value;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FStrPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzStringArrayByNodeName_Statics::NewProp_nodeName = { "nodeName", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventSendVentuzStringArrayByNodeName_Parms, nodeName), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_nodeName_MetaData), NewProp_nodeName_MetaData) };
const UECodeGen_Private::FStrPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzStringArrayByNodeName_Statics::NewProp_fieldName = { "fieldName", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventSendVentuzStringArrayByNodeName_Parms, fieldName), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_fieldName_MetaData), NewProp_fieldName_MetaData) };
const UECodeGen_Private::FStrPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzStringArrayByNodeName_Statics::NewProp_value_Inner = { "value", nullptr, (EPropertyFlags)0x0000000000000000, UECodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, 0, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FArrayPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzStringArrayByNodeName_Statics::NewProp_value = { "value", nullptr, (EPropertyFlags)0x0010000000000082, UECodeGen_Private::EPropertyGenFlags::Array, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventSendVentuzStringArrayByNodeName_Parms, value), EArrayPropertyFlags::None, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_value_MetaData), NewProp_value_MetaData) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzStringArrayByNodeName_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzStringArrayByNodeName_Statics::NewProp_nodeName,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzStringArrayByNodeName_Statics::NewProp_fieldName,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzStringArrayByNodeName_Statics::NewProp_value_Inner,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzStringArrayByNodeName_Statics::NewProp_value,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzStringArrayByNodeName_Statics::PropPointers) < 2048);
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzStringArrayByNodeName_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UVentuzBPFunctionLibrary, nullptr, "SendVentuzStringArrayByNodeName", nullptr, nullptr, Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzStringArrayByNodeName_Statics::PropPointers, UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzStringArrayByNodeName_Statics::PropPointers), sizeof(Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzStringArrayByNodeName_Statics::VentuzBPFunctionLibrary_eventSendVentuzStringArrayByNodeName_Parms), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04022401, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzStringArrayByNodeName_Statics::Function_MetaDataParams), Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzStringArrayByNodeName_Statics::Function_MetaDataParams) };
static_assert(sizeof(Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzStringArrayByNodeName_Statics::VentuzBPFunctionLibrary_eventSendVentuzStringArrayByNodeName_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzStringArrayByNodeName()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzStringArrayByNodeName_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UVentuzBPFunctionLibrary::execSendVentuzStringArrayByNodeName)
{
	P_GET_PROPERTY(FStrProperty,Z_Param_nodeName);
	P_GET_PROPERTY(FStrProperty,Z_Param_fieldName);
	P_GET_TARRAY(FString,Z_Param_value);
	P_FINISH;
	P_NATIVE_BEGIN;
	UVentuzBPFunctionLibrary::SendVentuzStringArrayByNodeName(Z_Param_nodeName,Z_Param_fieldName,Z_Param_value);
	P_NATIVE_END;
}
// End Class UVentuzBPFunctionLibrary Function SendVentuzStringArrayByNodeName

// Begin Class UVentuzBPFunctionLibrary Function SendVentuzStringValueByNodeName
struct Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzStringValueByNodeName_Statics
{
	struct VentuzBPFunctionLibrary_eventSendVentuzStringValueByNodeName_Parms
	{
		FString nodeName;
		FString fieldName;
		FString value;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "BlueprintInternalUseOnly", "true" },
		{ "BlueprintType", "true" },
		{ "Category", "Ventuz" },
		{ "ModuleRelativePath", "Public/VentuzBPEvent.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_nodeName_MetaData[] = {
		{ "NativeConst", "" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_fieldName_MetaData[] = {
		{ "NativeConst", "" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_value_MetaData[] = {
		{ "NativeConst", "" },
	};
#endif // WITH_METADATA
	static const UECodeGen_Private::FStrPropertyParams NewProp_nodeName;
	static const UECodeGen_Private::FStrPropertyParams NewProp_fieldName;
	static const UECodeGen_Private::FStrPropertyParams NewProp_value;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FStrPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzStringValueByNodeName_Statics::NewProp_nodeName = { "nodeName", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventSendVentuzStringValueByNodeName_Parms, nodeName), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_nodeName_MetaData), NewProp_nodeName_MetaData) };
const UECodeGen_Private::FStrPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzStringValueByNodeName_Statics::NewProp_fieldName = { "fieldName", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventSendVentuzStringValueByNodeName_Parms, fieldName), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_fieldName_MetaData), NewProp_fieldName_MetaData) };
const UECodeGen_Private::FStrPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzStringValueByNodeName_Statics::NewProp_value = { "value", nullptr, (EPropertyFlags)0x0010000000000082, UECodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventSendVentuzStringValueByNodeName_Parms, value), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_value_MetaData), NewProp_value_MetaData) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzStringValueByNodeName_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzStringValueByNodeName_Statics::NewProp_nodeName,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzStringValueByNodeName_Statics::NewProp_fieldName,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzStringValueByNodeName_Statics::NewProp_value,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzStringValueByNodeName_Statics::PropPointers) < 2048);
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzStringValueByNodeName_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UVentuzBPFunctionLibrary, nullptr, "SendVentuzStringValueByNodeName", nullptr, nullptr, Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzStringValueByNodeName_Statics::PropPointers, UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzStringValueByNodeName_Statics::PropPointers), sizeof(Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzStringValueByNodeName_Statics::VentuzBPFunctionLibrary_eventSendVentuzStringValueByNodeName_Parms), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04022401, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzStringValueByNodeName_Statics::Function_MetaDataParams), Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzStringValueByNodeName_Statics::Function_MetaDataParams) };
static_assert(sizeof(Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzStringValueByNodeName_Statics::VentuzBPFunctionLibrary_eventSendVentuzStringValueByNodeName_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzStringValueByNodeName()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzStringValueByNodeName_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UVentuzBPFunctionLibrary::execSendVentuzStringValueByNodeName)
{
	P_GET_PROPERTY(FStrProperty,Z_Param_nodeName);
	P_GET_PROPERTY(FStrProperty,Z_Param_fieldName);
	P_GET_PROPERTY(FStrProperty,Z_Param_value);
	P_FINISH;
	P_NATIVE_BEGIN;
	UVentuzBPFunctionLibrary::SendVentuzStringValueByNodeName(Z_Param_nodeName,Z_Param_fieldName,Z_Param_value);
	P_NATIVE_END;
}
// End Class UVentuzBPFunctionLibrary Function SendVentuzStringValueByNodeName

// Begin Class UVentuzBPFunctionLibrary Function SendVentuzTransformValue
struct Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzTransformValue_Statics
{
	struct VentuzBPFunctionLibrary_eventSendVentuzTransformValue_Parms
	{
		FString valueName;
		FTransform value;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Category", "Ventuz" },
		{ "Comment", "/**\n     * Send a Transform value to the named Ventuz Axis Unreal node\n     *\n     * @param\x09valueName  The name of the node to send to on the Ventuz side\n     * @param\x09value\x09The transform to send to Ventuz, given in the Unreal coordinate system (conversion to Ventuz coordinates is done automatically)\n     */" },
		{ "ModuleRelativePath", "Public/VentuzBPEvent.h" },
		{ "ToolTip", "Send a Transform value to the named Ventuz Axis Unreal node\n\n@param  valueName  The name of the node to send to on the Ventuz side\n@param  value   The transform to send to Ventuz, given in the Unreal coordinate system (conversion to Ventuz coordinates is done automatically)" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_valueName_MetaData[] = {
		{ "NativeConst", "" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_value_MetaData[] = {
		{ "NativeConst", "" },
	};
#endif // WITH_METADATA
	static const UECodeGen_Private::FStrPropertyParams NewProp_valueName;
	static const UECodeGen_Private::FStructPropertyParams NewProp_value;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FStrPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzTransformValue_Statics::NewProp_valueName = { "valueName", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventSendVentuzTransformValue_Parms, valueName), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_valueName_MetaData), NewProp_valueName_MetaData) };
const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzTransformValue_Statics::NewProp_value = { "value", nullptr, (EPropertyFlags)0x0010000008000182, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventSendVentuzTransformValue_Parms, value), Z_Construct_UScriptStruct_FTransform, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_value_MetaData), NewProp_value_MetaData) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzTransformValue_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzTransformValue_Statics::NewProp_valueName,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzTransformValue_Statics::NewProp_value,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzTransformValue_Statics::PropPointers) < 2048);
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzTransformValue_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UVentuzBPFunctionLibrary, nullptr, "SendVentuzTransformValue", nullptr, nullptr, Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzTransformValue_Statics::PropPointers, UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzTransformValue_Statics::PropPointers), sizeof(Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzTransformValue_Statics::VentuzBPFunctionLibrary_eventSendVentuzTransformValue_Parms), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04C22401, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzTransformValue_Statics::Function_MetaDataParams), Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzTransformValue_Statics::Function_MetaDataParams) };
static_assert(sizeof(Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzTransformValue_Statics::VentuzBPFunctionLibrary_eventSendVentuzTransformValue_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzTransformValue()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzTransformValue_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UVentuzBPFunctionLibrary::execSendVentuzTransformValue)
{
	P_GET_PROPERTY(FStrProperty,Z_Param_valueName);
	P_GET_STRUCT_REF(FTransform,Z_Param_Out_value);
	P_FINISH;
	P_NATIVE_BEGIN;
	UVentuzBPFunctionLibrary::SendVentuzTransformValue(Z_Param_valueName,Z_Param_Out_value);
	P_NATIVE_END;
}
// End Class UVentuzBPFunctionLibrary Function SendVentuzTransformValue

// Begin Class UVentuzBPFunctionLibrary Function TriggerVentuzEvent
struct Z_Construct_UFunction_UVentuzBPFunctionLibrary_TriggerVentuzEvent_Statics
{
	struct VentuzBPFunctionLibrary_eventTriggerVentuzEvent_Parms
	{
		FString node;
		FString event;
		int32 argument;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Category", "Ventuz" },
		{ "Comment", "/**\n     * Trigger an event in Ventuz\n     *\n     * @param\x09""eventName   The name of the event to trigger in Ventuz\n     * @param\x09""argument    The argument of the event\n     */" },
		{ "ModuleRelativePath", "Public/VentuzBPEvent.h" },
		{ "ToolTip", "Trigger an event in Ventuz\n\n@param  eventName   The name of the event to trigger in Ventuz\n@param  argument    The argument of the event" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_node_MetaData[] = {
		{ "NativeConst", "" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_event_MetaData[] = {
		{ "NativeConst", "" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_argument_MetaData[] = {
		{ "NativeConst", "" },
	};
#endif // WITH_METADATA
	static const UECodeGen_Private::FStrPropertyParams NewProp_node;
	static const UECodeGen_Private::FStrPropertyParams NewProp_event;
	static const UECodeGen_Private::FIntPropertyParams NewProp_argument;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FStrPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_TriggerVentuzEvent_Statics::NewProp_node = { "node", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventTriggerVentuzEvent_Parms, node), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_node_MetaData), NewProp_node_MetaData) };
const UECodeGen_Private::FStrPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_TriggerVentuzEvent_Statics::NewProp_event = { "event", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventTriggerVentuzEvent_Parms, event), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_event_MetaData), NewProp_event_MetaData) };
const UECodeGen_Private::FIntPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_TriggerVentuzEvent_Statics::NewProp_argument = { "argument", nullptr, (EPropertyFlags)0x0010000000000082, UECodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventTriggerVentuzEvent_Parms, argument), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_argument_MetaData), NewProp_argument_MetaData) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UVentuzBPFunctionLibrary_TriggerVentuzEvent_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_TriggerVentuzEvent_Statics::NewProp_node,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_TriggerVentuzEvent_Statics::NewProp_event,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_TriggerVentuzEvent_Statics::NewProp_argument,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_TriggerVentuzEvent_Statics::PropPointers) < 2048);
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_TriggerVentuzEvent_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UVentuzBPFunctionLibrary, nullptr, "TriggerVentuzEvent", nullptr, nullptr, Z_Construct_UFunction_UVentuzBPFunctionLibrary_TriggerVentuzEvent_Statics::PropPointers, UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_TriggerVentuzEvent_Statics::PropPointers), sizeof(Z_Construct_UFunction_UVentuzBPFunctionLibrary_TriggerVentuzEvent_Statics::VentuzBPFunctionLibrary_eventTriggerVentuzEvent_Parms), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04022401, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_TriggerVentuzEvent_Statics::Function_MetaDataParams), Z_Construct_UFunction_UVentuzBPFunctionLibrary_TriggerVentuzEvent_Statics::Function_MetaDataParams) };
static_assert(sizeof(Z_Construct_UFunction_UVentuzBPFunctionLibrary_TriggerVentuzEvent_Statics::VentuzBPFunctionLibrary_eventTriggerVentuzEvent_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UVentuzBPFunctionLibrary_TriggerVentuzEvent()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UVentuzBPFunctionLibrary_TriggerVentuzEvent_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UVentuzBPFunctionLibrary::execTriggerVentuzEvent)
{
	P_GET_PROPERTY(FStrProperty,Z_Param_node);
	P_GET_PROPERTY(FStrProperty,Z_Param_event);
	P_GET_PROPERTY(FIntProperty,Z_Param_argument);
	P_FINISH;
	P_NATIVE_BEGIN;
	UVentuzBPFunctionLibrary::TriggerVentuzEvent(Z_Param_node,Z_Param_event,Z_Param_argument);
	P_NATIVE_END;
}
// End Class UVentuzBPFunctionLibrary Function TriggerVentuzEvent

// Begin Class UVentuzBPFunctionLibrary Function UE4_ToVentuzPosition
struct Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzPosition_Statics
{
	struct VentuzBPFunctionLibrary_eventUE4_ToVentuzPosition_Parms
	{
		FVector position;
		FVector ReturnValue;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Category", "Ventuz" },
		{ "Comment", "/**\n     * Convert a position vector from the Unreal coordinate system to the Ventuz coordinate system\n     *\n     * @param\x09position\x09The position vector to convert in Unreal coordinates\n     * @return\x09The result position in Ventuz coordinates\n     */" },
		{ "DisplayName", "Unreal to Ventuz Position" },
		{ "ModuleRelativePath", "Public/VentuzBPEvent.h" },
		{ "ToolTip", "Convert a position vector from the Unreal coordinate system to the Ventuz coordinate system\n\n@param  position        The position vector to convert in Unreal coordinates\n@return The result position in Ventuz coordinates" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_position_MetaData[] = {
		{ "NativeConst", "" },
	};
#endif // WITH_METADATA
	static const UECodeGen_Private::FStructPropertyParams NewProp_position;
	static const UECodeGen_Private::FStructPropertyParams NewProp_ReturnValue;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzPosition_Statics::NewProp_position = { "position", nullptr, (EPropertyFlags)0x0010000008000182, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventUE4_ToVentuzPosition_Parms, position), Z_Construct_UScriptStruct_FVector, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_position_MetaData), NewProp_position_MetaData) };
const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzPosition_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventUE4_ToVentuzPosition_Parms, ReturnValue), Z_Construct_UScriptStruct_FVector, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzPosition_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzPosition_Statics::NewProp_position,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzPosition_Statics::NewProp_ReturnValue,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzPosition_Statics::PropPointers) < 2048);
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzPosition_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UVentuzBPFunctionLibrary, nullptr, "UE4_ToVentuzPosition", nullptr, nullptr, Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzPosition_Statics::PropPointers, UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzPosition_Statics::PropPointers), sizeof(Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzPosition_Statics::VentuzBPFunctionLibrary_eventUE4_ToVentuzPosition_Parms), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x14C22401, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzPosition_Statics::Function_MetaDataParams), Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzPosition_Statics::Function_MetaDataParams) };
static_assert(sizeof(Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzPosition_Statics::VentuzBPFunctionLibrary_eventUE4_ToVentuzPosition_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzPosition()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzPosition_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UVentuzBPFunctionLibrary::execUE4_ToVentuzPosition)
{
	P_GET_STRUCT_REF(FVector,Z_Param_Out_position);
	P_FINISH;
	P_NATIVE_BEGIN;
	*(FVector*)Z_Param__Result=UVentuzBPFunctionLibrary::UE4_ToVentuzPosition(Z_Param_Out_position);
	P_NATIVE_END;
}
// End Class UVentuzBPFunctionLibrary Function UE4_ToVentuzPosition

// Begin Class UVentuzBPFunctionLibrary Function UE4_ToVentuzRotation
struct Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzRotation_Statics
{
	struct VentuzBPFunctionLibrary_eventUE4_ToVentuzRotation_Parms
	{
		FRotator rotation;
		LimitedEulerRotationOrder ventuzRotationOrder;
		FVector ReturnValue;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Category", "Ventuz" },
		{ "Comment", "/**\n     * Convert a Unreal rotator to Ventuz coordinate system Euler angle values\n     * WARNING: this node is currently limited to the XYZ Ventuz Euler angle rotation order\n     *\n     * @param\x09rotation\x09The input rotator in the Unreal coordinate system\n     * @param\x09ventuzRotationOrder\x09The Ventuz rotation order in which to apply the rotation values (Limited to XYZ for this node currently)\n     * @return\x09The result rotation values in Ventuz coordinates\n     */" },
		{ "CPP_Default_ventuzRotationOrder", "XYZ" },
		{ "DisplayName", "Unreal to Ventuz Rotation" },
		{ "ModuleRelativePath", "Public/VentuzBPEvent.h" },
		{ "ToolTip", "Convert a Unreal rotator to Ventuz coordinate system Euler angle values\nWARNING: this node is currently limited to the XYZ Ventuz Euler angle rotation order\n\n@param  rotation        The input rotator in the Unreal coordinate system\n@param  ventuzRotationOrder     The Ventuz rotation order in which to apply the rotation values (Limited to XYZ for this node currently)\n@return The result rotation values in Ventuz coordinates" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_rotation_MetaData[] = {
		{ "NativeConst", "" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_ventuzRotationOrder_MetaData[] = {
		{ "NativeConst", "" },
	};
#endif // WITH_METADATA
	static const UECodeGen_Private::FStructPropertyParams NewProp_rotation;
	static const UECodeGen_Private::FBytePropertyParams NewProp_ventuzRotationOrder_Underlying;
	static const UECodeGen_Private::FEnumPropertyParams NewProp_ventuzRotationOrder;
	static const UECodeGen_Private::FStructPropertyParams NewProp_ReturnValue;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzRotation_Statics::NewProp_rotation = { "rotation", nullptr, (EPropertyFlags)0x0010000008000182, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventUE4_ToVentuzRotation_Parms, rotation), Z_Construct_UScriptStruct_FRotator, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_rotation_MetaData), NewProp_rotation_MetaData) };
const UECodeGen_Private::FBytePropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzRotation_Statics::NewProp_ventuzRotationOrder_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UECodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, 0, nullptr, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FEnumPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzRotation_Statics::NewProp_ventuzRotationOrder = { "ventuzRotationOrder", nullptr, (EPropertyFlags)0x0010000000000082, UECodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventUE4_ToVentuzRotation_Parms, ventuzRotationOrder), Z_Construct_UEnum_VentuzPlugin_LimitedEulerRotationOrder, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_ventuzRotationOrder_MetaData), NewProp_ventuzRotationOrder_MetaData) }; // 3996442786
const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzRotation_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventUE4_ToVentuzRotation_Parms, ReturnValue), Z_Construct_UScriptStruct_FVector, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzRotation_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzRotation_Statics::NewProp_rotation,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzRotation_Statics::NewProp_ventuzRotationOrder_Underlying,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzRotation_Statics::NewProp_ventuzRotationOrder,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzRotation_Statics::NewProp_ReturnValue,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzRotation_Statics::PropPointers) < 2048);
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzRotation_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UVentuzBPFunctionLibrary, nullptr, "UE4_ToVentuzRotation", nullptr, nullptr, Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzRotation_Statics::PropPointers, UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzRotation_Statics::PropPointers), sizeof(Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzRotation_Statics::VentuzBPFunctionLibrary_eventUE4_ToVentuzRotation_Parms), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x14C22401, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzRotation_Statics::Function_MetaDataParams), Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzRotation_Statics::Function_MetaDataParams) };
static_assert(sizeof(Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzRotation_Statics::VentuzBPFunctionLibrary_eventUE4_ToVentuzRotation_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzRotation()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzRotation_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UVentuzBPFunctionLibrary::execUE4_ToVentuzRotation)
{
	P_GET_STRUCT_REF(FRotator,Z_Param_Out_rotation);
	P_GET_ENUM(LimitedEulerRotationOrder,Z_Param_ventuzRotationOrder);
	P_FINISH;
	P_NATIVE_BEGIN;
	*(FVector*)Z_Param__Result=UVentuzBPFunctionLibrary::UE4_ToVentuzRotation(Z_Param_Out_rotation,LimitedEulerRotationOrder(Z_Param_ventuzRotationOrder));
	P_NATIVE_END;
}
// End Class UVentuzBPFunctionLibrary Function UE4_ToVentuzRotation

// Begin Class UVentuzBPFunctionLibrary Function UE4_ToVentuzScale
struct Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzScale_Statics
{
	struct VentuzBPFunctionLibrary_eventUE4_ToVentuzScale_Parms
	{
		FVector scale;
		FVector ReturnValue;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Category", "Ventuz" },
		{ "Comment", "/**\n     * Convert a scaling vector from the Unreal coordinate system to the Ventuz coordinate system\n     *\n     * @param\x09scale\x09The scaling vector to convert in Unreal coordinates\n     * @return\x09The result scaling vector in Ventuz coordinates\n     */" },
		{ "DisplayName", "Unreal to Ventuz Scale" },
		{ "ModuleRelativePath", "Public/VentuzBPEvent.h" },
		{ "ToolTip", "Convert a scaling vector from the Unreal coordinate system to the Ventuz coordinate system\n\n@param  scale   The scaling vector to convert in Unreal coordinates\n@return The result scaling vector in Ventuz coordinates" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_scale_MetaData[] = {
		{ "NativeConst", "" },
	};
#endif // WITH_METADATA
	static const UECodeGen_Private::FStructPropertyParams NewProp_scale;
	static const UECodeGen_Private::FStructPropertyParams NewProp_ReturnValue;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzScale_Statics::NewProp_scale = { "scale", nullptr, (EPropertyFlags)0x0010000008000182, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventUE4_ToVentuzScale_Parms, scale), Z_Construct_UScriptStruct_FVector, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_scale_MetaData), NewProp_scale_MetaData) };
const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzScale_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventUE4_ToVentuzScale_Parms, ReturnValue), Z_Construct_UScriptStruct_FVector, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzScale_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzScale_Statics::NewProp_scale,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzScale_Statics::NewProp_ReturnValue,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzScale_Statics::PropPointers) < 2048);
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzScale_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UVentuzBPFunctionLibrary, nullptr, "UE4_ToVentuzScale", nullptr, nullptr, Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzScale_Statics::PropPointers, UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzScale_Statics::PropPointers), sizeof(Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzScale_Statics::VentuzBPFunctionLibrary_eventUE4_ToVentuzScale_Parms), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x14C22401, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzScale_Statics::Function_MetaDataParams), Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzScale_Statics::Function_MetaDataParams) };
static_assert(sizeof(Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzScale_Statics::VentuzBPFunctionLibrary_eventUE4_ToVentuzScale_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzScale()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzScale_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UVentuzBPFunctionLibrary::execUE4_ToVentuzScale)
{
	P_GET_STRUCT_REF(FVector,Z_Param_Out_scale);
	P_FINISH;
	P_NATIVE_BEGIN;
	*(FVector*)Z_Param__Result=UVentuzBPFunctionLibrary::UE4_ToVentuzScale(Z_Param_Out_scale);
	P_NATIVE_END;
}
// End Class UVentuzBPFunctionLibrary Function UE4_ToVentuzScale

// Begin Class UVentuzBPFunctionLibrary Function UE4_ToVentuzTransform
struct Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzTransform_Statics
{
	struct VentuzBPFunctionLibrary_eventUE4_ToVentuzTransform_Parms
	{
		FTransform transform;
		FVector position;
		FVector rotation;
		FVector scale;
		LimitedEulerRotationOrder ventuzRotationOrder;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Category", "Ventuz" },
		{ "Comment", "/**\n     * Convert a Unreal Transform to the Ventuz coordinate system \n     * WARNING: this node is currently limited to the XYZ Ventuz Euler angle rotation order\n     *\n     * @param\x09transform\x09The input transform in the Unreal coordinate system\n     * @param\x09position\x09The resulting position in Ventuz coordinates\n     * @param\x09rotation\x09The resulting Euler angle rotation values in the Ventuz coordinate system\n     * @param\x09ventuzRotationOrder\x09The Ventuz rotation order in which to apply the rotation values (Limited to XYZ for this node currently)\n     * @param\x09scale\x09The resulting scale values in Ventuz coordinates\n     */" },
		{ "CPP_Default_ventuzRotationOrder", "XYZ" },
		{ "DisplayName", "Unreal to Ventuz Transform" },
		{ "ModuleRelativePath", "Public/VentuzBPEvent.h" },
		{ "ToolTip", "Convert a Unreal Transform to the Ventuz coordinate system\nWARNING: this node is currently limited to the XYZ Ventuz Euler angle rotation order\n\n@param  transform       The input transform in the Unreal coordinate system\n@param  position        The resulting position in Ventuz coordinates\n@param  rotation        The resulting Euler angle rotation values in the Ventuz coordinate system\n@param  ventuzRotationOrder     The Ventuz rotation order in which to apply the rotation values (Limited to XYZ for this node currently)\n@param  scale   The resulting scale values in Ventuz coordinates" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_transform_MetaData[] = {
		{ "NativeConst", "" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_ventuzRotationOrder_MetaData[] = {
		{ "NativeConst", "" },
	};
#endif // WITH_METADATA
	static const UECodeGen_Private::FStructPropertyParams NewProp_transform;
	static const UECodeGen_Private::FStructPropertyParams NewProp_position;
	static const UECodeGen_Private::FStructPropertyParams NewProp_rotation;
	static const UECodeGen_Private::FStructPropertyParams NewProp_scale;
	static const UECodeGen_Private::FBytePropertyParams NewProp_ventuzRotationOrder_Underlying;
	static const UECodeGen_Private::FEnumPropertyParams NewProp_ventuzRotationOrder;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzTransform_Statics::NewProp_transform = { "transform", nullptr, (EPropertyFlags)0x0010000008000182, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventUE4_ToVentuzTransform_Parms, transform), Z_Construct_UScriptStruct_FTransform, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_transform_MetaData), NewProp_transform_MetaData) };
const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzTransform_Statics::NewProp_position = { "position", nullptr, (EPropertyFlags)0x0010000000000180, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventUE4_ToVentuzTransform_Parms, position), Z_Construct_UScriptStruct_FVector, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzTransform_Statics::NewProp_rotation = { "rotation", nullptr, (EPropertyFlags)0x0010000000000180, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventUE4_ToVentuzTransform_Parms, rotation), Z_Construct_UScriptStruct_FVector, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzTransform_Statics::NewProp_scale = { "scale", nullptr, (EPropertyFlags)0x0010000000000180, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventUE4_ToVentuzTransform_Parms, scale), Z_Construct_UScriptStruct_FVector, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FBytePropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzTransform_Statics::NewProp_ventuzRotationOrder_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UECodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, 0, nullptr, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FEnumPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzTransform_Statics::NewProp_ventuzRotationOrder = { "ventuzRotationOrder", nullptr, (EPropertyFlags)0x0010000000000082, UECodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventUE4_ToVentuzTransform_Parms, ventuzRotationOrder), Z_Construct_UEnum_VentuzPlugin_LimitedEulerRotationOrder, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_ventuzRotationOrder_MetaData), NewProp_ventuzRotationOrder_MetaData) }; // 3996442786
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzTransform_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzTransform_Statics::NewProp_transform,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzTransform_Statics::NewProp_position,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzTransform_Statics::NewProp_rotation,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzTransform_Statics::NewProp_scale,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzTransform_Statics::NewProp_ventuzRotationOrder_Underlying,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzTransform_Statics::NewProp_ventuzRotationOrder,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzTransform_Statics::PropPointers) < 2048);
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzTransform_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UVentuzBPFunctionLibrary, nullptr, "UE4_ToVentuzTransform", nullptr, nullptr, Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzTransform_Statics::PropPointers, UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzTransform_Statics::PropPointers), sizeof(Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzTransform_Statics::VentuzBPFunctionLibrary_eventUE4_ToVentuzTransform_Parms), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x14C22401, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzTransform_Statics::Function_MetaDataParams), Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzTransform_Statics::Function_MetaDataParams) };
static_assert(sizeof(Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzTransform_Statics::VentuzBPFunctionLibrary_eventUE4_ToVentuzTransform_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzTransform()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzTransform_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UVentuzBPFunctionLibrary::execUE4_ToVentuzTransform)
{
	P_GET_STRUCT_REF(FTransform,Z_Param_Out_transform);
	P_GET_STRUCT_REF(FVector,Z_Param_Out_position);
	P_GET_STRUCT_REF(FVector,Z_Param_Out_rotation);
	P_GET_STRUCT_REF(FVector,Z_Param_Out_scale);
	P_GET_ENUM(LimitedEulerRotationOrder,Z_Param_ventuzRotationOrder);
	P_FINISH;
	P_NATIVE_BEGIN;
	UVentuzBPFunctionLibrary::UE4_ToVentuzTransform(Z_Param_Out_transform,Z_Param_Out_position,Z_Param_Out_rotation,Z_Param_Out_scale,LimitedEulerRotationOrder(Z_Param_ventuzRotationOrder));
	P_NATIVE_END;
}
// End Class UVentuzBPFunctionLibrary Function UE4_ToVentuzTransform

// Begin Class UVentuzBPFunctionLibrary Function VentuzClusterClock
struct Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzClusterClock_Statics
{
	struct VentuzBPFunctionLibrary_eventVentuzClusterClock_Parms
	{
		int64 frameCounter;
		float time;
		int32 frameRateNumerator;
		int32 frameRateDenominator;
		bool ReturnValue;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Category", "Ventuz" },
		{ "Comment", "/**\n     * Query the status of the Ventuz connection\n     *\n     * @param   frameCounter          Cluster Clock frame counter which represents the elapsed time as frame index\n     * @param   time                  Cluster Clock value which represents the elapsed time in seconds\n     * @param   frameRateNumerator    Frame-rate numerator value to calculate exact frame-rate\n     * @param   frameRateDenominator  Frame-rate denominator value to calculate exact frame-rate\n     *\n     * @return\x09True if the values are valid\n     */" },
		{ "ModuleRelativePath", "Public/VentuzBPEvent.h" },
		{ "ToolTip", "Query the status of the Ventuz connection\n\n@param   frameCounter          Cluster Clock frame counter which represents the elapsed time as frame index\n@param   time                  Cluster Clock value which represents the elapsed time in seconds\n@param   frameRateNumerator    Frame-rate numerator value to calculate exact frame-rate\n@param   frameRateDenominator  Frame-rate denominator value to calculate exact frame-rate\n\n@return True if the values are valid" },
	};
#endif // WITH_METADATA
	static const UECodeGen_Private::FInt64PropertyParams NewProp_frameCounter;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_time;
	static const UECodeGen_Private::FIntPropertyParams NewProp_frameRateNumerator;
	static const UECodeGen_Private::FIntPropertyParams NewProp_frameRateDenominator;
	static void NewProp_ReturnValue_SetBit(void* Obj);
	static const UECodeGen_Private::FBoolPropertyParams NewProp_ReturnValue;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FInt64PropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzClusterClock_Statics::NewProp_frameCounter = { "frameCounter", nullptr, (EPropertyFlags)0x0010000000000180, UECodeGen_Private::EPropertyGenFlags::Int64, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventVentuzClusterClock_Parms, frameCounter), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzClusterClock_Statics::NewProp_time = { "time", nullptr, (EPropertyFlags)0x0010000000000180, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventVentuzClusterClock_Parms, time), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FIntPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzClusterClock_Statics::NewProp_frameRateNumerator = { "frameRateNumerator", nullptr, (EPropertyFlags)0x0010000000000180, UECodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventVentuzClusterClock_Parms, frameRateNumerator), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FIntPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzClusterClock_Statics::NewProp_frameRateDenominator = { "frameRateDenominator", nullptr, (EPropertyFlags)0x0010000000000180, UECodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventVentuzClusterClock_Parms, frameRateDenominator), METADATA_PARAMS(0, nullptr) };
void Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzClusterClock_Statics::NewProp_ReturnValue_SetBit(void* Obj)
{
	((VentuzBPFunctionLibrary_eventVentuzClusterClock_Parms*)Obj)->ReturnValue = 1;
}
const UECodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzClusterClock_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UECodeGen_Private::EPropertyGenFlags::Bool | UECodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, sizeof(bool), sizeof(VentuzBPFunctionLibrary_eventVentuzClusterClock_Parms), &Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzClusterClock_Statics::NewProp_ReturnValue_SetBit, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzClusterClock_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzClusterClock_Statics::NewProp_frameCounter,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzClusterClock_Statics::NewProp_time,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzClusterClock_Statics::NewProp_frameRateNumerator,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzClusterClock_Statics::NewProp_frameRateDenominator,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzClusterClock_Statics::NewProp_ReturnValue,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzClusterClock_Statics::PropPointers) < 2048);
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzClusterClock_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UVentuzBPFunctionLibrary, nullptr, "VentuzClusterClock", nullptr, nullptr, Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzClusterClock_Statics::PropPointers, UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzClusterClock_Statics::PropPointers), sizeof(Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzClusterClock_Statics::VentuzBPFunctionLibrary_eventVentuzClusterClock_Parms), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x14422401, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzClusterClock_Statics::Function_MetaDataParams), Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzClusterClock_Statics::Function_MetaDataParams) };
static_assert(sizeof(Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzClusterClock_Statics::VentuzBPFunctionLibrary_eventVentuzClusterClock_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzClusterClock()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzClusterClock_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UVentuzBPFunctionLibrary::execVentuzClusterClock)
{
	P_GET_PROPERTY_REF(FInt64Property,Z_Param_Out_frameCounter);
	P_GET_PROPERTY_REF(FFloatProperty,Z_Param_Out_time);
	P_GET_PROPERTY_REF(FIntProperty,Z_Param_Out_frameRateNumerator);
	P_GET_PROPERTY_REF(FIntProperty,Z_Param_Out_frameRateDenominator);
	P_FINISH;
	P_NATIVE_BEGIN;
	*(bool*)Z_Param__Result=UVentuzBPFunctionLibrary::VentuzClusterClock(Z_Param_Out_frameCounter,Z_Param_Out_time,Z_Param_Out_frameRateNumerator,Z_Param_Out_frameRateDenominator);
	P_NATIVE_END;
}
// End Class UVentuzBPFunctionLibrary Function VentuzClusterClock

// Begin Class UVentuzBPFunctionLibrary Function VentuzConnectionState
struct Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzConnectionState_Statics
{
	struct VentuzBPFunctionLibrary_eventVentuzConnectionState_Parms
	{
		VentuzConnectionStatus connectionStatus;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Category", "Ventuz" },
		{ "ExpandEnumAsExecs", "connectionStatus" },
		{ "ModuleRelativePath", "Public/VentuzBPEvent.h" },
	};
#endif // WITH_METADATA
	static const UECodeGen_Private::FBytePropertyParams NewProp_connectionStatus_Underlying;
	static const UECodeGen_Private::FEnumPropertyParams NewProp_connectionStatus;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FBytePropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzConnectionState_Statics::NewProp_connectionStatus_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UECodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, 0, nullptr, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FEnumPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzConnectionState_Statics::NewProp_connectionStatus = { "connectionStatus", nullptr, (EPropertyFlags)0x0010000000000180, UECodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventVentuzConnectionState_Parms, connectionStatus), Z_Construct_UEnum_VentuzPlugin_VentuzConnectionStatus, METADATA_PARAMS(0, nullptr) }; // 73725262
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzConnectionState_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzConnectionState_Statics::NewProp_connectionStatus_Underlying,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzConnectionState_Statics::NewProp_connectionStatus,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzConnectionState_Statics::PropPointers) < 2048);
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzConnectionState_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UVentuzBPFunctionLibrary, nullptr, "VentuzConnectionState", nullptr, nullptr, Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzConnectionState_Statics::PropPointers, UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzConnectionState_Statics::PropPointers), sizeof(Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzConnectionState_Statics::VentuzBPFunctionLibrary_eventVentuzConnectionState_Parms), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04422401, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzConnectionState_Statics::Function_MetaDataParams), Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzConnectionState_Statics::Function_MetaDataParams) };
static_assert(sizeof(Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzConnectionState_Statics::VentuzBPFunctionLibrary_eventVentuzConnectionState_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzConnectionState()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzConnectionState_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UVentuzBPFunctionLibrary::execVentuzConnectionState)
{
	P_GET_ENUM_REF(VentuzConnectionStatus,Z_Param_Out_connectionStatus);
	P_FINISH;
	P_NATIVE_BEGIN;
	UVentuzBPFunctionLibrary::VentuzConnectionState((VentuzConnectionStatus&)(Z_Param_Out_connectionStatus));
	P_NATIVE_END;
}
// End Class UVentuzBPFunctionLibrary Function VentuzConnectionState

// Begin Class UVentuzBPFunctionLibrary Function VentuzToUE4_Position
struct Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Position_Statics
{
	struct VentuzBPFunctionLibrary_eventVentuzToUE4_Position_Parms
	{
		FVector position;
		FVector ReturnValue;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Category", "Ventuz" },
		{ "Comment", "/**\n     * Convert a position vector from the Ventuz coordinate system to the Unreal coordinate system\n     *\n     * @param\x09position\x09The position vector to convert in Ventuz coordinates\n     * @return\x09The result position in Unreal coordinates\n     */" },
		{ "DisplayName", "Ventuz to Unreal Position" },
		{ "ModuleRelativePath", "Public/VentuzBPEvent.h" },
		{ "ToolTip", "Convert a position vector from the Ventuz coordinate system to the Unreal coordinate system\n\n@param  position        The position vector to convert in Ventuz coordinates\n@return The result position in Unreal coordinates" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_position_MetaData[] = {
		{ "NativeConst", "" },
	};
#endif // WITH_METADATA
	static const UECodeGen_Private::FStructPropertyParams NewProp_position;
	static const UECodeGen_Private::FStructPropertyParams NewProp_ReturnValue;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Position_Statics::NewProp_position = { "position", nullptr, (EPropertyFlags)0x0010000008000182, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventVentuzToUE4_Position_Parms, position), Z_Construct_UScriptStruct_FVector, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_position_MetaData), NewProp_position_MetaData) };
const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Position_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventVentuzToUE4_Position_Parms, ReturnValue), Z_Construct_UScriptStruct_FVector, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Position_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Position_Statics::NewProp_position,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Position_Statics::NewProp_ReturnValue,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Position_Statics::PropPointers) < 2048);
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Position_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UVentuzBPFunctionLibrary, nullptr, "VentuzToUE4_Position", nullptr, nullptr, Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Position_Statics::PropPointers, UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Position_Statics::PropPointers), sizeof(Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Position_Statics::VentuzBPFunctionLibrary_eventVentuzToUE4_Position_Parms), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x14C22401, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Position_Statics::Function_MetaDataParams), Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Position_Statics::Function_MetaDataParams) };
static_assert(sizeof(Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Position_Statics::VentuzBPFunctionLibrary_eventVentuzToUE4_Position_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Position()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Position_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UVentuzBPFunctionLibrary::execVentuzToUE4_Position)
{
	P_GET_STRUCT_REF(FVector,Z_Param_Out_position);
	P_FINISH;
	P_NATIVE_BEGIN;
	*(FVector*)Z_Param__Result=UVentuzBPFunctionLibrary::VentuzToUE4_Position(Z_Param_Out_position);
	P_NATIVE_END;
}
// End Class UVentuzBPFunctionLibrary Function VentuzToUE4_Position

// Begin Class UVentuzBPFunctionLibrary Function VentuzToUE4_Rotation
struct Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Rotation_Statics
{
	struct VentuzBPFunctionLibrary_eventVentuzToUE4_Rotation_Parms
	{
		FVector rotation;
		EulerRotationOrder ventuzRotationOrder;
		FRotator ReturnValue;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Category", "Ventuz" },
		{ "Comment", "/**\n     * Convert an Euler angle rotation from the Ventuz coordinate system to a Unreal rotator\n     *\n     * @param\x09rotation\x09The rotation values in Ventuz coordinates\n     * @param\x09ventuzRotationOrder\x09The Ventuz rotation order in which to apply the rotation values\n     * @return\x09The result rotator in Unreal coordinates\n     */" },
		{ "CPP_Default_ventuzRotationOrder", "ZYX" },
		{ "DisplayName", "Ventuz to Unreal Rotation" },
		{ "ModuleRelativePath", "Public/VentuzBPEvent.h" },
		{ "ToolTip", "Convert an Euler angle rotation from the Ventuz coordinate system to a Unreal rotator\n\n@param  rotation        The rotation values in Ventuz coordinates\n@param  ventuzRotationOrder     The Ventuz rotation order in which to apply the rotation values\n@return The result rotator in Unreal coordinates" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_rotation_MetaData[] = {
		{ "NativeConst", "" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_ventuzRotationOrder_MetaData[] = {
		{ "NativeConst", "" },
	};
#endif // WITH_METADATA
	static const UECodeGen_Private::FStructPropertyParams NewProp_rotation;
	static const UECodeGen_Private::FBytePropertyParams NewProp_ventuzRotationOrder_Underlying;
	static const UECodeGen_Private::FEnumPropertyParams NewProp_ventuzRotationOrder;
	static const UECodeGen_Private::FStructPropertyParams NewProp_ReturnValue;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Rotation_Statics::NewProp_rotation = { "rotation", nullptr, (EPropertyFlags)0x0010000008000182, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventVentuzToUE4_Rotation_Parms, rotation), Z_Construct_UScriptStruct_FVector, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_rotation_MetaData), NewProp_rotation_MetaData) };
const UECodeGen_Private::FBytePropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Rotation_Statics::NewProp_ventuzRotationOrder_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UECodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, 0, nullptr, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FEnumPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Rotation_Statics::NewProp_ventuzRotationOrder = { "ventuzRotationOrder", nullptr, (EPropertyFlags)0x0010000000000082, UECodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventVentuzToUE4_Rotation_Parms, ventuzRotationOrder), Z_Construct_UEnum_VentuzPlugin_EulerRotationOrder, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_ventuzRotationOrder_MetaData), NewProp_ventuzRotationOrder_MetaData) }; // 1142045815
const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Rotation_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventVentuzToUE4_Rotation_Parms, ReturnValue), Z_Construct_UScriptStruct_FRotator, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Rotation_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Rotation_Statics::NewProp_rotation,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Rotation_Statics::NewProp_ventuzRotationOrder_Underlying,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Rotation_Statics::NewProp_ventuzRotationOrder,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Rotation_Statics::NewProp_ReturnValue,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Rotation_Statics::PropPointers) < 2048);
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Rotation_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UVentuzBPFunctionLibrary, nullptr, "VentuzToUE4_Rotation", nullptr, nullptr, Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Rotation_Statics::PropPointers, UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Rotation_Statics::PropPointers), sizeof(Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Rotation_Statics::VentuzBPFunctionLibrary_eventVentuzToUE4_Rotation_Parms), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x14C22401, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Rotation_Statics::Function_MetaDataParams), Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Rotation_Statics::Function_MetaDataParams) };
static_assert(sizeof(Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Rotation_Statics::VentuzBPFunctionLibrary_eventVentuzToUE4_Rotation_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Rotation()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Rotation_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UVentuzBPFunctionLibrary::execVentuzToUE4_Rotation)
{
	P_GET_STRUCT_REF(FVector,Z_Param_Out_rotation);
	P_GET_ENUM(EulerRotationOrder,Z_Param_ventuzRotationOrder);
	P_FINISH;
	P_NATIVE_BEGIN;
	*(FRotator*)Z_Param__Result=UVentuzBPFunctionLibrary::VentuzToUE4_Rotation(Z_Param_Out_rotation,EulerRotationOrder(Z_Param_ventuzRotationOrder));
	P_NATIVE_END;
}
// End Class UVentuzBPFunctionLibrary Function VentuzToUE4_Rotation

// Begin Class UVentuzBPFunctionLibrary Function VentuzToUE4_Scale
struct Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Scale_Statics
{
	struct VentuzBPFunctionLibrary_eventVentuzToUE4_Scale_Parms
	{
		FVector scale;
		FVector ReturnValue;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Category", "Ventuz" },
		{ "Comment", "/**\n     * Convert a scaling vector from the Ventuz coordinate system to the Unreal coordinate system\n     *\n     * @param\x09scale\x09The scaling vector to convert in Ventuz coordinates\n     * @return\x09The result scaling vector in Unreal coordinates\n     */" },
		{ "DisplayName", "Ventuz to Unreal Scale" },
		{ "ModuleRelativePath", "Public/VentuzBPEvent.h" },
		{ "ToolTip", "Convert a scaling vector from the Ventuz coordinate system to the Unreal coordinate system\n\n@param  scale   The scaling vector to convert in Ventuz coordinates\n@return The result scaling vector in Unreal coordinates" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_scale_MetaData[] = {
		{ "NativeConst", "" },
	};
#endif // WITH_METADATA
	static const UECodeGen_Private::FStructPropertyParams NewProp_scale;
	static const UECodeGen_Private::FStructPropertyParams NewProp_ReturnValue;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Scale_Statics::NewProp_scale = { "scale", nullptr, (EPropertyFlags)0x0010000008000182, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventVentuzToUE4_Scale_Parms, scale), Z_Construct_UScriptStruct_FVector, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_scale_MetaData), NewProp_scale_MetaData) };
const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Scale_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventVentuzToUE4_Scale_Parms, ReturnValue), Z_Construct_UScriptStruct_FVector, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Scale_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Scale_Statics::NewProp_scale,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Scale_Statics::NewProp_ReturnValue,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Scale_Statics::PropPointers) < 2048);
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Scale_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UVentuzBPFunctionLibrary, nullptr, "VentuzToUE4_Scale", nullptr, nullptr, Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Scale_Statics::PropPointers, UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Scale_Statics::PropPointers), sizeof(Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Scale_Statics::VentuzBPFunctionLibrary_eventVentuzToUE4_Scale_Parms), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x14C22401, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Scale_Statics::Function_MetaDataParams), Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Scale_Statics::Function_MetaDataParams) };
static_assert(sizeof(Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Scale_Statics::VentuzBPFunctionLibrary_eventVentuzToUE4_Scale_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Scale()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Scale_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UVentuzBPFunctionLibrary::execVentuzToUE4_Scale)
{
	P_GET_STRUCT_REF(FVector,Z_Param_Out_scale);
	P_FINISH;
	P_NATIVE_BEGIN;
	*(FVector*)Z_Param__Result=UVentuzBPFunctionLibrary::VentuzToUE4_Scale(Z_Param_Out_scale);
	P_NATIVE_END;
}
// End Class UVentuzBPFunctionLibrary Function VentuzToUE4_Scale

// Begin Class UVentuzBPFunctionLibrary Function VentuzToUE4_Transform
struct Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Transform_Statics
{
	struct VentuzBPFunctionLibrary_eventVentuzToUE4_Transform_Parms
	{
		FVector position;
		FVector rotation;
		EulerRotationOrder ventuzRotationOrder;
		FVector scale;
		FTransform ReturnValue;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Category", "Ventuz" },
		{ "Comment", "/**\n     * Convert Ventuz coordinate system transformation values to a Unreal coordinate system Transform\n     *\n     * @param\x09position\x09The position in Ventuz coordinates\n     * @param\x09rotation\x09The Euler angle rotation values in the Ventuz coordinate system\n     * @param\x09ventuzRotationOrder\x09The Ventuz rotation order in which to apply the rotation values\n     * @param\x09scale\x09The scale values in Ventuz coordinates\n     * @return\x09The result Transform in the Unreal coordinate system\n     */" },
		{ "CPP_Default_scale", "1.000000,1.000000,1.000000" },
		{ "CPP_Default_ventuzRotationOrder", "ZYX" },
		{ "DisplayName", "Ventuz to Unreal Transform" },
		{ "ModuleRelativePath", "Public/VentuzBPEvent.h" },
		{ "ToolTip", "Convert Ventuz coordinate system transformation values to a Unreal coordinate system Transform\n\n@param  position        The position in Ventuz coordinates\n@param  rotation        The Euler angle rotation values in the Ventuz coordinate system\n@param  ventuzRotationOrder     The Ventuz rotation order in which to apply the rotation values\n@param  scale   The scale values in Ventuz coordinates\n@return The result Transform in the Unreal coordinate system" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_position_MetaData[] = {
		{ "NativeConst", "" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_rotation_MetaData[] = {
		{ "NativeConst", "" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_ventuzRotationOrder_MetaData[] = {
		{ "NativeConst", "" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_scale_MetaData[] = {
		{ "NativeConst", "" },
	};
#endif // WITH_METADATA
	static const UECodeGen_Private::FStructPropertyParams NewProp_position;
	static const UECodeGen_Private::FStructPropertyParams NewProp_rotation;
	static const UECodeGen_Private::FBytePropertyParams NewProp_ventuzRotationOrder_Underlying;
	static const UECodeGen_Private::FEnumPropertyParams NewProp_ventuzRotationOrder;
	static const UECodeGen_Private::FStructPropertyParams NewProp_scale;
	static const UECodeGen_Private::FStructPropertyParams NewProp_ReturnValue;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Transform_Statics::NewProp_position = { "position", nullptr, (EPropertyFlags)0x0010000008000182, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventVentuzToUE4_Transform_Parms, position), Z_Construct_UScriptStruct_FVector, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_position_MetaData), NewProp_position_MetaData) };
const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Transform_Statics::NewProp_rotation = { "rotation", nullptr, (EPropertyFlags)0x0010000008000182, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventVentuzToUE4_Transform_Parms, rotation), Z_Construct_UScriptStruct_FVector, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_rotation_MetaData), NewProp_rotation_MetaData) };
const UECodeGen_Private::FBytePropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Transform_Statics::NewProp_ventuzRotationOrder_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UECodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, 0, nullptr, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FEnumPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Transform_Statics::NewProp_ventuzRotationOrder = { "ventuzRotationOrder", nullptr, (EPropertyFlags)0x0010000000000082, UECodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventVentuzToUE4_Transform_Parms, ventuzRotationOrder), Z_Construct_UEnum_VentuzPlugin_EulerRotationOrder, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_ventuzRotationOrder_MetaData), NewProp_ventuzRotationOrder_MetaData) }; // 1142045815
const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Transform_Statics::NewProp_scale = { "scale", nullptr, (EPropertyFlags)0x0010000008000182, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventVentuzToUE4_Transform_Parms, scale), Z_Construct_UScriptStruct_FVector, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_scale_MetaData), NewProp_scale_MetaData) };
const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Transform_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(VentuzBPFunctionLibrary_eventVentuzToUE4_Transform_Parms, ReturnValue), Z_Construct_UScriptStruct_FTransform, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Transform_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Transform_Statics::NewProp_position,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Transform_Statics::NewProp_rotation,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Transform_Statics::NewProp_ventuzRotationOrder_Underlying,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Transform_Statics::NewProp_ventuzRotationOrder,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Transform_Statics::NewProp_scale,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Transform_Statics::NewProp_ReturnValue,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Transform_Statics::PropPointers) < 2048);
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Transform_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UVentuzBPFunctionLibrary, nullptr, "VentuzToUE4_Transform", nullptr, nullptr, Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Transform_Statics::PropPointers, UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Transform_Statics::PropPointers), sizeof(Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Transform_Statics::VentuzBPFunctionLibrary_eventVentuzToUE4_Transform_Parms), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x14C22401, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Transform_Statics::Function_MetaDataParams), Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Transform_Statics::Function_MetaDataParams) };
static_assert(sizeof(Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Transform_Statics::VentuzBPFunctionLibrary_eventVentuzToUE4_Transform_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Transform()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Transform_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UVentuzBPFunctionLibrary::execVentuzToUE4_Transform)
{
	P_GET_STRUCT_REF(FVector,Z_Param_Out_position);
	P_GET_STRUCT_REF(FVector,Z_Param_Out_rotation);
	P_GET_ENUM(EulerRotationOrder,Z_Param_ventuzRotationOrder);
	P_GET_STRUCT_REF(FVector,Z_Param_Out_scale);
	P_FINISH;
	P_NATIVE_BEGIN;
	*(FTransform*)Z_Param__Result=UVentuzBPFunctionLibrary::VentuzToUE4_Transform(Z_Param_Out_position,Z_Param_Out_rotation,EulerRotationOrder(Z_Param_ventuzRotationOrder),Z_Param_Out_scale);
	P_NATIVE_END;
}
// End Class UVentuzBPFunctionLibrary Function VentuzToUE4_Transform

// Begin Class UVentuzBPFunctionLibrary
void UVentuzBPFunctionLibrary::StaticRegisterNativesUVentuzBPFunctionLibrary()
{
	UClass* Class = UVentuzBPFunctionLibrary::StaticClass();
	static const FNameNativePtrPair Funcs[] = {
		{ "GetVentuzBoolArrayByNodeName", &UVentuzBPFunctionLibrary::execGetVentuzBoolArrayByNodeName },
		{ "GetVentuzBoolValueByNodeName", &UVentuzBPFunctionLibrary::execGetVentuzBoolValueByNodeName },
		{ "GetVentuzCameraTransform", &UVentuzBPFunctionLibrary::execGetVentuzCameraTransform },
		{ "GetVentuzFloatArrayByNodeName", &UVentuzBPFunctionLibrary::execGetVentuzFloatArrayByNodeName },
		{ "GetVentuzFloatValueByNodeName", &UVentuzBPFunctionLibrary::execGetVentuzFloatValueByNodeName },
		{ "GetVentuzIntArrayByNodeName", &UVentuzBPFunctionLibrary::execGetVentuzIntArrayByNodeName },
		{ "GetVentuzIntValueByNodeName", &UVentuzBPFunctionLibrary::execGetVentuzIntValueByNodeName },
		{ "GetVentuzStringArrayByNodeName", &UVentuzBPFunctionLibrary::execGetVentuzStringArrayByNodeName },
		{ "GetVentuzStringValueByNodeName", &UVentuzBPFunctionLibrary::execGetVentuzStringValueByNodeName },
		{ "GetVentuzTransformValue", &UVentuzBPFunctionLibrary::execGetVentuzTransformValue },
		{ "IsVentuzConnected", &UVentuzBPFunctionLibrary::execIsVentuzConnected },
		{ "RegisterVentuzMethod", &UVentuzBPFunctionLibrary::execRegisterVentuzMethod },
		{ "SendVentuzBoolArrayByNodeName", &UVentuzBPFunctionLibrary::execSendVentuzBoolArrayByNodeName },
		{ "SendVentuzBoolValueByNodeName", &UVentuzBPFunctionLibrary::execSendVentuzBoolValueByNodeName },
		{ "SendVentuzFloatArrayByNodeName", &UVentuzBPFunctionLibrary::execSendVentuzFloatArrayByNodeName },
		{ "SendVentuzFloatValueByNodeName", &UVentuzBPFunctionLibrary::execSendVentuzFloatValueByNodeName },
		{ "SendVentuzIntArrayByNodeName", &UVentuzBPFunctionLibrary::execSendVentuzIntArrayByNodeName },
		{ "SendVentuzIntValueByNodeName", &UVentuzBPFunctionLibrary::execSendVentuzIntValueByNodeName },
		{ "SendVentuzStringArrayByNodeName", &UVentuzBPFunctionLibrary::execSendVentuzStringArrayByNodeName },
		{ "SendVentuzStringValueByNodeName", &UVentuzBPFunctionLibrary::execSendVentuzStringValueByNodeName },
		{ "SendVentuzTransformValue", &UVentuzBPFunctionLibrary::execSendVentuzTransformValue },
		{ "TriggerVentuzEvent", &UVentuzBPFunctionLibrary::execTriggerVentuzEvent },
		{ "UE4_ToVentuzPosition", &UVentuzBPFunctionLibrary::execUE4_ToVentuzPosition },
		{ "UE4_ToVentuzRotation", &UVentuzBPFunctionLibrary::execUE4_ToVentuzRotation },
		{ "UE4_ToVentuzScale", &UVentuzBPFunctionLibrary::execUE4_ToVentuzScale },
		{ "UE4_ToVentuzTransform", &UVentuzBPFunctionLibrary::execUE4_ToVentuzTransform },
		{ "VentuzClusterClock", &UVentuzBPFunctionLibrary::execVentuzClusterClock },
		{ "VentuzConnectionState", &UVentuzBPFunctionLibrary::execVentuzConnectionState },
		{ "VentuzToUE4_Position", &UVentuzBPFunctionLibrary::execVentuzToUE4_Position },
		{ "VentuzToUE4_Rotation", &UVentuzBPFunctionLibrary::execVentuzToUE4_Rotation },
		{ "VentuzToUE4_Scale", &UVentuzBPFunctionLibrary::execVentuzToUE4_Scale },
		{ "VentuzToUE4_Transform", &UVentuzBPFunctionLibrary::execVentuzToUE4_Transform },
	};
	FNativeFunctionRegistrar::RegisterFunctions(Class, Funcs, UE_ARRAY_COUNT(Funcs));
}
IMPLEMENT_CLASS_NO_AUTO_REGISTRATION(UVentuzBPFunctionLibrary);
UClass* Z_Construct_UClass_UVentuzBPFunctionLibrary_NoRegister()
{
	return UVentuzBPFunctionLibrary::StaticClass();
}
struct Z_Construct_UClass_UVentuzBPFunctionLibrary_Statics
{
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Class_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "ClassGroupNames", "Ventuz" },
		{ "IncludePath", "VentuzBPEvent.h" },
		{ "IsBlueprintBase", "true" },
		{ "ModuleRelativePath", "Public/VentuzBPEvent.h" },
	};
#endif // WITH_METADATA
	static UObject* (*const DependentSingletons[])();
	static constexpr FClassFunctionLinkInfo FuncInfo[] = {
		{ &Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzBoolArrayByNodeName, "GetVentuzBoolArrayByNodeName" }, // 1016829635
		{ &Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzBoolValueByNodeName, "GetVentuzBoolValueByNodeName" }, // 115401589
		{ &Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzCameraTransform, "GetVentuzCameraTransform" }, // 1660996414
		{ &Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzFloatArrayByNodeName, "GetVentuzFloatArrayByNodeName" }, // 600577669
		{ &Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzFloatValueByNodeName, "GetVentuzFloatValueByNodeName" }, // 316620773
		{ &Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzIntArrayByNodeName, "GetVentuzIntArrayByNodeName" }, // 2311693128
		{ &Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzIntValueByNodeName, "GetVentuzIntValueByNodeName" }, // 1864846861
		{ &Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzStringArrayByNodeName, "GetVentuzStringArrayByNodeName" }, // 4086216117
		{ &Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzStringValueByNodeName, "GetVentuzStringValueByNodeName" }, // 121279395
		{ &Z_Construct_UFunction_UVentuzBPFunctionLibrary_GetVentuzTransformValue, "GetVentuzTransformValue" }, // 1468498372
		{ &Z_Construct_UFunction_UVentuzBPFunctionLibrary_IsVentuzConnected, "IsVentuzConnected" }, // 360834631
		{ &Z_Construct_UFunction_UVentuzBPFunctionLibrary_RegisterVentuzMethod, "RegisterVentuzMethod" }, // 1059424359
		{ &Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzBoolArrayByNodeName, "SendVentuzBoolArrayByNodeName" }, // 4021335847
		{ &Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzBoolValueByNodeName, "SendVentuzBoolValueByNodeName" }, // 2158090468
		{ &Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzFloatArrayByNodeName, "SendVentuzFloatArrayByNodeName" }, // 4029600642
		{ &Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzFloatValueByNodeName, "SendVentuzFloatValueByNodeName" }, // 3127056140
		{ &Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzIntArrayByNodeName, "SendVentuzIntArrayByNodeName" }, // 3816876699
		{ &Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzIntValueByNodeName, "SendVentuzIntValueByNodeName" }, // 1623493038
		{ &Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzStringArrayByNodeName, "SendVentuzStringArrayByNodeName" }, // 2951260653
		{ &Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzStringValueByNodeName, "SendVentuzStringValueByNodeName" }, // 3125470369
		{ &Z_Construct_UFunction_UVentuzBPFunctionLibrary_SendVentuzTransformValue, "SendVentuzTransformValue" }, // 3784876214
		{ &Z_Construct_UFunction_UVentuzBPFunctionLibrary_TriggerVentuzEvent, "TriggerVentuzEvent" }, // 4155659004
		{ &Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzPosition, "UE4_ToVentuzPosition" }, // 2687699939
		{ &Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzRotation, "UE4_ToVentuzRotation" }, // 1891550983
		{ &Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzScale, "UE4_ToVentuzScale" }, // 1410437061
		{ &Z_Construct_UFunction_UVentuzBPFunctionLibrary_UE4_ToVentuzTransform, "UE4_ToVentuzTransform" }, // 1845657230
		{ &Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzClusterClock, "VentuzClusterClock" }, // 2280921990
		{ &Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzConnectionState, "VentuzConnectionState" }, // 2316791103
		{ &Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Position, "VentuzToUE4_Position" }, // 2430954541
		{ &Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Rotation, "VentuzToUE4_Rotation" }, // 1068514586
		{ &Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Scale, "VentuzToUE4_Scale" }, // 2625439736
		{ &Z_Construct_UFunction_UVentuzBPFunctionLibrary_VentuzToUE4_Transform, "VentuzToUE4_Transform" }, // 4266748053
	};
	static_assert(UE_ARRAY_COUNT(FuncInfo) < 2048);
	static constexpr FCppClassTypeInfoStatic StaticCppClassTypeInfo = {
		TCppClassTypeTraits<UVentuzBPFunctionLibrary>::IsAbstract,
	};
	static const UECodeGen_Private::FClassParams ClassParams;
};
UObject* (*const Z_Construct_UClass_UVentuzBPFunctionLibrary_Statics::DependentSingletons[])() = {
	(UObject* (*)())Z_Construct_UClass_UBlueprintFunctionLibrary,
	(UObject* (*)())Z_Construct_UPackage__Script_VentuzPlugin,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UClass_UVentuzBPFunctionLibrary_Statics::DependentSingletons) < 16);
const UECodeGen_Private::FClassParams Z_Construct_UClass_UVentuzBPFunctionLibrary_Statics::ClassParams = {
	&UVentuzBPFunctionLibrary::StaticClass,
	nullptr,
	&StaticCppClassTypeInfo,
	DependentSingletons,
	FuncInfo,
	nullptr,
	nullptr,
	UE_ARRAY_COUNT(DependentSingletons),
	UE_ARRAY_COUNT(FuncInfo),
	0,
	0,
	0x001000A0u,
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UClass_UVentuzBPFunctionLibrary_Statics::Class_MetaDataParams), Z_Construct_UClass_UVentuzBPFunctionLibrary_Statics::Class_MetaDataParams)
};
UClass* Z_Construct_UClass_UVentuzBPFunctionLibrary()
{
	if (!Z_Registration_Info_UClass_UVentuzBPFunctionLibrary.OuterSingleton)
	{
		UECodeGen_Private::ConstructUClass(Z_Registration_Info_UClass_UVentuzBPFunctionLibrary.OuterSingleton, Z_Construct_UClass_UVentuzBPFunctionLibrary_Statics::ClassParams);
	}
	return Z_Registration_Info_UClass_UVentuzBPFunctionLibrary.OuterSingleton;
}
template<> VENTUZPLUGIN_API UClass* StaticClass<UVentuzBPFunctionLibrary>()
{
	return UVentuzBPFunctionLibrary::StaticClass();
}
DEFINE_VTABLE_PTR_HELPER_CTOR(UVentuzBPFunctionLibrary);
UVentuzBPFunctionLibrary::~UVentuzBPFunctionLibrary() {}
// End Class UVentuzBPFunctionLibrary

// Begin Registration
struct Z_CompiledInDeferFile_FID_HostProject_Plugins_VentuzPlugin_Source_VentuzPlugin_Public_VentuzBPEvent_h_Statics
{
	static constexpr FEnumRegisterCompiledInInfo EnumInfo[] = {
		{ EulerRotationOrder_StaticEnum, TEXT("EulerRotationOrder"), &Z_Registration_Info_UEnum_EulerRotationOrder, CONSTRUCT_RELOAD_VERSION_INFO(FEnumReloadVersionInfo, 1142045815U) },
		{ LimitedEulerRotationOrder_StaticEnum, TEXT("LimitedEulerRotationOrder"), &Z_Registration_Info_UEnum_LimitedEulerRotationOrder, CONSTRUCT_RELOAD_VERSION_INFO(FEnumReloadVersionInfo, 3996442786U) },
		{ VentuzConnectionStatus_StaticEnum, TEXT("VentuzConnectionStatus"), &Z_Registration_Info_UEnum_VentuzConnectionStatus, CONSTRUCT_RELOAD_VERSION_INFO(FEnumReloadVersionInfo, 73725262U) },
	};
	static constexpr FClassRegisterCompiledInInfo ClassInfo[] = {
		{ Z_Construct_UClass_UVentuzBPFunctionLibrary, UVentuzBPFunctionLibrary::StaticClass, TEXT("UVentuzBPFunctionLibrary"), &Z_Registration_Info_UClass_UVentuzBPFunctionLibrary, CONSTRUCT_RELOAD_VERSION_INFO(FClassReloadVersionInfo, sizeof(UVentuzBPFunctionLibrary), 1494592396U) },
	};
};
static FRegisterCompiledInInfo Z_CompiledInDeferFile_FID_HostProject_Plugins_VentuzPlugin_Source_VentuzPlugin_Public_VentuzBPEvent_h_3461609190(TEXT("/Script/VentuzPlugin"),
	Z_CompiledInDeferFile_FID_HostProject_Plugins_VentuzPlugin_Source_VentuzPlugin_Public_VentuzBPEvent_h_Statics::ClassInfo, UE_ARRAY_COUNT(Z_CompiledInDeferFile_FID_HostProject_Plugins_VentuzPlugin_Source_VentuzPlugin_Public_VentuzBPEvent_h_Statics::ClassInfo),
	nullptr, 0,
	Z_CompiledInDeferFile_FID_HostProject_Plugins_VentuzPlugin_Source_VentuzPlugin_Public_VentuzBPEvent_h_Statics::EnumInfo, UE_ARRAY_COUNT(Z_CompiledInDeferFile_FID_HostProject_Plugins_VentuzPlugin_Source_VentuzPlugin_Public_VentuzBPEvent_h_Statics::EnumInfo));
// End Registration
PRAGMA_ENABLE_DEPRECATION_WARNINGS
