#pragma once

/*
* SDK generated by Dumper-7
*
* https://github.com/Encryqed/Dumper-7
*/

// Package: InterchangeNodes

#include "Basic.hpp"

#include "InterchangeNodes_classes.hpp"
#include "InterchangeNodes_parameters.hpp"


SDK_NAMESPACE_START

// Function InterchangeNodes.InterchangeAnimationTrackSetNode.AddCustomAnimationTrackUid
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    AnimationTrackUid                                      (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeAnimationTrackSetNode::AddCustomAnimationTrackUid(const class FString& AnimationTrackUid)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeAnimationTrackSetNode", "AddCustomAnimationTrackUid");

	Params::InterchangeAnimationTrackSetNode_AddCustomAnimationTrackUid Parms{};

	Parms.AnimationTrackUid = std::move(AnimationTrackUid);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeAnimationTrackSetNode.RemoveCustomAnimationTrackUid
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    AnimationTrackUid                                      (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeAnimationTrackSetNode::RemoveCustomAnimationTrackUid(const class FString& AnimationTrackUid)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeAnimationTrackSetNode", "RemoveCustomAnimationTrackUid");

	Params::InterchangeAnimationTrackSetNode_RemoveCustomAnimationTrackUid Parms{};

	Parms.AnimationTrackUid = std::move(AnimationTrackUid);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeAnimationTrackSetNode.SetCustomFrameRate
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const float&                            AttributeValue                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeAnimationTrackSetNode::SetCustomFrameRate(const float& AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeAnimationTrackSetNode", "SetCustomFrameRate");

	Params::InterchangeAnimationTrackSetNode_SetCustomFrameRate Parms{};

	Parms.AttributeValue = AttributeValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeAnimationTrackSetNode.GetCustomAnimationTrackUid
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const int32                             Index_0                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString*                          OutAnimationTrackUid                                   (Parm, OutParm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UInterchangeAnimationTrackSetNode::GetCustomAnimationTrackUid(const int32 Index_0, class FString* OutAnimationTrackUid) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeAnimationTrackSetNode", "GetCustomAnimationTrackUid");

	Params::InterchangeAnimationTrackSetNode_GetCustomAnimationTrackUid Parms{};

	Parms.Index_0 = Index_0;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutAnimationTrackUid != nullptr)
		*OutAnimationTrackUid = std::move(Parms.OutAnimationTrackUid);
}


// Function InterchangeNodes.InterchangeAnimationTrackSetNode.GetCustomAnimationTrackUidCount
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UInterchangeAnimationTrackSetNode::GetCustomAnimationTrackUidCount() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeAnimationTrackSetNode", "GetCustomAnimationTrackUidCount");

	Params::InterchangeAnimationTrackSetNode_GetCustomAnimationTrackUidCount Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeAnimationTrackSetNode.GetCustomAnimationTrackUids
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<class FString>*                  OutAnimationTrackUids                                  (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void UInterchangeAnimationTrackSetNode::GetCustomAnimationTrackUids(TArray<class FString>* OutAnimationTrackUids) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeAnimationTrackSetNode", "GetCustomAnimationTrackUids");

	Params::InterchangeAnimationTrackSetNode_GetCustomAnimationTrackUids Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutAnimationTrackUids != nullptr)
		*OutAnimationTrackUids = std::move(Parms.OutAnimationTrackUids);
}


// Function InterchangeNodes.InterchangeAnimationTrackSetNode.GetCustomFrameRate
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float*                                  AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeAnimationTrackSetNode::GetCustomFrameRate(float* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeAnimationTrackSetNode", "GetCustomFrameRate");

	Params::InterchangeAnimationTrackSetNode_GetCustomFrameRate Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = Parms.AttributeValue;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeAnimationTrackBaseNode.SetCustomCompletionMode
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const int32&                            AttributeValue                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeAnimationTrackBaseNode::SetCustomCompletionMode(const int32& AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeAnimationTrackBaseNode", "SetCustomCompletionMode");

	Params::InterchangeAnimationTrackBaseNode_SetCustomCompletionMode Parms{};

	Parms.AttributeValue = AttributeValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeAnimationTrackBaseNode.GetCustomCompletionMode
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32*                                  AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeAnimationTrackBaseNode::GetCustomCompletionMode(int32* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeAnimationTrackBaseNode", "GetCustomCompletionMode");

	Params::InterchangeAnimationTrackBaseNode_GetCustomCompletionMode Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = Parms.AttributeValue;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeAnimationTrackSetInstanceNode.SetCustomDuration
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const int32&                            AttributeValue                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeAnimationTrackSetInstanceNode::SetCustomDuration(const int32& AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeAnimationTrackSetInstanceNode", "SetCustomDuration");

	Params::InterchangeAnimationTrackSetInstanceNode_SetCustomDuration Parms{};

	Parms.AttributeValue = AttributeValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeAnimationTrackSetInstanceNode.SetCustomStartFrame
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const int32&                            AttributeValue                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeAnimationTrackSetInstanceNode::SetCustomStartFrame(const int32& AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeAnimationTrackSetInstanceNode", "SetCustomStartFrame");

	Params::InterchangeAnimationTrackSetInstanceNode_SetCustomStartFrame Parms{};

	Parms.AttributeValue = AttributeValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeAnimationTrackSetInstanceNode.SetCustomTimeScale
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const float&                            AttributeValue                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeAnimationTrackSetInstanceNode::SetCustomTimeScale(const float& AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeAnimationTrackSetInstanceNode", "SetCustomTimeScale");

	Params::InterchangeAnimationTrackSetInstanceNode_SetCustomTimeScale Parms{};

	Parms.AttributeValue = AttributeValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeAnimationTrackSetInstanceNode.SetCustomTrackSetDependencyUid
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    AttributeValue                                         (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeAnimationTrackSetInstanceNode::SetCustomTrackSetDependencyUid(const class FString& AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeAnimationTrackSetInstanceNode", "SetCustomTrackSetDependencyUid");

	Params::InterchangeAnimationTrackSetInstanceNode_SetCustomTrackSetDependencyUid Parms{};

	Parms.AttributeValue = std::move(AttributeValue);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeAnimationTrackSetInstanceNode.GetCustomDuration
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32*                                  AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeAnimationTrackSetInstanceNode::GetCustomDuration(int32* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeAnimationTrackSetInstanceNode", "GetCustomDuration");

	Params::InterchangeAnimationTrackSetInstanceNode_GetCustomDuration Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = Parms.AttributeValue;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeAnimationTrackSetInstanceNode.GetCustomStartFrame
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32*                                  AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeAnimationTrackSetInstanceNode::GetCustomStartFrame(int32* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeAnimationTrackSetInstanceNode", "GetCustomStartFrame");

	Params::InterchangeAnimationTrackSetInstanceNode_GetCustomStartFrame Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = Parms.AttributeValue;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeAnimationTrackSetInstanceNode.GetCustomTimeScale
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float*                                  AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeAnimationTrackSetInstanceNode::GetCustomTimeScale(float* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeAnimationTrackSetInstanceNode", "GetCustomTimeScale");

	Params::InterchangeAnimationTrackSetInstanceNode_GetCustomTimeScale Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = Parms.AttributeValue;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeAnimationTrackSetInstanceNode.GetCustomTrackSetDependencyUid
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FString*                          AttributeValue                                         (Parm, OutParm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeAnimationTrackSetInstanceNode::GetCustomTrackSetDependencyUid(class FString* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeAnimationTrackSetInstanceNode", "GetCustomTrackSetDependencyUid");

	Params::InterchangeAnimationTrackSetInstanceNode_GetCustomTrackSetDependencyUid Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = std::move(Parms.AttributeValue);

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeAnimationTrackNode.SetCustomActorDependencyUid
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    DependencyUid                                          (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeAnimationTrackNode::SetCustomActorDependencyUid(const class FString& DependencyUid)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeAnimationTrackNode", "SetCustomActorDependencyUid");

	Params::InterchangeAnimationTrackNode_SetCustomActorDependencyUid Parms{};

	Parms.DependencyUid = std::move(DependencyUid);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeAnimationTrackNode.SetCustomAnimationPayloadKey
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FString&                    InUniqueId                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EInterchangeAnimationPayLoadType& InType                                                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeAnimationTrackNode::SetCustomAnimationPayloadKey(const class FString& InUniqueId, const EInterchangeAnimationPayLoadType& InType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeAnimationTrackNode", "SetCustomAnimationPayloadKey");

	Params::InterchangeAnimationTrackNode_SetCustomAnimationPayloadKey Parms{};

	Parms.InUniqueId = std::move(InUniqueId);
	Parms.InType = InType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeAnimationTrackNode.SetCustomFrameCount
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const int32&                            AttributeValue                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeAnimationTrackNode::SetCustomFrameCount(const int32& AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeAnimationTrackNode", "SetCustomFrameCount");

	Params::InterchangeAnimationTrackNode_SetCustomFrameCount Parms{};

	Parms.AttributeValue = AttributeValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeAnimationTrackNode.SetCustomPropertyTrack
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// EInterchangePropertyTracks              PropertyTrack                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeAnimationTrackNode::SetCustomPropertyTrack(EInterchangePropertyTracks PropertyTrack)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeAnimationTrackNode", "SetCustomPropertyTrack");

	Params::InterchangeAnimationTrackNode_SetCustomPropertyTrack Parms{};

	Parms.PropertyTrack = PropertyTrack;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeAnimationTrackNode.GetCustomActorDependencyUid
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FString*                          DependencyUid                                          (Parm, OutParm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeAnimationTrackNode::GetCustomActorDependencyUid(class FString* DependencyUid) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeAnimationTrackNode", "GetCustomActorDependencyUid");

	Params::InterchangeAnimationTrackNode_GetCustomActorDependencyUid Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (DependencyUid != nullptr)
		*DependencyUid = std::move(Parms.DependencyUid);

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeAnimationTrackNode.GetCustomAnimationPayloadKey
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FInterchangeAnimationPayLoadKey* AnimationPayLoadKey                                    (Parm, OutParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeAnimationTrackNode::GetCustomAnimationPayloadKey(struct FInterchangeAnimationPayLoadKey* AnimationPayLoadKey) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeAnimationTrackNode", "GetCustomAnimationPayloadKey");

	Params::InterchangeAnimationTrackNode_GetCustomAnimationPayloadKey Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AnimationPayLoadKey != nullptr)
		*AnimationPayLoadKey = std::move(Parms.AnimationPayLoadKey);

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeAnimationTrackNode.GetCustomFrameCount
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32*                                  AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeAnimationTrackNode::GetCustomFrameCount(int32* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeAnimationTrackNode", "GetCustomFrameCount");

	Params::InterchangeAnimationTrackNode_GetCustomFrameCount Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = Parms.AttributeValue;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeAnimationTrackNode.GetCustomPropertyTrack
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EInterchangePropertyTracks*             PropertyTrack                                          (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeAnimationTrackNode::GetCustomPropertyTrack(EInterchangePropertyTracks* PropertyTrack) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeAnimationTrackNode", "GetCustomPropertyTrack");

	Params::InterchangeAnimationTrackNode_GetCustomPropertyTrack Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (PropertyTrack != nullptr)
		*PropertyTrack = Parms.PropertyTrack;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeTransformAnimationTrackNode.SetCustomUsedChannels
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const int32&                            AttributeValue                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeTransformAnimationTrackNode::SetCustomUsedChannels(const int32& AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeTransformAnimationTrackNode", "SetCustomUsedChannels");

	Params::InterchangeTransformAnimationTrackNode_SetCustomUsedChannels Parms{};

	Parms.AttributeValue = AttributeValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeTransformAnimationTrackNode.GetCustomUsedChannels
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32*                                  AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeTransformAnimationTrackNode::GetCustomUsedChannels(int32* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeTransformAnimationTrackNode", "GetCustomUsedChannels");

	Params::InterchangeTransformAnimationTrackNode_GetCustomUsedChannels Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = Parms.AttributeValue;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeSkeletalAnimationTrackNode.SetAnimationPayloadKeyForMorphTargetNodeUid
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FString&                    MorphTargetNodeUid                                     (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    InUniqueId                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EInterchangeAnimationPayLoadType& InType                                                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeSkeletalAnimationTrackNode::SetAnimationPayloadKeyForMorphTargetNodeUid(const class FString& MorphTargetNodeUid, const class FString& InUniqueId, const EInterchangeAnimationPayLoadType& InType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSkeletalAnimationTrackNode", "SetAnimationPayloadKeyForMorphTargetNodeUid");

	Params::InterchangeSkeletalAnimationTrackNode_SetAnimationPayloadKeyForMorphTargetNodeUid Parms{};

	Parms.MorphTargetNodeUid = std::move(MorphTargetNodeUid);
	Parms.InUniqueId = std::move(InUniqueId);
	Parms.InType = InType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeSkeletalAnimationTrackNode.SetAnimationPayloadKeyForSceneNodeUid
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FString&                    SceneNodeUid                                           (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    InUniqueId                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EInterchangeAnimationPayLoadType& InType                                                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeSkeletalAnimationTrackNode::SetAnimationPayloadKeyForSceneNodeUid(const class FString& SceneNodeUid, const class FString& InUniqueId, const EInterchangeAnimationPayLoadType& InType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSkeletalAnimationTrackNode", "SetAnimationPayloadKeyForSceneNodeUid");

	Params::InterchangeSkeletalAnimationTrackNode_SetAnimationPayloadKeyForSceneNodeUid Parms{};

	Parms.SceneNodeUid = std::move(SceneNodeUid);
	Parms.InUniqueId = std::move(InUniqueId);
	Parms.InType = InType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeSkeletalAnimationTrackNode.SetCustomAnimationSampleRate
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const double&                           SampleRate                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeSkeletalAnimationTrackNode::SetCustomAnimationSampleRate(const double& SampleRate)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSkeletalAnimationTrackNode", "SetCustomAnimationSampleRate");

	Params::InterchangeSkeletalAnimationTrackNode_SetCustomAnimationSampleRate Parms{};

	Parms.SampleRate = SampleRate;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeSkeletalAnimationTrackNode.SetCustomAnimationStartTime
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const double&                           StartTime                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeSkeletalAnimationTrackNode::SetCustomAnimationStartTime(const double& StartTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSkeletalAnimationTrackNode", "SetCustomAnimationStartTime");

	Params::InterchangeSkeletalAnimationTrackNode_SetCustomAnimationStartTime Parms{};

	Parms.StartTime = StartTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeSkeletalAnimationTrackNode.SetCustomAnimationStopTime
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const double&                           StopTime                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeSkeletalAnimationTrackNode::SetCustomAnimationStopTime(const double& StopTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSkeletalAnimationTrackNode", "SetCustomAnimationStopTime");

	Params::InterchangeSkeletalAnimationTrackNode_SetCustomAnimationStopTime Parms{};

	Parms.StopTime = StopTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeSkeletalAnimationTrackNode.SetCustomSkeletonNodeUid
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    AttributeValue                                         (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeSkeletalAnimationTrackNode::SetCustomSkeletonNodeUid(const class FString& AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSkeletalAnimationTrackNode", "SetCustomSkeletonNodeUid");

	Params::InterchangeSkeletalAnimationTrackNode_SetCustomSkeletonNodeUid Parms{};

	Parms.AttributeValue = std::move(AttributeValue);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeSkeletalAnimationTrackNode.SetCustomSourceTimelineAnimationStartTime
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const double&                           StartTime                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeSkeletalAnimationTrackNode::SetCustomSourceTimelineAnimationStartTime(const double& StartTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSkeletalAnimationTrackNode", "SetCustomSourceTimelineAnimationStartTime");

	Params::InterchangeSkeletalAnimationTrackNode_SetCustomSourceTimelineAnimationStartTime Parms{};

	Parms.StartTime = StartTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeSkeletalAnimationTrackNode.SetCustomSourceTimelineAnimationStopTime
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const double&                           StopTime                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeSkeletalAnimationTrackNode::SetCustomSourceTimelineAnimationStopTime(const double& StopTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSkeletalAnimationTrackNode", "SetCustomSourceTimelineAnimationStopTime");

	Params::InterchangeSkeletalAnimationTrackNode_SetCustomSourceTimelineAnimationStopTime Parms{};

	Parms.StopTime = StopTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeSkeletalAnimationTrackNode.GetCustomAnimationSampleRate
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// double*                                 SampleRate                                             (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeSkeletalAnimationTrackNode::GetCustomAnimationSampleRate(double* SampleRate) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSkeletalAnimationTrackNode", "GetCustomAnimationSampleRate");

	Params::InterchangeSkeletalAnimationTrackNode_GetCustomAnimationSampleRate Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (SampleRate != nullptr)
		*SampleRate = Parms.SampleRate;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeSkeletalAnimationTrackNode.GetCustomAnimationStartTime
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// double*                                 StartTime                                              (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeSkeletalAnimationTrackNode::GetCustomAnimationStartTime(double* StartTime) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSkeletalAnimationTrackNode", "GetCustomAnimationStartTime");

	Params::InterchangeSkeletalAnimationTrackNode_GetCustomAnimationStartTime Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (StartTime != nullptr)
		*StartTime = Parms.StartTime;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeSkeletalAnimationTrackNode.GetCustomAnimationStopTime
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// double*                                 StopTime                                               (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeSkeletalAnimationTrackNode::GetCustomAnimationStopTime(double* StopTime) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSkeletalAnimationTrackNode", "GetCustomAnimationStopTime");

	Params::InterchangeSkeletalAnimationTrackNode_GetCustomAnimationStopTime Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (StopTime != nullptr)
		*StopTime = Parms.StopTime;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeSkeletalAnimationTrackNode.GetCustomSkeletonNodeUid
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FString*                          AttributeValue                                         (Parm, OutParm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeSkeletalAnimationTrackNode::GetCustomSkeletonNodeUid(class FString* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSkeletalAnimationTrackNode", "GetCustomSkeletonNodeUid");

	Params::InterchangeSkeletalAnimationTrackNode_GetCustomSkeletonNodeUid Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = std::move(Parms.AttributeValue);

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeSkeletalAnimationTrackNode.GetCustomSourceTimelineAnimationStartTime
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// double*                                 StartTime                                              (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeSkeletalAnimationTrackNode::GetCustomSourceTimelineAnimationStartTime(double* StartTime) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSkeletalAnimationTrackNode", "GetCustomSourceTimelineAnimationStartTime");

	Params::InterchangeSkeletalAnimationTrackNode_GetCustomSourceTimelineAnimationStartTime Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (StartTime != nullptr)
		*StartTime = Parms.StartTime;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeSkeletalAnimationTrackNode.GetCustomSourceTimelineAnimationStopTime
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// double*                                 StopTime                                               (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeSkeletalAnimationTrackNode::GetCustomSourceTimelineAnimationStopTime(double* StopTime) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSkeletalAnimationTrackNode", "GetCustomSourceTimelineAnimationStopTime");

	Params::InterchangeSkeletalAnimationTrackNode_GetCustomSourceTimelineAnimationStopTime Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (StopTime != nullptr)
		*StopTime = Parms.StopTime;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeSkeletalAnimationTrackNode.GetMorphTargetNodeAnimationPayloadKeys
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TMap<class FString, class FString>*     OutMorphTargetNodeAnimationPayloadKeyUids              (Parm, OutParm, NativeAccessSpecifierPublic)
// TMap<class FString, uint8>*             OutMorphTargetNodeAnimationPayloadKeyTypes             (Parm, OutParm, NativeAccessSpecifierPublic)

void UInterchangeSkeletalAnimationTrackNode::GetMorphTargetNodeAnimationPayloadKeys(TMap<class FString, class FString>* OutMorphTargetNodeAnimationPayloadKeyUids, TMap<class FString, uint8>* OutMorphTargetNodeAnimationPayloadKeyTypes) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSkeletalAnimationTrackNode", "GetMorphTargetNodeAnimationPayloadKeys");

	Params::InterchangeSkeletalAnimationTrackNode_GetMorphTargetNodeAnimationPayloadKeys Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutMorphTargetNodeAnimationPayloadKeyUids != nullptr)
		*OutMorphTargetNodeAnimationPayloadKeyUids = std::move(Parms.OutMorphTargetNodeAnimationPayloadKeyUids);

	if (OutMorphTargetNodeAnimationPayloadKeyTypes != nullptr)
		*OutMorphTargetNodeAnimationPayloadKeyTypes = std::move(Parms.OutMorphTargetNodeAnimationPayloadKeyTypes);
}


// Function InterchangeNodes.InterchangeSkeletalAnimationTrackNode.GetSceneNodeAnimationPayloadKeys
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TMap<class FString, class FString>*     OutSceneNodeAnimationPayloadKeyUids                    (Parm, OutParm, NativeAccessSpecifierPublic)
// TMap<class FString, uint8>*             OutSceneNodeAnimationPayloadKeyTypes                   (Parm, OutParm, NativeAccessSpecifierPublic)

void UInterchangeSkeletalAnimationTrackNode::GetSceneNodeAnimationPayloadKeys(TMap<class FString, class FString>* OutSceneNodeAnimationPayloadKeyUids, TMap<class FString, uint8>* OutSceneNodeAnimationPayloadKeyTypes) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSkeletalAnimationTrackNode", "GetSceneNodeAnimationPayloadKeys");

	Params::InterchangeSkeletalAnimationTrackNode_GetSceneNodeAnimationPayloadKeys Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutSceneNodeAnimationPayloadKeyUids != nullptr)
		*OutSceneNodeAnimationPayloadKeyUids = std::move(Parms.OutSceneNodeAnimationPayloadKeyUids);

	if (OutSceneNodeAnimationPayloadKeyTypes != nullptr)
		*OutSceneNodeAnimationPayloadKeyTypes = std::move(Parms.OutSceneNodeAnimationPayloadKeyTypes);
}


// Function InterchangeNodes.InterchangeSkeletalAnimationTrackNode.IsNodeAnimatedWithBakedCurve
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class FString&                    SceneNodeUid                                           (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeSkeletalAnimationTrackNode::IsNodeAnimatedWithBakedCurve(const class FString& SceneNodeUid) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSkeletalAnimationTrackNode", "IsNodeAnimatedWithBakedCurve");

	Params::InterchangeSkeletalAnimationTrackNode_IsNodeAnimatedWithBakedCurve Parms{};

	Parms.SceneNodeUid = std::move(SceneNodeUid);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangePhysicalCameraNode.SetCustomEnableDepthOfField
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const bool&                             AttributeValue                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangePhysicalCameraNode::SetCustomEnableDepthOfField(const bool& AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangePhysicalCameraNode", "SetCustomEnableDepthOfField");

	Params::InterchangePhysicalCameraNode_SetCustomEnableDepthOfField Parms{};

	Parms.AttributeValue = AttributeValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangePhysicalCameraNode.SetCustomFocalLength
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const float&                            AttributeValue                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangePhysicalCameraNode::SetCustomFocalLength(const float& AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangePhysicalCameraNode", "SetCustomFocalLength");

	Params::InterchangePhysicalCameraNode_SetCustomFocalLength Parms{};

	Parms.AttributeValue = AttributeValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangePhysicalCameraNode.SetCustomSensorHeight
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const float&                            AttributeValue                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangePhysicalCameraNode::SetCustomSensorHeight(const float& AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangePhysicalCameraNode", "SetCustomSensorHeight");

	Params::InterchangePhysicalCameraNode_SetCustomSensorHeight Parms{};

	Parms.AttributeValue = AttributeValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangePhysicalCameraNode.SetCustomSensorWidth
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const float&                            AttributeValue                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangePhysicalCameraNode::SetCustomSensorWidth(const float& AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangePhysicalCameraNode", "SetCustomSensorWidth");

	Params::InterchangePhysicalCameraNode_SetCustomSensorWidth Parms{};

	Parms.AttributeValue = AttributeValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangePhysicalCameraNode.GetCustomEnableDepthOfField
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool*                                   AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangePhysicalCameraNode::GetCustomEnableDepthOfField(bool* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangePhysicalCameraNode", "GetCustomEnableDepthOfField");

	Params::InterchangePhysicalCameraNode_GetCustomEnableDepthOfField Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = Parms.AttributeValue;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangePhysicalCameraNode.GetCustomFocalLength
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float*                                  AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangePhysicalCameraNode::GetCustomFocalLength(float* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangePhysicalCameraNode", "GetCustomFocalLength");

	Params::InterchangePhysicalCameraNode_GetCustomFocalLength Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = Parms.AttributeValue;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangePhysicalCameraNode.GetCustomSensorHeight
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float*                                  AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangePhysicalCameraNode::GetCustomSensorHeight(float* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangePhysicalCameraNode", "GetCustomSensorHeight");

	Params::InterchangePhysicalCameraNode_GetCustomSensorHeight Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = Parms.AttributeValue;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangePhysicalCameraNode.GetCustomSensorWidth
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float*                                  AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangePhysicalCameraNode::GetCustomSensorWidth(float* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangePhysicalCameraNode", "GetCustomSensorWidth");

	Params::InterchangePhysicalCameraNode_GetCustomSensorWidth Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = Parms.AttributeValue;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeStandardCameraNode.SetCustomAspectRatio
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const float&                            AttributeValue                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeStandardCameraNode::SetCustomAspectRatio(const float& AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeStandardCameraNode", "SetCustomAspectRatio");

	Params::InterchangeStandardCameraNode_SetCustomAspectRatio Parms{};

	Parms.AttributeValue = AttributeValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeStandardCameraNode.SetCustomFarClipPlane
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const float&                            AttributeValue                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeStandardCameraNode::SetCustomFarClipPlane(const float& AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeStandardCameraNode", "SetCustomFarClipPlane");

	Params::InterchangeStandardCameraNode_SetCustomFarClipPlane Parms{};

	Parms.AttributeValue = AttributeValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeStandardCameraNode.SetCustomFieldOfView
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const float&                            AttributeValue                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeStandardCameraNode::SetCustomFieldOfView(const float& AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeStandardCameraNode", "SetCustomFieldOfView");

	Params::InterchangeStandardCameraNode_SetCustomFieldOfView Parms{};

	Parms.AttributeValue = AttributeValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeStandardCameraNode.SetCustomNearClipPlane
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const float&                            AttributeValue                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeStandardCameraNode::SetCustomNearClipPlane(const float& AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeStandardCameraNode", "SetCustomNearClipPlane");

	Params::InterchangeStandardCameraNode_SetCustomNearClipPlane Parms{};

	Parms.AttributeValue = AttributeValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeStandardCameraNode.SetCustomProjectionMode
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const EInterchangeCameraProjectionType& AttributeValue                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeStandardCameraNode::SetCustomProjectionMode(const EInterchangeCameraProjectionType& AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeStandardCameraNode", "SetCustomProjectionMode");

	Params::InterchangeStandardCameraNode_SetCustomProjectionMode Parms{};

	Parms.AttributeValue = AttributeValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeStandardCameraNode.SetCustomWidth
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const float&                            AttributeValue                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeStandardCameraNode::SetCustomWidth(const float& AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeStandardCameraNode", "SetCustomWidth");

	Params::InterchangeStandardCameraNode_SetCustomWidth Parms{};

	Parms.AttributeValue = AttributeValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeStandardCameraNode.GetCustomAspectRatio
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float*                                  AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeStandardCameraNode::GetCustomAspectRatio(float* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeStandardCameraNode", "GetCustomAspectRatio");

	Params::InterchangeStandardCameraNode_GetCustomAspectRatio Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = Parms.AttributeValue;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeStandardCameraNode.GetCustomFarClipPlane
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float*                                  AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeStandardCameraNode::GetCustomFarClipPlane(float* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeStandardCameraNode", "GetCustomFarClipPlane");

	Params::InterchangeStandardCameraNode_GetCustomFarClipPlane Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = Parms.AttributeValue;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeStandardCameraNode.GetCustomFieldOfView
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float*                                  AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeStandardCameraNode::GetCustomFieldOfView(float* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeStandardCameraNode", "GetCustomFieldOfView");

	Params::InterchangeStandardCameraNode_GetCustomFieldOfView Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = Parms.AttributeValue;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeStandardCameraNode.GetCustomNearClipPlane
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float*                                  AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeStandardCameraNode::GetCustomNearClipPlane(float* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeStandardCameraNode", "GetCustomNearClipPlane");

	Params::InterchangeStandardCameraNode_GetCustomNearClipPlane Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = Parms.AttributeValue;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeStandardCameraNode.GetCustomProjectionMode
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EInterchangeCameraProjectionType*       AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeStandardCameraNode::GetCustomProjectionMode(EInterchangeCameraProjectionType* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeStandardCameraNode", "GetCustomProjectionMode");

	Params::InterchangeStandardCameraNode_GetCustomProjectionMode Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = Parms.AttributeValue;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeStandardCameraNode.GetCustomWidth
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float*                                  AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeStandardCameraNode::GetCustomWidth(float* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeStandardCameraNode", "GetCustomWidth");

	Params::InterchangeStandardCameraNode_GetCustomWidth Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = Parms.AttributeValue;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeShaderNode.AddFloatInput
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FString&                    InputName                                              (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const float&                            AttributeValue                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bIsAParameter                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeShaderNode::AddFloatInput(const class FString& InputName, const float& AttributeValue, bool bIsAParameter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeShaderNode", "AddFloatInput");

	Params::InterchangeShaderNode_AddFloatInput Parms{};

	Parms.InputName = std::move(InputName);
	Parms.AttributeValue = AttributeValue;
	Parms.bIsAParameter = bIsAParameter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeShaderNode.AddLinearColorInput
// (Final, RequiredAPI, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class FString&                    InputName                                              (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FLinearColor&              AttributeValue                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bIsAParameter                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeShaderNode::AddLinearColorInput(const class FString& InputName, const struct FLinearColor& AttributeValue, bool bIsAParameter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeShaderNode", "AddLinearColorInput");

	Params::InterchangeShaderNode_AddLinearColorInput Parms{};

	Parms.InputName = std::move(InputName);
	Parms.AttributeValue = std::move(AttributeValue);
	Parms.bIsAParameter = bIsAParameter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeShaderNode.AddStringInput
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    InputName                                              (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    AttributeValue                                         (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bIsAParameter                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeShaderNode::AddStringInput(const class FString& InputName, const class FString& AttributeValue, bool bIsAParameter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeShaderNode", "AddStringInput");

	Params::InterchangeShaderNode_AddStringInput Parms{};

	Parms.InputName = std::move(InputName);
	Parms.AttributeValue = std::move(AttributeValue);
	Parms.bIsAParameter = bIsAParameter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeShaderNode.SetCustomShaderType
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    AttributeValue                                         (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeShaderNode::SetCustomShaderType(const class FString& AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeShaderNode", "SetCustomShaderType");

	Params::InterchangeShaderNode_SetCustomShaderType Parms{};

	Parms.AttributeValue = std::move(AttributeValue);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeShaderNode.GetCustomShaderType
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FString*                          AttributeValue                                         (Parm, OutParm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeShaderNode::GetCustomShaderType(class FString* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeShaderNode", "GetCustomShaderType");

	Params::InterchangeShaderNode_GetCustomShaderType Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = std::move(Parms.AttributeValue);

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeDecalNode.SetCustomDecalMaterialPathName
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    AttributeValue                                         (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeDecalNode::SetCustomDecalMaterialPathName(const class FString& AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeDecalNode", "SetCustomDecalMaterialPathName");

	Params::InterchangeDecalNode_SetCustomDecalMaterialPathName Parms{};

	Parms.AttributeValue = std::move(AttributeValue);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeDecalNode.SetCustomDecalSize
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   AttributeValue                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeDecalNode::SetCustomDecalSize(const struct FVector& AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeDecalNode", "SetCustomDecalSize");

	Params::InterchangeDecalNode_SetCustomDecalSize Parms{};

	Parms.AttributeValue = std::move(AttributeValue);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeDecalNode.SetCustomSortOrder
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const int32&                            AttributeValue                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeDecalNode::SetCustomSortOrder(const int32& AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeDecalNode", "SetCustomSortOrder");

	Params::InterchangeDecalNode_SetCustomSortOrder Parms{};

	Parms.AttributeValue = AttributeValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeDecalNode.GetCustomDecalMaterialPathName
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FString*                          AttributeValue                                         (Parm, OutParm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeDecalNode::GetCustomDecalMaterialPathName(class FString* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeDecalNode", "GetCustomDecalMaterialPathName");

	Params::InterchangeDecalNode_GetCustomDecalMaterialPathName Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = std::move(Parms.AttributeValue);

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeDecalNode.GetCustomDecalSize
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector*                         AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeDecalNode::GetCustomDecalSize(struct FVector* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeDecalNode", "GetCustomDecalSize");

	Params::InterchangeDecalNode_GetCustomDecalSize Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = std::move(Parms.AttributeValue);

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeDecalNode.GetCustomSortOrder
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32*                                  AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeDecalNode::GetCustomSortOrder(int32* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeDecalNode", "GetCustomSortOrder");

	Params::InterchangeDecalNode_GetCustomSortOrder Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = Parms.AttributeValue;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeBaseLightNode.SetCustomIntensity
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// float                                   AttributeValue                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeBaseLightNode::SetCustomIntensity(float AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeBaseLightNode", "SetCustomIntensity");

	Params::InterchangeBaseLightNode_SetCustomIntensity Parms{};

	Parms.AttributeValue = AttributeValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeBaseLightNode.SetCustomLightColor
// (Final, RequiredAPI, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FLinearColor&              AttributeValue                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeBaseLightNode::SetCustomLightColor(const struct FLinearColor& AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeBaseLightNode", "SetCustomLightColor");

	Params::InterchangeBaseLightNode_SetCustomLightColor Parms{};

	Parms.AttributeValue = std::move(AttributeValue);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeBaseLightNode.SetCustomTemperature
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// float                                   AttributeValue                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeBaseLightNode::SetCustomTemperature(float AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeBaseLightNode", "SetCustomTemperature");

	Params::InterchangeBaseLightNode_SetCustomTemperature Parms{};

	Parms.AttributeValue = AttributeValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeBaseLightNode.SetCustomUseTemperature
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    AttributeValue                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeBaseLightNode::SetCustomUseTemperature(bool AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeBaseLightNode", "SetCustomUseTemperature");

	Params::InterchangeBaseLightNode_SetCustomUseTemperature Parms{};

	Parms.AttributeValue = AttributeValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeBaseLightNode.GetCustomIntensity
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float*                                  AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeBaseLightNode::GetCustomIntensity(float* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeBaseLightNode", "GetCustomIntensity");

	Params::InterchangeBaseLightNode_GetCustomIntensity Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = Parms.AttributeValue;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeBaseLightNode.GetCustomLightColor
// (Final, RequiredAPI, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FLinearColor*                    AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeBaseLightNode::GetCustomLightColor(struct FLinearColor* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeBaseLightNode", "GetCustomLightColor");

	Params::InterchangeBaseLightNode_GetCustomLightColor Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = std::move(Parms.AttributeValue);

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeBaseLightNode.GetCustomTemperature
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float*                                  AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeBaseLightNode::GetCustomTemperature(float* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeBaseLightNode", "GetCustomTemperature");

	Params::InterchangeBaseLightNode_GetCustomTemperature Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = Parms.AttributeValue;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeBaseLightNode.GetCustomUseTemperature
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool*                                   AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeBaseLightNode::GetCustomUseTemperature(bool* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeBaseLightNode", "GetCustomUseTemperature");

	Params::InterchangeBaseLightNode_GetCustomUseTemperature Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = Parms.AttributeValue;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeLightNode.SetCustomAttenuationRadius
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// float                                   AttributeValue                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeLightNode::SetCustomAttenuationRadius(float AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeLightNode", "SetCustomAttenuationRadius");

	Params::InterchangeLightNode_SetCustomAttenuationRadius Parms{};

	Parms.AttributeValue = AttributeValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeLightNode.SetCustomIESBrightnessScale
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const float&                            AttributeValue                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bAddApplyDelegate                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeLightNode::SetCustomIESBrightnessScale(const float& AttributeValue, bool bAddApplyDelegate)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeLightNode", "SetCustomIESBrightnessScale");

	Params::InterchangeLightNode_SetCustomIESBrightnessScale Parms{};

	Parms.AttributeValue = AttributeValue;
	Parms.bAddApplyDelegate = bAddApplyDelegate;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeLightNode.SetCustomIESTexture
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    AttributeValue                                         (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeLightNode::SetCustomIESTexture(const class FString& AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeLightNode", "SetCustomIESTexture");

	Params::InterchangeLightNode_SetCustomIESTexture Parms{};

	Parms.AttributeValue = std::move(AttributeValue);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeLightNode.SetCustomIntensityUnits
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const EInterchangeLightUnits&           AttributeValue                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeLightNode::SetCustomIntensityUnits(const EInterchangeLightUnits& AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeLightNode", "SetCustomIntensityUnits");

	Params::InterchangeLightNode_SetCustomIntensityUnits Parms{};

	Parms.AttributeValue = AttributeValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeLightNode.SetCustomRotation
// (Final, RequiredAPI, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FRotator&                  AttributeValue                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bAddApplyDelegate                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeLightNode::SetCustomRotation(const struct FRotator& AttributeValue, bool bAddApplyDelegate)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeLightNode", "SetCustomRotation");

	Params::InterchangeLightNode_SetCustomRotation Parms{};

	Parms.AttributeValue = std::move(AttributeValue);
	Parms.bAddApplyDelegate = bAddApplyDelegate;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeLightNode.SetCustomUseIESBrightness
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const bool&                             AttributeValue                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bAddApplyDelegate                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeLightNode::SetCustomUseIESBrightness(const bool& AttributeValue, bool bAddApplyDelegate)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeLightNode", "SetCustomUseIESBrightness");

	Params::InterchangeLightNode_SetCustomUseIESBrightness Parms{};

	Parms.AttributeValue = AttributeValue;
	Parms.bAddApplyDelegate = bAddApplyDelegate;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeLightNode.GetCustomAttenuationRadius
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float*                                  AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeLightNode::GetCustomAttenuationRadius(float* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeLightNode", "GetCustomAttenuationRadius");

	Params::InterchangeLightNode_GetCustomAttenuationRadius Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = Parms.AttributeValue;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeLightNode.GetCustomIESBrightnessScale
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float*                                  AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeLightNode::GetCustomIESBrightnessScale(float* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeLightNode", "GetCustomIESBrightnessScale");

	Params::InterchangeLightNode_GetCustomIESBrightnessScale Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = Parms.AttributeValue;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeLightNode.GetCustomIESTexture
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FString*                          AttributeValue                                         (Parm, OutParm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeLightNode::GetCustomIESTexture(class FString* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeLightNode", "GetCustomIESTexture");

	Params::InterchangeLightNode_GetCustomIESTexture Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = std::move(Parms.AttributeValue);

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeLightNode.GetCustomIntensityUnits
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EInterchangeLightUnits*                 AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeLightNode::GetCustomIntensityUnits(EInterchangeLightUnits* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeLightNode", "GetCustomIntensityUnits");

	Params::InterchangeLightNode_GetCustomIntensityUnits Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = Parms.AttributeValue;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeLightNode.GetCustomRotation
// (Final, RequiredAPI, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FRotator*                        AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeLightNode::GetCustomRotation(struct FRotator* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeLightNode", "GetCustomRotation");

	Params::InterchangeLightNode_GetCustomRotation Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = std::move(Parms.AttributeValue);

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeLightNode.GetCustomUseIESBrightness
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool*                                   AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeLightNode::GetCustomUseIESBrightness(bool* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeLightNode", "GetCustomUseIESBrightness");

	Params::InterchangeLightNode_GetCustomUseIESBrightness Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = Parms.AttributeValue;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangePointLightNode.SetCustomLightFalloffExponent
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// float                                   AttributeValue                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangePointLightNode::SetCustomLightFalloffExponent(float AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangePointLightNode", "SetCustomLightFalloffExponent");

	Params::InterchangePointLightNode_SetCustomLightFalloffExponent Parms{};

	Parms.AttributeValue = AttributeValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangePointLightNode.SetCustomUseInverseSquaredFalloff
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    AttributeValue                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangePointLightNode::SetCustomUseInverseSquaredFalloff(bool AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangePointLightNode", "SetCustomUseInverseSquaredFalloff");

	Params::InterchangePointLightNode_SetCustomUseInverseSquaredFalloff Parms{};

	Parms.AttributeValue = AttributeValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangePointLightNode.GetCustomLightFalloffExponent
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float*                                  AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangePointLightNode::GetCustomLightFalloffExponent(float* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangePointLightNode", "GetCustomLightFalloffExponent");

	Params::InterchangePointLightNode_GetCustomLightFalloffExponent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = Parms.AttributeValue;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangePointLightNode.GetCustomUseInverseSquaredFalloff
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool*                                   AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangePointLightNode::GetCustomUseInverseSquaredFalloff(bool* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangePointLightNode", "GetCustomUseInverseSquaredFalloff");

	Params::InterchangePointLightNode_GetCustomUseInverseSquaredFalloff Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = Parms.AttributeValue;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeSpotLightNode.SetCustomInnerConeAngle
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// float                                   AttributeValue                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeSpotLightNode::SetCustomInnerConeAngle(float AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSpotLightNode", "SetCustomInnerConeAngle");

	Params::InterchangeSpotLightNode_SetCustomInnerConeAngle Parms{};

	Parms.AttributeValue = AttributeValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeSpotLightNode.SetCustomOuterConeAngle
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// float                                   AttributeValue                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeSpotLightNode::SetCustomOuterConeAngle(float AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSpotLightNode", "SetCustomOuterConeAngle");

	Params::InterchangeSpotLightNode_SetCustomOuterConeAngle Parms{};

	Parms.AttributeValue = AttributeValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeSpotLightNode.GetCustomInnerConeAngle
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float*                                  AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeSpotLightNode::GetCustomInnerConeAngle(float* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSpotLightNode", "GetCustomInnerConeAngle");

	Params::InterchangeSpotLightNode_GetCustomInnerConeAngle Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = Parms.AttributeValue;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeSpotLightNode.GetCustomOuterConeAngle
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float*                                  AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeSpotLightNode::GetCustomOuterConeAngle(float* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSpotLightNode", "GetCustomOuterConeAngle");

	Params::InterchangeSpotLightNode_GetCustomOuterConeAngle Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = Parms.AttributeValue;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeRectLightNode.SetCustomSourceHeight
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// float                                   AttributeValue                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeRectLightNode::SetCustomSourceHeight(float AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeRectLightNode", "SetCustomSourceHeight");

	Params::InterchangeRectLightNode_SetCustomSourceHeight Parms{};

	Parms.AttributeValue = AttributeValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeRectLightNode.SetCustomSourceWidth
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// float                                   AttributeValue                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeRectLightNode::SetCustomSourceWidth(float AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeRectLightNode", "SetCustomSourceWidth");

	Params::InterchangeRectLightNode_SetCustomSourceWidth Parms{};

	Parms.AttributeValue = AttributeValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeRectLightNode.GetCustomSourceHeight
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float*                                  AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeRectLightNode::GetCustomSourceHeight(float* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeRectLightNode", "GetCustomSourceHeight");

	Params::InterchangeRectLightNode_GetCustomSourceHeight Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = Parms.AttributeValue;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeRectLightNode.GetCustomSourceWidth
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float*                                  AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeRectLightNode::GetCustomSourceWidth(float* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeRectLightNode", "GetCustomSourceWidth");

	Params::InterchangeRectLightNode_GetCustomSourceWidth Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = Parms.AttributeValue;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeTextureNode.SetCustombFlipGreenChannel
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const bool&                             AttributeValue                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeTextureNode::SetCustombFlipGreenChannel(const bool& AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeTextureNode", "SetCustombFlipGreenChannel");

	Params::InterchangeTextureNode_SetCustombFlipGreenChannel Parms{};

	Parms.AttributeValue = AttributeValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeTextureNode.SetCustomColorSpace
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const EInterchangeTextureColorSpace&    AttributeValue                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeTextureNode::SetCustomColorSpace(const EInterchangeTextureColorSpace& AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeTextureNode", "SetCustomColorSpace");

	Params::InterchangeTextureNode_SetCustomColorSpace Parms{};

	Parms.AttributeValue = AttributeValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeTextureNode.SetCustomFilter
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const EInterchangeTextureFilterMode&    AttributeValue                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeTextureNode::SetCustomFilter(const EInterchangeTextureFilterMode& AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeTextureNode", "SetCustomFilter");

	Params::InterchangeTextureNode_SetCustomFilter Parms{};

	Parms.AttributeValue = AttributeValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeTextureNode.SetCustomSRGB
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const bool&                             AttributeValue                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeTextureNode::SetCustomSRGB(const bool& AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeTextureNode", "SetCustomSRGB");

	Params::InterchangeTextureNode_SetCustomSRGB Parms{};

	Parms.AttributeValue = AttributeValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeTextureNode.SetPayLoadKey
// (Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    PayloadKey                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UInterchangeTextureNode::SetPayLoadKey(const class FString& PayloadKey)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeTextureNode", "SetPayLoadKey");

	Params::InterchangeTextureNode_SetPayLoadKey Parms{};

	Parms.PayloadKey = std::move(PayloadKey);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function InterchangeNodes.InterchangeTextureNode.GetCustombFlipGreenChannel
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool*                                   AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeTextureNode::GetCustombFlipGreenChannel(bool* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeTextureNode", "GetCustombFlipGreenChannel");

	Params::InterchangeTextureNode_GetCustombFlipGreenChannel Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = Parms.AttributeValue;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeTextureNode.GetCustomColorSpace
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EInterchangeTextureColorSpace*          AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeTextureNode::GetCustomColorSpace(EInterchangeTextureColorSpace* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeTextureNode", "GetCustomColorSpace");

	Params::InterchangeTextureNode_GetCustomColorSpace Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = Parms.AttributeValue;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeTextureNode.GetCustomFilter
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EInterchangeTextureFilterMode*          AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeTextureNode::GetCustomFilter(EInterchangeTextureFilterMode* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeTextureNode", "GetCustomFilter");

	Params::InterchangeTextureNode_GetCustomFilter Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = Parms.AttributeValue;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeTextureNode.GetCustomSRGB
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool*                                   AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeTextureNode::GetCustomSRGB(bool* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeTextureNode", "GetCustomSRGB");

	Params::InterchangeTextureNode_GetCustomSRGB Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = Parms.AttributeValue;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeVariantSetNode.AddCustomDependencyUid
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    DependencyUid                                          (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeVariantSetNode::AddCustomDependencyUid(const class FString& DependencyUid)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeVariantSetNode", "AddCustomDependencyUid");

	Params::InterchangeVariantSetNode_AddCustomDependencyUid Parms{};

	Parms.DependencyUid = std::move(DependencyUid);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeVariantSetNode.RemoveCustomDependencyUid
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    DependencyUid                                          (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeVariantSetNode::RemoveCustomDependencyUid(const class FString& DependencyUid)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeVariantSetNode", "RemoveCustomDependencyUid");

	Params::InterchangeVariantSetNode_RemoveCustomDependencyUid Parms{};

	Parms.DependencyUid = std::move(DependencyUid);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeVariantSetNode.SetCustomDisplayText
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    AttributeValue                                         (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeVariantSetNode::SetCustomDisplayText(const class FString& AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeVariantSetNode", "SetCustomDisplayText");

	Params::InterchangeVariantSetNode_SetCustomDisplayText Parms{};

	Parms.AttributeValue = std::move(AttributeValue);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeVariantSetNode.SetCustomVariantsPayloadKey
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    PayloadKey                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeVariantSetNode::SetCustomVariantsPayloadKey(const class FString& PayloadKey)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeVariantSetNode", "SetCustomVariantsPayloadKey");

	Params::InterchangeVariantSetNode_SetCustomVariantsPayloadKey Parms{};

	Parms.PayloadKey = std::move(PayloadKey);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeVariantSetNode.GetCustomDependencyUid
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const int32                             Index_0                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString*                          OutDependencyUid                                       (Parm, OutParm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UInterchangeVariantSetNode::GetCustomDependencyUid(const int32 Index_0, class FString* OutDependencyUid) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeVariantSetNode", "GetCustomDependencyUid");

	Params::InterchangeVariantSetNode_GetCustomDependencyUid Parms{};

	Parms.Index_0 = Index_0;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutDependencyUid != nullptr)
		*OutDependencyUid = std::move(Parms.OutDependencyUid);
}


// Function InterchangeNodes.InterchangeVariantSetNode.GetCustomDependencyUidCount
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UInterchangeVariantSetNode::GetCustomDependencyUidCount() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeVariantSetNode", "GetCustomDependencyUidCount");

	Params::InterchangeVariantSetNode_GetCustomDependencyUidCount Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeVariantSetNode.GetCustomDependencyUids
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<class FString>*                  OutDependencyUids                                      (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void UInterchangeVariantSetNode::GetCustomDependencyUids(TArray<class FString>* OutDependencyUids) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeVariantSetNode", "GetCustomDependencyUids");

	Params::InterchangeVariantSetNode_GetCustomDependencyUids Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutDependencyUids != nullptr)
		*OutDependencyUids = std::move(Parms.OutDependencyUids);
}


// Function InterchangeNodes.InterchangeVariantSetNode.GetCustomDisplayText
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FString*                          AttributeValue                                         (Parm, OutParm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeVariantSetNode::GetCustomDisplayText(class FString* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeVariantSetNode", "GetCustomDisplayText");

	Params::InterchangeVariantSetNode_GetCustomDisplayText Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = std::move(Parms.AttributeValue);

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeVariantSetNode.GetCustomVariantsPayloadKey
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FString*                          PayloadKey                                             (Parm, OutParm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeVariantSetNode::GetCustomVariantsPayloadKey(class FString* PayloadKey) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeVariantSetNode", "GetCustomVariantsPayloadKey");

	Params::InterchangeVariantSetNode_GetCustomVariantsPayloadKey Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (PayloadKey != nullptr)
		*PayloadKey = std::move(Parms.PayloadKey);

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeSceneVariantSetsNode.AddCustomVariantSetUid
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    VariantUid                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeSceneVariantSetsNode::AddCustomVariantSetUid(const class FString& VariantUid)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSceneVariantSetsNode", "AddCustomVariantSetUid");

	Params::InterchangeSceneVariantSetsNode_AddCustomVariantSetUid Parms{};

	Parms.VariantUid = std::move(VariantUid);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeSceneVariantSetsNode.RemoveCustomVariantSetUid
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    VariantUid                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeSceneVariantSetsNode::RemoveCustomVariantSetUid(const class FString& VariantUid)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSceneVariantSetsNode", "RemoveCustomVariantSetUid");

	Params::InterchangeSceneVariantSetsNode_RemoveCustomVariantSetUid Parms{};

	Parms.VariantUid = std::move(VariantUid);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeSceneVariantSetsNode.GetCustomVariantSetUid
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const int32                             Index_0                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString*                          OutVariantUid                                          (Parm, OutParm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UInterchangeSceneVariantSetsNode::GetCustomVariantSetUid(const int32 Index_0, class FString* OutVariantUid) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSceneVariantSetsNode", "GetCustomVariantSetUid");

	Params::InterchangeSceneVariantSetsNode_GetCustomVariantSetUid Parms{};

	Parms.Index_0 = Index_0;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutVariantUid != nullptr)
		*OutVariantUid = std::move(Parms.OutVariantUid);
}


// Function InterchangeNodes.InterchangeSceneVariantSetsNode.GetCustomVariantSetUidCount
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UInterchangeSceneVariantSetsNode::GetCustomVariantSetUidCount() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSceneVariantSetsNode", "GetCustomVariantSetUidCount");

	Params::InterchangeSceneVariantSetsNode_GetCustomVariantSetUidCount Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeSceneVariantSetsNode.GetCustomVariantSetUids
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<class FString>*                  OutVariantUids                                         (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void UInterchangeSceneVariantSetsNode::GetCustomVariantSetUids(TArray<class FString>* OutVariantUids) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSceneVariantSetsNode", "GetCustomVariantSetUids");

	Params::InterchangeSceneVariantSetsNode_GetCustomVariantSetUids Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutVariantUids != nullptr)
		*OutVariantUids = std::move(Parms.OutVariantUids);
}


// Function InterchangeNodes.InterchangeVolumeNode.AddCustomFrameIndexInAnimation
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   Index_0                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeVolumeNode::AddCustomFrameIndexInAnimation(int32 Index_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeVolumeNode", "AddCustomFrameIndexInAnimation");

	Params::InterchangeVolumeNode_AddCustomFrameIndexInAnimation Parms{};

	Parms.Index_0 = Index_0;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeVolumeNode.AddCustomGridDependency
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    DependencyUid                                          (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeVolumeNode::AddCustomGridDependency(const class FString& DependencyUid)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeVolumeNode", "AddCustomGridDependency");

	Params::InterchangeVolumeNode_AddCustomGridDependency Parms{};

	Parms.DependencyUid = std::move(DependencyUid);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeVolumeNode.RemoveCustomFrameIndexInAnimation
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   Index_0                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeVolumeNode::RemoveCustomFrameIndexInAnimation(int32 Index_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeVolumeNode", "RemoveCustomFrameIndexInAnimation");

	Params::InterchangeVolumeNode_RemoveCustomFrameIndexInAnimation Parms{};

	Parms.Index_0 = Index_0;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeVolumeNode.RemoveCustomGridDependency
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    DependencyUid                                          (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeVolumeNode::RemoveCustomGridDependency(const class FString& DependencyUid)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeVolumeNode", "RemoveCustomGridDependency");

	Params::InterchangeVolumeNode_RemoveCustomGridDependency Parms{};

	Parms.DependencyUid = std::move(DependencyUid);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeVolumeNode.SetCustomAnimationID
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    AttributeValue                                         (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeVolumeNode::SetCustomAnimationID(const class FString& AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeVolumeNode", "SetCustomAnimationID");

	Params::InterchangeVolumeNode_SetCustomAnimationID Parms{};

	Parms.AttributeValue = std::move(AttributeValue);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeVolumeNode.SetCustomFileName
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    AttributeValue                                         (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeVolumeNode::SetCustomFileName(const class FString& AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeVolumeNode", "SetCustomFileName");

	Params::InterchangeVolumeNode_SetCustomFileName Parms{};

	Parms.AttributeValue = std::move(AttributeValue);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeVolumeNode.GetCustomAnimationID
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FString*                          AttributeValue                                         (Parm, OutParm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeVolumeNode::GetCustomAnimationID(class FString* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeVolumeNode", "GetCustomAnimationID");

	Params::InterchangeVolumeNode_GetCustomAnimationID Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = std::move(Parms.AttributeValue);

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeVolumeNode.GetCustomFileName
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FString*                          AttributeValue                                         (Parm, OutParm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeVolumeNode::GetCustomFileName(class FString* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeVolumeNode", "GetCustomFileName");

	Params::InterchangeVolumeNode_GetCustomFileName Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = std::move(Parms.AttributeValue);

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeVolumeNode.GetCustomFrameIndexInAnimation
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   IndexIndex                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32*                                  OutIndex                                               (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UInterchangeVolumeNode::GetCustomFrameIndexInAnimation(int32 IndexIndex, int32* OutIndex) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeVolumeNode", "GetCustomFrameIndexInAnimation");

	Params::InterchangeVolumeNode_GetCustomFrameIndexInAnimation Parms{};

	Parms.IndexIndex = IndexIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutIndex != nullptr)
		*OutIndex = Parms.OutIndex;
}


// Function InterchangeNodes.InterchangeVolumeNode.GetCustomFrameIndicesInAnimation
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<int32>*                          OutAnimationIndices                                    (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void UInterchangeVolumeNode::GetCustomFrameIndicesInAnimation(TArray<int32>* OutAnimationIndices) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeVolumeNode", "GetCustomFrameIndicesInAnimation");

	Params::InterchangeVolumeNode_GetCustomFrameIndicesInAnimation Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutAnimationIndices != nullptr)
		*OutAnimationIndices = std::move(Parms.OutAnimationIndices);
}


// Function InterchangeNodes.InterchangeVolumeNode.GetCustomGridDependecies
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<class FString>*                  OutDependencies                                        (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void UInterchangeVolumeNode::GetCustomGridDependecies(TArray<class FString>* OutDependencies) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeVolumeNode", "GetCustomGridDependecies");

	Params::InterchangeVolumeNode_GetCustomGridDependecies Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutDependencies != nullptr)
		*OutDependencies = std::move(Parms.OutDependencies);
}


// Function InterchangeNodes.InterchangeVolumeNode.GetCustomGridDependeciesCount
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UInterchangeVolumeNode::GetCustomGridDependeciesCount() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeVolumeNode", "GetCustomGridDependeciesCount");

	Params::InterchangeVolumeNode_GetCustomGridDependeciesCount Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeVolumeNode.GetCustomGridDependency
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const int32                             Index_0                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString*                          OutDependency                                          (Parm, OutParm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UInterchangeVolumeNode::GetCustomGridDependency(const int32 Index_0, class FString* OutDependency) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeVolumeNode", "GetCustomGridDependency");

	Params::InterchangeVolumeNode_GetCustomGridDependency Parms{};

	Parms.Index_0 = Index_0;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutDependency != nullptr)
		*OutDependency = std::move(Parms.OutDependency);
}


// Function InterchangeNodes.InterchangeVolumeGridNode.SetCustomElementType
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const EVolumeGridElementType&           AttributeValue                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeVolumeGridNode::SetCustomElementType(const EVolumeGridElementType& AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeVolumeGridNode", "SetCustomElementType");

	Params::InterchangeVolumeGridNode_SetCustomElementType Parms{};

	Parms.AttributeValue = AttributeValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeVolumeGridNode.SetCustomGridActiveAABBMax
// (Final, RequiredAPI, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FIntVector&                AttributeValue                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeVolumeGridNode::SetCustomGridActiveAABBMax(const struct FIntVector& AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeVolumeGridNode", "SetCustomGridActiveAABBMax");

	Params::InterchangeVolumeGridNode_SetCustomGridActiveAABBMax Parms{};

	Parms.AttributeValue = std::move(AttributeValue);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeVolumeGridNode.SetCustomGridActiveAABBMin
// (Final, RequiredAPI, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FIntVector&                AttributeValue                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeVolumeGridNode::SetCustomGridActiveAABBMin(const struct FIntVector& AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeVolumeGridNode", "SetCustomGridActiveAABBMin");

	Params::InterchangeVolumeGridNode_SetCustomGridActiveAABBMin Parms{};

	Parms.AttributeValue = std::move(AttributeValue);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeVolumeGridNode.SetCustomGridActiveDimensions
// (Final, RequiredAPI, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FIntVector&                AttributeValue                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeVolumeGridNode::SetCustomGridActiveDimensions(const struct FIntVector& AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeVolumeGridNode", "SetCustomGridActiveDimensions");

	Params::InterchangeVolumeGridNode_SetCustomGridActiveDimensions Parms{};

	Parms.AttributeValue = std::move(AttributeValue);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeVolumeGridNode.SetCustomGridTransform
// (Final, RequiredAPI, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FTransform&                AttributeValue                                         (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeVolumeGridNode::SetCustomGridTransform(const struct FTransform& AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeVolumeGridNode", "SetCustomGridTransform");

	Params::InterchangeVolumeGridNode_SetCustomGridTransform Parms{};

	Parms.AttributeValue = std::move(AttributeValue);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeVolumeGridNode.SetCustomNumComponents
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const int32&                            NumComponents                                          (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeVolumeGridNode::SetCustomNumComponents(const int32& NumComponents)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeVolumeGridNode", "SetCustomNumComponents");

	Params::InterchangeVolumeGridNode_SetCustomNumComponents Parms{};

	Parms.NumComponents = NumComponents;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeVolumeGridNode.GetCustomElementType
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EVolumeGridElementType*                 AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeVolumeGridNode::GetCustomElementType(EVolumeGridElementType* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeVolumeGridNode", "GetCustomElementType");

	Params::InterchangeVolumeGridNode_GetCustomElementType Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = Parms.AttributeValue;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeVolumeGridNode.GetCustomGridActiveAABBMax
// (Final, RequiredAPI, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FIntVector*                      AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeVolumeGridNode::GetCustomGridActiveAABBMax(struct FIntVector* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeVolumeGridNode", "GetCustomGridActiveAABBMax");

	Params::InterchangeVolumeGridNode_GetCustomGridActiveAABBMax Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = std::move(Parms.AttributeValue);

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeVolumeGridNode.GetCustomGridActiveAABBMin
// (Final, RequiredAPI, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FIntVector*                      AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeVolumeGridNode::GetCustomGridActiveAABBMin(struct FIntVector* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeVolumeGridNode", "GetCustomGridActiveAABBMin");

	Params::InterchangeVolumeGridNode_GetCustomGridActiveAABBMin Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = std::move(Parms.AttributeValue);

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeVolumeGridNode.GetCustomGridActiveDimensions
// (Final, RequiredAPI, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FIntVector*                      AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeVolumeGridNode::GetCustomGridActiveDimensions(struct FIntVector* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeVolumeGridNode", "GetCustomGridActiveDimensions");

	Params::InterchangeVolumeGridNode_GetCustomGridActiveDimensions Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = std::move(Parms.AttributeValue);

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeVolumeGridNode.GetCustomGridTransform
// (Final, RequiredAPI, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FTransform*                      AttributeValue                                         (Parm, OutParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeVolumeGridNode::GetCustomGridTransform(struct FTransform* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeVolumeGridNode", "GetCustomGridTransform");

	Params::InterchangeVolumeGridNode_GetCustomGridTransform Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = std::move(Parms.AttributeValue);

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeVolumeGridNode.GetCustomNumComponents
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32*                                  NumComponents                                          (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeVolumeGridNode::GetCustomNumComponents(int32* NumComponents) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeVolumeGridNode", "GetCustomNumComponents");

	Params::InterchangeVolumeGridNode_GetCustomNumComponents Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (NumComponents != nullptr)
		*NumComponents = Parms.NumComponents;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeMaterialInstanceNode.AddScalarParameterValue
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    ParameterName                                          (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   AttributeValue                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeMaterialInstanceNode::AddScalarParameterValue(const class FString& ParameterName, float AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeMaterialInstanceNode", "AddScalarParameterValue");

	Params::InterchangeMaterialInstanceNode_AddScalarParameterValue Parms{};

	Parms.ParameterName = std::move(ParameterName);
	Parms.AttributeValue = AttributeValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeMaterialInstanceNode.AddStaticSwitchParameterValue
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    ParameterName                                          (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    AttributeValue                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeMaterialInstanceNode::AddStaticSwitchParameterValue(const class FString& ParameterName, bool AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeMaterialInstanceNode", "AddStaticSwitchParameterValue");

	Params::InterchangeMaterialInstanceNode_AddStaticSwitchParameterValue Parms{};

	Parms.ParameterName = std::move(ParameterName);
	Parms.AttributeValue = AttributeValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeMaterialInstanceNode.AddTextureParameterValue
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    ParameterName                                          (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    AttributeValue                                         (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeMaterialInstanceNode::AddTextureParameterValue(const class FString& ParameterName, const class FString& AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeMaterialInstanceNode", "AddTextureParameterValue");

	Params::InterchangeMaterialInstanceNode_AddTextureParameterValue Parms{};

	Parms.ParameterName = std::move(ParameterName);
	Parms.AttributeValue = std::move(AttributeValue);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeMaterialInstanceNode.AddVectorParameterValue
// (Final, RequiredAPI, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class FString&                    ParameterName                                          (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FLinearColor&              AttributeValue                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeMaterialInstanceNode::AddVectorParameterValue(const class FString& ParameterName, const struct FLinearColor& AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeMaterialInstanceNode", "AddVectorParameterValue");

	Params::InterchangeMaterialInstanceNode_AddVectorParameterValue Parms{};

	Parms.ParameterName = std::move(ParameterName);
	Parms.AttributeValue = std::move(AttributeValue);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeMaterialInstanceNode.GetCustomParent
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FString*                          AttributeValue                                         (Parm, OutParm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeMaterialInstanceNode::GetCustomParent(class FString* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeMaterialInstanceNode", "GetCustomParent");

	Params::InterchangeMaterialInstanceNode_GetCustomParent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = std::move(Parms.AttributeValue);

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeMaterialInstanceNode.GetScalarParameterValue
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class FString&                    ParameterName                                          (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float*                                  AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeMaterialInstanceNode::GetScalarParameterValue(const class FString& ParameterName, float* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeMaterialInstanceNode", "GetScalarParameterValue");

	Params::InterchangeMaterialInstanceNode_GetScalarParameterValue Parms{};

	Parms.ParameterName = std::move(ParameterName);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = Parms.AttributeValue;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeMaterialInstanceNode.GetStaticSwitchParameterValue
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class FString&                    ParameterName                                          (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool*                                   AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeMaterialInstanceNode::GetStaticSwitchParameterValue(const class FString& ParameterName, bool* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeMaterialInstanceNode", "GetStaticSwitchParameterValue");

	Params::InterchangeMaterialInstanceNode_GetStaticSwitchParameterValue Parms{};

	Parms.ParameterName = std::move(ParameterName);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = Parms.AttributeValue;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeMaterialInstanceNode.GetTextureParameterValue
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class FString&                    ParameterName                                          (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString*                          AttributeValue                                         (Parm, OutParm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeMaterialInstanceNode::GetTextureParameterValue(const class FString& ParameterName, class FString* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeMaterialInstanceNode", "GetTextureParameterValue");

	Params::InterchangeMaterialInstanceNode_GetTextureParameterValue Parms{};

	Parms.ParameterName = std::move(ParameterName);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = std::move(Parms.AttributeValue);

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeMaterialInstanceNode.GetVectorParameterValue
// (Final, RequiredAPI, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class FString&                    ParameterName                                          (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FLinearColor*                    AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeMaterialInstanceNode::GetVectorParameterValue(const class FString& ParameterName, struct FLinearColor* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeMaterialInstanceNode", "GetVectorParameterValue");

	Params::InterchangeMaterialInstanceNode_GetVectorParameterValue Parms{};

	Parms.ParameterName = std::move(ParameterName);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = std::move(Parms.AttributeValue);

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeMaterialInstanceNode.SetCustomParent
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class FString&                    AttributeValue                                         (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeMaterialInstanceNode::SetCustomParent(const class FString& AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeMaterialInstanceNode", "SetCustomParent");

	Params::InterchangeMaterialInstanceNode_SetCustomParent Parms{};

	Parms.AttributeValue = std::move(AttributeValue);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeMaterialReferenceNode.GetCustomContentPath
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FString*                          AttributeValue                                         (Parm, OutParm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeMaterialReferenceNode::GetCustomContentPath(class FString* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeMaterialReferenceNode", "GetCustomContentPath");

	Params::InterchangeMaterialReferenceNode_GetCustomContentPath Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = std::move(Parms.AttributeValue);

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeMaterialReferenceNode.SetCustomContentPath
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class FString&                    AttributeValue                                         (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeMaterialReferenceNode::SetCustomContentPath(const class FString& AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeMaterialReferenceNode", "SetCustomContentPath");

	Params::InterchangeMaterialReferenceNode_SetCustomContentPath Parms{};

	Parms.AttributeValue = std::move(AttributeValue);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeMeshNode.RemoveMorphTargetDependencyUid
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    DependencyUid                                          (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeMeshNode::RemoveMorphTargetDependencyUid(const class FString& DependencyUid)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeMeshNode", "RemoveMorphTargetDependencyUid");

	Params::InterchangeMeshNode_RemoveMorphTargetDependencyUid Parms{};

	Parms.DependencyUid = std::move(DependencyUid);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeMeshNode.RemoveSceneInstanceUid
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    DependencyUid                                          (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeMeshNode::RemoveSceneInstanceUid(const class FString& DependencyUid)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeMeshNode", "RemoveSceneInstanceUid");

	Params::InterchangeMeshNode_RemoveSceneInstanceUid Parms{};

	Parms.DependencyUid = std::move(DependencyUid);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeMeshNode.RemoveSkeletonDependencyUid
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    DependencyUid                                          (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeMeshNode::RemoveSkeletonDependencyUid(const class FString& DependencyUid)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeMeshNode", "RemoveSkeletonDependencyUid");

	Params::InterchangeMeshNode_RemoveSkeletonDependencyUid Parms{};

	Parms.DependencyUid = std::move(DependencyUid);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeMeshNode.RemoveSlotMaterialDependencyUid
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    SlotName                                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeMeshNode::RemoveSlotMaterialDependencyUid(const class FString& SlotName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeMeshNode", "RemoveSlotMaterialDependencyUid");

	Params::InterchangeMeshNode_RemoveSlotMaterialDependencyUid Parms{};

	Parms.SlotName = std::move(SlotName);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeMeshNode.SetCustomBoundingBox
// (Final, RequiredAPI, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FBox&                      AttributeValue                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeMeshNode::SetCustomBoundingBox(const struct FBox& AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeMeshNode", "SetCustomBoundingBox");

	Params::InterchangeMeshNode_SetCustomBoundingBox Parms{};

	Parms.AttributeValue = std::move(AttributeValue);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeMeshNode.SetCustomCollisionType
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// EInterchangeMeshCollision               AttributeValue                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeMeshNode::SetCustomCollisionType(EInterchangeMeshCollision AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeMeshNode", "SetCustomCollisionType");

	Params::InterchangeMeshNode_SetCustomCollisionType Parms{};

	Parms.AttributeValue = AttributeValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeMeshNode.SetCustomHasSmoothGroup
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const bool&                             AttributeValue                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeMeshNode::SetCustomHasSmoothGroup(const bool& AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeMeshNode", "SetCustomHasSmoothGroup");

	Params::InterchangeMeshNode_SetCustomHasSmoothGroup Parms{};

	Parms.AttributeValue = AttributeValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeMeshNode.SetCustomHasVertexBinormal
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const bool&                             AttributeValue                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeMeshNode::SetCustomHasVertexBinormal(const bool& AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeMeshNode", "SetCustomHasVertexBinormal");

	Params::InterchangeMeshNode_SetCustomHasVertexBinormal Parms{};

	Parms.AttributeValue = AttributeValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeMeshNode.SetCustomHasVertexColor
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const bool&                             AttributeValue                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeMeshNode::SetCustomHasVertexColor(const bool& AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeMeshNode", "SetCustomHasVertexColor");

	Params::InterchangeMeshNode_SetCustomHasVertexColor Parms{};

	Parms.AttributeValue = AttributeValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeMeshNode.SetCustomHasVertexNormal
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const bool&                             AttributeValue                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeMeshNode::SetCustomHasVertexNormal(const bool& AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeMeshNode", "SetCustomHasVertexNormal");

	Params::InterchangeMeshNode_SetCustomHasVertexNormal Parms{};

	Parms.AttributeValue = AttributeValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeMeshNode.SetCustomHasVertexTangent
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const bool&                             AttributeValue                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeMeshNode::SetCustomHasVertexTangent(const bool& AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeMeshNode", "SetCustomHasVertexTangent");

	Params::InterchangeMeshNode_SetCustomHasVertexTangent Parms{};

	Parms.AttributeValue = AttributeValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeMeshNode.SetCustomPolygonCount
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const int32&                            AttributeValue                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeMeshNode::SetCustomPolygonCount(const int32& AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeMeshNode", "SetCustomPolygonCount");

	Params::InterchangeMeshNode_SetCustomPolygonCount Parms{};

	Parms.AttributeValue = AttributeValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeMeshNode.SetCustomUVCount
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const int32&                            AttributeValue                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeMeshNode::SetCustomUVCount(const int32& AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeMeshNode", "SetCustomUVCount");

	Params::InterchangeMeshNode_SetCustomUVCount Parms{};

	Parms.AttributeValue = AttributeValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeMeshNode.SetCustomVertexCount
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const int32&                            AttributeValue                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeMeshNode::SetCustomVertexCount(const int32& AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeMeshNode", "SetCustomVertexCount");

	Params::InterchangeMeshNode_SetCustomVertexCount Parms{};

	Parms.AttributeValue = AttributeValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeMeshNode.SetMorphTarget
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// const bool                              bIsMorphTarget                                         (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeMeshNode::SetMorphTarget(const bool bIsMorphTarget)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeMeshNode", "SetMorphTarget");

	Params::InterchangeMeshNode_SetMorphTarget Parms{};

	Parms.bIsMorphTarget = bIsMorphTarget;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeMeshNode.SetMorphTargetDependencyUid
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    DependencyUid                                          (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeMeshNode::SetMorphTargetDependencyUid(const class FString& DependencyUid)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeMeshNode", "SetMorphTargetDependencyUid");

	Params::InterchangeMeshNode_SetMorphTargetDependencyUid Parms{};

	Parms.DependencyUid = std::move(DependencyUid);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeMeshNode.SetMorphTargetName
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    MorphTargetName                                        (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeMeshNode::SetMorphTargetName(const class FString& MorphTargetName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeMeshNode", "SetMorphTargetName");

	Params::InterchangeMeshNode_SetMorphTargetName Parms{};

	Parms.MorphTargetName = std::move(MorphTargetName);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeMeshNode.SetPayLoadKey
// (RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FString&                    PayloadKey                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EInterchangeMeshPayLoadType&      PayloadType                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UInterchangeMeshNode::SetPayLoadKey(const class FString& PayloadKey, const EInterchangeMeshPayLoadType& PayloadType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeMeshNode", "SetPayLoadKey");

	Params::InterchangeMeshNode_SetPayLoadKey Parms{};

	Parms.PayloadKey = std::move(PayloadKey);
	Parms.PayloadType = PayloadType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function InterchangeNodes.InterchangeMeshNode.SetSceneInstanceUid
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    DependencyUid                                          (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeMeshNode::SetSceneInstanceUid(const class FString& DependencyUid)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeMeshNode", "SetSceneInstanceUid");

	Params::InterchangeMeshNode_SetSceneInstanceUid Parms{};

	Parms.DependencyUid = std::move(DependencyUid);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeMeshNode.SetSkeletonDependencyUid
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    DependencyUid                                          (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeMeshNode::SetSkeletonDependencyUid(const class FString& DependencyUid)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeMeshNode", "SetSkeletonDependencyUid");

	Params::InterchangeMeshNode_SetSkeletonDependencyUid Parms{};

	Parms.DependencyUid = std::move(DependencyUid);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeMeshNode.SetSkinnedMesh
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// const bool                              bIsSkinnedMesh                                         (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeMeshNode::SetSkinnedMesh(const bool bIsSkinnedMesh)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeMeshNode", "SetSkinnedMesh");

	Params::InterchangeMeshNode_SetSkinnedMesh Parms{};

	Parms.bIsSkinnedMesh = bIsSkinnedMesh;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeMeshNode.SetSlotMaterialDependencyUid
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    SlotName                                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    MaterialDependencyUid                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeMeshNode::SetSlotMaterialDependencyUid(const class FString& SlotName, const class FString& MaterialDependencyUid)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeMeshNode", "SetSlotMaterialDependencyUid");

	Params::InterchangeMeshNode_SetSlotMaterialDependencyUid Parms{};

	Parms.SlotName = std::move(SlotName);
	Parms.MaterialDependencyUid = std::move(MaterialDependencyUid);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeMeshNode.GetCustomBoundingBox
// (Final, RequiredAPI, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FBox*                            AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeMeshNode::GetCustomBoundingBox(struct FBox* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeMeshNode", "GetCustomBoundingBox");

	Params::InterchangeMeshNode_GetCustomBoundingBox Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = std::move(Parms.AttributeValue);

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeMeshNode.GetCustomCollisionType
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EInterchangeMeshCollision*              AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeMeshNode::GetCustomCollisionType(EInterchangeMeshCollision* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeMeshNode", "GetCustomCollisionType");

	Params::InterchangeMeshNode_GetCustomCollisionType Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = Parms.AttributeValue;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeMeshNode.GetCustomHasSmoothGroup
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool*                                   AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeMeshNode::GetCustomHasSmoothGroup(bool* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeMeshNode", "GetCustomHasSmoothGroup");

	Params::InterchangeMeshNode_GetCustomHasSmoothGroup Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = Parms.AttributeValue;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeMeshNode.GetCustomHasVertexBinormal
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool*                                   AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeMeshNode::GetCustomHasVertexBinormal(bool* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeMeshNode", "GetCustomHasVertexBinormal");

	Params::InterchangeMeshNode_GetCustomHasVertexBinormal Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = Parms.AttributeValue;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeMeshNode.GetCustomHasVertexColor
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool*                                   AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeMeshNode::GetCustomHasVertexColor(bool* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeMeshNode", "GetCustomHasVertexColor");

	Params::InterchangeMeshNode_GetCustomHasVertexColor Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = Parms.AttributeValue;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeMeshNode.GetCustomHasVertexNormal
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool*                                   AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeMeshNode::GetCustomHasVertexNormal(bool* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeMeshNode", "GetCustomHasVertexNormal");

	Params::InterchangeMeshNode_GetCustomHasVertexNormal Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = Parms.AttributeValue;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeMeshNode.GetCustomHasVertexTangent
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool*                                   AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeMeshNode::GetCustomHasVertexTangent(bool* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeMeshNode", "GetCustomHasVertexTangent");

	Params::InterchangeMeshNode_GetCustomHasVertexTangent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = Parms.AttributeValue;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeMeshNode.GetCustomPolygonCount
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32*                                  AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeMeshNode::GetCustomPolygonCount(int32* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeMeshNode", "GetCustomPolygonCount");

	Params::InterchangeMeshNode_GetCustomPolygonCount Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = Parms.AttributeValue;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeMeshNode.GetCustomUVCount
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32*                                  AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeMeshNode::GetCustomUVCount(int32* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeMeshNode", "GetCustomUVCount");

	Params::InterchangeMeshNode_GetCustomUVCount Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = Parms.AttributeValue;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeMeshNode.GetCustomVertexCount
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32*                                  AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeMeshNode::GetCustomVertexCount(int32* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeMeshNode", "GetCustomVertexCount");

	Params::InterchangeMeshNode_GetCustomVertexCount Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = Parms.AttributeValue;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeMeshNode.GetMorphTargetDependeciesCount
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UInterchangeMeshNode::GetMorphTargetDependeciesCount() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeMeshNode", "GetMorphTargetDependeciesCount");

	Params::InterchangeMeshNode_GetMorphTargetDependeciesCount Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeMeshNode.GetMorphTargetDependencies
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<class FString>*                  OutDependencies                                        (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void UInterchangeMeshNode::GetMorphTargetDependencies(TArray<class FString>* OutDependencies) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeMeshNode", "GetMorphTargetDependencies");

	Params::InterchangeMeshNode_GetMorphTargetDependencies Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutDependencies != nullptr)
		*OutDependencies = std::move(Parms.OutDependencies);
}


// Function InterchangeNodes.InterchangeMeshNode.GetMorphTargetDependency
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const int32                             Index_0                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString*                          OutDependency                                          (Parm, OutParm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UInterchangeMeshNode::GetMorphTargetDependency(const int32 Index_0, class FString* OutDependency) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeMeshNode", "GetMorphTargetDependency");

	Params::InterchangeMeshNode_GetMorphTargetDependency Parms{};

	Parms.Index_0 = Index_0;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutDependency != nullptr)
		*OutDependency = std::move(Parms.OutDependency);
}


// Function InterchangeNodes.InterchangeMeshNode.GetMorphTargetName
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FString*                          OutMorphTargetName                                     (Parm, OutParm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeMeshNode::GetMorphTargetName(class FString* OutMorphTargetName) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeMeshNode", "GetMorphTargetName");

	Params::InterchangeMeshNode_GetMorphTargetName Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutMorphTargetName != nullptr)
		*OutMorphTargetName = std::move(Parms.OutMorphTargetName);

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeMeshNode.GetSceneInstanceUid
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const int32                             Index_0                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString*                          OutDependency                                          (Parm, OutParm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UInterchangeMeshNode::GetSceneInstanceUid(const int32 Index_0, class FString* OutDependency) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeMeshNode", "GetSceneInstanceUid");

	Params::InterchangeMeshNode_GetSceneInstanceUid Parms{};

	Parms.Index_0 = Index_0;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutDependency != nullptr)
		*OutDependency = std::move(Parms.OutDependency);
}


// Function InterchangeNodes.InterchangeMeshNode.GetSceneInstanceUids
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<class FString>*                  OutDependencies                                        (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void UInterchangeMeshNode::GetSceneInstanceUids(TArray<class FString>* OutDependencies) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeMeshNode", "GetSceneInstanceUids");

	Params::InterchangeMeshNode_GetSceneInstanceUids Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutDependencies != nullptr)
		*OutDependencies = std::move(Parms.OutDependencies);
}


// Function InterchangeNodes.InterchangeMeshNode.GetSceneInstanceUidsCount
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UInterchangeMeshNode::GetSceneInstanceUidsCount() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeMeshNode", "GetSceneInstanceUidsCount");

	Params::InterchangeMeshNode_GetSceneInstanceUidsCount Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeMeshNode.GetSkeletonDependeciesCount
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UInterchangeMeshNode::GetSkeletonDependeciesCount() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeMeshNode", "GetSkeletonDependeciesCount");

	Params::InterchangeMeshNode_GetSkeletonDependeciesCount Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeMeshNode.GetSkeletonDependencies
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<class FString>*                  OutDependencies                                        (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void UInterchangeMeshNode::GetSkeletonDependencies(TArray<class FString>* OutDependencies) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeMeshNode", "GetSkeletonDependencies");

	Params::InterchangeMeshNode_GetSkeletonDependencies Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutDependencies != nullptr)
		*OutDependencies = std::move(Parms.OutDependencies);
}


// Function InterchangeNodes.InterchangeMeshNode.GetSkeletonDependency
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const int32                             Index_0                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString*                          OutDependency                                          (Parm, OutParm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UInterchangeMeshNode::GetSkeletonDependency(const int32 Index_0, class FString* OutDependency) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeMeshNode", "GetSkeletonDependency");

	Params::InterchangeMeshNode_GetSkeletonDependency Parms{};

	Parms.Index_0 = Index_0;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutDependency != nullptr)
		*OutDependency = std::move(Parms.OutDependency);
}


// Function InterchangeNodes.InterchangeMeshNode.GetSlotMaterialDependencies
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TMap<class FString, class FString>*     OutMaterialDependencies                                (Parm, OutParm, NativeAccessSpecifierPublic)

void UInterchangeMeshNode::GetSlotMaterialDependencies(TMap<class FString, class FString>* OutMaterialDependencies) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeMeshNode", "GetSlotMaterialDependencies");

	Params::InterchangeMeshNode_GetSlotMaterialDependencies Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutMaterialDependencies != nullptr)
		*OutMaterialDependencies = std::move(Parms.OutMaterialDependencies);
}


// Function InterchangeNodes.InterchangeMeshNode.GetSlotMaterialDependencyUid
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class FString&                    SlotName                                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString*                          OutMaterialDependency                                  (Parm, OutParm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeMeshNode::GetSlotMaterialDependencyUid(const class FString& SlotName, class FString* OutMaterialDependency) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeMeshNode", "GetSlotMaterialDependencyUid");

	Params::InterchangeMeshNode_GetSlotMaterialDependencyUid Parms{};

	Parms.SlotName = std::move(SlotName);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutMaterialDependency != nullptr)
		*OutMaterialDependency = std::move(Parms.OutMaterialDependency);

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeMeshNode.IsMorphTarget
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeMeshNode::IsMorphTarget() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeMeshNode", "IsMorphTarget");

	Params::InterchangeMeshNode_IsMorphTarget Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeMeshNode.IsSkinnedMesh
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeMeshNode::IsSkinnedMesh() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeMeshNode", "IsSkinnedMesh");

	Params::InterchangeMeshNode_IsSkinnedMesh Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeGeometryCacheNode.SetCustomEndFrame
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const int32&                            AttributeValue                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeGeometryCacheNode::SetCustomEndFrame(const int32& AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeGeometryCacheNode", "SetCustomEndFrame");

	Params::InterchangeGeometryCacheNode_SetCustomEndFrame Parms{};

	Parms.AttributeValue = AttributeValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeGeometryCacheNode.SetCustomFrameRate
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const double&                           AttributeValue                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeGeometryCacheNode::SetCustomFrameRate(const double& AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeGeometryCacheNode", "SetCustomFrameRate");

	Params::InterchangeGeometryCacheNode_SetCustomFrameRate Parms{};

	Parms.AttributeValue = AttributeValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeGeometryCacheNode.SetCustomHasConstantTopology
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const bool&                             AttributeValue                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeGeometryCacheNode::SetCustomHasConstantTopology(const bool& AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeGeometryCacheNode", "SetCustomHasConstantTopology");

	Params::InterchangeGeometryCacheNode_SetCustomHasConstantTopology Parms{};

	Parms.AttributeValue = AttributeValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeGeometryCacheNode.SetCustomStartFrame
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const int32&                            AttributeValue                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeGeometryCacheNode::SetCustomStartFrame(const int32& AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeGeometryCacheNode", "SetCustomStartFrame");

	Params::InterchangeGeometryCacheNode_SetCustomStartFrame Parms{};

	Parms.AttributeValue = AttributeValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeGeometryCacheNode.GetCustomEndFrame
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32*                                  AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeGeometryCacheNode::GetCustomEndFrame(int32* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeGeometryCacheNode", "GetCustomEndFrame");

	Params::InterchangeGeometryCacheNode_GetCustomEndFrame Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = Parms.AttributeValue;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeGeometryCacheNode.GetCustomFrameRate
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// double*                                 AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeGeometryCacheNode::GetCustomFrameRate(double* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeGeometryCacheNode", "GetCustomFrameRate");

	Params::InterchangeGeometryCacheNode_GetCustomFrameRate Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = Parms.AttributeValue;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeGeometryCacheNode.GetCustomHasConstantTopology
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool*                                   AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeGeometryCacheNode::GetCustomHasConstantTopology(bool* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeGeometryCacheNode", "GetCustomHasConstantTopology");

	Params::InterchangeGeometryCacheNode_GetCustomHasConstantTopology Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = Parms.AttributeValue;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeGeometryCacheNode.GetCustomStartFrame
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32*                                  AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeGeometryCacheNode::GetCustomStartFrame(int32* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeGeometryCacheNode", "GetCustomStartFrame");

	Params::InterchangeGeometryCacheNode_GetCustomStartFrame Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = Parms.AttributeValue;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeSceneNode.AddSpecializedType
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    SpecializedType                                        (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeSceneNode::AddSpecializedType(const class FString& SpecializedType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSceneNode", "AddSpecializedType");

	Params::InterchangeSceneNode_AddSpecializedType Parms{};

	Parms.SpecializedType = std::move(SpecializedType);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeSceneNode.RemoveSlotMaterialDependencyUid
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    SlotName                                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeSceneNode::RemoveSlotMaterialDependencyUid(const class FString& SlotName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSceneNode", "RemoveSlotMaterialDependencyUid");

	Params::InterchangeSceneNode_RemoveSlotMaterialDependencyUid Parms{};

	Parms.SlotName = std::move(SlotName);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeSceneNode.RemoveSpecializedType
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    SpecializedType                                        (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeSceneNode::RemoveSpecializedType(const class FString& SpecializedType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSceneNode", "RemoveSpecializedType");

	Params::InterchangeSceneNode_RemoveSpecializedType Parms{};

	Parms.SpecializedType = std::move(SpecializedType);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeSceneNode.SetAnimationCurveTypeForCurveName
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FString&                    CurveName                                              (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EInterchangeAnimationPayLoadType& AnimationCurveType                                     (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeSceneNode::SetAnimationCurveTypeForCurveName(const class FString& CurveName, const EInterchangeAnimationPayLoadType& AnimationCurveType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSceneNode", "SetAnimationCurveTypeForCurveName");

	Params::InterchangeSceneNode_SetAnimationCurveTypeForCurveName Parms{};

	Parms.CurveName = std::move(CurveName);
	Parms.AnimationCurveType = AnimationCurveType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeSceneNode.SetCustomActorVisibility
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bInIsVisible                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeSceneNode::SetCustomActorVisibility(bool bInIsVisible)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSceneNode", "SetCustomActorVisibility");

	Params::InterchangeSceneNode_SetCustomActorVisibility Parms{};

	Parms.bInIsVisible = bInIsVisible;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeSceneNode.SetCustomAnimationAssetUidToPlay
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    AttributeValue                                         (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeSceneNode::SetCustomAnimationAssetUidToPlay(const class FString& AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSceneNode", "SetCustomAnimationAssetUidToPlay");

	Params::InterchangeSceneNode_SetCustomAnimationAssetUidToPlay Parms{};

	Parms.AttributeValue = std::move(AttributeValue);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeSceneNode.SetCustomAssetInstanceUid
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    AttributeValue                                         (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeSceneNode::SetCustomAssetInstanceUid(const class FString& AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSceneNode", "SetCustomAssetInstanceUid");

	Params::InterchangeSceneNode_SetCustomAssetInstanceUid Parms{};

	Parms.AttributeValue = std::move(AttributeValue);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeSceneNode.SetCustomBindPoseLocalTransform
// (Final, RequiredAPI, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class UInterchangeBaseNodeContainer*BaseNodeContainer                                      (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FTransform&                AttributeValue                                         (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bResetCache                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeSceneNode::SetCustomBindPoseLocalTransform(const class UInterchangeBaseNodeContainer* BaseNodeContainer, const struct FTransform& AttributeValue, bool bResetCache)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSceneNode", "SetCustomBindPoseLocalTransform");

	Params::InterchangeSceneNode_SetCustomBindPoseLocalTransform Parms{};

	Parms.BaseNodeContainer = BaseNodeContainer;
	Parms.AttributeValue = std::move(AttributeValue);
	Parms.bResetCache = bResetCache;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeSceneNode.SetCustomComponentVisibility
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bInIsVisible                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeSceneNode::SetCustomComponentVisibility(bool bInIsVisible)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSceneNode", "SetCustomComponentVisibility");

	Params::InterchangeSceneNode_SetCustomComponentVisibility Parms{};

	Parms.bInIsVisible = bInIsVisible;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeSceneNode.SetCustomGeometricTransform
// (Final, RequiredAPI, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FTransform&                AttributeValue                                         (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeSceneNode::SetCustomGeometricTransform(const struct FTransform& AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSceneNode", "SetCustomGeometricTransform");

	Params::InterchangeSceneNode_SetCustomGeometricTransform Parms{};

	Parms.AttributeValue = std::move(AttributeValue);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeSceneNode.SetCustomHasBindPose
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const bool&                             bHasBindPose                                           (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeSceneNode::SetCustomHasBindPose(const bool& bHasBindPose)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSceneNode", "SetCustomHasBindPose");

	Params::InterchangeSceneNode_SetCustomHasBindPose Parms{};

	Parms.bHasBindPose = bHasBindPose;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeSceneNode.SetCustomLocalTransform
// (Final, RequiredAPI, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class UInterchangeBaseNodeContainer*BaseNodeContainer                                      (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FTransform&                AttributeValue                                         (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bResetCache                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeSceneNode::SetCustomLocalTransform(const class UInterchangeBaseNodeContainer* BaseNodeContainer, const struct FTransform& AttributeValue, bool bResetCache)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSceneNode", "SetCustomLocalTransform");

	Params::InterchangeSceneNode_SetCustomLocalTransform Parms{};

	Parms.BaseNodeContainer = BaseNodeContainer;
	Parms.AttributeValue = std::move(AttributeValue);
	Parms.bResetCache = bResetCache;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeSceneNode.SetCustomPivotNodeTransform
// (Final, RequiredAPI, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FTransform&                AttributeValue                                         (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeSceneNode::SetCustomPivotNodeTransform(const struct FTransform& AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSceneNode", "SetCustomPivotNodeTransform");

	Params::InterchangeSceneNode_SetCustomPivotNodeTransform Parms{};

	Parms.AttributeValue = std::move(AttributeValue);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeSceneNode.SetCustomTimeZeroLocalTransform
// (Final, RequiredAPI, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class UInterchangeBaseNodeContainer*BaseNodeContainer                                      (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FTransform&                AttributeValue                                         (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bResetCache                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeSceneNode::SetCustomTimeZeroLocalTransform(const class UInterchangeBaseNodeContainer* BaseNodeContainer, const struct FTransform& AttributeValue, bool bResetCache)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSceneNode", "SetCustomTimeZeroLocalTransform");

	Params::InterchangeSceneNode_SetCustomTimeZeroLocalTransform Parms{};

	Parms.BaseNodeContainer = BaseNodeContainer;
	Parms.AttributeValue = std::move(AttributeValue);
	Parms.bResetCache = bResetCache;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeSceneNode.SetGlobalBindPoseReferenceForMeshUIDs
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const TMap<class FString, struct FMatrix>&GlobalBindPoseReferenceForMeshUIDs                     (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UInterchangeSceneNode::SetGlobalBindPoseReferenceForMeshUIDs(const TMap<class FString, struct FMatrix>& GlobalBindPoseReferenceForMeshUIDs)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSceneNode", "SetGlobalBindPoseReferenceForMeshUIDs");

	Params::InterchangeSceneNode_SetGlobalBindPoseReferenceForMeshUIDs Parms{};

	Parms.GlobalBindPoseReferenceForMeshUIDs = std::move(GlobalBindPoseReferenceForMeshUIDs);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function InterchangeNodes.InterchangeSceneNode.SetMorphTargetCurveWeight
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FString&                    MorphTargetName                                        (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const float&                            Weight                                                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeSceneNode::SetMorphTargetCurveWeight(const class FString& MorphTargetName, const float& Weight)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSceneNode", "SetMorphTargetCurveWeight");

	Params::InterchangeSceneNode_SetMorphTargetCurveWeight Parms{};

	Parms.MorphTargetName = std::move(MorphTargetName);
	Parms.Weight = Weight;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeSceneNode.SetSlotMaterialDependencyUid
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    SlotName                                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    MaterialDependencyUid                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeSceneNode::SetSlotMaterialDependencyUid(const class FString& SlotName, const class FString& MaterialDependencyUid)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSceneNode", "SetSlotMaterialDependencyUid");

	Params::InterchangeSceneNode_SetSlotMaterialDependencyUid Parms{};

	Parms.SlotName = std::move(SlotName);
	Parms.MaterialDependencyUid = std::move(MaterialDependencyUid);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeSceneNode.GetAnimationCurveTypeForCurveName
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class FString&                    CurveName                                              (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EInterchangeAnimationPayLoadType*       OutCurveAnimationType                                  (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeSceneNode::GetAnimationCurveTypeForCurveName(const class FString& CurveName, EInterchangeAnimationPayLoadType* OutCurveAnimationType) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSceneNode", "GetAnimationCurveTypeForCurveName");

	Params::InterchangeSceneNode_GetAnimationCurveTypeForCurveName Parms{};

	Parms.CurveName = std::move(CurveName);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutCurveAnimationType != nullptr)
		*OutCurveAnimationType = Parms.OutCurveAnimationType;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeSceneNode.GetCustomActorVisibility
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool*                                   bOutIsVisible                                          (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeSceneNode::GetCustomActorVisibility(bool* bOutIsVisible) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSceneNode", "GetCustomActorVisibility");

	Params::InterchangeSceneNode_GetCustomActorVisibility Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (bOutIsVisible != nullptr)
		*bOutIsVisible = Parms.bOutIsVisible;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeSceneNode.GetCustomAnimationAssetUidToPlay
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FString*                          AttributeValue                                         (Parm, OutParm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeSceneNode::GetCustomAnimationAssetUidToPlay(class FString* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSceneNode", "GetCustomAnimationAssetUidToPlay");

	Params::InterchangeSceneNode_GetCustomAnimationAssetUidToPlay Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = std::move(Parms.AttributeValue);

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeSceneNode.GetCustomAssetInstanceUid
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FString*                          AttributeValue                                         (Parm, OutParm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeSceneNode::GetCustomAssetInstanceUid(class FString* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSceneNode", "GetCustomAssetInstanceUid");

	Params::InterchangeSceneNode_GetCustomAssetInstanceUid Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = std::move(Parms.AttributeValue);

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeSceneNode.GetCustomBindPoseGlobalTransform
// (Final, RequiredAPI, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class UInterchangeBaseNodeContainer*BaseNodeContainer                                      (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FTransform&                GlobalOffsetTransform                                  (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FTransform*                      AttributeValue                                         (Parm, OutParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bForceRecache                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeSceneNode::GetCustomBindPoseGlobalTransform(const class UInterchangeBaseNodeContainer* BaseNodeContainer, const struct FTransform& GlobalOffsetTransform, struct FTransform* AttributeValue, bool bForceRecache) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSceneNode", "GetCustomBindPoseGlobalTransform");

	Params::InterchangeSceneNode_GetCustomBindPoseGlobalTransform Parms{};

	Parms.BaseNodeContainer = BaseNodeContainer;
	Parms.GlobalOffsetTransform = std::move(GlobalOffsetTransform);
	Parms.bForceRecache = bForceRecache;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = std::move(Parms.AttributeValue);

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeSceneNode.GetCustomBindPoseLocalTransform
// (Final, RequiredAPI, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FTransform*                      AttributeValue                                         (Parm, OutParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeSceneNode::GetCustomBindPoseLocalTransform(struct FTransform* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSceneNode", "GetCustomBindPoseLocalTransform");

	Params::InterchangeSceneNode_GetCustomBindPoseLocalTransform Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = std::move(Parms.AttributeValue);

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeSceneNode.GetCustomComponentVisibility
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool*                                   bOutIsVisible                                          (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeSceneNode::GetCustomComponentVisibility(bool* bOutIsVisible) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSceneNode", "GetCustomComponentVisibility");

	Params::InterchangeSceneNode_GetCustomComponentVisibility Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (bOutIsVisible != nullptr)
		*bOutIsVisible = Parms.bOutIsVisible;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeSceneNode.GetCustomGeometricTransform
// (Final, RequiredAPI, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FTransform*                      AttributeValue                                         (Parm, OutParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeSceneNode::GetCustomGeometricTransform(struct FTransform* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSceneNode", "GetCustomGeometricTransform");

	Params::InterchangeSceneNode_GetCustomGeometricTransform Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = std::move(Parms.AttributeValue);

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeSceneNode.GetCustomGlobalTransform
// (Final, RequiredAPI, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class UInterchangeBaseNodeContainer*BaseNodeContainer                                      (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FTransform&                GlobalOffsetTransform                                  (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FTransform*                      AttributeValue                                         (Parm, OutParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bForceRecache                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeSceneNode::GetCustomGlobalTransform(const class UInterchangeBaseNodeContainer* BaseNodeContainer, const struct FTransform& GlobalOffsetTransform, struct FTransform* AttributeValue, bool bForceRecache) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSceneNode", "GetCustomGlobalTransform");

	Params::InterchangeSceneNode_GetCustomGlobalTransform Parms{};

	Parms.BaseNodeContainer = BaseNodeContainer;
	Parms.GlobalOffsetTransform = std::move(GlobalOffsetTransform);
	Parms.bForceRecache = bForceRecache;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = std::move(Parms.AttributeValue);

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeSceneNode.GetCustomHasBindPose
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool*                                   bHasBindPose                                           (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeSceneNode::GetCustomHasBindPose(bool* bHasBindPose) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSceneNode", "GetCustomHasBindPose");

	Params::InterchangeSceneNode_GetCustomHasBindPose Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (bHasBindPose != nullptr)
		*bHasBindPose = Parms.bHasBindPose;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeSceneNode.GetCustomLocalTransform
// (Final, RequiredAPI, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FTransform*                      AttributeValue                                         (Parm, OutParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeSceneNode::GetCustomLocalTransform(struct FTransform* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSceneNode", "GetCustomLocalTransform");

	Params::InterchangeSceneNode_GetCustomLocalTransform Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = std::move(Parms.AttributeValue);

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeSceneNode.GetCustomPivotNodeTransform
// (Final, RequiredAPI, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FTransform*                      AttributeValue                                         (Parm, OutParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeSceneNode::GetCustomPivotNodeTransform(struct FTransform* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSceneNode", "GetCustomPivotNodeTransform");

	Params::InterchangeSceneNode_GetCustomPivotNodeTransform Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = std::move(Parms.AttributeValue);

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeSceneNode.GetCustomTimeZeroGlobalTransform
// (Final, RequiredAPI, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class UInterchangeBaseNodeContainer*BaseNodeContainer                                      (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FTransform&                GlobalOffsetTransform                                  (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FTransform*                      AttributeValue                                         (Parm, OutParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bForceRecache                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeSceneNode::GetCustomTimeZeroGlobalTransform(const class UInterchangeBaseNodeContainer* BaseNodeContainer, const struct FTransform& GlobalOffsetTransform, struct FTransform* AttributeValue, bool bForceRecache) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSceneNode", "GetCustomTimeZeroGlobalTransform");

	Params::InterchangeSceneNode_GetCustomTimeZeroGlobalTransform Parms{};

	Parms.BaseNodeContainer = BaseNodeContainer;
	Parms.GlobalOffsetTransform = std::move(GlobalOffsetTransform);
	Parms.bForceRecache = bForceRecache;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = std::move(Parms.AttributeValue);

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeSceneNode.GetCustomTimeZeroLocalTransform
// (Final, RequiredAPI, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FTransform*                      AttributeValue                                         (Parm, OutParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeSceneNode::GetCustomTimeZeroLocalTransform(struct FTransform* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSceneNode", "GetCustomTimeZeroLocalTransform");

	Params::InterchangeSceneNode_GetCustomTimeZeroLocalTransform Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = std::move(Parms.AttributeValue);

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeSceneNode.GetGlobalBindPoseReferenceForMeshUID
// (Final, RequiredAPI, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class FString&                    MeshUid                                                (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FMatrix*                         GlobalBindPoseReference                                (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeSceneNode::GetGlobalBindPoseReferenceForMeshUID(const class FString& MeshUid, struct FMatrix* GlobalBindPoseReference) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSceneNode", "GetGlobalBindPoseReferenceForMeshUID");

	Params::InterchangeSceneNode_GetGlobalBindPoseReferenceForMeshUID Parms{};

	Parms.MeshUid = std::move(MeshUid);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (GlobalBindPoseReference != nullptr)
		*GlobalBindPoseReference = std::move(Parms.GlobalBindPoseReference);

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeSceneNode.GetMorphTargetCurveWeights
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TMap<class FString, float>*             OutMorphTargetCurveWeights                             (Parm, OutParm, NativeAccessSpecifierPublic)

void UInterchangeSceneNode::GetMorphTargetCurveWeights(TMap<class FString, float>* OutMorphTargetCurveWeights) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSceneNode", "GetMorphTargetCurveWeights");

	Params::InterchangeSceneNode_GetMorphTargetCurveWeights Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutMorphTargetCurveWeights != nullptr)
		*OutMorphTargetCurveWeights = std::move(Parms.OutMorphTargetCurveWeights);
}


// Function InterchangeNodes.InterchangeSceneNode.GetSlotMaterialDependencies
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TMap<class FString, class FString>*     OutMaterialDependencies                                (Parm, OutParm, NativeAccessSpecifierPublic)

void UInterchangeSceneNode::GetSlotMaterialDependencies(TMap<class FString, class FString>* OutMaterialDependencies) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSceneNode", "GetSlotMaterialDependencies");

	Params::InterchangeSceneNode_GetSlotMaterialDependencies Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutMaterialDependencies != nullptr)
		*OutMaterialDependencies = std::move(Parms.OutMaterialDependencies);
}


// Function InterchangeNodes.InterchangeSceneNode.GetSlotMaterialDependencyUid
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class FString&                    SlotName                                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString*                          OutMaterialDependency                                  (Parm, OutParm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeSceneNode::GetSlotMaterialDependencyUid(const class FString& SlotName, class FString* OutMaterialDependency) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSceneNode", "GetSlotMaterialDependencyUid");

	Params::InterchangeSceneNode_GetSlotMaterialDependencyUid Parms{};

	Parms.SlotName = std::move(SlotName);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutMaterialDependency != nullptr)
		*OutMaterialDependency = std::move(Parms.OutMaterialDependency);

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeSceneNode.GetSpecializedType
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const int32                             Index_0                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString*                          OutSpecializedType                                     (Parm, OutParm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UInterchangeSceneNode::GetSpecializedType(const int32 Index_0, class FString* OutSpecializedType) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSceneNode", "GetSpecializedType");

	Params::InterchangeSceneNode_GetSpecializedType Parms{};

	Parms.Index_0 = Index_0;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutSpecializedType != nullptr)
		*OutSpecializedType = std::move(Parms.OutSpecializedType);
}


// Function InterchangeNodes.InterchangeSceneNode.GetSpecializedTypeCount
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UInterchangeSceneNode::GetSpecializedTypeCount() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSceneNode", "GetSpecializedTypeCount");

	Params::InterchangeSceneNode_GetSpecializedTypeCount Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeSceneNode.GetSpecializedTypes
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<class FString>*                  OutSpecializedTypes                                    (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void UInterchangeSceneNode::GetSpecializedTypes(TArray<class FString>* OutSpecializedTypes) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSceneNode", "GetSpecializedTypes");

	Params::InterchangeSceneNode_GetSpecializedTypes Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutSpecializedTypes != nullptr)
		*OutSpecializedTypes = std::move(Parms.OutSpecializedTypes);
}


// Function InterchangeNodes.InterchangeSceneNode.IsSpecializedTypeContains
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class FString&                    SpecializedType                                        (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeSceneNode::IsSpecializedTypeContains(const class FString& SpecializedType) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSceneNode", "IsSpecializedTypeContains");

	Params::InterchangeSceneNode_IsSpecializedTypeContains Parms{};

	Parms.SpecializedType = std::move(SpecializedType);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeShaderPortsAPI.ConnectDefaultOuputToInput
// (Final, RequiredAPI, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UInterchangeBaseNode*             InterchangeNode                                        (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    InputName                                              (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    ExpressionUid                                          (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeShaderPortsAPI::ConnectDefaultOuputToInput(class UInterchangeBaseNode* InterchangeNode, const class FString& InputName, const class FString& ExpressionUid)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("InterchangeShaderPortsAPI", "ConnectDefaultOuputToInput");

	Params::InterchangeShaderPortsAPI_ConnectDefaultOuputToInput Parms{};

	Parms.InterchangeNode = InterchangeNode;
	Parms.InputName = std::move(InputName);
	Parms.ExpressionUid = std::move(ExpressionUid);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeShaderPortsAPI.ConnectOuputToInputByIndex
// (Final, RequiredAPI, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UInterchangeBaseNode*             InterchangeNode                                        (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    InputName                                              (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    ExpressionUid                                          (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OutputIndex                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeShaderPortsAPI::ConnectOuputToInputByIndex(class UInterchangeBaseNode* InterchangeNode, const class FString& InputName, const class FString& ExpressionUid, int32 OutputIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("InterchangeShaderPortsAPI", "ConnectOuputToInputByIndex");

	Params::InterchangeShaderPortsAPI_ConnectOuputToInputByIndex Parms{};

	Parms.InterchangeNode = InterchangeNode;
	Parms.InputName = std::move(InputName);
	Parms.ExpressionUid = std::move(ExpressionUid);
	Parms.OutputIndex = OutputIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeShaderPortsAPI.ConnectOuputToInputByName
// (Final, RequiredAPI, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UInterchangeBaseNode*             InterchangeNode                                        (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    InputName                                              (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    ExpressionUid                                          (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    OutputName                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeShaderPortsAPI::ConnectOuputToInputByName(class UInterchangeBaseNode* InterchangeNode, const class FString& InputName, const class FString& ExpressionUid, const class FString& OutputName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("InterchangeShaderPortsAPI", "ConnectOuputToInputByName");

	Params::InterchangeShaderPortsAPI_ConnectOuputToInputByName Parms{};

	Parms.InterchangeNode = InterchangeNode;
	Parms.InputName = std::move(InputName);
	Parms.ExpressionUid = std::move(ExpressionUid);
	Parms.OutputName = std::move(OutputName);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeShaderPortsAPI.GatherInputs
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class UInterchangeBaseNode*       InterchangeNode                                        (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class FString>*                  OutInputNames                                          (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void UInterchangeShaderPortsAPI::GatherInputs(const class UInterchangeBaseNode* InterchangeNode, TArray<class FString>* OutInputNames)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("InterchangeShaderPortsAPI", "GatherInputs");

	Params::InterchangeShaderPortsAPI_GatherInputs Parms{};

	Parms.InterchangeNode = InterchangeNode;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutInputNames != nullptr)
		*OutInputNames = std::move(Parms.OutInputNames);
}


// Function InterchangeNodes.InterchangeShaderPortsAPI.GetInputConnection
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class UInterchangeBaseNode*       InterchangeNode                                        (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    InputName                                              (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString*                          OutExpressionUid                                       (Parm, OutParm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString*                          OutputName                                             (Parm, OutParm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeShaderPortsAPI::GetInputConnection(const class UInterchangeBaseNode* InterchangeNode, const class FString& InputName, class FString* OutExpressionUid, class FString* OutputName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("InterchangeShaderPortsAPI", "GetInputConnection");

	Params::InterchangeShaderPortsAPI_GetInputConnection Parms{};

	Parms.InterchangeNode = InterchangeNode;
	Parms.InputName = std::move(InputName);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutExpressionUid != nullptr)
		*OutExpressionUid = std::move(Parms.OutExpressionUid);

	if (OutputName != nullptr)
		*OutputName = std::move(Parms.OutputName);

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeShaderPortsAPI.HasInput
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class UInterchangeBaseNode*       InterchangeNode                                        (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      InInputName                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeShaderPortsAPI::HasInput(const class UInterchangeBaseNode* InterchangeNode, const class FName& InInputName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("InterchangeShaderPortsAPI", "HasInput");

	Params::InterchangeShaderPortsAPI_HasInput Parms{};

	Parms.InterchangeNode = InterchangeNode;
	Parms.InInputName = InInputName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeShaderPortsAPI.HasParameter
// (Final, RequiredAPI, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class UInterchangeBaseNode*       InterchangeNode                                        (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      InInputName                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeShaderPortsAPI::HasParameter(const class UInterchangeBaseNode* InterchangeNode, const class FName& InInputName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("InterchangeShaderPortsAPI", "HasParameter");

	Params::InterchangeShaderPortsAPI_HasParameter Parms{};

	Parms.InterchangeNode = InterchangeNode;
	Parms.InInputName = InInputName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeShaderPortsAPI.IsAnInput
// (Final, RequiredAPI, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class FString&                    AttributeKey                                           (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeShaderPortsAPI::IsAnInput(const class FString& AttributeKey)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("InterchangeShaderPortsAPI", "IsAnInput");

	Params::InterchangeShaderPortsAPI_IsAnInput Parms{};

	Parms.AttributeKey = std::move(AttributeKey);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeShaderPortsAPI.IsAParameter
// (Final, RequiredAPI, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class FString&                    AttributeKey                                           (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeShaderPortsAPI::IsAParameter(const class FString& AttributeKey)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("InterchangeShaderPortsAPI", "IsAParameter");

	Params::InterchangeShaderPortsAPI_IsAParameter Parms{};

	Parms.AttributeKey = std::move(AttributeKey);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeShaderPortsAPI.MakeInputConnectionKey
// (Final, RequiredAPI, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class FString&                    InputName                                              (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UInterchangeShaderPortsAPI::MakeInputConnectionKey(const class FString& InputName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("InterchangeShaderPortsAPI", "MakeInputConnectionKey");

	Params::InterchangeShaderPortsAPI_MakeInputConnectionKey Parms{};

	Parms.InputName = std::move(InputName);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeShaderPortsAPI.MakeInputName
// (Final, RequiredAPI, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class FString&                    InputKey                                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UInterchangeShaderPortsAPI::MakeInputName(const class FString& InputKey)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("InterchangeShaderPortsAPI", "MakeInputName");

	Params::InterchangeShaderPortsAPI_MakeInputName Parms{};

	Parms.InputKey = std::move(InputKey);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeShaderPortsAPI.MakeInputParameterKey
// (Final, RequiredAPI, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class FString&                    InputName                                              (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UInterchangeShaderPortsAPI::MakeInputParameterKey(const class FString& InputName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("InterchangeShaderPortsAPI", "MakeInputParameterKey");

	Params::InterchangeShaderPortsAPI_MakeInputParameterKey Parms{};

	Parms.InputName = std::move(InputName);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeShaderPortsAPI.MakeInputValueKey
// (Final, RequiredAPI, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class FString&                    InputName                                              (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UInterchangeShaderPortsAPI::MakeInputValueKey(const class FString& InputName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("InterchangeShaderPortsAPI", "MakeInputValueKey");

	Params::InterchangeShaderPortsAPI_MakeInputValueKey Parms{};

	Parms.InputName = std::move(InputName);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeFunctionCallShaderNode.SetCustomMaterialFunction
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    AttributeValue                                         (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeFunctionCallShaderNode::SetCustomMaterialFunction(const class FString& AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeFunctionCallShaderNode", "SetCustomMaterialFunction");

	Params::InterchangeFunctionCallShaderNode_SetCustomMaterialFunction Parms{};

	Parms.AttributeValue = std::move(AttributeValue);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeFunctionCallShaderNode.GetCustomMaterialFunction
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FString*                          AttributeValue                                         (Parm, OutParm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeFunctionCallShaderNode::GetCustomMaterialFunction(class FString* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeFunctionCallShaderNode", "GetCustomMaterialFunction");

	Params::InterchangeFunctionCallShaderNode_GetCustomMaterialFunction Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = std::move(Parms.AttributeValue);

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeShaderGraphNode.SetCustomBlendMode
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   AttributeValue                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeShaderGraphNode::SetCustomBlendMode(int32 AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeShaderGraphNode", "SetCustomBlendMode");

	Params::InterchangeShaderGraphNode_SetCustomBlendMode Parms{};

	Parms.AttributeValue = AttributeValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeShaderGraphNode.SetCustomDisplacementCenterMode
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// float                                   AttributeValue                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeShaderGraphNode::SetCustomDisplacementCenterMode(float AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeShaderGraphNode", "SetCustomDisplacementCenterMode");

	Params::InterchangeShaderGraphNode_SetCustomDisplacementCenterMode Parms{};

	Parms.AttributeValue = AttributeValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeShaderGraphNode.SetCustomIsAShaderFunction
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const bool&                             AttributeValue                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeShaderGraphNode::SetCustomIsAShaderFunction(const bool& AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeShaderGraphNode", "SetCustomIsAShaderFunction");

	Params::InterchangeShaderGraphNode_SetCustomIsAShaderFunction Parms{};

	Parms.AttributeValue = AttributeValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeShaderGraphNode.SetCustomOpacityMaskClipValue
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const float&                            AttributeValue                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bAddApplyDelegate                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeShaderGraphNode::SetCustomOpacityMaskClipValue(const float& AttributeValue, bool bAddApplyDelegate)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeShaderGraphNode", "SetCustomOpacityMaskClipValue");

	Params::InterchangeShaderGraphNode_SetCustomOpacityMaskClipValue Parms{};

	Parms.AttributeValue = AttributeValue;
	Parms.bAddApplyDelegate = bAddApplyDelegate;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeShaderGraphNode.SetCustomScreenSpaceReflections
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const bool&                             AttributeValue                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeShaderGraphNode::SetCustomScreenSpaceReflections(const bool& AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeShaderGraphNode", "SetCustomScreenSpaceReflections");

	Params::InterchangeShaderGraphNode_SetCustomScreenSpaceReflections Parms{};

	Parms.AttributeValue = AttributeValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeShaderGraphNode.SetCustomTwoSided
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const bool&                             AttributeValue                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeShaderGraphNode::SetCustomTwoSided(const bool& AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeShaderGraphNode", "SetCustomTwoSided");

	Params::InterchangeShaderGraphNode_SetCustomTwoSided Parms{};

	Parms.AttributeValue = AttributeValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeShaderGraphNode.SetCustomTwoSidedTransmission
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const bool&                             AttributeValue                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeShaderGraphNode::SetCustomTwoSidedTransmission(const bool& AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeShaderGraphNode", "SetCustomTwoSidedTransmission");

	Params::InterchangeShaderGraphNode_SetCustomTwoSidedTransmission Parms{};

	Parms.AttributeValue = AttributeValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeShaderGraphNode.GetCustomBlendMode
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32*                                  AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeShaderGraphNode::GetCustomBlendMode(int32* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeShaderGraphNode", "GetCustomBlendMode");

	Params::InterchangeShaderGraphNode_GetCustomBlendMode Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = Parms.AttributeValue;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeShaderGraphNode.GetCustomDisplacementCenterMode
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float*                                  AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeShaderGraphNode::GetCustomDisplacementCenterMode(float* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeShaderGraphNode", "GetCustomDisplacementCenterMode");

	Params::InterchangeShaderGraphNode_GetCustomDisplacementCenterMode Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = Parms.AttributeValue;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeShaderGraphNode.GetCustomIsAShaderFunction
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool*                                   AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeShaderGraphNode::GetCustomIsAShaderFunction(bool* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeShaderGraphNode", "GetCustomIsAShaderFunction");

	Params::InterchangeShaderGraphNode_GetCustomIsAShaderFunction Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = Parms.AttributeValue;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeShaderGraphNode.GetCustomOpacityMaskClipValue
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float*                                  AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeShaderGraphNode::GetCustomOpacityMaskClipValue(float* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeShaderGraphNode", "GetCustomOpacityMaskClipValue");

	Params::InterchangeShaderGraphNode_GetCustomOpacityMaskClipValue Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = Parms.AttributeValue;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeShaderGraphNode.GetCustomScreenSpaceReflections
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool*                                   AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeShaderGraphNode::GetCustomScreenSpaceReflections(bool* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeShaderGraphNode", "GetCustomScreenSpaceReflections");

	Params::InterchangeShaderGraphNode_GetCustomScreenSpaceReflections Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = Parms.AttributeValue;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeShaderGraphNode.GetCustomTwoSided
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool*                                   AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeShaderGraphNode::GetCustomTwoSided(bool* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeShaderGraphNode", "GetCustomTwoSided");

	Params::InterchangeShaderGraphNode_GetCustomTwoSided Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = Parms.AttributeValue;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeShaderGraphNode.GetCustomTwoSidedTransmission
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool*                                   AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeShaderGraphNode::GetCustomTwoSidedTransmission(bool* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeShaderGraphNode", "GetCustomTwoSidedTransmission");

	Params::InterchangeShaderGraphNode_GetCustomTwoSidedTransmission Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = Parms.AttributeValue;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeSpecularProfileNode.SetCustomFormat
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// uint8                                   Format                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeSpecularProfileNode::SetCustomFormat(uint8 Format)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSpecularProfileNode", "SetCustomFormat");

	Params::InterchangeSpecularProfileNode_SetCustomFormat Parms{};

	Parms.Format = Format;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeSpecularProfileNode.SetCustomTexture
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    TextureUid                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeSpecularProfileNode::SetCustomTexture(const class FString& TextureUid)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSpecularProfileNode", "SetCustomTexture");

	Params::InterchangeSpecularProfileNode_SetCustomTexture Parms{};

	Parms.TextureUid = std::move(TextureUid);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeSpecularProfileNode.GetCustomFormat
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// uint8*                                  Format                                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeSpecularProfileNode::GetCustomFormat(uint8* Format) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSpecularProfileNode", "GetCustomFormat");

	Params::InterchangeSpecularProfileNode_GetCustomFormat Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Format != nullptr)
		*Format = Parms.Format;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeSpecularProfileNode.GetCustomTexture
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FString*                          TextureUid                                             (Parm, OutParm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeSpecularProfileNode::GetCustomTexture(class FString* TextureUid) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeSpecularProfileNode", "GetCustomTexture");

	Params::InterchangeSpecularProfileNode_GetCustomTexture Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (TextureUid != nullptr)
		*TextureUid = std::move(Parms.TextureUid);

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeTexture2DNode.SetCustomWrapU
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const EInterchangeTextureWrapMode&      AttributeValue                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeTexture2DNode::SetCustomWrapU(const EInterchangeTextureWrapMode& AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeTexture2DNode", "SetCustomWrapU");

	Params::InterchangeTexture2DNode_SetCustomWrapU Parms{};

	Parms.AttributeValue = AttributeValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeTexture2DNode.SetCustomWrapV
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const EInterchangeTextureWrapMode&      AttributeValue                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeTexture2DNode::SetCustomWrapV(const EInterchangeTextureWrapMode& AttributeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeTexture2DNode", "SetCustomWrapV");

	Params::InterchangeTexture2DNode_SetCustomWrapV Parms{};

	Parms.AttributeValue = AttributeValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeTexture2DNode.GetCustomWrapU
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EInterchangeTextureWrapMode*            AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeTexture2DNode::GetCustomWrapU(EInterchangeTextureWrapMode* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeTexture2DNode", "GetCustomWrapU");

	Params::InterchangeTexture2DNode_GetCustomWrapU Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = Parms.AttributeValue;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeTexture2DNode.GetCustomWrapV
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EInterchangeTextureWrapMode*            AttributeValue                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeTexture2DNode::GetCustomWrapV(EInterchangeTextureWrapMode* AttributeValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeTexture2DNode", "GetCustomWrapV");

	Params::InterchangeTexture2DNode_GetCustomWrapV Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AttributeValue != nullptr)
		*AttributeValue = Parms.AttributeValue;

	return Parms.ReturnValue;
}


// Function InterchangeNodes.InterchangeTexture2DNode.GetSourceBlocks
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TMap<int32, class FString>              ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

TMap<int32, class FString> UInterchangeTexture2DNode::GetSourceBlocks() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeTexture2DNode", "GetSourceBlocks");

	Params::InterchangeTexture2DNode_GetSourceBlocks Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


SDK_NAMESPACE_END
