672 lines
29 KiB
C++
672 lines
29 KiB
C++
// Copyright Epic Games, Inc. All Rights Reserved.
|
|
|
|
#include "NiagaraClipboard.h"
|
|
#include "NiagaraDataInterface.h"
|
|
|
|
#include "Factories.h"
|
|
#include "UObject/UObjectMarks.h"
|
|
#include "UObject/PropertyPortFlags.h"
|
|
#include "Containers/UnrealString.h"
|
|
#include "UnrealExporter.h"
|
|
#include "Exporters/Exporter.h"
|
|
#include "HAL/PlatformApplicationMisc.h"
|
|
#include "Misc/StringOutputDevice.h"
|
|
#include "NiagaraNodeFunctionCall.h"
|
|
#include "Engine/UserDefinedEnum.h"
|
|
#include "StructUtils/UserDefinedStruct.h"
|
|
#include "NiagaraEditorModule.h"
|
|
#include "INiagaraEditorTypeUtilities.h"
|
|
#include "Logging/LogScopedVerbosityOverride.h"
|
|
#include "PropertyHandle.h"
|
|
|
|
#include UE_INLINE_GENERATED_CPP_BY_NAME(NiagaraClipboard)
|
|
|
|
struct FNiagaraClipboardContentTextObjectFactory : public FCustomizableTextObjectFactory
|
|
{
|
|
public:
|
|
UNiagaraClipboardContent* ClipboardContent;
|
|
|
|
public:
|
|
FNiagaraClipboardContentTextObjectFactory()
|
|
: FCustomizableTextObjectFactory(GWarn)
|
|
, ClipboardContent(nullptr)
|
|
{
|
|
}
|
|
|
|
protected:
|
|
virtual bool CanCreateClass(UClass* ObjectClass, bool& bOmitSubObjs) const override
|
|
{
|
|
return ObjectClass == UNiagaraClipboardContent::StaticClass();
|
|
}
|
|
|
|
virtual void ProcessConstructedObject(UObject* CreatedObject) override
|
|
{
|
|
if (CreatedObject->IsA<UNiagaraClipboardContent>())
|
|
{
|
|
ClipboardContent = CastChecked<UNiagaraClipboardContent>(CreatedObject);
|
|
}
|
|
}
|
|
};
|
|
|
|
UNiagaraClipboardFunctionInput* MakeNewInput(UObject* InOuter, FName InInputName, FNiagaraTypeDefinition InInputType, TOptional<bool> bInEditConditionValue, ENiagaraClipboardFunctionInputValueMode InValueMode)
|
|
{
|
|
UNiagaraClipboardFunctionInput* NewInput = Cast<UNiagaraClipboardFunctionInput>(NewObject<UNiagaraClipboardFunctionInput>(InOuter));
|
|
NewInput->InputName = InInputName;
|
|
NewInput->InputType = InInputType;
|
|
NewInput->bHasEditCondition = bInEditConditionValue.IsSet();
|
|
NewInput->bEditConditionValue = bInEditConditionValue.Get(false);
|
|
NewInput->ValueMode = InValueMode;
|
|
return NewInput;
|
|
}
|
|
|
|
const UNiagaraClipboardFunctionInput* UNiagaraClipboardFunctionInput::CreateLocalValue(UObject* InOuter, FName InInputName, FNiagaraTypeDefinition InInputType, TOptional<bool> bInEditConditionValue, TArray<uint8>& InLocalValueData)
|
|
{
|
|
checkf(InLocalValueData.Num() == InInputType.GetSize(), TEXT("Input data size (%d) didn't match type size (%d)."), InLocalValueData.Num(), InInputType.GetSize());
|
|
UNiagaraClipboardFunctionInput* NewInput = MakeNewInput(InOuter, InInputName, InInputType, bInEditConditionValue, ENiagaraClipboardFunctionInputValueMode::Local);
|
|
NewInput->Local = InLocalValueData;
|
|
return NewInput;
|
|
}
|
|
|
|
const UNiagaraClipboardFunctionInput* UNiagaraClipboardFunctionInput::CreateLinkedValue(UObject* InOuter, FName InInputName, FNiagaraTypeDefinition InInputType, TOptional<bool> bInEditConditionValue, const FNiagaraVariableBase& InLinkedValue)
|
|
{
|
|
UNiagaraClipboardFunctionInput* NewInput = MakeNewInput(InOuter, InInputName, InInputType, bInEditConditionValue, ENiagaraClipboardFunctionInputValueMode::Linked);
|
|
NewInput->Linked = InLinkedValue;
|
|
return NewInput;
|
|
}
|
|
|
|
const UNiagaraClipboardFunctionInput* UNiagaraClipboardFunctionInput::CreateDataValue(UObject* InOuter, FName InInputName, FNiagaraTypeDefinition InInputType, TOptional<bool> bInEditConditionValue, UNiagaraDataInterface* InDataValue)
|
|
{
|
|
UNiagaraClipboardFunctionInput* NewInput = MakeNewInput(InOuter, InInputName, InInputType, bInEditConditionValue, ENiagaraClipboardFunctionInputValueMode::Data);
|
|
NewInput->Data = NewObject<UNiagaraDataInterface>(NewInput, InDataValue->GetClass());
|
|
InDataValue->CopyTo(NewInput->Data);
|
|
return NewInput;
|
|
}
|
|
|
|
const UNiagaraClipboardFunctionInput* UNiagaraClipboardFunctionInput::CreateObjectAssetValue(UObject* InOuter, FName InInputName, FNiagaraTypeDefinition InInputType, TOptional<bool> bInEditConditionValue, UObject* InObject)
|
|
{
|
|
UNiagaraClipboardFunctionInput* NewInput = MakeNewInput(InOuter, InInputName, InInputType, bInEditConditionValue, ENiagaraClipboardFunctionInputValueMode::ObjectAsset);
|
|
NewInput->ObjectAsset = InObject;
|
|
return NewInput;
|
|
}
|
|
|
|
const UNiagaraClipboardFunctionInput* UNiagaraClipboardFunctionInput::CreateExpressionValue(UObject* InOuter, FName InInputName, FNiagaraTypeDefinition InInputType, TOptional<bool> bInEditConditionValue, const FString& InExpressionValue)
|
|
{
|
|
UNiagaraClipboardFunctionInput* NewInput = MakeNewInput(InOuter, InInputName, InInputType, bInEditConditionValue, ENiagaraClipboardFunctionInputValueMode::Expression);
|
|
NewInput->Expression = InExpressionValue;
|
|
return NewInput;
|
|
}
|
|
|
|
const UNiagaraClipboardFunctionInput* UNiagaraClipboardFunctionInput::CreateDynamicValue(UObject* InOuter, FName InInputName, FNiagaraTypeDefinition InInputType, TOptional<bool> bInEditConditionValue, FString InDynamicValueName, UNiagaraScript* InDynamicValue, const FGuid& InScriptVersion)
|
|
{
|
|
UNiagaraClipboardFunctionInput* NewInput = MakeNewInput(InOuter, InInputName, InInputType, bInEditConditionValue, ENiagaraClipboardFunctionInputValueMode::Dynamic);
|
|
NewInput->Dynamic = UNiagaraClipboardFunction::CreateScriptFunction(NewInput, InDynamicValueName, InDynamicValue, InScriptVersion);
|
|
return NewInput;
|
|
}
|
|
|
|
const UNiagaraClipboardFunctionInput* UNiagaraClipboardFunctionInput::CreateDefaultInputValue(UObject* InOuter, FName InInputName, FNiagaraTypeDefinition InInputType)
|
|
{
|
|
UNiagaraClipboardFunctionInput* NewInput = MakeNewInput(InOuter, InInputName, InInputType, TOptional<bool>(), ENiagaraClipboardFunctionInputValueMode::ResetToDefault);
|
|
NewInput->Local.SetNumZeroed(InInputType.GetSize());
|
|
return NewInput;
|
|
}
|
|
|
|
|
|
bool UNiagaraClipboardFunctionInput::CopyValuesFrom(const UNiagaraClipboardFunctionInput* InOther)
|
|
{
|
|
if (InputType != InOther->InputType)
|
|
return false;
|
|
|
|
ValueMode = InOther->ValueMode;
|
|
Local = InOther->Local;
|
|
Linked = InOther->Linked;
|
|
|
|
Data = nullptr;
|
|
if (InOther->Data)
|
|
Data = Cast<UNiagaraDataInterface>(StaticDuplicateObject(InOther->Data, this));
|
|
Expression = InOther->Expression;
|
|
Dynamic = nullptr;
|
|
if (InOther->Dynamic)
|
|
Dynamic = Cast<UNiagaraClipboardFunction>(StaticDuplicateObject(InOther->Dynamic, this));
|
|
|
|
return true;
|
|
}
|
|
|
|
const UNiagaraClipboardRenderer* UNiagaraClipboardRenderer::CreateRenderer(UObject* InOuter, UNiagaraRendererProperties* Renderer, TOptional<FNiagaraStackNoteData> StackNoteData)
|
|
{
|
|
UNiagaraClipboardRenderer* NewRenderer = Cast<UNiagaraClipboardRenderer>(NewObject<UNiagaraClipboardRenderer>(InOuter));
|
|
NewRenderer->RendererProperties = CastChecked<UNiagaraRendererProperties>(StaticDuplicateObject(Renderer, InOuter));
|
|
|
|
if(StackNoteData.IsSet())
|
|
{
|
|
NewRenderer->StackNoteData = StackNoteData.GetValue();
|
|
}
|
|
|
|
return NewRenderer;
|
|
}
|
|
|
|
UNiagaraClipboardFunction* UNiagaraClipboardFunction::CreateScriptFunction(UObject* InOuter, FString InFunctionName, UNiagaraScript* InScript, const FGuid& InScriptVersion, const TOptional<FNiagaraStackNoteData>& InStackNote)
|
|
{
|
|
UNiagaraClipboardFunction* NewFunction = Cast<UNiagaraClipboardFunction>(NewObject<UNiagaraClipboardFunction>(InOuter));
|
|
NewFunction->ScriptMode = ENiagaraClipboardFunctionScriptMode::ScriptAsset;
|
|
NewFunction->FunctionName = InFunctionName;
|
|
NewFunction->Script = InScript;
|
|
NewFunction->ScriptVersion = InScriptVersion;
|
|
|
|
if(InStackNote.IsSet())
|
|
{
|
|
NewFunction->StackNoteData = InStackNote.GetValue();
|
|
}
|
|
|
|
return NewFunction;
|
|
}
|
|
|
|
UNiagaraClipboardFunction* UNiagaraClipboardFunction::CreateAssignmentFunction(UObject* InOuter, FString InFunctionName, const TArray<FNiagaraVariable>& InAssignmentTargets, const TArray<FString>& InAssignmentDefaults, TOptional<FNiagaraStackNoteData> InStackNoteData)
|
|
{
|
|
UNiagaraClipboardFunction* NewFunction = Cast<UNiagaraClipboardFunction>(NewObject<UNiagaraClipboardFunction>(InOuter));
|
|
NewFunction->ScriptMode = ENiagaraClipboardFunctionScriptMode::Assignment;
|
|
NewFunction->FunctionName = InFunctionName;
|
|
NewFunction->AssignmentTargets = InAssignmentTargets;
|
|
NewFunction->AssignmentDefaults = InAssignmentDefaults;
|
|
|
|
if(InStackNoteData.IsSet())
|
|
{
|
|
NewFunction->StackNoteData = InStackNoteData.GetValue();
|
|
}
|
|
|
|
return NewFunction;
|
|
}
|
|
|
|
FNiagaraClipboardPortableValue FNiagaraClipboardPortableValue::CreateFromStructValue(const UScriptStruct& TargetStruct, uint8* StructMemory)
|
|
{
|
|
FNiagaraClipboardPortableValue PortableValue;
|
|
TargetStruct.ExportText(PortableValue.ValueString, StructMemory, nullptr, nullptr, PPF_Copy, nullptr);
|
|
return PortableValue;
|
|
}
|
|
|
|
FNiagaraClipboardPortableValue FNiagaraClipboardPortableValue::CreateFromTypedValue(const FNiagaraTypeDefinition& InType, const FNiagaraVariant& InValue)
|
|
{
|
|
FNiagaraClipboardPortableValue PortableValue;
|
|
|
|
TSharedPtr<INiagaraEditorTypeUtilities> InputTypeUtilities = FNiagaraEditorModule::Get().GetTypeUtilities(InType);
|
|
if (InputTypeUtilities.IsValid() && InputTypeUtilities->SupportsClipboardPortableValues())
|
|
{
|
|
if (InputTypeUtilities->TryUpdateClipboardPortableValueFromTypedValue(InType, InValue, PortableValue) == false)
|
|
{
|
|
PortableValue.Reset();
|
|
}
|
|
}
|
|
|
|
if (PortableValue.IsValid() == false)
|
|
{
|
|
if (InType.GetStruct() != nullptr &&
|
|
InType.GetStruct()->IsA<UScriptStruct>() &&
|
|
InType.GetSize() == InValue.GetNumBytes())
|
|
{
|
|
UScriptStruct* ValueStruct = CastChecked<UScriptStruct>(InType.GetStruct());
|
|
PortableValue = CreateFromStructValue(*ValueStruct, InValue.GetBytes());
|
|
}
|
|
}
|
|
|
|
if (PortableValue.IsValid() == false)
|
|
{
|
|
PortableValue.Reset();
|
|
}
|
|
return PortableValue;
|
|
}
|
|
|
|
FNiagaraClipboardPortableValue FNiagaraClipboardPortableValue::CreateFromPropertyHandle(const IPropertyHandle& InPropertyHandle)
|
|
{
|
|
FNiagaraClipboardPortableValue PortableValue;
|
|
FProperty* Property = InPropertyHandle.GetProperty();
|
|
if (Property != nullptr)
|
|
{
|
|
UScriptStruct* ValueStruct = nullptr;
|
|
if (Property->IsA(FStructProperty::StaticClass()))
|
|
{
|
|
FStructProperty* StructProperty = CastField<FStructProperty>(Property);
|
|
ValueStruct = StructProperty->Struct;
|
|
TSharedPtr<INiagaraEditorPropertyUtilities, ESPMode::ThreadSafe> PropertyUtilities = FNiagaraEditorModule::Get().GetPropertyUtilities(*ValueStruct);
|
|
if (PropertyUtilities.IsValid() && PropertyUtilities->SupportsClipboardPortableValues())
|
|
{
|
|
if (PropertyUtilities->TryUpdateClipboardPortableValueFromProperty(InPropertyHandle, PortableValue) == false)
|
|
{
|
|
PortableValue.Reset();
|
|
}
|
|
}
|
|
}
|
|
|
|
if (PortableValue.IsValid() == false)
|
|
{
|
|
if (InPropertyHandle.GetValueAsFormattedString(PortableValue.ValueString, PPF_Copy) != FPropertyAccess::Success)
|
|
{
|
|
PortableValue.Reset();
|
|
}
|
|
}
|
|
}
|
|
|
|
return PortableValue;
|
|
}
|
|
|
|
bool FNiagaraClipboardPortableValue::CanUpdateTypedValue(const FNiagaraTypeDefinition& InTargetType) const
|
|
{
|
|
if (IsValid() == false)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
TSharedPtr<INiagaraEditorTypeUtilities> TargetTypeUtilities = FNiagaraEditorModule::Get().GetTypeUtilities(InTargetType);
|
|
if (TargetTypeUtilities.IsValid() && TargetTypeUtilities->SupportsClipboardPortableValues())
|
|
{
|
|
return TargetTypeUtilities->CanUpdateTypedValueFromClipboardPortableValue(*this, InTargetType);
|
|
}
|
|
if (InTargetType.GetStruct() != nullptr && InTargetType.GetStruct()->IsA<UScriptStruct>())
|
|
{
|
|
UScriptStruct* TargetStruct = CastChecked<UScriptStruct>(InTargetType.GetStruct());
|
|
TArray<uint8> ValueBytes;
|
|
ValueBytes.AddDefaulted(InTargetType.GetSize());
|
|
return TryUpdateStructValue(*TargetStruct, ValueBytes.GetData());
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool FNiagaraClipboardPortableValue::TryUpdateStructValue(const UScriptStruct& TargetStruct, uint8* StructMemory) const
|
|
{
|
|
LOG_SCOPE_VERBOSITY_OVERRIDE(LogExec, ELogVerbosity::Verbose);
|
|
FErrorPipe ErrorPipe;
|
|
return TargetStruct.ImportText(*ValueString, StructMemory, nullptr, PPF_Copy, &ErrorPipe, TargetStruct.GetName()) != nullptr && ErrorPipe.NumErrors == 0;
|
|
}
|
|
|
|
bool FNiagaraClipboardPortableValue::TryUpdateTypedValue(const FNiagaraTypeDefinition& InTargetType, FNiagaraVariant& InTargetValue) const
|
|
{
|
|
if (IsValid() == false)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
TSharedPtr<INiagaraEditorTypeUtilities> TargetTypeUtilities = FNiagaraEditorModule::Get().GetTypeUtilities(InTargetType);
|
|
if (TargetTypeUtilities.IsValid() && TargetTypeUtilities->SupportsClipboardPortableValues())
|
|
{
|
|
if (TargetTypeUtilities->TryUpdateTypedValueFromClipboardPortableValue(*this, InTargetType, InTargetValue))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
if (InTargetType.GetStruct() != nullptr && InTargetType.GetStruct()->IsA<UScriptStruct>())
|
|
{
|
|
UScriptStruct* TargetStruct = CastChecked<UScriptStruct>(InTargetType.GetStruct());
|
|
TArray<uint8> ValueBytes;
|
|
ValueBytes.AddDefaulted(TargetStruct->GetStructureSize());
|
|
if (TryUpdateStructValue(*TargetStruct, ValueBytes.GetData()))
|
|
{
|
|
InTargetValue.SetBytes(ValueBytes.GetData(), ValueBytes.Num());
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool FNiagaraClipboardPortableValue::TryUpdatePropertyHandle(IPropertyHandle& InTargetPropertyHandle) const
|
|
{
|
|
if (IsValid() == false)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
FProperty* Property = InTargetPropertyHandle.GetProperty();
|
|
if (Property != nullptr)
|
|
{
|
|
if (Property->IsA(FStructProperty::StaticClass()))
|
|
{
|
|
FStructProperty* StructProperty = CastField<FStructProperty>(Property);
|
|
TSharedPtr<INiagaraEditorPropertyUtilities, ESPMode::ThreadSafe> PropertyUtilities = FNiagaraEditorModule::Get().GetPropertyUtilities(*StructProperty->Struct);
|
|
if (PropertyUtilities.IsValid() && PropertyUtilities->SupportsClipboardPortableValues())
|
|
{
|
|
if (PropertyUtilities->TryUpdatePropertyFromClipboardPortableValue(*this, InTargetPropertyHandle))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return InTargetPropertyHandle.SetValueFromFormattedString(ValueString) == FPropertyAccess::Success;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
UNiagaraClipboardContent* UNiagaraClipboardContent::Create()
|
|
{
|
|
return NewObject<UNiagaraClipboardContent>(GetTransientPackage());
|
|
}
|
|
|
|
FNiagaraClipboard::FNiagaraClipboard()
|
|
{
|
|
}
|
|
|
|
void FNiagaraClipboard::SetClipboardContent(UNiagaraClipboardContent* ClipboardContent)
|
|
{
|
|
// Clear the mark state for saving.
|
|
UnMarkAllObjects(EObjectMark(OBJECTMARK_TagExp | OBJECTMARK_TagImp));
|
|
|
|
// Export the clipboard to text.
|
|
FStringOutputDevice Archive;
|
|
const FExportObjectInnerContext Context;
|
|
UExporter::ExportToOutputDevice(&Context, ClipboardContent, nullptr, Archive, TEXT("copy"), 0, PPF_ExportsNotFullyQualified | PPF_Copy | PPF_Delimited, false, ClipboardContent->GetOuter());
|
|
FPlatformApplicationMisc::ClipboardCopy(*Archive);
|
|
}
|
|
|
|
const UNiagaraClipboardContent* FNiagaraClipboard::GetClipboardContent() const
|
|
{
|
|
// Get the text from the clipboard.
|
|
FString ClipboardText;
|
|
FPlatformApplicationMisc::ClipboardPaste(ClipboardText);
|
|
|
|
// Try to create niagara clipboard content from that.
|
|
FNiagaraClipboardContentTextObjectFactory ClipboardContentFactory;
|
|
if (ClipboardContentFactory.CanCreateObjectsFromText(ClipboardText))
|
|
{
|
|
ClipboardContentFactory.ProcessBuffer(GetTransientPackage(), RF_Transactional, ClipboardText);
|
|
return ClipboardContentFactory.ClipboardContent;
|
|
}
|
|
|
|
if (ClipboardText.IsEmpty() == false)
|
|
{
|
|
// If the clipboard text wasn't a niagara clipboard object, it's likely been copied from elsewhere in the editor and may be
|
|
// a valid portable value so we consturct an empty clipboard object and set the portable data.
|
|
UNiagaraClipboardContent* ClipboardContent = UNiagaraClipboardContent::Create();
|
|
FNiagaraClipboardPortableValue& PortableValue = ClipboardContent->PortableValues.AddDefaulted_GetRef();
|
|
PortableValue.ValueString = ClipboardText;
|
|
return ClipboardContent;
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
void UNiagaraClipboardEditorScriptingUtilities::TryGetInputByName(const TArray<UNiagaraClipboardFunctionInput*>& InInputs, FName InInputName, bool& bOutSucceeded, UNiagaraClipboardFunctionInput*& OutInput)
|
|
{
|
|
for (UNiagaraClipboardFunctionInput* Input : InInputs)
|
|
{
|
|
if (Input->InputName == InInputName)
|
|
{
|
|
bOutSucceeded = true;
|
|
OutInput = const_cast<UNiagaraClipboardFunctionInput*>(Input);
|
|
}
|
|
}
|
|
bOutSucceeded = false;
|
|
OutInput = nullptr;
|
|
}
|
|
|
|
void UNiagaraClipboardEditorScriptingUtilities::TryGetLocalValueAsFloat(const UNiagaraClipboardFunctionInput* InInput, bool& bOutSucceeded, float& OutValue)
|
|
{
|
|
if (InInput->ValueMode == ENiagaraClipboardFunctionInputValueMode::Local && InInput->InputType == FNiagaraTypeDefinition::GetFloatDef() && InInput->Local.Num() == InInput->InputType.GetSize())
|
|
{
|
|
bOutSucceeded = true;
|
|
OutValue = *((float*)InInput->Local.GetData());
|
|
}
|
|
else
|
|
{
|
|
bOutSucceeded = false;
|
|
OutValue = 0.0f;
|
|
}
|
|
}
|
|
|
|
void UNiagaraClipboardEditorScriptingUtilities::TryGetLocalValueAsInt(const UNiagaraClipboardFunctionInput* InInput, bool& bOutSucceeded, int32& OutValue)
|
|
{
|
|
bool bCompatibleType = InInput->InputType == FNiagaraTypeDefinition::GetIntDef() || (InInput->InputType.IsEnum() && InInput->InputType.GetSize() == sizeof(int32)) ||
|
|
InInput->InputType == FNiagaraTypeDefinition::GetBoolDef();
|
|
if (InInput->ValueMode == ENiagaraClipboardFunctionInputValueMode::Local && bCompatibleType && InInput->Local.Num() == InInput->InputType.GetSize())
|
|
{
|
|
bOutSucceeded = true;
|
|
OutValue = *((int32*)InInput->Local.GetData());
|
|
}
|
|
else
|
|
{
|
|
bOutSucceeded = false;
|
|
OutValue = 0;
|
|
}
|
|
}
|
|
|
|
void UNiagaraClipboardEditorScriptingUtilities::TrySetLocalValueAsInt(UNiagaraClipboardFunctionInput* InInput, bool& bOutSucceeded, int32 InValue,bool bLooseTyping)
|
|
{
|
|
bool bCompatibleType = InInput->InputType == FNiagaraTypeDefinition::GetIntDef() || (bLooseTyping && InInput->InputType.IsEnum() && InInput->InputType.GetSize() == sizeof(int32)) ||
|
|
(bLooseTyping && InInput->InputType == FNiagaraTypeDefinition::GetBoolDef() && InInput->InputType.GetSize() == sizeof(int32));
|
|
if (InInput->ValueMode == ENiagaraClipboardFunctionInputValueMode::Local && bCompatibleType && InInput->Local.Num() == InInput->InputType.GetSize())
|
|
{
|
|
bOutSucceeded = true;
|
|
*((int32*)InInput->Local.GetData()) = InValue;
|
|
}
|
|
else
|
|
{
|
|
bOutSucceeded = false;
|
|
}
|
|
}
|
|
|
|
FName UNiagaraClipboardEditorScriptingUtilities::GetTypeName(const UNiagaraClipboardFunctionInput* InInput)
|
|
{
|
|
return InInput->InputType.GetFName();
|
|
}
|
|
|
|
const UNiagaraClipboardFunctionInput* CreateLocalValue(UObject* InOuter, FName InInputName, FNiagaraTypeDefinition InInputType, bool bInHasEditCondition, bool bInEditConditionValue, TArray<uint8>& InLocalValueData)
|
|
{
|
|
return UNiagaraClipboardFunctionInput::CreateLocalValue(
|
|
InOuter != nullptr ? InOuter : GetTransientPackage(),
|
|
InInputName,
|
|
InInputType,
|
|
bInHasEditCondition ? TOptional<bool>(bInEditConditionValue) : TOptional<bool>(),
|
|
InLocalValueData);
|
|
}
|
|
|
|
FNiagaraTypeDefinition UNiagaraClipboardEditorScriptingUtilities::GetRegisteredTypeDefinitionByName(FName InTypeName)
|
|
{
|
|
return FNiagaraTypeRegistry::GetRegisteredTypeByName(InTypeName).Get(FNiagaraTypeDefinition());
|
|
}
|
|
|
|
UNiagaraClipboardFunctionInput* UNiagaraClipboardEditorScriptingUtilities::CreateColorLocalValueInput(UObject* InOuter, FName InInputName, bool bInHasEditCondition, bool bInEditConditionValue, FLinearColor InColorValue)
|
|
{
|
|
FNiagaraTypeDefinition InputType = FNiagaraTypeDefinition::GetColorDef();
|
|
TArray<uint8> ColorValue;
|
|
ColorValue.AddUninitialized(InputType.GetSize());
|
|
FMemory::Memcpy(ColorValue.GetData(), &InColorValue, InputType.GetSize());
|
|
|
|
return const_cast<UNiagaraClipboardFunctionInput*>(CreateLocalValue(InOuter, InInputName, InputType, bInHasEditCondition, bInEditConditionValue, ColorValue));
|
|
}
|
|
|
|
UNiagaraClipboardFunctionInput* UNiagaraClipboardEditorScriptingUtilities::CreateFloatLocalValueInput(UObject* InOuter, FName InInputName, bool bInHasEditCondition, bool bInEditConditionValue, float InFloatValue)
|
|
{
|
|
FNiagaraTypeDefinition InputType = FNiagaraTypeDefinition::GetFloatDef();
|
|
TArray<uint8> FloatValue;
|
|
FloatValue.AddUninitialized(InputType.GetSize());
|
|
FMemory::Memcpy(FloatValue.GetData(), &InFloatValue, InputType.GetSize());
|
|
|
|
return const_cast<UNiagaraClipboardFunctionInput*>(CreateLocalValue(InOuter, InInputName, InputType, bInHasEditCondition, bInEditConditionValue, FloatValue));
|
|
}
|
|
|
|
UNiagaraClipboardFunctionInput* UNiagaraClipboardEditorScriptingUtilities::CreateMatrixLocalValueInput(UObject* InOuter, FName InInputName, bool bInHasEditCondition, bool bInEditConditionValue, FMatrix44f InMatrixValue)
|
|
{
|
|
FNiagaraTypeDefinition InputType = FNiagaraTypeDefinition::GetMatrix4Def();
|
|
FNiagaraMatrix Matrix;
|
|
Matrix.Row0 = FVector4f(InMatrixValue.M[0][0], InMatrixValue.M[0][1], InMatrixValue.M[0][2], InMatrixValue.M[0][3]);
|
|
Matrix.Row1 = FVector4f(InMatrixValue.M[1][0], InMatrixValue.M[1][1], InMatrixValue.M[1][2], InMatrixValue.M[1][3]);
|
|
Matrix.Row2 = FVector4f(InMatrixValue.M[2][0], InMatrixValue.M[2][1], InMatrixValue.M[2][2], InMatrixValue.M[2][3]);
|
|
Matrix.Row3 = FVector4f(InMatrixValue.M[3][0], InMatrixValue.M[3][1], InMatrixValue.M[3][2], InMatrixValue.M[3][3]);
|
|
TArray<uint8> MatrixValue;
|
|
MatrixValue.AddUninitialized(InputType.GetSize());
|
|
FMemory::Memcpy(MatrixValue.GetData(), &Matrix, InputType.GetSize());
|
|
|
|
return const_cast<UNiagaraClipboardFunctionInput*>(CreateLocalValue(InOuter, InInputName, InputType, bInHasEditCondition, bInEditConditionValue, MatrixValue));
|
|
}
|
|
|
|
UNiagaraClipboardFunctionInput* UNiagaraClipboardEditorScriptingUtilities::CreateQuatLocalValueInput(UObject* InOuter, FName InInputName, bool bInHasEditCondition, bool bInEditConditionValue, FQuat4f InQuatValue)
|
|
{
|
|
FNiagaraTypeDefinition InputType = FNiagaraTypeDefinition::GetQuatDef();
|
|
TArray<uint8> QuatValue;
|
|
QuatValue.AddUninitialized(InputType.GetSize());
|
|
FMemory::Memcpy(QuatValue.GetData(), &InQuatValue, InputType.GetSize());
|
|
|
|
return const_cast<UNiagaraClipboardFunctionInput*>(CreateLocalValue(InOuter, InInputName, InputType, bInHasEditCondition, bInEditConditionValue, QuatValue));
|
|
}
|
|
|
|
UNiagaraClipboardFunctionInput* UNiagaraClipboardEditorScriptingUtilities::CreateVec2LocalValueInput(UObject* InOuter, FName InInputName, bool bInHasEditCondition, bool bInEditConditionValue, FVector2D InVec2Value)
|
|
{
|
|
FNiagaraTypeDefinition InputType = FNiagaraTypeDefinition::GetVec2Def();
|
|
const FVector2f InVec2ValueFloat = FVector2f(InVec2Value); // LWC_TODO: Precision loss
|
|
TArray<uint8> Vec2ValueFloat;
|
|
Vec2ValueFloat.AddUninitialized(InputType.GetSize());
|
|
FMemory::Memcpy(Vec2ValueFloat.GetData(), &InVec2ValueFloat, InputType.GetSize());
|
|
|
|
return const_cast<UNiagaraClipboardFunctionInput*>(CreateLocalValue(InOuter, InInputName, InputType, bInHasEditCondition, bInEditConditionValue, Vec2ValueFloat));
|
|
}
|
|
|
|
UNiagaraClipboardFunctionInput* UNiagaraClipboardEditorScriptingUtilities::CreateVec3LocalValueInput(UObject* InOuter, FName InInputName, bool bInHasEditCondition, bool bInEditConditionValue, FVector InVec3Value)
|
|
{
|
|
FNiagaraTypeDefinition InputType = FNiagaraTypeDefinition::GetVec3Def();
|
|
const FVector3f InVec3ValueFloat = (FVector3f)InVec3Value;
|
|
TArray<uint8> Vec3ValueFloat;
|
|
Vec3ValueFloat.AddUninitialized(InputType.GetSize());
|
|
FMemory::Memcpy(Vec3ValueFloat.GetData(), &InVec3ValueFloat, InputType.GetSize());
|
|
|
|
return const_cast<UNiagaraClipboardFunctionInput*>(CreateLocalValue(InOuter, InInputName, InputType, bInHasEditCondition, bInEditConditionValue, Vec3ValueFloat));
|
|
}
|
|
|
|
UNiagaraClipboardFunctionInput* UNiagaraClipboardEditorScriptingUtilities::CreateVec4LocalValueInput(UObject* InOuter, FName InInputName, bool bInHasEditCondition, bool bInEditConditionValue, FVector4f InVec4Value)
|
|
{
|
|
FNiagaraTypeDefinition InputType = FNiagaraTypeDefinition::GetVec4Def();
|
|
TArray<uint8> Vec4Value;
|
|
Vec4Value.AddUninitialized(InputType.GetSize());
|
|
FMemory::Memcpy(Vec4Value.GetData(), &InVec4Value, InputType.GetSize());
|
|
|
|
return const_cast<UNiagaraClipboardFunctionInput*>(CreateLocalValue(InOuter, InInputName, InputType, bInHasEditCondition, bInEditConditionValue, Vec4Value));
|
|
}
|
|
|
|
UNiagaraClipboardFunctionInput* UNiagaraClipboardEditorScriptingUtilities::CreateIntLocalValueInput(UObject* InOuter, FName InInputName, bool bInHasEditCondition, bool bInEditConditionValue, int32 InIntValue)
|
|
{
|
|
FNiagaraTypeDefinition InputType = FNiagaraTypeDefinition::GetIntDef();
|
|
TArray<uint8> IntValue;
|
|
IntValue.AddUninitialized(InputType.GetSize());
|
|
FMemory::Memcpy(IntValue.GetData(), &InIntValue, InputType.GetSize());
|
|
|
|
return const_cast<UNiagaraClipboardFunctionInput*>(CreateLocalValue(InOuter, InInputName, InputType, bInHasEditCondition, bInEditConditionValue, IntValue));
|
|
}
|
|
|
|
UNiagaraClipboardFunctionInput* UNiagaraClipboardEditorScriptingUtilities::CreateBoolLocalValueInput(UObject* InOuter, FName InInputName, bool bInHasEditCondition, bool bInEditConditionValue, bool InBoolValue)
|
|
{
|
|
FNiagaraTypeDefinition InputType = FNiagaraTypeDefinition::GetBoolDef();
|
|
const int32 BoolAsIntValue = InBoolValue ? 1 : 0;
|
|
TArray<uint8> IntValue;
|
|
IntValue.AddUninitialized(InputType.GetSize());
|
|
FMemory::Memcpy(IntValue.GetData(), &BoolAsIntValue, InputType.GetSize());
|
|
|
|
return const_cast<UNiagaraClipboardFunctionInput*>(CreateLocalValue(InOuter, InInputName, InputType, bInHasEditCondition, bInEditConditionValue, IntValue));
|
|
}
|
|
|
|
UNiagaraClipboardFunctionInput* UNiagaraClipboardEditorScriptingUtilities::CreateStructLocalValueInput(UObject* InOuter, FName InInputName, bool bInHasEditCondition, bool bInEditConditionValue, UUserDefinedStruct* InStructValue)
|
|
{
|
|
FNiagaraTypeDefinition InputType = FNiagaraTypeDefinition(InStructValue);
|
|
FStructOnScope StructOnScope = FStructOnScope(InStructValue);
|
|
TArray<uint8> StructValue;
|
|
const int32 StructSize = InStructValue->GetStructureSize();
|
|
StructValue.AddUninitialized(StructSize);
|
|
FMemory::Memcpy(StructValue.GetData(), StructOnScope.GetStructMemory(), StructSize);
|
|
|
|
return const_cast<UNiagaraClipboardFunctionInput*>(UNiagaraClipboardFunctionInput::CreateLocalValue(
|
|
InOuter != nullptr ? InOuter : GetTransientPackage(),
|
|
InInputName,
|
|
InputType,
|
|
bInHasEditCondition ? TOptional<bool>(bInEditConditionValue) : TOptional<bool>(),
|
|
StructValue)
|
|
);
|
|
}
|
|
|
|
UNiagaraClipboardFunctionInput* UNiagaraClipboardEditorScriptingUtilities::CreateEnumLocalValueInput(UObject* InOuter, FName InInputName, bool bInHasEditCondition, bool bInEditCoditionValue, UUserDefinedEnum* InEnumType, int32 InEnumValue)
|
|
{
|
|
FNiagaraTypeDefinition InputType = FNiagaraTypeDefinition(Cast<UEnum>(InEnumType));
|
|
TArray<uint8> EnumValue;
|
|
EnumValue.AddUninitialized(sizeof(int32));
|
|
FMemory::Memcpy(EnumValue.GetData(), &InEnumValue, sizeof(int32));
|
|
|
|
return const_cast<UNiagaraClipboardFunctionInput*>(UNiagaraClipboardFunctionInput::CreateLocalValue(
|
|
InOuter != nullptr ? InOuter : GetTransientPackage(),
|
|
InInputName,
|
|
InputType,
|
|
bInHasEditCondition ? TOptional<bool>(bInEditCoditionValue) : TOptional<bool>(),
|
|
EnumValue)
|
|
);
|
|
}
|
|
|
|
UNiagaraClipboardFunctionInput* UNiagaraClipboardEditorScriptingUtilities::CreateEnumLinkedValueInput(UObject* InOuter, FName InInputName, bool bInHasEditCondition, bool bInEditConditionValue, UUserDefinedEnum* InEnumType, FName InLinkedValue)
|
|
{
|
|
FNiagaraTypeDefinition InputType = FNiagaraTypeDefinition(Cast<UEnum>(InEnumType));
|
|
if (InputType.IsValid())
|
|
{
|
|
FNiagaraVariableBase LinkedParameter = FNiagaraVariableBase(InputType, InLinkedValue);
|
|
return const_cast<UNiagaraClipboardFunctionInput*>(UNiagaraClipboardFunctionInput::CreateLinkedValue(
|
|
InOuter != nullptr ? InOuter : GetTransientPackage(),
|
|
InInputName,
|
|
InputType,
|
|
bInHasEditCondition ? TOptional<bool>(bInEditConditionValue) : TOptional<bool>(),
|
|
LinkedParameter));
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
UNiagaraClipboardFunctionInput* UNiagaraClipboardEditorScriptingUtilities::CreateLinkedValueInput(UObject* InOuter, FName InInputName, FName InInputTypeName, bool bInHasEditCondition, bool bInEditConditionValue, FName InLinkedValue)
|
|
{
|
|
FNiagaraTypeDefinition InputType = GetRegisteredTypeDefinitionByName(InInputTypeName);
|
|
if (InputType.IsValid())
|
|
{
|
|
FNiagaraVariableBase LinkedParameter = FNiagaraVariableBase(InputType, InLinkedValue);
|
|
return const_cast<UNiagaraClipboardFunctionInput*>(UNiagaraClipboardFunctionInput::CreateLinkedValue(
|
|
InOuter != nullptr ? InOuter : GetTransientPackage(),
|
|
InInputName,
|
|
InputType,
|
|
bInHasEditCondition ? TOptional<bool>(bInEditConditionValue) : TOptional<bool>(),
|
|
LinkedParameter));
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
UNiagaraClipboardFunctionInput* UNiagaraClipboardEditorScriptingUtilities::CreateDataValueInput(UObject* InOuter, FName InInputName, bool bInHasEditCondition, bool bInEditConditionValue, UNiagaraDataInterface* InDataValue)
|
|
{
|
|
if (InDataValue != nullptr)
|
|
{
|
|
return const_cast<UNiagaraClipboardFunctionInput*>(UNiagaraClipboardFunctionInput::CreateDataValue(
|
|
InOuter != nullptr ? InOuter : GetTransientPackage(),
|
|
InInputName,
|
|
FNiagaraTypeDefinition(InDataValue->GetClass()),
|
|
bInHasEditCondition ? TOptional<bool>(bInEditConditionValue) : TOptional<bool>(),
|
|
InDataValue));
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
UNiagaraClipboardFunctionInput* UNiagaraClipboardEditorScriptingUtilities::CreateExpressionValueInput(UObject* InOuter, FName InInputName, FName InInputTypeName, bool bInHasEditCondition, bool bInEditConditionValue, const FString& InExpressionValue)
|
|
{
|
|
FNiagaraTypeDefinition InputType = GetRegisteredTypeDefinitionByName(InInputTypeName);
|
|
if (InputType.IsValid())
|
|
{
|
|
return const_cast<UNiagaraClipboardFunctionInput*>(UNiagaraClipboardFunctionInput::CreateExpressionValue(
|
|
InOuter != nullptr ? InOuter : GetTransientPackage(),
|
|
InInputName,
|
|
InputType,
|
|
bInHasEditCondition ? TOptional<bool>(bInEditConditionValue) : TOptional<bool>(),
|
|
InExpressionValue));
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
UNiagaraClipboardFunctionInput* UNiagaraClipboardEditorScriptingUtilities::CreateDynamicValueInput(UObject* InOuter, FName InInputName, FName InInputTypeName, bool bInHasEditCondition, bool bInEditConditionValue, FString InDynamicValueName, UNiagaraScript* InDynamicValue)
|
|
{
|
|
FNiagaraTypeDefinition InputType = GetRegisteredTypeDefinitionByName(InInputTypeName);
|
|
if (InputType.IsValid())
|
|
{
|
|
return const_cast<UNiagaraClipboardFunctionInput*>(UNiagaraClipboardFunctionInput::CreateDynamicValue(
|
|
InOuter != nullptr ? InOuter : GetTransientPackage(),
|
|
InInputName,
|
|
InputType,
|
|
bInHasEditCondition ? TOptional<bool>(bInEditConditionValue) : TOptional<bool>(),
|
|
InDynamicValueName,
|
|
InDynamicValue,
|
|
FGuid()));
|
|
}
|
|
return nullptr;
|
|
}
|
|
|