683 lines
24 KiB
C++
683 lines
24 KiB
C++
// Copyright Epic Games, Inc. All Rights Reserved.
|
|
|
|
#pragma once
|
|
|
|
#include "CoreMinimal.h"
|
|
#include "Containers/ArrayView.h"
|
|
#include "UObject/ObjectMacros.h"
|
|
#include "RigVMCore/RigVMRegistry.h"
|
|
#include "RigVMCore/RigVMByteCode.h"
|
|
#include "RigVMCore/RigVMTemplate.h"
|
|
#include "RigVMCompiler/RigVMASTProxy.h"
|
|
#include "UObject/StructOnScope.h"
|
|
#include <RigVMCore/RigVMTrait.h>
|
|
#include "RigVMModelCachedValue.h"
|
|
#include "RigVMPin.generated.h"
|
|
|
|
#define UE_API RIGVMDEVELOPER_API
|
|
|
|
class URigVMGraph;
|
|
class URigVMNode;
|
|
class URigVMUnitNode;
|
|
class URigVMPin;
|
|
class URigVMLink;
|
|
class URigVMVariableNode;
|
|
|
|
extern RIGVMDEVELOPER_API TAutoConsoleVariable<bool> CVarRigVMEnablePinOverrides;
|
|
|
|
/**
|
|
* The Injected Info is used for injecting a node on a pin.
|
|
* Injected nodes are not visible to the user, but they are normal
|
|
* nodes on the graph.
|
|
*/
|
|
UCLASS(MinimalAPI, BlueprintType)
|
|
class URigVMInjectionInfo: public UObject
|
|
{
|
|
GENERATED_BODY()
|
|
|
|
public:
|
|
|
|
URigVMInjectionInfo()
|
|
{
|
|
bInjectedAsInput = true;
|
|
}
|
|
|
|
#if WITH_EDITORONLY_DATA
|
|
UPROPERTY()
|
|
TObjectPtr<URigVMUnitNode> UnitNode_DEPRECATED;
|
|
#endif
|
|
|
|
UPROPERTY()
|
|
TObjectPtr<URigVMNode> Node;
|
|
|
|
UPROPERTY()
|
|
bool bInjectedAsInput;
|
|
|
|
UPROPERTY()
|
|
TObjectPtr<URigVMPin> InputPin;
|
|
|
|
UPROPERTY()
|
|
TObjectPtr<URigVMPin> OutputPin;
|
|
|
|
// Returns the graph of this injected node.
|
|
UFUNCTION(BlueprintCallable, Category = RigVMInjectionInfo)
|
|
UE_API URigVMGraph* GetGraph() const;
|
|
|
|
// Returns the pin of this injected node.
|
|
UFUNCTION(BlueprintCallable, Category = RigVMInjectionInfo)
|
|
UE_API URigVMPin* GetPin() const;
|
|
|
|
struct FWeakInfo
|
|
{
|
|
TWeakObjectPtr<URigVMNode> Node;
|
|
bool bInjectedAsInput;
|
|
FName InputPinName;
|
|
FName OutputPinName;
|
|
};
|
|
|
|
UE_API FWeakInfo GetWeakInfo() const;
|
|
};
|
|
|
|
UENUM()
|
|
enum class ERigVMPinDefaultValueType : uint8
|
|
{
|
|
AutoDetect, // Detect if this is an unchanged or overridden value based on the delta
|
|
Unset, // The value is unchanged and will remain the original default
|
|
Override, // The value is overridden by the user and should stay like this no matter what
|
|
KeepValueType, // The value type should be kept as well as the value itself (don't touch this)
|
|
};
|
|
|
|
/**
|
|
* The Pin represents a single connector / pin on a node in the RigVM model.
|
|
* Pins can be connected based on rules. Pins also provide access to a 'PinPath',
|
|
* which essentially represents . separated list of names to reach the pin within
|
|
* the owning graph. PinPaths are unique.
|
|
* In comparison to the EdGraph Pin the URigVMPin supports the concept of 'SubPins',
|
|
* so child / parent relationships between pins. A FVector Pin for example might
|
|
* have its X, Y and Z components as SubPins. Array Pins will have its elements as
|
|
* SubPins, and so on.
|
|
* A URigVMPin is owned solely by a URigVMNode.
|
|
*/
|
|
UCLASS(MinimalAPI, BlueprintType)
|
|
class URigVMPin : public UObject
|
|
{
|
|
GENERATED_BODY()
|
|
|
|
public:
|
|
|
|
// A struct to store a pin override value
|
|
struct FPinOverrideValue
|
|
{
|
|
FPinOverrideValue()
|
|
: DefaultValue()
|
|
, BoundVariablePath()
|
|
{}
|
|
|
|
FPinOverrideValue(URigVMPin* InPin)
|
|
: DefaultValue(InPin->GetDefaultValue())
|
|
, BoundVariablePath(InPin->GetBoundVariablePath())
|
|
{
|
|
}
|
|
|
|
FPinOverrideValue(URigVMPin* InPin, const TPair<FRigVMASTProxy, const TMap<FRigVMASTProxy, FPinOverrideValue>&>& InOverride)
|
|
: DefaultValue(InPin->GetDefaultValue(InOverride))
|
|
, BoundVariablePath(InPin->GetBoundVariablePath())
|
|
{
|
|
}
|
|
|
|
FString DefaultValue;
|
|
FString BoundVariablePath;
|
|
};
|
|
|
|
// A map used to override pin default values
|
|
typedef TMap<FRigVMASTProxy, FPinOverrideValue> FPinOverrideMap;
|
|
typedef TPair<FRigVMASTProxy, const FPinOverrideMap&> FPinOverride;
|
|
static UE_API const URigVMPin::FPinOverrideMap EmptyPinOverrideMap;
|
|
static UE_API const FPinOverride EmptyPinOverride;
|
|
|
|
// Splits a PinPath at the start, so for example "Node.Color.R" becomes "Node" and "Color.R"
|
|
static UE_API bool SplitPinPathAtStart(const FString& InPinPath, FString& LeftMost, FString& Right);
|
|
|
|
// Splits a PinPath at the start, so for example "Node.Color.R" becomes "Node.Color" and "R"
|
|
static UE_API bool SplitPinPathAtEnd(const FString& InPinPath, FString& Left, FString& RightMost);
|
|
|
|
// Splits a PinPath into all segments, so for example "Node.Color.R" becomes ["Node", "Color", "R"]
|
|
static UE_API bool SplitPinPath(const FString& InPinPath, TArray<FString>& Parts);
|
|
|
|
// Joins a PinPath from to segments, so for example "Node.Color" and "R" becomes "Node.Color.R"
|
|
static UE_API FString JoinPinPath(const FString& Left, const FString& Right);
|
|
|
|
// Joins a PinPath from to segments, so for example ["Node", "Color", "R"] becomes "Node.Color.R"
|
|
static UE_API FString JoinPinPath(const TArray<FString>& InParts);
|
|
|
|
// Splits the default value into name-value pairs
|
|
static UE_API TArray<FString> SplitDefaultValue(const FString& InDefaultValue);
|
|
// Joins a collection of element DefaultValues into a default value for an array of those elements
|
|
static UE_API FString GetDefaultValueForArray(TConstArrayView<FString> InDefaultValues);
|
|
|
|
// Default constructor
|
|
UE_API URigVMPin();
|
|
|
|
// returns true if the name of this pin matches a given name
|
|
UE_API bool NameEquals(const FString& InName, bool bFollowCoreRedirectors = false) const;
|
|
|
|
// Returns a . separated path containing all names of the pin and its owners,
|
|
// this includes the node name, for example "Node.Color.R"
|
|
UFUNCTION(BlueprintCallable, Category = RigVMPin)
|
|
UE_API FString GetPinPath(bool bUseNodePath = false) const;
|
|
|
|
// Returns a . separated path containing all names of the pin and its owners
|
|
// until we hit the provided parent pin.
|
|
UFUNCTION(BlueprintCallable, Category = RigVMPin)
|
|
UE_API FString GetSubPinPath(const URigVMPin* InParentPin, bool bIncludeParentPinName = false) const;
|
|
|
|
// Returns the category on a pin. The category is UI relevant only and used
|
|
// to order pins in the user interface of the node as well as on the details panel.
|
|
UFUNCTION(BlueprintCallable, Category = RigVMPin)
|
|
UE_API FString GetCategory() const;
|
|
|
|
// Returns index within a category on a pin. The category is UI relevant only and used
|
|
// to order pins in the user interface of the node as well as on the details panel.
|
|
UFUNCTION(BlueprintCallable, Category = RigVMPin)
|
|
UE_API int32 GetIndexInCategory() const;
|
|
|
|
// Returns a . separated path containing all names of the pin within its main
|
|
// memory owner / storage. This is typically used to create an offset pointer
|
|
// within memory (FRigVMRegisterOffset).
|
|
// So for example for a PinPath such as "Node.Transform.Translation.X" the
|
|
// corresponding SegmentPath is "Translation.X", since the transform is the
|
|
// storage / memory.
|
|
UFUNCTION(BlueprintCallable, Category = RigVMPin)
|
|
UE_API FString GetSegmentPath(bool bIncludeRootPin = false) const;
|
|
|
|
// Populates an array of pins which will be reduced to the same operand in the
|
|
// VM. This includes Source-Target pins in different nodes, pins in collapse and
|
|
// referenced function nodes, and their corresponding entry and return nodes.
|
|
UE_API void GetExposedPinChain(TArray<const URigVMPin*>& OutExposedPins) const;
|
|
|
|
// Returns the display label of the pin
|
|
UFUNCTION(BlueprintCallable, Category = RigVMPin)
|
|
UE_API FName GetDisplayName() const;
|
|
|
|
// Returns the direction of the pin
|
|
UFUNCTION(BlueprintCallable, Category = RigVMPin)
|
|
UE_API ERigVMPinDirection GetDirection() const;
|
|
|
|
// Returns true if the pin is currently expanded
|
|
UFUNCTION(BlueprintCallable, Category = RigVMPin)
|
|
UE_API bool IsExpanded() const;
|
|
|
|
// Returns true if the pin is defined as a constant value / literal
|
|
UFUNCTION(BlueprintCallable, Category = RigVMPin)
|
|
UE_API bool IsDefinedAsConstant() const;
|
|
|
|
// Returns true if the pin should be watched
|
|
UFUNCTION(BlueprintCallable, Category = RigVMPin)
|
|
UE_API bool RequiresWatch(const bool bCheckExposedPinChain = false) const;
|
|
|
|
// Returns true if the data type of the Pin is a enum
|
|
UFUNCTION(BlueprintCallable, Category = RigVMPin)
|
|
UE_API bool IsEnum() const;
|
|
|
|
// Returns true if the data type of the Pin is a struct
|
|
UFUNCTION(BlueprintCallable, Category = RigVMPin)
|
|
UE_API bool IsStruct() const;
|
|
|
|
// Returns true if the Pin is a SubPin within a struct
|
|
UFUNCTION(BlueprintCallable, Category = RigVMPin)
|
|
UE_API bool IsStructMember() const;
|
|
|
|
// Returns true if the data type of the Pin is a uobject
|
|
UFUNCTION(BlueprintCallable, Category = RigVMPin)
|
|
UE_API bool IsUObject() const;
|
|
|
|
// Returns true if the data type of the Pin is a interface
|
|
UFUNCTION(BlueprintCallable, Category = RigVMPin)
|
|
UE_API bool IsInterface() const;
|
|
|
|
// Returns true if the data type of the Pin is an array
|
|
UFUNCTION(BlueprintCallable, Category = RigVMPin)
|
|
UE_API bool IsArray() const;
|
|
|
|
// Returns true if the Pin is a SubPin within an array
|
|
UFUNCTION(BlueprintCallable, Category = RigVMPin)
|
|
UE_API bool IsArrayElement() const;
|
|
|
|
// Returns true if this pin represents a dynamic array
|
|
UFUNCTION(BlueprintCallable, Category = RigVMPin)
|
|
UE_API bool IsDynamicArray() const;
|
|
|
|
// Returns true if this data type is referenced counted
|
|
UFUNCTION(BlueprintCallable, Category = RigVMPin)
|
|
bool IsReferenceCountedContainer() const { return IsDynamicArray(); }
|
|
|
|
// Returns true if this pin's value may be executed lazily
|
|
UFUNCTION(BlueprintCallable, Category = RigVMPin)
|
|
UE_API bool IsLazy() const;
|
|
|
|
// Returns the index of the Pin within the node / parent Pin
|
|
UFUNCTION(BlueprintCallable, Category = RigVMPin)
|
|
UE_API int32 GetPinIndex() const;
|
|
|
|
// Returns the absolute index of the Pin within the node / parent Pin
|
|
UFUNCTION(BlueprintCallable, Category = RigVMPin)
|
|
UE_API int32 GetAbsolutePinIndex() const;
|
|
|
|
// Returns the number of elements within an array Pin
|
|
UFUNCTION(BlueprintCallable, Category = RigVMPin)
|
|
UE_API int32 GetArraySize() const;
|
|
|
|
// Returns the C++ data type of the pin
|
|
UFUNCTION(BlueprintCallable, Category = RigVMPin)
|
|
UE_API FString GetCPPType() const;
|
|
|
|
// Returns the C++ data type of an element of the Pin array
|
|
UFUNCTION(BlueprintCallable, Category = RigVMPin)
|
|
UE_API FString GetArrayElementCppType() const;
|
|
|
|
// Returns the argument type this pin would represent within a template
|
|
UE_API FRigVMTemplateArgumentType GetTemplateArgumentType() const;
|
|
|
|
// Returns the argument type index this pin would represent within a template
|
|
UE_API TRigVMTypeIndex GetTypeIndex() const;
|
|
|
|
// Returns true if the C++ data type is FString or FName
|
|
UFUNCTION(BlueprintCallable, Category = RigVMPin)
|
|
UE_API bool IsStringType() const;
|
|
|
|
// Returns true if the C++ data type is an execute context
|
|
UFUNCTION(BlueprintCallable, Category = RigVMPin)
|
|
UE_API bool IsExecuteContext() const;
|
|
|
|
// Returns true if the C++ data type is unknown
|
|
UFUNCTION(BlueprintCallable, Category = RigVMPin)
|
|
UE_API bool IsWildCard() const;
|
|
|
|
// Returns true if any of the subpins is a wildcard
|
|
UFUNCTION(BlueprintCallable, Category = RigVMPin)
|
|
UE_API bool ContainsWildCardSubPin() const;
|
|
|
|
// Returns true if this pin is an array that should be displayed as elements only
|
|
UFUNCTION(BlueprintCallable, Category = RigVMPin)
|
|
UE_API bool IsFixedSizeArray() const;
|
|
|
|
// Returns true if this pin is an array that should be displayed as elements only
|
|
UFUNCTION(BlueprintCallable, Category = RigVMPin)
|
|
UE_API bool ShouldOnlyShowSubPins() const;
|
|
|
|
// Returns true if this pin's subpins should be hidden in the UI
|
|
UFUNCTION(BlueprintCallable, Category = RigVMPin)
|
|
UE_API bool ShouldHideSubPins() const;
|
|
|
|
UFUNCTION(BlueprintCallable, Category = RigVMPin)
|
|
UE_API FString GetOriginalDefaultValue() const;
|
|
|
|
UFUNCTION(BlueprintCallable, Category = RigVMPin)
|
|
UE_API bool HasOriginalDefaultValue() const;
|
|
|
|
// Returns the default value of the Pin as a string.
|
|
// Note that this value is computed based on the Pin's
|
|
// SubPins - so for example for a FVector typed Pin
|
|
// the default value is actually composed out of the
|
|
// default values of the X, Y and Z SubPins.
|
|
UFUNCTION(BlueprintCallable, Category = RigVMPin)
|
|
UE_API FString GetDefaultValue() const;
|
|
|
|
// Returns the default value with an additional override ma
|
|
UE_API FString GetDefaultValue(const FPinOverride& InOverride, bool bAdaptValueForPinType = true) const;
|
|
|
|
// Returns the default value as stored by the user.
|
|
UE_API FString GetDefaultValueStoredByUserInterface() const;
|
|
|
|
// Returns true if the default value provided is valid
|
|
UFUNCTION(BlueprintPure, Category = RigVMPin)
|
|
UE_API bool IsValidDefaultValue(const FString& InDefaultValue) const;
|
|
|
|
// Returns true if the default value was ever changed by the user
|
|
UE_DEPRECATED(5.6, "Please use URigVMPin::HasDefaultValueOverride()")
|
|
UFUNCTION(BlueprintPure, Category = RigVMPin)
|
|
UE_API bool HasUserProvidedDefaultValue() const;
|
|
|
|
// Returns true if the default value was ever changed by the user
|
|
UFUNCTION(BlueprintPure, Category = RigVMPin)
|
|
UE_API bool HasDefaultValueOverride() const;
|
|
|
|
// Returns true if the pin can / may provide a default value
|
|
UFUNCTION(BlueprintPure, Category = RigVMPin)
|
|
ERigVMPinDefaultValueType GetDefaultValueType() const { return DefaultValueType; }
|
|
|
|
// Returns true if the pin can / may provide a default value
|
|
UFUNCTION(BlueprintPure, Category = RigVMPin)
|
|
UE_API bool CanProvideDefaultValue() const;
|
|
|
|
// Returns the default value clamped with the limit meta values defined by the UPROPERTY in URigVMUnitNodes
|
|
UE_API FString ClampDefaultValueFromMetaData(const FString& InDefaultValue) const;
|
|
|
|
// Returns the keyed metadata associated with this pin, if any
|
|
UFUNCTION(BlueprintCallable, Category = RigVMPin)
|
|
UE_API FString GetMetaData(FName InKey) const;
|
|
|
|
// Returns whether the keyed metadata associated with this pin exists (can be empty)
|
|
UFUNCTION(BlueprintCallable, Category = RigVMPin)
|
|
UE_API bool HasMetaData(FName InKey) const;
|
|
|
|
// Returns the name of a custom widget to be used
|
|
// for editing the Pin.
|
|
UFUNCTION(BlueprintCallable, Category = RigVMPin)
|
|
UE_API FName GetCustomWidgetName() const;
|
|
|
|
// Returns the tooltip of this pin
|
|
UFUNCTION(BlueprintCallable, Category = RigVMPin)
|
|
UE_API FText GetToolTipText() const;
|
|
|
|
// Returns the struct of the data type of the Pin,
|
|
// or nullptr otherwise.
|
|
UFUNCTION(BlueprintCallable, Category = RigVMPin)
|
|
UE_API UObject* GetCPPTypeObject() const;
|
|
|
|
// Returns the struct of the data type of the Pin,
|
|
// or nullptr otherwise.
|
|
UFUNCTION(BlueprintCallable, Category = RigVMPin)
|
|
UE_API UScriptStruct* GetScriptStruct() const;
|
|
|
|
// Returns the parent struct of the data type of the Pin
|
|
UFUNCTION(BlueprintCallable, Category = RigVMPin)
|
|
UE_API UScriptStruct* GetParentScriptStruct(const URigVMUnitNode* FallbackNode) const;
|
|
|
|
// Returns the enum of the data type of the Pin,
|
|
// or nullptr otherwise.
|
|
UFUNCTION(BlueprintCallable, Category = RigVMPin)
|
|
UE_API UEnum* GetEnum() const;
|
|
|
|
// Returns the parent Pin - or nullptr if the Pin
|
|
// is nested directly below a node.
|
|
UFUNCTION(BlueprintCallable, Category = RigVMPin)
|
|
UE_API URigVMPin* GetParentPin() const;
|
|
|
|
// Returns the top-most parent Pin, so for example
|
|
// for "Node.Transform.Translation.X" this returns
|
|
// the Pin for "Node.Transform".
|
|
UFUNCTION(BlueprintCallable, Category = RigVMPin)
|
|
UE_API URigVMPin* GetRootPin() const;
|
|
|
|
// Returns true if this pin is a root pin
|
|
UFUNCTION(BlueprintCallable, Category = RigVMPin)
|
|
UE_API bool IsRootPin() const;
|
|
|
|
// Returns the pin to be used for a link.
|
|
// This might differ from this actual pin, since
|
|
// the pin might contain injected nodes.
|
|
UFUNCTION(BlueprintCallable, Category = RigVMPin)
|
|
UE_API URigVMPin* GetPinForLink() const;
|
|
|
|
// Returns the link that represents the connection
|
|
// between this pin and InOtherPin. nullptr is returned
|
|
// if the pins are not connected.
|
|
UFUNCTION(BlueprintCallable, Category = RigVMPin)
|
|
UE_API URigVMLink* FindLinkForPin(const URigVMPin* InOtherPin) const;
|
|
|
|
// Returns the original pin for a pin on an injected
|
|
// node. This can be used to determine where a link
|
|
// should go in the user interface
|
|
UFUNCTION(BlueprintCallable, Category = RigVMPin)
|
|
UE_API URigVMPin* GetOriginalPinFromInjectedNode() const;
|
|
|
|
// Returns all of the SubPins of this one.
|
|
UFUNCTION(BlueprintCallable, Category = RigVMPin)
|
|
UE_API const TArray<URigVMPin*>& GetSubPins() const;
|
|
|
|
// Returns all of the SubPins of this one including sub-sub-pins
|
|
UFUNCTION(BlueprintCallable, Category = RigVMPin)
|
|
UE_API TArray<URigVMPin*> GetAllSubPinsRecursively() const;
|
|
|
|
// Returns a SubPin given a name / path or nullptr.
|
|
UFUNCTION(BlueprintCallable, Category = RigVMPin)
|
|
UE_API URigVMPin* FindSubPin(const FString& InPinPath) const;
|
|
|
|
// Returns true if this Pin is linked to another Pin
|
|
UFUNCTION(BlueprintCallable, Category = RigVMPin)
|
|
UE_API bool IsLinkedTo(const URigVMPin* InPin) const;
|
|
|
|
// Returns true if the pin has any link
|
|
UE_API bool IsLinked(bool bRecursive = false) const;
|
|
|
|
// Returns all of the links linked to this Pin.
|
|
UFUNCTION(BlueprintCallable, Category = RigVMPin)
|
|
UE_API const TArray<URigVMLink*>& GetLinks() const;
|
|
|
|
// Returns all of the linked source Pins,
|
|
// using this Pin as the target.
|
|
UFUNCTION(BlueprintCallable, Category = RigVMPin)
|
|
UE_API TArray<URigVMPin*> GetLinkedSourcePins(bool bRecursive = false) const;
|
|
|
|
// Returns all of the linked target Pins,
|
|
// using this Pin as the source.
|
|
UFUNCTION(BlueprintCallable, Category = RigVMPin)
|
|
UE_API TArray<URigVMPin*> GetLinkedTargetPins(bool bRecursive = false) const;
|
|
|
|
// Returns all of the source pins
|
|
// using this Pin as the target.
|
|
UFUNCTION(BlueprintCallable, Category = RigVMPin)
|
|
UE_API TArray<URigVMLink*> GetSourceLinks(bool bRecursive = false) const;
|
|
|
|
// Returns all of the target links,
|
|
// using this Pin as the source.
|
|
UFUNCTION(BlueprintCallable, Category = RigVMPin)
|
|
UE_API TArray<URigVMLink*> GetTargetLinks(bool bRecursive = false) const;
|
|
|
|
// Returns the node of this Pin.
|
|
UFUNCTION(BlueprintCallable, Category = RigVMPin)
|
|
UE_API URigVMNode* GetNode() const;
|
|
|
|
// Returns the graph of this Pin.
|
|
UFUNCTION(BlueprintCallable, Category = RigVMPin)
|
|
UE_API URigVMGraph* GetGraph() const;
|
|
|
|
// Returns true is the two provided source and target Pins
|
|
// can be linked to one another.
|
|
static UE_API bool CanLink(const URigVMPin* InSourcePin, const URigVMPin* InTargetPin, FString* OutFailureReason, const FRigVMByteCode* InByteCode, ERigVMPinDirection InUserLinkDirection = ERigVMPinDirection::IO, bool bInAllowWildcard = false, bool bEnableTypeCasting = true);
|
|
|
|
// Returns true if this pin has injected nodes
|
|
bool HasInjectedNodes() const { return InjectionInfos.Num() > 0; }
|
|
|
|
// Returns true if this pin has injected nodes
|
|
UE_API bool HasInjectedUnitNodes() const;
|
|
|
|
// Returns the injected nodes this pin contains.
|
|
const TArray<URigVMInjectionInfo*> GetInjectedNodes() const { return InjectionInfos; }
|
|
|
|
UE_API URigVMVariableNode* GetBoundVariableNode() const;
|
|
|
|
// Returns the variable bound to this pin (or NAME_None)
|
|
UE_API const FString GetBoundVariablePath() const;
|
|
|
|
// Returns the variable bound to this pin (or NAME_None)
|
|
UE_API const FString GetBoundVariablePath(const FPinOverride& InOverride) const;
|
|
|
|
// Returns the variable bound to this pin (or NAME_None)
|
|
UE_API FString GetBoundVariableName() const;
|
|
|
|
// Returns true if this pin is bound to a variable
|
|
UE_API bool IsBoundToVariable() const;
|
|
|
|
// Returns true if this pin is bound to a variable
|
|
UE_API bool IsBoundToVariable(const FPinOverride& InOverride) const;
|
|
|
|
// Returns true if this pin is bound to an external variable
|
|
UE_API bool IsBoundToExternalVariable() const;
|
|
|
|
// Returns true if this pin is bound to a local variable
|
|
UE_API bool IsBoundToLocalVariable() const;
|
|
|
|
// Returns true if this pin is bound to an input argument
|
|
UE_API bool IsBoundToInputArgument() const;
|
|
|
|
// Returns true if the pin can be bound to a given variable
|
|
UE_API bool CanBeBoundToVariable(const FRigVMExternalVariable& InExternalVariable, const FString& InSegmentPath = FString()) const;
|
|
|
|
// Returns true if the pin should not show up on a node, but in the details panel
|
|
UE_API bool ShowInDetailsPanelOnly() const;
|
|
|
|
// Returns an external variable matching this pin's type
|
|
UE_API FRigVMExternalVariable ToExternalVariable() const;
|
|
|
|
// Returns true if the pin has been orphaned
|
|
UE_API bool IsOrphanPin() const;
|
|
|
|
UE_API uint32 GetStructureHash() const;
|
|
|
|
// Returns true if this pin represents a trait
|
|
UFUNCTION(BlueprintPure, Category = RigVMPin)
|
|
UE_API bool IsTraitPin() const;
|
|
|
|
// Returns true if this pin represents a trait's programmatic pin
|
|
UE_API bool IsProgrammaticPin() const;
|
|
|
|
// Get all the sub-pins that are programmatic
|
|
UE_API TArray<URigVMPin*> GetProgrammaticSubPins() const;
|
|
|
|
// Returns the trait backing up this pin
|
|
UE_API TSharedPtr<FStructOnScope> GetTraitInstance(bool bUseDefaultValueFromPin = true) const;
|
|
|
|
// Returns the struct of the trait backing up this pin
|
|
UE_API UScriptStruct* GetTraitScriptStruct() const;
|
|
|
|
UE_API const uint32& GetNodeCachedValueVersion() const;
|
|
UE_API const uint32& GetCachedValueVersion() const;
|
|
|
|
private:
|
|
|
|
UE_API void UpdateTypeInformationIfRequired() const;
|
|
UE_API void SetNameFromIndex();
|
|
UE_API void SetDisplayName(const FName& InDisplayName);
|
|
UE_API void IncrementVersion(bool bAffectParentPin = true, bool bAffectSubPins = true);
|
|
|
|
UE_API void GetExposedPinChainImpl(TArray<const URigVMPin*>& OutExposedPins, TArray<const URigVMPin*>& VisitedPins) const;
|
|
|
|
UPROPERTY()
|
|
FName DisplayName;
|
|
|
|
// if new members are added to the pin in the future
|
|
// it is important to search for all existing usages of all members
|
|
// to make sure things are copied/initialized properly
|
|
|
|
UPROPERTY()
|
|
ERigVMPinDirection Direction;
|
|
|
|
UPROPERTY()
|
|
bool bIsExpanded;
|
|
|
|
UPROPERTY()
|
|
bool bIsConstant;
|
|
|
|
UPROPERTY(transient)
|
|
bool bRequiresWatch;
|
|
|
|
UPROPERTY()
|
|
bool bIsDynamicArray;
|
|
|
|
UPROPERTY()
|
|
bool bIsLazy;
|
|
|
|
UPROPERTY()
|
|
FString CPPType;
|
|
|
|
// serialize object ptr here to keep track of the latest version of the type object,
|
|
// type object can reference assets like user defined struct, which can be renamed
|
|
// or moved to new locations, serializing the type object with the pin
|
|
// ensure automatic update whenever those things happen
|
|
UPROPERTY()
|
|
TObjectPtr<UObject> CPPTypeObject;
|
|
|
|
UPROPERTY()
|
|
FName CPPTypeObjectPath;
|
|
|
|
UPROPERTY()
|
|
FString DefaultValue;
|
|
|
|
UPROPERTY()
|
|
ERigVMPinDefaultValueType DefaultValueType;
|
|
|
|
UPROPERTY()
|
|
FName CustomWidgetName;
|
|
|
|
UPROPERTY()
|
|
TArray<TObjectPtr<URigVMPin>> SubPins;
|
|
|
|
UPROPERTY(transient)
|
|
TArray<TObjectPtr<URigVMLink>> Links;
|
|
|
|
UPROPERTY()
|
|
TArray<TObjectPtr<URigVMInjectionInfo>> InjectionInfos;
|
|
|
|
UPROPERTY()
|
|
FString UserDefinedCategory;
|
|
|
|
UPROPERTY()
|
|
int32 IndexInCategory;
|
|
|
|
#if WITH_EDITORONLY_DATA
|
|
UPROPERTY()
|
|
FString BoundVariablePath_DEPRECATED;
|
|
#endif
|
|
|
|
uint32 PinVersion;
|
|
mutable uint32 CombinedPinVersion;
|
|
|
|
mutable FString LastKnownCPPType;
|
|
mutable TRigVMTypeIndex LastKnownTypeIndex;
|
|
mutable TRigVMModelCachedValue<URigVMPin, bool> CachedIsStringType;
|
|
mutable TRigVMModelCachedValue<URigVMPin, FString> CachedDefaultValue;
|
|
mutable TRigVMModelCachedValue<URigVMPin, FString> CachedAdaptedDefaultValue;
|
|
mutable TRigVMModelCachedValue<URigVMPin, uint32> CachedCPPTypeObjectHash;
|
|
mutable TRigVMModelCachedValue<URigVMPin, bool> CachedShowInDetailsPanelOnly;
|
|
mutable TRigVMModelCachedValue<URigVMPin, FString> CachedPinPath;
|
|
mutable TRigVMModelCachedValue<URigVMPin, FString> CachedPinPathWithNodePath;
|
|
mutable TRigVMModelCachedValue<URigVMPin, FString> CachedPinCategory;
|
|
mutable TRigVMModelCachedValue<URigVMPin, FName> CachedDisplayName;
|
|
mutable TRigVMModelCachedValue<URigVMPin, bool> CachedDefaultValueOverride;
|
|
mutable TRigVMModelCachedValue<URigVMPin, bool> CachedHasOriginalDefaultValue;
|
|
|
|
static const inline TCHAR* OrphanPinPrefix = TEXT("Orphan::");
|
|
|
|
friend class URigVMController;
|
|
friend class URigVMGraph;
|
|
friend class URigVMNode;
|
|
friend class URigVMLink;
|
|
friend class FRigVMParserAST;
|
|
friend struct FRigVMSetPinDisplayNameAction;
|
|
friend struct FRigVMSetPinCategoryAction;
|
|
friend class URigVMLibraryNode;
|
|
friend class URigVMEdGraphNode;
|
|
friend struct FRigVMClient;
|
|
};
|
|
|
|
class FRigVMPinDefaultValueImportErrorContext : public FOutputDevice
|
|
{
|
|
public:
|
|
|
|
int32 NumErrors;
|
|
|
|
FRigVMPinDefaultValueImportErrorContext( ELogVerbosity::Type InMaxVerbosity = ELogVerbosity::Warning )
|
|
: FOutputDevice()
|
|
, NumErrors(0)
|
|
, MaxVerbosity(InMaxVerbosity)
|
|
{
|
|
}
|
|
|
|
virtual void Serialize(const TCHAR* V, ELogVerbosity::Type Verbosity, const class FName& Category) override
|
|
{
|
|
if(Verbosity <= MaxVerbosity)
|
|
{
|
|
NumErrors++;
|
|
}
|
|
}
|
|
|
|
ELogVerbosity::Type GetMaxVerbosity() const { return MaxVerbosity; }
|
|
|
|
private:
|
|
ELogVerbosity::Type MaxVerbosity;
|
|
};
|
|
|
|
#undef UE_API
|