description: Key-based implmentations

code: template<typename T> static T GetAttribute ( [PCGMetadataEntryKey](API\Plugins\PCG\Metadata\PCGMetadataEntryKey) Key, const [UPCGMetadata](API\Plugins\PCG\Metadata\UPCGMetadata) * Metadata, [FName](API\Runtime\Core\UObject\FName) AttributeName )


module: PCG

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="PCG|Metadata") static bool GetBoolAttributeByMetadataKey ( int64 Key, const [UPCGMetadata](API\Plugins\PCG\Metadata\UPCGMetadata) * Metadata, [FName](API\Runtime\Core\UObject\FName) AttributeName )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="PCG|Metadata", Meta=(ScriptMethod)) static bool GetBoolAttribute ( const [FPCGPoint](API\Plugins\PCG\FPCGPoint) & Point, const [UPCGMetadata](API\Plugins\PCG\Metadata\UPCGMetadata) * Metadata, [FName](API\Runtime\Core\UObject\FName) AttributeName )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="PCG|Metadata") static double GetDoubleAttributeByMetadataKey ( int64 Key, const [UPCGMetadata](API\Plugins\PCG\Metadata\UPCGMetadata) * Metadata, [FName](API\Runtime\Core\UObject\FName) AttributeName )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="PCG|Metadata") void SetPointAttributes ( const [FPCGPoint](API\Plugins\PCG\FPCGPoint) & Point, const [UPCGMetadata](API\Plugins\PCG\Metadata\UPCGMetadata) * Metadata, [FPCGPoint](API\Plugins\PCG\FPCGPoint) & OutPoint )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="PCG|Metadata", Meta=(ScriptMethod)) static double GetDoubleAttribute ( const [FPCGPoint](API\Plugins\PCG\FPCGPoint) & Point, const [UPCGMetadata](API\Plugins\PCG\Metadata\UPCGMetadata) * Metadata, [FName](API\Runtime\Core\UObject\FName) AttributeName )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="PCG|Metadata") static float GetFloatAttributeByMetadataKey ( int64 Key, const [UPCGMetadata](API\Plugins\PCG\Metadata\UPCGMetadata) * Metadata, [FName](API\Runtime\Core\UObject\FName) AttributeName )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="PCG|Metadata", Meta=(ScriptMethod)) static float GetFloatAttribute ( const [FPCGPoint](API\Plugins\PCG\FPCGPoint) & Point, const [UPCGMetadata](API\Plugins\PCG\Metadata\UPCGMetadata) * Metadata, [FName](API\Runtime\Core\UObject\FName) AttributeName )


description: Id-based metadata functions

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="PCG|Metadata") static int32 GetInteger32AttributeByMetadataKey ( int64 Key, const [UPCGMetadata](API\Plugins\PCG\Metadata\UPCGMetadata) * Metadata, [FName](API\Runtime\Core\UObject\FName) AttributeName )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="PCG|Metadata", Meta=(ScriptMethod)) static int32 GetInteger32Attribute ( const [FPCGPoint](API\Plugins\PCG\FPCGPoint) & Point, const [UPCGMetadata](API\Plugins\PCG\Metadata\UPCGMetadata) * Metadata, [FName](API\Runtime\Core\UObject\FName) AttributeName )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="PCG|Metadata") static int64 GetInteger64AttributeByMetadataKey ( int64 Key, const [UPCGMetadata](API\Plugins\PCG\Metadata\UPCGMetadata) * Metadata, [FName](API\Runtime\Core\UObject\FName) AttributeName )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="PCG|Metadata", Meta=(ScriptMethod)) static int64 GetInteger64Attribute ( const [FPCGPoint](API\Plugins\PCG\FPCGPoint) & Point, const [UPCGMetadata](API\Plugins\PCG\Metadata\UPCGMetadata) * Metadata, [FName](API\Runtime\Core\UObject\FName) AttributeName )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="PCG|Metadata", Meta=(ScriptMethod)) static [FName](API\Runtime\Core\UObject\FName) GetNameAttribute ( const [FPCGPoint](API\Plugins\PCG\FPCGPoint) & Point, const [UPCGMetadata](API\Plugins\PCG\Metadata\UPCGMetadata) * Metadata, [FName](API\Runtime\Core\UObject\FName) AttributeName )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="PCG|Metadata") static FQuat GetQuatAttributeByMetadataKey ( int64 Key, const [UPCGMetadata](API\Plugins\PCG\Metadata\UPCGMetadata) * Metadata, [FName](API\Runtime\Core\UObject\FName) AttributeName )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="PCG|Metadata", Meta=(ScriptMethod)) static FQuat GetQuatAttribute ( const [FPCGPoint](API\Plugins\PCG\FPCGPoint) & Point, const [UPCGMetadata](API\Plugins\PCG\Metadata\UPCGMetadata) * Metadata, [FName](API\Runtime\Core\UObject\FName) AttributeName )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="PCG|Metadata") static FRotator GetRotatorAttributeByMetadataKey ( int64 Key, const [UPCGMetadata](API\Plugins\PCG\Metadata\UPCGMetadata) * Metadata, [FName](API\Runtime\Core\UObject\FName) AttributeName )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="PCG|Metadata") static [FString](API\Runtime\Core\Containers\FString) GetStringAttributeByMetadataKey ( int64 Key, const [UPCGMetadata](API\Plugins\PCG\Metadata\UPCGMetadata) * Metadata, [FName](API\Runtime\Core\UObject\FName) AttributeName )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="PCG|Metadata", Meta=(ScriptMethod)) static FRotator GetRotatorAttribute ( const [FPCGPoint](API\Plugins\PCG\FPCGPoint) & Point, const [UPCGMetadata](API\Plugins\PCG\Metadata\UPCGMetadata) * Metadata, [FName](API\Runtime\Core\UObject\FName) AttributeName )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="PCG|Metadata", Meta=(ScriptMethod)) static [FString](API\Runtime\Core\Containers\FString) GetStringAttribute ( const [FPCGPoint](API\Plugins\PCG\FPCGPoint) & Point, const [UPCGMetadata](API\Plugins\PCG\Metadata\UPCGMetadata) * Metadata, [FName](API\Runtime\Core\UObject\FName) AttributeName )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="PCG|Metadata") static FTransform GetTransformAttributeByMetadataKey ( int64 Key, const [UPCGMetadata](API\Plugins\PCG\Metadata\UPCGMetadata) * Metadata, [FName](API\Runtime\Core\UObject\FName) AttributeName )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="PCG|Metadata", Meta=(ScriptMethod)) static FTransform GetTransformAttribute ( const [FPCGPoint](API\Plugins\PCG\FPCGPoint) & Point, const [UPCGMetadata](API\Plugins\PCG\Metadata\UPCGMetadata) * Metadata, [FName](API\Runtime\Core\UObject\FName) AttributeName )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="PCG|Metadata") static FVector2D GetVector2AttributeByMetadataKey ( int64 Key, const [UPCGMetadata](API\Plugins\PCG\Metadata\UPCGMetadata) * Metadata, [FName](API\Runtime\Core\UObject\FName) AttributeName )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="PCG|Metadata", Meta=(ScriptMethod)) static FVector2D GetVector2Attribute ( const [FPCGPoint](API\Plugins\PCG\FPCGPoint) & Point, const [UPCGMetadata](API\Plugins\PCG\Metadata\UPCGMetadata) * Metadata, [FName](API\Runtime\Core\UObject\FName) AttributeName )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="PCG|Metadata") static FVector4 GetVector4AttributeByMetadataKey ( int64 Key, const [UPCGMetadata](API\Plugins\PCG\Metadata\UPCGMetadata) * Metadata, [FName](API\Runtime\Core\UObject\FName) AttributeName )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="PCG|Metadata") static FVector GetVectorAttributeByMetadataKey ( int64 Key, const [UPCGMetadata](API\Plugins\PCG\Metadata\UPCGMetadata) * Metadata, [FName](API\Runtime\Core\UObject\FName) AttributeName )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="PCG|Metadata", Meta=(ScriptMethod)) static FVector4 GetVector4Attribute ( const [FPCGPoint](API\Plugins\PCG\FPCGPoint) & Point, const [UPCGMetadata](API\Plugins\PCG\Metadata\UPCGMetadata) * Metadata, [FName](API\Runtime\Core\UObject\FName) AttributeName )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="PCG|Metadata", Meta=(ScriptMethod)) static FVector GetVectorAttribute ( const [FPCGPoint](API\Plugins\PCG\FPCGPoint) & Point, const [UPCGMetadata](API\Plugins\PCG\Metadata\UPCGMetadata) * Metadata, [FName](API\Runtime\Core\UObject\FName) AttributeName )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="PCG|Metadata", Meta=(ScriptMethod)) static bool HasAttributeSet ( const [FPCGPoint](API\Plugins\PCG\FPCGPoint) & Point, const [UPCGMetadata](API\Plugins\PCG\Metadata\UPCGMetadata) * Metadata, [FName](API\Runtime\Core\UObject\FName) AttributeName )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="PCG|Metadata") static bool HasAttributeSetByMetadataKey ( int64 Key, const [UPCGMetadata](API\Plugins\PCG\Metadata\UPCGMetadata) * Metadata, [FName](API\Runtime\Core\UObject\FName) AttributeName )


code: static void InitializeMetadata ( [FPCGPoint](API\Plugins\PCG\FPCGPoint) & Point, [UPCGMetadata](API\Plugins\PCG\Metadata\UPCGMetadata) * Metadata )


description: Assigns a metadata entry key and will copy attribute values if from an unrelated metadata. Note: a null ParentMetadata assumes this is the same as Metadata

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="PCG|Metadata", Meta=(ScriptMethod)) static void InitializeMetadata ( [FPCGPoint](API\Plugins\PCG\FPCGPoint) & Point, [UPCGMetadata](API\Plugins\PCG\Metadata\UPCGMetadata) * Metadata, const [FPCGPoint](API\Plugins\PCG\FPCGPoint) & ParentPoint, const [UPCGMetadata](API\Plugins\PCG\Metadata\UPCGMetadata) * ParentMetadata )


description: Assigns a metadata entry but does not copy values if from a non-parented metadata

code: static void InitializeMetadataWithParent ( [FPCGPoint](API\Plugins\PCG\FPCGPoint) & Point, [UPCGMetadata](API\Plugins\PCG\Metadata\UPCGMetadata) * Metadata, const [FPCGPoint](API\Plugins\PCG\FPCGPoint) & ParentPoint, const [UPCGMetadata](API\Plugins\PCG\Metadata\UPCGMetadata) * ParentMetadata )


code: template<typename T> static void SetAttribute ( [PCGMetadataEntryKey](API\Plugins\PCG\Metadata\PCGMetadataEntryKey) & Key, [UPCGMetadata](API\Plugins\PCG\Metadata\UPCGMetadata) * Metadata, [FName](API\Runtime\Core\UObject\FName) AttributeName, const T & Value )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="PCG|Metadata") static bool SetAttributeFromPropertyByMetadataKey ( int64 & Key, [UPCGMetadata](API\Plugins\PCG\Metadata\UPCGMetadata) * Metadata, [FName](API\Runtime\Core\UObject\FName) AttributeName, const [UObject](API\Runtime\CoreUObject\UObject\UObject) * Object, [FName](API\Runtime\Core\UObject\FName) PropertyName )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="PCG|Metadata", Meta=(ScriptMethod)) static void SetBoolAttribute ( [FPCGPoint](API\Plugins\PCG\FPCGPoint) & Point, [UPCGMetadata](API\Plugins\PCG\Metadata\UPCGMetadata) * Metadata, [FName](API\Runtime\Core\UObject\FName) AttributeName, bool Value )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="PCG|Metadata") static void SetBoolAttributeByMetadataKey ( int64 & Key, [UPCGMetadata](API\Plugins\PCG\Metadata\UPCGMetadata) * Metadata, [FName](API\Runtime\Core\UObject\FName) AttributeName, bool Value )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="PCG|Metadata") static void SetDoubleAttributeByMetadataKey ( int64 & Key, [UPCGMetadata](API\Plugins\PCG\Metadata\UPCGMetadata) * Metadata, [FName](API\Runtime\Core\UObject\FName) AttributeName, double Value )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="PCG|Metadata", Meta=(ScriptMethod)) static void SetDoubleAttribute ( [FPCGPoint](API\Plugins\PCG\FPCGPoint) & Point, [UPCGMetadata](API\Plugins\PCG\Metadata\UPCGMetadata) * Metadata, [FName](API\Runtime\Core\UObject\FName) AttributeName, double Value )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="PCG|Metadata") static void SetFloatAttributeByMetadataKey ( int64 & Key, [UPCGMetadata](API\Plugins\PCG\Metadata\UPCGMetadata) * Metadata, [FName](API\Runtime\Core\UObject\FName) AttributeName, float Value )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="PCG|Metadata") static void SetInteger32AttributeByMetadataKey ( int64 & Key, [UPCGMetadata](API\Plugins\PCG\Metadata\UPCGMetadata) * Metadata, [FName](API\Runtime\Core\UObject\FName) AttributeName, int32 Value )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="PCG|Metadata", Meta=(ScriptMethod)) static void SetFloatAttribute ( [FPCGPoint](API\Plugins\PCG\FPCGPoint) & Point, [UPCGMetadata](API\Plugins\PCG\Metadata\UPCGMetadata) * Metadata, [FName](API\Runtime\Core\UObject\FName) AttributeName, float Value )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="PCG|Metadata", Meta=(ScriptMethod)) static void SetInteger32Attribute ( [FPCGPoint](API\Plugins\PCG\FPCGPoint) & Point, [UPCGMetadata](API\Plugins\PCG\Metadata\UPCGMetadata) * Metadata, [FName](API\Runtime\Core\UObject\FName) AttributeName, int32 Value )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="PCG|Metadata", Meta=(ScriptMethod)) static void SetInteger64Attribute ( [FPCGPoint](API\Plugins\PCG\FPCGPoint) & Point, [UPCGMetadata](API\Plugins\PCG\Metadata\UPCGMetadata) * Metadata, [FName](API\Runtime\Core\UObject\FName) AttributeName, int64 Value )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="PCG|Metadata") static void SetInteger64AttributeByMetadataKey ( int64 & Key, [UPCGMetadata](API\Plugins\PCG\Metadata\UPCGMetadata) * Metadata, [FName](API\Runtime\Core\UObject\FName) AttributeName, int64 Value )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="PCG|Metadata", Meta=(ScriptMethod)) static void SetNameAttribute ( [FPCGPoint](API\Plugins\PCG\FPCGPoint) & Point, [UPCGMetadata](API\Plugins\PCG\Metadata\UPCGMetadata) * Metadata, [FName](API\Runtime\Core\UObject\FName) AttributeName, const [FName](API\Runtime\Core\UObject\FName) & Value )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="PCG|Metadata") static void SetQuatAttributeByMetadataKey ( int64 & Key, [UPCGMetadata](API\Plugins\PCG\Metadata\UPCGMetadata) * Metadata, [FName](API\Runtime\Core\UObject\FName) AttributeName, const FQuat & Value )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="PCG|Metadata", Meta=(ScriptMethod)) static void SetQuatAttribute ( [FPCGPoint](API\Plugins\PCG\FPCGPoint) & Point, [UPCGMetadata](API\Plugins\PCG\Metadata\UPCGMetadata) * Metadata, [FName](API\Runtime\Core\UObject\FName) AttributeName, const FQuat & Value )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="PCG|Metadata") static void SetRotatorAttributeByMetadataKey ( int64 & Key, [UPCGMetadata](API\Plugins\PCG\Metadata\UPCGMetadata) * Metadata, [FName](API\Runtime\Core\UObject\FName) AttributeName, const FRotator & Value )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="PCG|Metadata", Meta=(ScriptMethod)) static void SetRotatorAttribute ( [FPCGPoint](API\Plugins\PCG\FPCGPoint) & Point, [UPCGMetadata](API\Plugins\PCG\Metadata\UPCGMetadata) * Metadata, [FName](API\Runtime\Core\UObject\FName) AttributeName, const FRotator & Value )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="PCG|Metadata") static void SetStringAttributeByMetadataKey ( int64 & Key, [UPCGMetadata](API\Plugins\PCG\Metadata\UPCGMetadata) * Metadata, [FName](API\Runtime\Core\UObject\FName) AttributeName, const [FString](API\Runtime\Core\Containers\FString) & Value )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="PCG|Metadata", Meta=(ScriptMethod)) static void SetStringAttribute ( [FPCGPoint](API\Plugins\PCG\FPCGPoint) & Point, [UPCGMetadata](API\Plugins\PCG\Metadata\UPCGMetadata) * Metadata, [FName](API\Runtime\Core\UObject\FName) AttributeName, const [FString](API\Runtime\Core\Containers\FString) & Value )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="PCG|Metadata") static void SetTransformAttributeByMetadataKey ( int64 & Key, [UPCGMetadata](API\Plugins\PCG\Metadata\UPCGMetadata) * Metadata, [FName](API\Runtime\Core\UObject\FName) AttributeName, const FTransform & Value )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="PCG|Metadata", Meta=(ScriptMethod)) static void SetTransformAttribute ( [FPCGPoint](API\Plugins\PCG\FPCGPoint) & Point, [UPCGMetadata](API\Plugins\PCG\Metadata\UPCGMetadata) * Metadata, [FName](API\Runtime\Core\UObject\FName) AttributeName, const FTransform & Value )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="PCG|Metadata") static void SetVector2AttributeByMetadataKey ( int64 & Key, [UPCGMetadata](API\Plugins\PCG\Metadata\UPCGMetadata) * Metadata, [FName](API\Runtime\Core\UObject\FName) AttributeName, const FVector2D & Value )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="PCG|Metadata", Meta=(ScriptMethod)) static void SetVector2Attribute ( [FPCGPoint](API\Plugins\PCG\FPCGPoint) & Point, [UPCGMetadata](API\Plugins\PCG\Metadata\UPCGMetadata) * Metadata, [FName](API\Runtime\Core\UObject\FName) AttributeName, const FVector2D & Value )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="PCG|Metadata") static void SetVector4AttributeByMetadataKey ( int64 & Key, [UPCGMetadata](API\Plugins\PCG\Metadata\UPCGMetadata) * Metadata, [FName](API\Runtime\Core\UObject\FName) AttributeName, const FVector4 & Value )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="PCG|Metadata", Meta=(ScriptMethod)) static void SetVector4Attribute ( [FPCGPoint](API\Plugins\PCG\FPCGPoint) & Point, [UPCGMetadata](API\Plugins\PCG\Metadata\UPCGMetadata) * Metadata, [FName](API\Runtime\Core\UObject\FName) AttributeName, const FVector4 & Value )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="PCG|Metadata") static void SetVectorAttributeByMetadataKey ( int64 & Key, [UPCGMetadata](API\Plugins\PCG\Metadata\UPCGMetadata) * Metadata, [FName](API\Runtime\Core\UObject\FName) AttributeName, const FVector & Value )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="PCG|Metadata", Meta=(ScriptMethod)) static void SetVectorAttribute ( [FPCGPoint](API\Plugins\PCG\FPCGPoint) & Point, [UPCGMetadata](API\Plugins\PCG\Metadata\UPCGMetadata) * Metadata, [FName](API\Runtime\Core\UObject\FName) AttributeName, const FVector & Value )


className: CanInterpolate

code: enum { CanInterpolate = true }


className: CanSearchString

code: enum { CanSearchString = false }


className: CompressData

code: enum { CompressData = false }


className: VectorTraits

description: Vector types.

code: template<typename T> struct VectorTraits : public [PCG::Private::DefaultOperationTraits< T >](API\Plugins\PCG\Metadata\DefaultOperationTraits), public [PCG::Private::DefaultWeightedSumTraits< T >](API\Plugins\PCG\Metadata\DefaultWeightedSumTraits), public [PCG::Private::DefaultStringTraits< T >](API\Plugins\PCG\Metadata\DefaultStringTraits)


className: operator&

code: constexpr [EPCGChangeType](API\Plugins\PCG\EPCGChangeType) operator& ( [EPCGChangeType](API\Plugins\PCG\EPCGChangeType) Lhs, [EPCGChangeType](API\Plugins\PCG\EPCGChangeType) Rhs )


code: constexpr [EPCGDataType](API\Plugins\PCG\EPCGDataType) operator& ( [EPCGDataType](API\Plugins\PCG\EPCGDataType) Lhs, [EPCGDataType](API\Plugins\PCG\EPCGDataType) Rhs )


code: constexpr [EPCGHiGenGrid](API\Plugins\PCG\EPCGHiGenGrid) operator& ( [EPCGHiGenGrid](API\Plugins\PCG\EPCGHiGenGrid) Lhs, [EPCGHiGenGrid](API\Plugins\PCG\EPCGHiGenGrid) Rhs )


code: constexpr [EPCGComponentDirtyFlag](API\Plugins\PCG\EPCGComponentDirtyFlag) operator& ( [EPCGComponentDirtyFlag](API\Plugins\PCG\EPCGComponentDirtyFlag) Lhs, [EPCGComponentDirtyFlag](API\Plugins\PCG\EPCGComponentDirtyFlag) Rhs )


className: operator&=

code: [EPCGChangeType](API\Plugins\PCG\EPCGChangeType) & operator&= ( [EPCGChangeType](API\Plugins\PCG\EPCGChangeType) & Lhs, [EPCGChangeType](API\Plugins\PCG\EPCGChangeType) Rhs )


code: [EPCGDataType](API\Plugins\PCG\EPCGDataType) & operator&= ( [EPCGDataType](API\Plugins\PCG\EPCGDataType) & Lhs, [EPCGDataType](API\Plugins\PCG\EPCGDataType) Rhs )


code: [EPCGHiGenGrid](API\Plugins\PCG\EPCGHiGenGrid) & operator&= ( [EPCGHiGenGrid](API\Plugins\PCG\EPCGHiGenGrid) & Lhs, [EPCGHiGenGrid](API\Plugins\PCG\EPCGHiGenGrid) Rhs )


code: [EPCGComponentDirtyFlag](API\Plugins\PCG\EPCGComponentDirtyFlag) & operator&= ( [EPCGComponentDirtyFlag](API\Plugins\PCG\EPCGComponentDirtyFlag) & Lhs, [EPCGComponentDirtyFlag](API\Plugins\PCG\EPCGComponentDirtyFlag) Rhs )


className: operator~

code: constexpr [EPCGChangeType](API\Plugins\PCG\EPCGChangeType) operator~ ( [EPCGChangeType](API\Plugins\PCG\EPCGChangeType) E )


code: constexpr [EPCGHiGenGrid](API\Plugins\PCG\EPCGHiGenGrid) operator~ ( [EPCGHiGenGrid](API\Plugins\PCG\EPCGHiGenGrid) E )


code: constexpr [EPCGDataType](API\Plugins\PCG\EPCGDataType) operator~ ( [EPCGDataType](API\Plugins\PCG\EPCGDataType) E )


code: constexpr [EPCGComponentDirtyFlag](API\Plugins\PCG\EPCGComponentDirtyFlag) operator~ ( [EPCGComponentDirtyFlag](API\Plugins\PCG\EPCGComponentDirtyFlag) E )


className: operator^

code: constexpr [EPCGChangeType](API\Plugins\PCG\EPCGChangeType) operator^ ( [EPCGChangeType](API\Plugins\PCG\EPCGChangeType) Lhs, [EPCGChangeType](API\Plugins\PCG\EPCGChangeType) Rhs )


code: constexpr [EPCGDataType](API\Plugins\PCG\EPCGDataType) operator^ ( [EPCGDataType](API\Plugins\PCG\EPCGDataType) Lhs, [EPCGDataType](API\Plugins\PCG\EPCGDataType) Rhs )


code: constexpr [EPCGHiGenGrid](API\Plugins\PCG\EPCGHiGenGrid) operator^ ( [EPCGHiGenGrid](API\Plugins\PCG\EPCGHiGenGrid) Lhs, [EPCGHiGenGrid](API\Plugins\PCG\EPCGHiGenGrid) Rhs )


code: constexpr [EPCGComponentDirtyFlag](API\Plugins\PCG\EPCGComponentDirtyFlag) operator^ ( [EPCGComponentDirtyFlag](API\Plugins\PCG\EPCGComponentDirtyFlag) Lhs, [EPCGComponentDirtyFlag](API\Plugins\PCG\EPCGComponentDirtyFlag) Rhs )


className: operator^=

code: [EPCGChangeType](API\Plugins\PCG\EPCGChangeType) & operator^= ( [EPCGChangeType](API\Plugins\PCG\EPCGChangeType) & Lhs, [EPCGChangeType](API\Plugins\PCG\EPCGChangeType) Rhs )


code: [EPCGDataType](API\Plugins\PCG\EPCGDataType) & operator^= ( [EPCGDataType](API\Plugins\PCG\EPCGDataType) & Lhs, [EPCGDataType](API\Plugins\PCG\EPCGDataType) Rhs )


code: [EPCGHiGenGrid](API\Plugins\PCG\EPCGHiGenGrid) & operator^= ( [EPCGHiGenGrid](API\Plugins\PCG\EPCGHiGenGrid) & Lhs, [EPCGHiGenGrid](API\Plugins\PCG\EPCGHiGenGrid) Rhs )


code: [EPCGComponentDirtyFlag](API\Plugins\PCG\EPCGComponentDirtyFlag) & operator^= ( [EPCGComponentDirtyFlag](API\Plugins\PCG\EPCGComponentDirtyFlag) & Lhs, [EPCGComponentDirtyFlag](API\Plugins\PCG\EPCGComponentDirtyFlag) Rhs )


className: operator!

code: constexpr bool operator! ( [EPCGChangeType](API\Plugins\PCG\EPCGChangeType) E )


code: constexpr bool operator! ( [EPCGDataType](API\Plugins\PCG\EPCGDataType) E )


code: constexpr bool operator! ( [EPCGHiGenGrid](API\Plugins\PCG\EPCGHiGenGrid) E )


code: namespace PCGBaseSubgraphConstants { static const [FString](API\Runtime\Core\Containers\FString) PCGBaseSubgraphConstants::UserParameterTagData = TEXT("PCGUserParametersTagData"); }


code: constexpr bool operator! ( [EPCGComponentDirtyFlag](API\Plugins\PCG\EPCGComponentDirtyFlag) E )


code: namespace PCGContextHelpers { template<typename SettingsType> const SettingsType * PCGContextHelpers::GetInputSettings ( const [UPCGNode](API\Plugins\PCG\UPCGNode) * Node, const [FPCGDataCollection](API\Plugins\PCG\FPCGDataCollection) & InputData ) }


className: PCGObjectMetadata::

description: Metadata usable in UPROPERTY for customizing the behavior when displaying the property in a property panel or graph node.

code: namespace PCGObjectMetadata { enum { PCG_Overridable, PCG_NotOverridable, PCG_OverrideAliases, PCG_DiscardPropertySelection, PCG_DiscardExtraSelection, } }


className: FPCGAttributeExtractorTestStruct

DepthStruct

type: FPCGAttributeEx...

Object

type: TObjectPtr<UPC...


className: UPCGAttributeExtractorTestObject

code: [UCLASS](Programming/UnrealArchitecture/Reference/Classes#classdeclaration)(Meta=(Hidden)) class UPCGAttributeExtractorTestObject : public [UObject](API\Runtime\CoreUObject\UObject\UObject)

DoubleValue

type: double


className: EDeterminismLevel

description: This will include multiple values of different meanings, but we use an enum to facilitate data passing.

code: enum EDeterminismLevel { None = 0u, NoDeterminism = None, Basic, OrderOrthogonal, OrderConsistent, OrderIndependent, Deterministic = OrderIndependent, }


className: FDeterminismTestResult

AdditionalDetails

type: TArray<FString...

description: A mapping of [test name : additional details]

bFlagRaised

type: bool

description: T/F whether a flag has been raised on this node's tests (for UI)

DataTypesTested

type: EPCGDataType

description: BitFlags for which data types were tested

TestResultName

type: FString

description: The node's name

TestResults

type: TMap<FName,ED...

description: A mapping of [test names : test results]

TestResultTitle

type: FName

description: The node's title


description: Deregisters a test function given the StaticClass of an element's settings

code: static void DeregisterTestFunction ( const [UClass](API\Runtime\CoreUObject\UObject\UClass) * SettingsStaticClass )


description: Allocates the static class

code: static void Create()


description: Deallocates the static class

code: static void Destroy()


description: Gets a native test function, given an element'sUPCGSettings

code: static [TFunction](API\Runtime\Core\GenericPlatform\TFunction)< bool()> GetNativeTestFunction ( const [UPCGSettings](API\Plugins\PCG\UPCGSettings) * PCGSettings )


description: Registers a test function given the StaticClass of an element's settings

code: static void RegisterTestFunction ( [UClass](API\Runtime\CoreUObject\UObject\UClass) * SettingsStaticClass, [TFunction](API\Runtime\Core\GenericPlatform\TFunction)< bool()> TestFunction )


className: RegistryPtr

code: static [FNativeTestRegistry](API\Plugins\PCG\Tests\Determinism\FNativeTestRegistry) * RegistryPtr = nullptr;


className: FNativeTestRegistry

description: No constructors are accessible with public or protected access.

code: class FNativeTestRegistry


className: FNodeAndOptions

code: struct FNodeAndOptions

BaseOptionsByPin

type: TArray<TArray<...

bMultipleOptionsPerPin

type: const bool

PCGNode

type: constUPCGNode...

Seed

type: const int32


code: FNodeAndOptions ( const [UPCGNode](API\Plugins\PCG\UPCGNode) * PCGNode, const int32 Seed, bool bMultipleOptionsPerPin )


code: FNodeTestInfo ( [FText](API\Runtime\Core\Internationalization\FText) Label, [TestFunction](API\Plugins\PCG\Tests\Determinism\TestFunction) Delegate, float LabelWidth )


className: FNodeTestInfo

code: struct FNodeTestInfo

TestDelegate

type: TestFunction

TestLabel

type: FText

TestLabelWidth

type: float

TestName

type: constFName


className: FPCGDeterminismSettings

DeterminismTestBlueprint

type: TSubclassOf<UP...


code: namespace PCGDeterminismTests { namespace Defaults { static PCGDeterminismTests::Defaults::NumPointsToGenerate = 1; } }


code: namespace PCGDeterminismTests { namespace Defaults { static PCGDeterminismTests::Defaults::NumTestPointsToGenerate = 100; } }


code: namespace PCGDeterminismTests { namespace Defaults { static PCGDeterminismTests::Defaults::NumPolyLinePointsToGenerate = 6; } }


code: namespace PCGDeterminismTests { namespace Defaults { static PCGDeterminismTests::Defaults::NumTestPolyLinePointsToGenerate = 6; } }


code: namespace PCGDeterminismTests { namespace Defaults { static PCGDeterminismTests::Defaults::NumSamplingStepsPerDimension = 15; } }


code: namespace PCGDeterminismTests { namespace Defaults { static PCGDeterminismTests::Defaults::NumTestInputsPerPin = 2; } }


description: This will expand the testing volume by an increase of this ratio - ex. 0.25 == 125%

code: namespace PCGDeterminismTests { namespace Defaults { static PCGDeterminismTests::Defaults::TestingVolumeExpandByFactor = 0.25; } }


code: namespace PCGDeterminismTests { namespace Defaults { static PCGDeterminismTests::Defaults::DeterminismBasicTestInfo = FNodeTestInfo(FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Basic Test" ), TEXT( "PCGDeterminism" ), TEXT( "BasicTest" )), RunBasicTestSuite, 90.f); } }


code: namespace PCGDeterminismTests { namespace Defaults { static PCGDeterminismTests::Defaults::DeterminismOrderIndependenceInfo = FNodeTestInfo(FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(TEXT( "Order Independence" ), TEXT( "PCGDeterminism" ), TEXT( "OrderIndependenceTest" )), RunOrderIndependenceSuite, 140.f); } }


description: Validates whether bothUPCGDatacan be cast to a specified subclass

code: namespace PCGDeterminismTests { template<typename [DataType](API\Plugins\OptimusCore\DataType)> bool PCGDeterminismTests::BothDataCastsToDataType ( const [UPCGData](API\Plugins\PCG\UPCGData) * FirstData, const [UPCGData](API\Plugins\PCG\UPCGData) * SecondData ) }


code: namespace PCGDeterminismTests { namespace Defaults { static PCGDeterminismTests::Defaults::LargeDistance = 500.0; } }


code: namespace PCGDeterminismTests { namespace Defaults { static PCGDeterminismTests::Defaults::Seed = 42; } }


code: namespace PCGDeterminismTests { namespace Defaults { static PCGDeterminismTests::Defaults::MediumDistance = 200.0; } }


code: namespace PCGDeterminismTests { namespace Defaults { static PCGDeterminismTests::Defaults::SmallDistance = 50.0; } }


description: Generates settings based upon aUPCGSettingssubclass

code: namespace PCGDeterminismTests { template<typename SettingsType> SettingsType * PCGDeterminismTests::GenerateSettings ( [PCGTestsCommon::FTestData](API\Plugins\PCG\Tests\FTestData) & TestData, [TFunction](API\Runtime\Core\GenericPlatform\TFunction)< void([PCGTestsCommon::FTestData](API\Plugins\PCG\Tests\FTestData) &)> ExtraSettingsDelegate ) }


description: A default delegate to report an unset test

code: namespace PCGDeterminismTests { bool PCGDeterminismTests::LogInvalidTest ( const [UPCGNode](API\Plugins\PCG\UPCGNode) * InPCGNode, const [FName](API\Runtime\Core\UObject\FName) & TestName, [FDeterminismTestResult](API\Plugins\PCG\Tests\Determinism\FDeterminismTestResult) & OutResult ) }


code: namespace PCGDeterminismTests { template<typename MetadataAttributeType> bool PCGDeterminismTests::MetadataAttributesAreEqual ( const [FPCGMetadataAttributeBase](API\Plugins\PCG\Metadata\FPCGMetadataAttributeBase) * FirstAttributeBase, const [FPCGMetadataAttributeBase](API\Plugins\PCG\Metadata\FPCGMetadataAttributeBase) * SecondAttributeBase, [PCGMetadataValueKey](API\Plugins\PCG\Metadata\PCGMetadataValueKey) ValueKey ) }


code: namespace PCGDeterminismTests { template<typename [DataType](API\Plugins\OptimusCore\DataType)> void PCGDeterminismTests::ShiftArrayElements ( [TArray](API\Runtime\Core\Containers\TArray)< [DataType](API\Plugins\OptimusCore\DataType) > & Array, int32 NumShifts ) }


code: namespace PCGDeterminismTests { template<typename [DataType](API\Plugins\OptimusCore\DataType)> void PCGDeterminismTests::ShuffleArray ( [TArray](API\Runtime\Core\Containers\TArray)< [DataType](API\Plugins\OptimusCore\DataType) > & Array, [FRandomStream](API\Runtime\Core\Math\FRandomStream) & RandomStream ) }


code: namespace PCGDeterminismTests { static PCGDeterminismTests::TestableDataTypes = { EPCGDataType::None, EPCGDataType::Point, EPCGDataType::Volume, EPCGDataType::PolyLine, EPCGDataType::Primitive, EPCGDataType::Landscape }; }


className: TestFunction

code: typedef [TFunction](API\Runtime\Core\GenericPlatform\TFunction)< bool(const [UPCGNode](API\Plugins\PCG\UPCGNode) *InPCGNode, const [FName](API\Runtime\Core\UObject\FName) &TestName, [FDeterminismTestResult](API\Plugins\PCG\Tests\Determinism\FDeterminismTestResult) &OutResult)> TestFunction


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintNativeEvent, BlueprintPure, CallInEditor, Category=Determinism) void ExecuteTest ( const [UPCGNode](API\Plugins\PCG\UPCGNode) * InPCGNode, [FDeterminismTestResult](API\Plugins\PCG\Tests\Determinism\FDeterminismTestResult) & InOutTestResult )


className: UPCGDeterminismTestBlueprintBase

code: [UCLASS](Programming/UnrealArchitecture/Reference/Classes#classdeclaration)(Abstract, BlueprintType, Blueprintable, HideCategories=(Object)) class UPCGDeterminismTestBlueprintBase : public [UObject](API\Runtime\CoreUObject\UObject\UObject)


description: Hook to expose private test function publicly

code: bool RunPCGTest ( const [FString](API\Runtime\Core\Containers\FString) & Parameters )


description: Generates all valid input combinations

code: bool SmokeTestAnyValidInput ( [UPCGSettings](API\Plugins\PCG\UPCGSettings) * InSettings, [TFunction](API\Runtime\Core\GenericPlatform\TFunction)< bool(const [FPCGDataCollection](API\Plugins\PCG\FPCGDataCollection) &, const [FPCGDataCollection](API\Plugins\PCG\FPCGDataCollection) &)> ValidationFn )


className: FPCGTestBaseClass

code: class FPCGTestBaseClass : public [FAutomationTestBase](API\Runtime\Core\Misc\FAutomationTestBase)


description: Initialize a context and set the number of tasks available to 1.

code: [TUniquePtr](API\Runtime\Core\Templates\TUniquePtr)< [FPCGContext](API\Plugins\PCG\FPCGContext) > InitializeTestContext ( const [UPCGNode](API\Plugins\PCG\UPCGNode) * InNode ) const


code: void Reset ( [UPCGSettings](API\Plugins\PCG\UPCGSettings) * InSettings )


code: FTestData ( int32 Seed, [UPCGSettings](API\Plugins\PCG\UPCGSettings) * DefaultSettings, [TSubclassOf](API\Runtime\CoreUObject\Templates\TSubclassOf)< [AActor](API\Runtime\Engine\GameFramework\AActor) > ActorClass )


className: FTestData

code: struct FTestData

InputData

type: FPCGDataCollect...

RandomStream

type: FRandomStream

Settings

type: UPCGSettings&#...

TestActor

type: AActor*

TestPCGComponent

type: UPCGComponent&...


description: Return a copy of all the registered partitioned components. Thread safe

code: [TSet](API\Runtime\Core\Containers\TSet)< [UPCGComponent](API\Plugins\PCG\UPCGComponent) * > GetAllRegisteredPartitionedComponents() const


description: Return a copy of all the registered non-partitioned components. Thread safe

code: [TSet](API\Runtime\Core\Containers\TSet)< [UPCGComponent](API\Plugins\PCG\UPCGComponent) * > GetAllRegisteredNonPartitionedComponents() const


description: Return a copy of all the registered components. Thread safe

code: [TSet](API\Runtime\Core\Containers\TSet)< [UPCGComponent](API\Plugins\PCG\UPCGComponent) * > GetAllRegisteredComponents() const


description: Register a new PCG Component or update it. Returns true if it was added/updated. Thread safe

code: bool RegisterOrUpdatePCGComponent ( [UPCGComponent](API\Plugins\PCG\UPCGComponent) * InComponent, bool bDoActorMapping )


description: Will register/update tracking if a component was registered/updated.

code: void RegisterOrUpdateTracking ( [UPCGComponent](API\Plugins\PCG\UPCGComponent) * InComponent, bool bInShouldDirtyActors )


description: In case of BP Actors, we need to remap the old component destroyed by the construction script to the new one. Returns true if a re-mapping was done. Thread safe

code: bool RemapPCGComponent ( const [UPCGComponent](API\Plugins\PCG\UPCGComponent) * OldComponent, [UPCGComponent](API\Plugins\PCG\UPCGComponent) * NewComponent, bool bDoActorMapping )


description: If the partition grid size change, call this to empty the Partition actors map

code: void ResetPartitionActorsMap()


description: Should be called by the subsystem to handle delayed operations.

code: void Tick()


description: Unregister a Partition actor, will be removed from the map and remove itself to all intersecting volumes. Thread safe

code: void UnregisterPartitionActor ( APCGPartitionActor * InActor )


description: Unregister a PCG Component. Can force it, if we have a delayed unregister. Thread safe

code: void UnregisterPCGComponent ( [UPCGComponent](API\Plugins\PCG\UPCGComponent) * InComponent, bool bForce )


description: Register a new Partition actor, will be added to a map and will query all intersecting volume to bind to them if asked. Thread safe

code: void RegisterPartitionActor ( APCGPartitionActor * InActor, bool bDoComponentMapping )


className: UPCGActorAndComponentMapping

description: No constructors are accessible with public or protected access.

code: class UPCGActorAndComponentMapping

UPCGSubsystem

type: friend


code: [TObjectPtr](API\Runtime\Core\Delegates\TObjectPtr)< [UPCGGraph](API\Plugins\PCG\UPCGGraph) > GetSubgraph() const


code: virtual [TObjectPtr](API\Runtime\Core\Delegates\TObjectPtr)< [UPCGGraphInterface](API\Plugins\PCG\UPCGGraphInterface) > GetSubgraphInterface() const


className: UPCGBaseSubgraphNode

code: [UCLASS](Programming/UnrealArchitecture/Reference/Classes#classdeclaration)(Abstract) class UPCGBaseSubgraphNode : public [UPCGNode](API\Plugins\PCG\UPCGNode)


description: Called before destroying the object. This is called immediately upon deciding to destroy the object, to allow the object to begin an asynchronous cleanup process.

code: virtual void BeginDestroy()


description: There is a weird issue where the BP class is not set correctly in some Server cases. We can try to recover if the PropertyClass is null.

code: virtual void FixingOverridableParamPropertyClass ( [FPCGSettingsOverridableParam](API\Plugins\PCG\FPCGSettingsOverridableParam) & Param ) const


description: Can be overridden to add more custom params (like in BP).

code: virtual [TArray](API\Runtime\Core\Containers\TArray)< [FPCGSettingsOverridableParam](API\Plugins\PCG\FPCGSettingsOverridableParam) > GatherOverridableParams() const


code: [UPCGGraph](API\Plugins\PCG\UPCGGraph) * GetSubgraph() const


code: virtual [UPCGGraphInterface](API\Plugins\PCG\UPCGGraphInterface) * GetSubgraphInterface() const


description: Derived classes must implement this to communicate dependencies on external actors

code: virtual void GetTrackedActorKeys ( [FPCGActorSelectionKeyToSettingsMap](API\Plugins\PCG\FPCGActorSelectionKeyToSettingsM-) & OutKeysToSettings, [TArray](API\Runtime\Core\Containers\TArray)< [TObjectPtr](API\Runtime\Core\Delegates\TObjectPtr)< const [UPCGGraph](API\Plugins\PCG\UPCGGraph) >> & OutVisitedGraphs ) const


description: Returns an array of all the input pin properties. You should not add manually a "params" pin, it is handled automatically by FillOverridableParamsPins.

code: virtual [TArray](API\Runtime\Core\Containers\TArray)< [FPCGPinProperties](API\Plugins\PCG\FPCGPinProperties) > InputPinProperties() const


description: Returns true if the subgraphs nodes were not inlined into the parent graphs tasks during compilation.

code: virtual bool IsDynamicGraph() const


code: virtual bool IsStructuralProperty ( const [FName](API\Runtime\Core\UObject\FName) & InPropertyName ) const


code: void OnSubgraphChanged ( [UPCGGraphInterface](API\Plugins\PCG\UPCGGraphInterface) * InGraph, [EPCGChangeType](API\Plugins\PCG\EPCGChangeType) ChangeType )


code: virtual [TArray](API\Runtime\Core\Containers\TArray)< [FPCGPinProperties](API\Plugins\PCG\FPCGPinProperties) > OutputPinProperties() const


description: Called when a property on this object has been modified externally

code: virtual void PostEditChangeProperty ( struct [FPropertyChangedEvent](API\Runtime\CoreUObject\UObject\FPropertyChangedEvent) & PropertyChangedEvent )


description: Called after the C++ constructor and after the properties have been initialized, including those loaded from config. This is called before any serialization or other setup has happened.

code: virtual void PostInitProperties()


description: Do any object-specific cleanup required immediately after loading an object. This is not called for newly-created objects, and by default will always execute on the game thread.

code: virtual void PostLoad()


description: This is called when a property is about to be modified externally

code: virtual void PreEditChange ( [FProperty](API\Runtime\CoreUObject\UObject\FProperty) * PropertyAboutToChange )


description: Use this method from the outside to set the subgraph, as it will connect editor callbacks.

code: virtual void SetSubgraph ( [UPCGGraphInterface](API\Plugins\PCG\UPCGGraphInterface) * InGraph )


code: virtual void SetSubgraphInternal ( [UPCGGraphInterface](API\Plugins\PCG\UPCGGraphInterface) * InGraph )


className: UPCGBaseSubgraphSettings

code: [UCLASS](Programming/UnrealArchitecture/Reference/Classes#classdeclaration)(Abstract) class UPCGBaseSubgraphSettings : public [UPCGSettings](API\Plugins\PCG\UPCGSettings)


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintPure, Category="PCG|Pins", Meta=(NativeBreakFunc)) static void BreakPinProperty ( const [FPCGPinProperties](API\Plugins\PCG\FPCGPinProperties) & PinProperty, [FName](API\Runtime\Core\UObject\FName) & Label, bool & bAllowMultipleData, bool & bAllowMultipleConnections, bool & bAdvancedPin, [EPCGExclusiveDataType](API\Plugins\PCG\EPCGExclusiveDataType) & AllowedType )


code: virtual void BeginDestroy()


className: UPCGBlueprintPinHelpers

code: [UCLASS](Programming/UnrealArchitecture/Reference/Classes#classdeclaration)() class UPCGBlueprintPinHelpers : public [UBlueprintFunctionLibrary](API\Runtime\Engine\Kismet\UBlueprintFunctionLibrary)


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintPure, Category="PCG|Pins", Meta=(NativeMakeFunc)) static [FPCGPinProperties](API\Plugins\PCG\FPCGPinProperties) MakePinProperty ( [FName](API\Runtime\Core\UObject\FName) Label, bool bAllowMultipleData, bool bAllowMultipleConnections, bool bAdvancedPin, [EPCGExclusiveDataType](API\Plugins\PCG\EPCGExclusiveDataType) AllowedType )


description: Registers some managed resource to the current component

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=PCG) void AddToManagedResources ( [UPCGManagedResource](API\Plugins\PCG\UPCGManagedResource) * InResource )


description: ~EndUObjectinterface

code: virtual void BeginPlay()


description: Cancels in-progress generation

code: void CancelGeneration()


description:
Called by the editor to query whether a property of this object is allowed to be modified. The property editor uses this to disable controls for properties that should not be changed. When overriding this function you should always call the parent implementation first.
true if the property can be modified in the editor, otherwise false

code: virtual bool CanEditChange ( const [FProperty](API\Runtime\CoreUObject\UObject\FProperty) * InProperty ) const


description: Networked cleanup call

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, NetMulticast, Reliable, Category=PCG) void Cleanup ( bool bRemoveComponents, bool bSave )


description: Cleans up the generation from a local (vs. remote) standpoint. Will not be replicated. Will be delayed.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=PCG) void CleanupLocal ( bool bRemoveComponents, bool bSave )


description: Same as CleanupLocal, but without any delayed tasks. All is done immediately.

code: void CleanupLocalImmediate ( bool bRemoveComponents )


description: Move all generated resources under a new actor, following a template (AActorif not provided), clearing all link to this PCG component. Returns the new actor.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=PCG) [AActor](API\Runtime\Engine\GameFramework\AActor) * ClearPCGLink ( [UClass](API\Runtime\CoreUObject\UObject\UClass) * TemplateActor )


description: Clear any data stored for any pins.

code: void ClearPerPinGeneratedOutput()


description: Builds the canonical PCG data from a given actor and its PCG component if any.

code: UPCGData &42; CreateActorPCGData &40; AActor &42; Actor, bool bParseActor &41;


code: static [UPCGData](API\Plugins\PCG\UPCGData) * CreateActorPCGData ( [AActor](API\Runtime\Engine\GameFramework\AActor) * Actor, const [UPCGComponent](API\Plugins\PCG\UPCGComponent) * Component, bool bParseActor )


description: Builds the PCG data from a given actor and its PCG component, and places it in a data collection with appropriate tags

code: static [FPCGDataCollection](API\Plugins\PCG\FPCGDataCollection) CreateActorPCGDataCollection ( [AActor](API\Runtime\Engine\GameFramework\AActor) * Actor, const [UPCGComponent](API\Plugins\PCG\UPCGComponent) * Component, [EPCGDataType](API\Plugins\PCG\EPCGDataType) InDataFilter, bool bParseActor )


description: Dirty generated data depending on the flag.Bydefault the call is forwarded to the local components. We don't forward if the local component has callbacks that would dirty them too. For example: When a tracked actor move, we only want to dirty the impacted local components.

code: void DirtyGenerated ( [EPCGComponentDirtyFlag](API\Plugins\PCG\EPCGComponentDirtyFlag) DataToDirtyFlag, const bool bDispatchToLocalComponents )


description: Ends gameplay for this component. Called fromAActor::EndPlayonly if bHasBegunPlay is true

code: virtual void EndPlay ( const [EEndPlayReason::Type](API\Runtime\Engine\Engine\EEndPlayReason__Type) EndPlayReason )


code: void ForEachManagedResource ( [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< void([UPCGManagedResource](API\Plugins\PCG\UPCGManagedResource) *)> InFunction )


description: Transactionable methods to be called from details UI

code: void Generate()


description: Networked generation call that also activates the component as needed

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, NetMulticast, Reliable, Category=PCG) void Generate ( bool bForce )


description: Starts generation from a local (vs. remote) standpoint. Will not be replicated. Will be delayed.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=PCG) void GenerateLocal ( bool bForce )


code: [FPCGTaskId](API\Plugins\PCG\FPCGTaskId) GenerateLocalGetTaskId ( bool bForce )


description: Called before we throw away components during RerunConstructionScripts, to cache any data we wish to persist across that operation

code: virtual [TStructOnScope](API\Runtime\CoreUObject\UObject\TStructOnScope)< [FActorComponentInstanceData](API\Runtime\Engine\FActorComponentInstanceData) > GetComponentInstanceData() const


description: Retrieves generated data

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=PCG) const [FPCGDataCollection](API\Plugins\PCG\FPCGDataCollection) & GetGeneratedGraphOutput() const


description: Returns task ids to do internal chaining


code: [UPCGGraph](API\Plugins\PCG\UPCGGraph) * GetGraph() const


code: [UPCGGraphInstance](API\Plugins\PCG\UPCGGraphInstance) * GetGraphInstance() const


code: FBox GetGridBounds &40; const AActor &42; InActor &41; const


code: const [FPCGDataCollection](API\Plugins\PCG\FPCGDataCollection) * GetInspectionData ( const [FPCGStack](API\Plugins\PCG\Graph\FPCGStack) & InStack ) const


description: If this is a local component returns self, otherwise returns the original component.


code: [UPCGSubsystem](API\Plugins\PCG\UPCGSubsystem) * GetSubsystem() const


code: bool IsActorTracked ( [AActor](API\Runtime\Engine\GameFramework\AActor) * InActor, bool & bOutIsCulled ) const


description: Functions for managing the node inspection cache

code: bool IsInspecting() const


description: Return if we are currently generating the graph for this component

code: bool IsGenerating() const


description: Responsibility of the PCG Partition Actor to mark is local

code: void MarkAsLocalComponent()


description: Notify properties changed, used in runtime cases, will dirty & trigger a regeneration if needed


description: Called when a component is destroyed

code: virtual void OnComponentDestroyed ( bool bDestroyingHierarchy )


code: void OnRefresh ( bool bForceRefresh )


description: Called when a component is registered, after Scene is set, but before CreateRenderState_Concurrent or OnCreatePhysicsState are called.

code: virtual void OnRegister()


description: Called when a component is unregistered. Called after DestroyRenderState_Concurrent and OnDestroyPhysicsState are called.

code: virtual void OnUnregister()


description: Called after importing property values for this object (paste, duplicate or .t3d import) Allow the object to perform any cleanup for properties which shouldn't be duplicated or are unsupported by the script serialization

code: virtual void PostEditImport()


description: Called after the C++ constructor and after the properties have been initialized, including those loaded from config. This is called before any serialization or other setup has happened.

code: virtual void PostInitProperties()


description: ~BeginUObjectinterface

code: virtual void PostLoad()


description: Reset last generated bounds to force PCGPartitionActor creation on next refresh

code: void ResetLastGeneratedBounds()


description: Lookup data using a resource key that identifies the pin.

code: const [FPCGDataCollection](API\Plugins\PCG\FPCGDataCollection) * RetrieveOutputDataForPin ( const [FString](API\Runtime\Core\Containers\FString) & InResourceKey )


code: void SetGenerationGridSize ( uint32 InGenerationGridSize )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, NetMulticast, Reliable, Category=PCG) void SetGraph ( [UPCGGraphInterface](API\Plugins\PCG\UPCGGraphInterface) * InGraph )


code: void SetGraphLocal ( [UPCGGraphInterface](API\Plugins\PCG\UPCGGraphInterface) * InGraph )


description: Updates internal properties from other component, dirties as required but does not trigger Refresh

code: void SetPropertiesFromOriginal ( const [UPCGComponent](API\Plugins\PCG\UPCGComponent) * Original )


description: Know if we need to force a generation, in case of BP added to the world in editor


description: Utility function (mostly for tests) to properly set the value of bIsComponentPartitioned. Will do an immediate cleanup first and then register/unregister the component to the subsystem. It's your responsibility after to regenerate the graph if you want to.

code: void SetIsPartitioned ( bool bIsNowPartitioned )


code: void StoreInspectionData ( const [FPCGStack](API\Plugins\PCG\Graph\FPCGStack) * InStack, const [UPCGNode](API\Plugins\PCG\UPCGNode) * InNode, const [FPCGDataCollection](API\Plugins\PCG\FPCGDataCollection) & InInputData, const [FPCGDataCollection](API\Plugins\PCG\FPCGDataCollection) & InOutputData )


className: UPCGComponent

description: No destructors are accessible with public or protected access.

code: [UCLASS](Programming/UnrealArchitecture/Reference/Classes#classdeclaration)(BlueprintType, ClassGroup=(Procedural), Meta=(BlueprintSpawnableComponent, prioritizeCategories="PCG")) class UPCGComponent : public [UActorComponent](API\Runtime\Engine\Components\UActorComponent)

bActivated

type: bool

bForceGenerateOnBPAddedToWorld

description: Property that will automatically be set on BP templates, to allow for "Generate on add to world" in editor.

bGenerated

description: Flag to indicate whether this component has run in the editor.

bIsComponentPartitioned

description: In World Partition map, will partition the component in a grid, according to PCGWorldActor settings, dispatching the generation to multiple local components.

GenerationTrigger

type: EPCGComponentGe...

GraphInstance

type: TObjectPtr<UPC...

InputType

type: EPCGComponentIn...

OnPCGGraphCleanedDelegate

type: FOnPCGGraphClea...

OnPCGGraphGeneratedDelegate

type: FOnPCGGraphGene...

PostGenerateFunctionNames

type: TArray<FName>

description: Can specify a list of functions from the owner of this component to be called when generation is done, in order.

Seed

type: int


description: Store data with a resource key that identifies the pin.

code: void StoreOutputDataForPin ( const [FString](API\Runtime\Core\Containers\FString) & InResourceKey, const [FPCGDataCollection](API\Plugins\PCG\FPCGDataCollection) & InData )


description: Computes Crc for this and any connected data.

code: virtual [FPCGCrc](API\Plugins\PCG\FPCGCrc) ComputeCrc ( bool bFullDataCrc ) const


description: Adds this data to Crc. Fallback implementation writes object instance UID.

code: virtual void AddToCrc ( [FArchiveCrc32](API\Runtime\CoreUObject\Serialization\FArchiveCrc32) & Ar, bool bFullDataCrc ) const


code: virtual [EPCGDataType](API\Plugins\PCG\EPCGDataType) GetDataType() const


description: Returns a Crc for this and any connected data.

code: [FPCGCrc](API\Plugins\PCG\FPCGCrc) GetOrComputeCrc ( bool bFullDataCrc ) const


code: virtual bool HasCachedLastSelector() const


description: Whether intersection, union, difference combine Crc values from operands. If false they fall back to using data UID.


code: virtual void SetLastSelector ( const [FPCGAttributePropertySelector](API\Plugins\PCG\Metadata\FPCGAttributePropertySelector) & InSelector )


className: UIDCounter

description: Serves unique ID values to instances of this object.

code: static std::atomic< uint64 > UIDCounter { 1 };


description: Executes a lambda over all connected data objects.

code: virtual void VisitDataNetwork ( [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< void(const [UPCGData](API\Plugins\PCG\UPCGData) *)> Action ) const


code: UPCGData ( const [FObjectInitializer](API\Runtime\CoreUObject\UObject\FObjectInitializer) & ObjectInitializer )


className: UPCGData

description: Base class for any "data" class in the PCG framework. This is an intentionally vague base class so we can have the required flexibility to pass in various concrete data types, settings, and more.

code: [UCLASS](Programming/UnrealArchitecture/Reference/Classes#classdeclaration)(BlueprintType, ClassGroup=(Procedural)) class UPCGData : public [UObject](API\Runtime\CoreUObject\UObject\UObject)

Crc

type: FPCGCrc

description: CRC for this object instance.

UID

description: Unique ID for this object instance.


description: Adds a data object to a given collection, simpler usage than making a PCGTaggedData object

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Data, Meta=(ScriptMethod, DeterminesOutputType="InDataTypeClass")) static void AddToCollection ( [FPCGDataCollection](API\Plugins\PCG\FPCGDataCollection) & InCollection, const [UPCGData](API\Plugins\PCG\UPCGData) * InData, [FName](API\Runtime\Core\UObject\FName) InPinLabel, [TArray](API\Runtime\Core\Containers\TArray)< [FString](API\Runtime\Core\Containers\FString) > InTags )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Data) static [TArray](API\Runtime\Core\Containers\TArray)< [FPCGTaggedData](API\Plugins\PCG\FPCGTaggedData) > GetAllSettings ( const [FPCGDataCollection](API\Plugins\PCG\FPCGDataCollection) & InCollection )


description: Blueprint methods to support interaction withFPCGDataCollection.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Data, Meta=(ScriptMethod)) static [TArray](API\Runtime\Core\Containers\TArray)< [FPCGTaggedData](API\Plugins\PCG\FPCGTaggedData) > GetInputs ( const [FPCGDataCollection](API\Plugins\PCG\FPCGDataCollection) & InCollection )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Data) static [TArray](API\Runtime\Core\Containers\TArray)< [FPCGTaggedData](API\Plugins\PCG\FPCGTaggedData) > GetInputsByPinLabel ( const [FPCGDataCollection](API\Plugins\PCG\FPCGDataCollection) & InCollection, const [FName](API\Runtime\Core\UObject\FName) InPinLabel )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Data) static [TArray](API\Runtime\Core\Containers\TArray)< [UPCGData](API\Plugins\PCG\UPCGData) * > GetInputsByPredicate ( const [FPCGDataCollection](API\Plugins\PCG\FPCGDataCollection) & InCollection, [TArray](API\Runtime\Core\Containers\TArray)< [FPCGTaggedData](API\Plugins\PCG\FPCGTaggedData) > & OutTaggedData, [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< bool(const [FPCGTaggedData](API\Plugins\PCG\FPCGTaggedData) &)> InPredicate )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Data) static [TArray](API\Runtime\Core\Containers\TArray)< [FPCGTaggedData](API\Plugins\PCG\FPCGTaggedData) > GetInputsByTag ( const [FPCGDataCollection](API\Plugins\PCG\FPCGDataCollection) & InCollection, const [FString](API\Runtime\Core\Containers\FString) & InTag )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Data) static [TArray](API\Runtime\Core\Containers\TArray)< [FPCGTaggedData](API\Plugins\PCG\FPCGTaggedData) > GetParams ( const [FPCGDataCollection](API\Plugins\PCG\FPCGDataCollection) & InCollection )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Data) static [TArray](API\Runtime\Core\Containers\TArray)< [FPCGTaggedData](API\Plugins\PCG\FPCGTaggedData) > GetParamsByPinLabel ( const [FPCGDataCollection](API\Plugins\PCG\FPCGDataCollection) & InCollection, const [FName](API\Runtime\Core\UObject\FName) InPinLabel )


description: Gets all inputs of the given class type, returning matching tagged data in the OutTaggedData value too

code: static [TArray](API\Runtime\Core\Containers\TArray)< [UPCGData](API\Plugins\PCG\UPCGData) * > GetTypedInputs ( const [FPCGDataCollection](API\Plugins\PCG\FPCGDataCollection) & InCollection, [TArray](API\Runtime\Core\Containers\TArray)< [FPCGTaggedData](API\Plugins\PCG\FPCGTaggedData) > & OutTaggedData, [TSubclassOf](API\Runtime\CoreUObject\Templates\TSubclassOf)< [UPCGData](API\Plugins\PCG\UPCGData) > InDataTypeClass )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Data) static [TArray](API\Runtime\Core\Containers\TArray)< [FPCGTaggedData](API\Plugins\PCG\FPCGTaggedData) > GetParamsByTag ( const [FPCGDataCollection](API\Plugins\PCG\FPCGDataCollection) & InCollection, const [FString](API\Runtime\Core\Containers\FString) & InTag )


description: Gets all inputs of the given class type and on the given pin, returning matching tagged data in the OutTaggedData value too

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Data, Meta=(ScriptMethod, DeterminesOutputType="InDataTypeClass")) static [TArray](API\Runtime\Core\Containers\TArray)< [UPCGData](API\Plugins\PCG\UPCGData) * > GetTypedInputsByPin ( const [FPCGDataCollection](API\Plugins\PCG\FPCGDataCollection) & InCollection, const [FPCGPinProperties](API\Plugins\PCG\FPCGPinProperties) & InPin, [TArray](API\Runtime\Core\Containers\TArray)< [FPCGTaggedData](API\Plugins\PCG\FPCGTaggedData) > & OutTaggedData, [TSubclassOf](API\Runtime\CoreUObject\Templates\TSubclassOf)< [UPCGData](API\Plugins\PCG\UPCGData) > InDataTypeClass )


description: Gets all inputs of the given class type and on the given pin label, returning matching tagged data in the OutTaggedData value too

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Data, Meta=(ScriptMethod, DeterminesOutputType="InDataTypeClass")) static [TArray](API\Runtime\Core\Containers\TArray)< [UPCGData](API\Plugins\PCG\UPCGData) * > GetTypedInputsByPinLabel ( const [FPCGDataCollection](API\Plugins\PCG\FPCGDataCollection) & InCollection, [FName](API\Runtime\Core\UObject\FName) InPinLabel, [TArray](API\Runtime\Core\Containers\TArray)< [FPCGTaggedData](API\Plugins\PCG\FPCGTaggedData) > & OutTaggedData, [TSubclassOf](API\Runtime\CoreUObject\Templates\TSubclassOf)< [UPCGData](API\Plugins\PCG\UPCGData) > InDataTypeClass )


description: Gets all inputs of the given class type and having the provided tag, returning matching tagged data in the OutTaggedData value too

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Data, Meta=(ScriptMethod, DeterminesOutputType="InDataTypeClass")) static [TArray](API\Runtime\Core\Containers\TArray)< [UPCGData](API\Plugins\PCG\UPCGData) * > GetTypedInputsByTag ( const [FPCGDataCollection](API\Plugins\PCG\FPCGDataCollection) & InCollection, const [FString](API\Runtime\Core\Containers\FString) & InTag, [TArray](API\Runtime\Core\Containers\TArray)< [FPCGTaggedData](API\Plugins\PCG\FPCGTaggedData) > & OutTaggedData, [TSubclassOf](API\Runtime\CoreUObject\Templates\TSubclassOf)< [UPCGData](API\Plugins\PCG\UPCGData) > InDataTypeClass )


code: [UPCGPin](API\Plugins\PCG\UPCGPin) * GetOtherPin ( const [UPCGPin](API\Plugins\PCG\UPCGPin) * Pin )


className: UPCGDataFunctionLibrary

code: class UPCGDataFunctionLibrary : public [UBlueprintFunctionLibrary](API\Runtime\Engine\Kismet\UBlueprintFunctionLibrary)


code: const [UPCGPin](API\Plugins\PCG\UPCGPin) * GetOtherPin ( const [UPCGPin](API\Plugins\PCG\UPCGPin) * Pin ) const


description: Do any object-specific cleanup required immediately after loading an object. This is not called for newly-created objects, and by default will always execute on the game thread.

code: virtual void PostLoad()


code: UPCGEdge ( const [FObjectInitializer](API\Runtime\CoreUObject\UObject\FObjectInitializer) & ObjectInitializer )


className: UPCGEdge

code: [UCLASS](Programming/UnrealArchitecture/Reference/Classes#classdeclaration)(ClassGroup=(Procedural)) class UPCGEdge : public [UObject](API\Runtime\CoreUObject\UObject\UObject)


className: UPCGEngineSettings

code: [UCLASS](Programming/UnrealArchitecture/Reference/Classes#classdeclaration)(Config=EditorPerProjectUserSettings) class UPCGEngineSettings : public [UObject](API\Runtime\CoreUObject\UObject\UObject)

bGenerateOnDrop

description: Whether we want to generate PCG graph/BP with PCG after drag/drop or not

VolumeScale

type: FVector

description: Specifies the scale of the volume created on PCG graph drag/drop


description: Adds a directed edge in the graph. Returns the "To" node for easy chaining

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Graph, Meta=(DeterminesOutputType="InSettings", DynamicOutputParam="OutCopiedSettings")) [UPCGNode](API\Plugins\PCG\UPCGNode) * AddEdge ( [UPCGNode](API\Plugins\PCG\UPCGNode) * From, const [FName](API\Runtime\Core\UObject\FName) & FromPinLabel, [UPCGNode](API\Plugins\PCG\UPCGNode) * To, const [FName](API\Runtime\Core\UObject\FName) & ToPinLabel )


description: Creates an edge between two nodes/pins based on the labels. Returns true if the To node has removed other edges (happens with single pins)

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Graph) bool AddLabeledEdge ( [UPCGNode](API\Plugins\PCG\UPCGNode) * From, const [FName](API\Runtime\Core\UObject\FName) & InboundLabel, [UPCGNode](API\Plugins\PCG\UPCGNode) * To, const [FName](API\Runtime\Core\UObject\FName) & OutboundLabel )


description: Creates a node using the given settings interface. Does not manage ownership - done outside of this method.

code: [UPCGNode](API\Plugins\PCG\UPCGNode) * AddNode ( [UPCGSettingsInterface](API\Plugins\PCG\UPCGSettingsInterface) * InSettings )


code: void AddNode ( [UPCGNode](API\Plugins\PCG\UPCGNode) * InNode )


description: Creates a node and copies the input settings. Returns the created node.

code: [UPCGNode](API\Plugins\PCG\UPCGNode) * AddNodeCopy ( [UPCGSettings](API\Plugins\PCG\UPCGSettings) * InSettings, [UPCGSettings](API\Plugins\PCG\UPCGSettings) *& DefaultNodeSettings )


description: Creates a node containing an instance to the given settings. Returns the created node.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Graph, Meta=(DeterminesOutputType="InSettingsClass", DynamicOutputParam="DefaultNodeSettings")) [UPCGNode](API\Plugins\PCG\UPCGNode) * AddNodeInstance ( [UPCGSettings](API\Plugins\PCG\UPCGSettings) * InSettings )


description: Creates a default node based on the settings class wanted. Returns the newly created node.

code: [UPCGNode](API\Plugins\PCG\UPCGNode) * AddNodeOfType ( [TSubclassOf](API\Runtime\CoreUObject\Templates\TSubclassOf)< class [UPCGSettings](API\Plugins\PCG\UPCGSettings) > InSettingsClass, [UPCGSettings](API\Plugins\PCG\UPCGSettings) *& DefaultNodeSettings )


description: Called before destroying the object. This is called immediately upon deciding to destroy the object, to allow the object to begin an asynchronous cleanup process.

code: virtual void BeginDestroy()


description: Calculates node grid size. Not thread safe, called within write lock.

code: uint32 CalculateNodeGridSizeRecursive_Unsafe ( const [UPCGNode](API\Plugins\PCG\UPCGNode) * InNode, uint32 InDefaultGridSize ) const


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Graph) bool Contains ( [UPCGNode](API\Plugins\PCG\UPCGNode) * Node ) const


code: static void DeclareConstructClasses ( [TArray](API\Runtime\Core\Containers\TArray)< [FTopLevelAssetPath](API\Runtime\CoreUObject\UObject\FTopLevelAssetPath) > & OutConstructClasses, const [UClass](API\Runtime\CoreUObject\UObject\UClass) * SpecificSubclass )


description: Calls the lambda on every node in graph.

code: void ForEachNode ( const [TFunction](API\Runtime\Core\GenericPlatform\TFunction)< void([UPCGNode](API\Plugins\PCG\UPCGNode) *)> & Action )


description: ~EndUPCGGraphInterfaceinterface


code: const [TArray](API\Runtime\Core\Containers\TArray)< [TObjectPtr](API\Runtime\Core\Delegates\TObjectPtr)< [UObject](API\Runtime\CoreUObject\UObject\UObject) > > & GetExtraEditorNodes() const


description: ~EndUObjectinterface ~BeginUPCGGraphInterfaceinterface

code: virtual [UPCGGraph](API\Plugins\PCG\UPCGGraph) * GetGraph()


code: virtual const [UPCGGraph](API\Plugins\PCG\UPCGGraph) * GetGraph() const


description: Determine the relevant grid sizes by inspecting all HiGenGridSize nodes.

code: void GetGridSizes ( [PCGHiGenGrid::FSizeArray](API\Plugins\PCG\FSizeArray) & OutGridSizes, bool & bOutHasUnbounded ) const


description: Returns the graph input node

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Graph) [UPCGNode](API\Plugins\PCG\UPCGNode) * GetInputNode() const


description: Size of grid on which this node should be executed. Nodes execute at the minimum of all input grid sizes.

code: uint32 GetNodeGenerationGridSize ( const [UPCGNode](API\Plugins\PCG\UPCGNode) * InNode, uint32 InDefaultGridSize ) const


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Graph) const [TArray](API\Runtime\Core\Containers\TArray)< [UPCGNode](API\Plugins\PCG\UPCGNode) * > & GetNodes() const


description: Returns the graph output node

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Graph) [UPCGNode](API\Plugins\PCG\UPCGNode) * GetOutputNode() const


code: void GetTrackedActorKeysToSettings ( [FPCGActorSelectionKeyToSettingsMap](API\Plugins\PCG\FPCGActorSelectionKeyToSettingsM-) & OutKeysToSettings, [TArray](API\Runtime\Core\Containers\TArray)< [TObjectPtr](API\Runtime\Core\Delegates\TObjectPtr)< const [UPCGGraph](API\Plugins\PCG\UPCGGraph) >> & OutVisitedGraphs ) const


code: virtual const [FInstancedPropertyBag](API\Plugins\StructUtils\FInstancedPropertyBag) * GetUserParametersStruct() const


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="Graph|Advanded") bool IsInspecting() const


code: void OnNodeAdded ( [UPCGNode](API\Plugins\PCG\UPCGNode) * InNode )


code: void OnNodeRemoved ( [UPCGNode](API\Plugins\PCG\UPCGNode) * InNode )


description: Called when a property on this object has been modified externally

code: virtual void PostEditChangeProperty ( [FPropertyChangedEvent](API\Runtime\CoreUObject\UObject\FPropertyChangedEvent) & PropertyChangedEvent )


code: void PostNodeUndo ( [UPCGNode](API\Plugins\PCG\UPCGNode) * InPCGNode )


description: ~BeginUObjectinterface

code: virtual void PostLoad()


description: This is called when a property is about to be modified externally

code: virtual void PreEditChange ( [FProperty](API\Runtime\CoreUObject\UObject\FProperty) * PropertyAboutToChange )


code: void PreNodeUndo ( [UPCGNode](API\Plugins\PCG\UPCGNode) * InPCGNode )


description: Duplicate a given node by creating a new node with the same settings and properties, but without any edges and add it to the graph

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Graph) [TObjectPtr](API\Runtime\Core\Delegates\TObjectPtr)< [UPCGNode](API\Plugins\PCG\UPCGNode) > ReconstructNewNode ( const [UPCGNode](API\Plugins\PCG\UPCGNode) * InNode )


description: Removes an edge in the graph. Returns true if an edge was removed.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Graph) bool RemoveEdge ( [UPCGNode](API\Plugins\PCG\UPCGNode) * From, const [FName](API\Runtime\Core\UObject\FName) & FromLabel, [UPCGNode](API\Plugins\PCG\UPCGNode) * To, const [FName](API\Runtime\Core\UObject\FName) & ToLabel )


code: bool RemoveInboundEdges ( [UPCGNode](API\Plugins\PCG\UPCGNode) * InNode, const [FName](API\Runtime\Core\UObject\FName) & InboundLabel )


description: Removes a node from the graph.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Graph) void RemoveNode ( [UPCGNode](API\Plugins\PCG\UPCGNode) * InNode )


code: bool RemoveOutboundEdges ( [UPCGNode](API\Plugins\PCG\UPCGNode) * InNode, const [FName](API\Runtime\Core\UObject\FName) & OutboundLabel )


code: void SetExtraEditorNodes ( const [TArray](API\Runtime\Core\Containers\TArray)< [TObjectPtr](API\Runtime\Core\Delegates\TObjectPtr)< const [UObject](API\Runtime\CoreUObject\UObject\UObject) >> & InNodes )


code: bool UserParametersCanRemoveProperty ( [FGuid](API\Runtime\Core\Misc\FGuid) InPropertyID, [FName](API\Runtime\Core\UObject\FName) InPropertyName )


code: bool UserParametersIsPinTypeAccepted ( [FEdGraphPinType](API\Runtime\Engine\EdGraph\FEdGraphPinType) InPinType )


code: UPCGGraph ( const [FObjectInitializer](API\Runtime\CoreUObject\UObject\FObjectInitializer) & ObjectInitializer )


className: UPCGGraph

code: class UPCGGraph : public [UPCGGraphInterface](API\Plugins\PCG\UPCGGraphInterface)

bDebugFlagAppliesToIndividualComponents

description: When true the Debug flag in the graph editor will display debug information contextually for the selected debug object.

Category

type: FText

ExtraEditorNodes

type: TArray<TObject...

description: Extra data to hold information that is useful only in editor (like comments)

HiGenGridSize

type: EPCGHiGenGrid

InputNode

description: Add input/output nodes.

NodeToGridSize

type: TMap< constUPC...

description: Execution grid size for nodes.

NodeToGridSizeLock

type: FRWLock

UserParameters

type: FInstancedPrope...

description: Parameters.


description: Add a new custom pin Note that you should use the return value of this function, since it can be different from the one passed as argument. It will change if its label collides with existing pins.

code: const [FPCGPinProperties](API\Plugins\PCG\FPCGPinProperties) & AddCustomPin ( const [FPCGPinProperties](API\Plugins\PCG\FPCGPinProperties) & NewCustomPinProperties )


code: virtual [FPCGElementPtr](API\Plugins\PCG\FPCGElementPtr) CreateElement() const


description: Internal functions, should not be used by any user. Return a different subset for for input/output pin properties, in case of a default object.

code: virtual [TArray](API\Runtime\Core\Containers\TArray)< [FPCGPinProperties](API\Plugins\PCG\FPCGPinProperties) > DefaultInputPinProperties() const


code: virtual [TArray](API\Runtime\Core\Containers\TArray)< [FPCGPinProperties](API\Plugins\PCG\FPCGPinProperties) > DefaultOutputPinProperties() const


code: FLabelAndTooltip &40; FName InLabel, FText InTooltip &41;


className: FLabelAndTooltip

code: struct FLabelAndTooltip

Label

type: FName


code: virtual [FName](API\Runtime\Core\UObject\FName) GetDefaultNodeName() const


code: [TArray](API\Runtime\Core\Containers\TArray)< [FPCGPinProperties](API\Plugins\PCG\FPCGPinProperties) > GetPinProperties() const


code: virtual [FText](API\Runtime\Core\Internationalization\FText) GetDefaultNodeTitle() const


code: virtual [EPCGSettingsType](API\Plugins\PCG\EPCGSettingsType) GetType() const


description: Returns an array of all the input pin properties. You should not add manually a "params" pin, it is handled automatically by FillOverridableParamsPins.

code: virtual [TArray](API\Runtime\Core\Containers\TArray)< [FPCGPinProperties](API\Plugins\PCG\FPCGPinProperties) > InputPinProperties() const


code: bool IsCustomPin ( const [UPCGPin](API\Plugins\PCG\UPCGPin) * InPin ) const


code: virtual [TArray](API\Runtime\Core\Containers\TArray)< [FPCGPinProperties](API\Plugins\PCG\FPCGPinProperties) > OutputPinProperties() const


code: virtual void PostEditChangeProperty ( struct [FPropertyChangedEvent](API\Runtime\CoreUObject\UObject\FPropertyChangedEvent) & PropertyChangedEvent )


description: Do any object-specific cleanup required immediately after loading an object. This is not called for newly-created objects, and by default will always execute on the game thread.

code: virtual void PostLoad()


code: const [TArray](API\Runtime\Core\Containers\TArray)< [FLabelAndTooltip](API\Plugins\PCG\UPCGGraphInputOutputSettings\FLabelAndTooltip) > & StaticAdvancedLabels() const


code: const [TArray](API\Runtime\Core\Containers\TArray)< [FLabelAndTooltip](API\Plugins\PCG\UPCGGraphInputOutputSettings\FLabelAndTooltip) > & StaticLabels() const


code: UPCGGraphInputOutputSettings ( const [FObjectInitializer](API\Runtime\CoreUObject\UObject\FObjectInitializer) & ObjectInitializer )


className: UPCGGraphInputOutputSettings

code: [UCLASS](Programming/UnrealArchitecture/Reference/Classes#classdeclaration)(NotBlueprintable, Hidden, ClassGroup=(Procedural)) class UPCGGraphInputOutputSettings : public [UPCGSettings](API\Plugins\PCG\UPCGSettings)

bIsInput

type: bool

CustomPins

type: TArray<FPCGPin...

StaticAdvancedInLabels

type: TArray<FLabelA...


code: virtual void BeginDestroy()


description:
Called by the editor to query whether a property of this object is allowed to be modified. The property editor uses this to disable controls for properties that should not be changed. When overriding this function you should always call the parent implementation first.
true if the property can be modified in the editor, otherwise false

code: virtual bool CanEditChange ( const [FProperty](API\Runtime\CoreUObject\UObject\FProperty) * InProperty ) const


code: void CopyParameterOverrides ( [UPCGGraphInterface](API\Plugins\PCG\UPCGGraphInterface) * InGraph )


description: ~BeginUPCGGraphInterfaceinterface

code: virtual [UPCGGraph](API\Plugins\PCG\UPCGGraph) * GetGraph()


code: static [TObjectPtr](API\Runtime\Core\Delegates\TObjectPtr)< [UPCGGraphInterface](API\Plugins\PCG\UPCGGraphInterface) > CreateInstance ( [UObject](API\Runtime\CoreUObject\UObject\UObject) * InOwner, [UPCGGraphInterface](API\Plugins\PCG\UPCGGraphInterface) * InGraph )


description: Reconstruction script specific, to fix callbacks on reconstructed component and teardown callback on trashed component.

code: void FixCallbacks()


code: virtual const [UPCGGraph](API\Plugins\PCG\UPCGGraph) * GetGraph() const


code: virtual const [FInstancedPropertyBag](API\Plugins\StructUtils\FInstancedPropertyBag) * GetUserParametersStruct() const


code: bool IsPropertyOverridden ( const [FProperty](API\Runtime\CoreUObject\UObject\FProperty) * InProperty ) const


code: bool IsPropertyOverriddenAndNotDefault ( const [FProperty](API\Runtime\CoreUObject\UObject\FProperty) * InProperty ) const


code: void NotifyGraphParametersChanged ( [EPCGGraphParameterEvent](API\Plugins\PCG\EPCGGraphParameterEvent) InChangeType, [FName](API\Runtime\Core\UObject\FName) InChangedPropertyName )


code: void OnGraphGridSizesChanged ( [UPCGGraphInterface](API\Plugins\PCG\UPCGGraphInterface) * InGraph )


code: void OnGraphChanged ( [UPCGGraphInterface](API\Plugins\PCG\UPCGGraphInterface) * InGraph, [EPCGChangeType](API\Plugins\PCG\EPCGChangeType) ChangeType )


code: void OnGraphParametersChanged ( [UPCGGraphInterface](API\Plugins\PCG\UPCGGraphInterface) * InGraph, [EPCGGraphParameterEvent](API\Plugins\PCG\EPCGGraphParameterEvent) InChangeType, [FName](API\Runtime\Core\UObject\FName) InChangedPropertyName )


code: virtual void PostEditChangeProperty ( [FPropertyChangedEvent](API\Runtime\CoreUObject\UObject\FPropertyChangedEvent) & PropertyChangedEvent )


description: ~EndUPCGGraphInterfaceinterface

code: virtual void PostLoad()


description: Called after applying a transaction to the object. Default implementation simply calls PostEditChange.

code: virtual void PostEditUndo()


code: virtual void PreEditChange ( [FProperty](API\Runtime\CoreUObject\UObject\FProperty) * PropertyAboutToChange )


description: Called before applying a transaction to the object. Default implementation simply calls PreEditChange.

code: virtual void PreEditUndo()


code: void ResetPropertyToDefault ( const [FProperty](API\Runtime\CoreUObject\UObject\FProperty) * InProperty )


code: void RefreshParameters ( [EPCGGraphParameterEvent](API\Plugins\PCG\EPCGGraphParameterEvent) InChangeType, [FName](API\Runtime\Core\UObject\FName) InChangedPropertyName )


code: void SetGraph ( [UPCGGraphInterface](API\Plugins\PCG\UPCGGraphInterface) * InGraph )


code: void UpdatePropertyOverride ( const [FProperty](API\Runtime\CoreUObject\UObject\FProperty) * InProperty, bool bMarkAsOverridden )


className: UPCGGraphInstance

code: class UPCGGraphInstance : public [UPCGGraphInterface](API\Plugins\PCG\UPCGGraphInterface)

Graph

type: TObjectPtr<UPC...

ParametersOverrides

type: FPCGOverrideIns...


description: Return the underlying PCGGraph for this interface.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Graph) const [UPCGGraph](API\Plugins\PCG\UPCGGraph) * GetConstPCGGraph() const


code: virtual [UPCGGraph](API\Plugins\PCG\UPCGGraph) * GetGraph()


code: virtual const [UPCGGraph](API\Plugins\PCG\UPCGGraph) * GetGraph() const


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Graph) [UPCGGraph](API\Plugins\PCG\UPCGGraph) * GetMutablePCGGraph()


code: virtual const [FInstancedPropertyBag](API\Plugins\StructUtils\FInstancedPropertyBag) * GetUserParametersStruct() const


description: A graph interface is equivalent to another graph interface if they are the same (same ptr), or if they have the same graph. Will be overridden when graph instance supports overrides.

code: virtual bool IsEquivalent ( const [UPCGGraphInterface](API\Plugins\PCG\UPCGGraphInterface) * Other ) const


className: UPCGGraphInterface

code: [UCLASS](Programming/UnrealArchitecture/Reference/Classes#classdeclaration)(Abstract) class UPCGGraphInterface : public [UObject](API\Runtime\CoreUObject\UObject\UObject)

OnGraphChangedDelegate

type: FOnPCGGraphChan...

OnGraphDynamicallyExecutedDelegate

type: FOnPCGGraphDyna...

OnGraphGridSizesChangedDelegate

type: FOnPCGGraphGrid...

OnGraphParametersChangedDelegate

type: FOnPCGGraphPara...


description: Ensure may fire if multiple executions of the graph are happening in parallel/overlapping.

code: virtual void MarkAsReused()


description: Move the given resource to a new actor. Return true if it has succeeded

code: virtual bool MoveResourceToNewActor ( [AActor](API\Runtime\Engine\GameFramework\AActor) * NewActor )


description: Called when after a PCG component is applied to (such as after a RerunConstructionScript)

code: virtual void PostApplyToComponent()


description: Called after importing property values for this object (paste, duplicate or .t3d import) Allow the object to perform any cleanup for properties which shouldn't be duplicated or are unsupported by the script serialization

code: virtual void PostEditImport()


description: Releases/Mark Unsued the resource depending on the bHardRelease flag. Returns true if resource can be removed from the PCG component

code: virtual bool Release ( bool bHardRelease, [TSet](API\Runtime\Core\Containers\TSet)< [TSoftObjectPtr](API\Runtime\CoreUObject\UObject\TSoftObjectPtr)< [AActor](API\Runtime\Engine\GameFramework\AActor) >> & OutActorsToDelete )


description: Releases resource if empty or unused. Returns true if the resource can be removed from the PCG component

code: virtual bool ReleaseIfUnused ( [TSet](API\Runtime\Core\Containers\TSet)< [TSoftObjectPtr](API\Runtime\CoreUObject\UObject\TSoftObjectPtr)< [AActor](API\Runtime\Engine\GameFramework\AActor) >> & OutActorsToDelete )


className: UPCGManagedActors

code: [UCLASS](Programming/UnrealArchitecture/Reference/Classes#classdeclaration)(BlueprintType) class UPCGManagedActors : public [UPCGManagedResource](API\Plugins\PCG\UPCGManagedResource)

GeneratedActors

type: TSet<TSoftObje...


code: virtual bool MoveResourceToNewActor ( [AActor](API\Runtime\Engine\GameFramework\AActor) * NewActor, const [AActor](API\Runtime\Engine\GameFramework\AActor) * ExpectedPreviousOwner )


code: virtual bool SupportsComponentReset() const


className: UPCGManagedComponent

code: [UCLASS](Programming/UnrealArchitecture/Reference/Classes#classdeclaration)(BlueprintType) class UPCGManagedComponent : public [UPCGManagedResource](API\Plugins\PCG\UPCGManagedResource)

GeneratedComponent

type: TSoftObjectPtr<...


code: [UInstancedStaticMeshComponent](API\Runtime\Engine\Components\UInstancedStaticMeshComponent) * GetComponent() const


code: const [FISMComponentDescriptor](API\Runtime\Engine\ISMPartition\FISMComponentDescriptor) & GetDescriptor() const


code: virtual void PostLoad()


code: void SetComponent ( [UInstancedStaticMeshComponent](API\Runtime\Engine\Components\UInstancedStaticMeshComponent) * InComponent )


code: void SetDescriptor ( const [FISMComponentDescriptor](API\Runtime\Engine\ISMPartition\FISMComponentDescriptor) & InDescriptor )


code: void SetRootLocation ( const FVector & InRootLocation )


code: void SetSettingsUID ( uint64 InSettingsUID )


className: UPCGManagedISMComponent

code: [UCLASS](Programming/UnrealArchitecture/Reference/Classes#classdeclaration)(BlueprintType) class UPCGManagedISMComponent : public [UPCGManagedComponent](API\Plugins\PCG\UPCGManagedComponent)

CachedRawComponentPtr

type: UInstancedStati...

description: Cached raw pointer to ISM component.

Descriptor

type: FISMComponentDe...

RootLocation

type: FVector


code: const [FPCGCrc](API\Plugins\PCG\FPCGCrc) & GetCrc() const


code: virtual void MarkAsReused()


code: virtual bool MoveResourceToNewActor ( [AActor](API\Runtime\Engine\GameFramework\AActor) * NewActor )


code: virtual void PostApplyToComponent()


code: virtual bool Release ( bool bHardRelease, [TSet](API\Runtime\Core\Containers\TSet)< [TSoftObjectPtr](API\Runtime\CoreUObject\UObject\TSoftObjectPtr)< [AActor](API\Runtime\Engine\GameFramework\AActor) >> & OutActorsToDelete )


code: virtual bool ReleaseIfUnused ( [TSet](API\Runtime\Core\Containers\TSet)< [TSoftObjectPtr](API\Runtime\CoreUObject\UObject\TSoftObjectPtr)< [AActor](API\Runtime\Engine\GameFramework\AActor) >> & OutActorsToDelete )


code: void SetCrc ( const [FPCGCrc](API\Plugins\PCG\FPCGCrc) & InCrc )


className: UPCGManagedResource

description: This class is used to hold resources and their mechanism to delete them on demand. In order to allow for some reuse (e.g. components), the Release call supports a "soft" release by marking them unused in order to be potentially re-used down the line. At the end of the generate, a call to ReleaseIfUnused will serve to finally cleanup what is not needed anymore.

code: [UCLASS](Programming/UnrealArchitecture/Reference/Classes#classdeclaration)(BlueprintType) class UPCGManagedResource : public [UObject](API\Runtime\CoreUObject\UObject\UObject)

Crc

type: FPCGCrc


description: Adds an edge in the owning graph to the given "To" node.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Node) [UPCGNode](API\Plugins\PCG\UPCGNode) * AddEdgeTo ( [FName](API\Runtime\Core\UObject\FName) FromPinLabel, [UPCGNode](API\Plugins\PCG\UPCGNode) * To, [FName](API\Runtime\Core\UObject\FName) ToPinLabel )


description: Used to be able to force deprecation when things need to be deprecated at the graph level.

code: void ApplyDeprecation()


description: ~EndUObjectinterface UpdatePins will kick off invalid edges, so this is useful for making pin changes graceful.

code: void ApplyDeprecationBeforeUpdatePins()


description: If a node does require structural changes, this will apply them


description: Called before destroying the object. This is called immediately upon deciding to destroy the object, to allow the object to begin an asynchronous cleanup process.

code: virtual void BeginDestroy()


description: When we create a new graph, we initialize the input/output nodes as default, with default pins. Those default pins are not serialized, therefore if we change the default pins, combined with the use of recycling objects in Unreal, can lead to pins that are garbage or even worse: valid pins but not the right one, potentially making the edges connecting wrong pins together! That is why we have a specific function to create default pins, and we have to make sure that those default pins are always created the same way.

code: void CreateDefaultPins ( [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< [UPCGPin](API\Plugins\PCG\UPCGPin) *([UPCGNode](API\Plugins\PCG\UPCGNode) *)> PinAllocator )


description: Returns the first connected pin on the node

code: const [UPCGPin](API\Plugins\PCG\UPCGPin) * GetFirstConnectedInputPin() const


description: Returns the owning graph

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Node) [UPCGGraph](API\Plugins\PCG\UPCGGraph) * GetGraph() const


code: [UPCGPin](API\Plugins\PCG\UPCGPin) * GetInputPin ( const [FName](API\Runtime\Core\UObject\FName) & Label )


code: const [UPCGPin](API\Plugins\PCG\UPCGPin) * GetInputPin ( const [FName](API\Runtime\Core\UObject\FName) & Label ) const


code: const [TArray](API\Runtime\Core\Containers\TArray)< [TObjectPtr](API\Runtime\Core\Delegates\TObjectPtr)< [UPCGPin](API\Plugins\PCG\UPCGPin) > > & GetInputPins() const


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Node) void GetNodePosition ( int32 & OutPositionX, int32 & OutPositionY ) const


description: Returns the node title, based either on the current node label, or defaulted to its settings


description: Tooltip that describes node functionality and other information.


code: [UPCGPin](API\Plugins\PCG\UPCGPin) * GetOutputPin ( const [FName](API\Runtime\Core\UObject\FName) & Label )


code: const [UPCGPin](API\Plugins\PCG\UPCGPin) * GetOutputPin ( const [FName](API\Runtime\Core\UObject\FName) & Label ) const


code: const [TArray](API\Runtime\Core\Containers\TArray)< [TObjectPtr](API\Runtime\Core\Delegates\TObjectPtr)< [UPCGPin](API\Plugins\PCG\UPCGPin) > > & GetOutputPins() const


description: Pin from which data is passed through when this node is disabled.

code: virtual const [UPCGPin](API\Plugins\PCG\UPCGPin) * GetPassThroughInputPin() const


description: Pin to which data is passed through when this node is disabled.

code: virtual const [UPCGPin](API\Plugins\PCG\UPCGPin) * GetPassThroughOutputPin() const


description: Returns the settings this node holds (either directly or through an instance)

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Node) [UPCGSettings](API\Plugins\PCG\UPCGSettings) * GetSettings() const


description: Returns the settings interface (settings or instance of settings) on this node

code: [UPCGSettingsInterface](API\Plugins\PCG\UPCGSettingsInterface) * GetSettingsInterface() const


description: Returns all the input pin properties

code: [TArray](API\Runtime\Core\Containers\TArray)< [FPCGPinProperties](API\Plugins\PCG\FPCGPinProperties) > InputPinProperties() const


description: True if the edge is being used by the node. UI will gray out unused pins.

code: virtual bool IsEdgeUsedByNodeExecution ( const [UPCGEdge](API\Plugins\PCG\UPCGEdge) * InEdge ) const


description: Returns true if the input pin is connected

code: bool IsInputPinConnected ( const [FName](API\Runtime\Core\UObject\FName) & Label ) const


description: Returns true if the node has an instance of the settings (e.g. does not own the settings)

code: bool IsInstance() const


description: Returns true if the output pin is connected

code: bool IsOutputPinConnected ( const [FName](API\Runtime\Core\UObject\FName) & Label ) const


description: True if the pin is being used by the node. UI will gray out unused pins.

code: virtual bool IsPinUsedByNodeExecution ( const [UPCGPin](API\Plugins\PCG\UPCGPin) * InPin ) const


description: Returns all the output pin properties

code: [TArray](API\Runtime\Core\Containers\TArray)< [FPCGPinProperties](API\Plugins\PCG\FPCGPinProperties) > OutputPinProperties() const


code: void OnSettingsChanged ( [UPCGSettings](API\Plugins\PCG\UPCGSettings) * InSettings, [EPCGChangeType](API\Plugins\PCG\EPCGChangeType) ChangeType )


description: Called when a property on this object has been modified externally

code: virtual void PostEditChangeProperty ( struct [FPropertyChangedEvent](API\Runtime\CoreUObject\UObject\FPropertyChangedEvent) & PropertyChangedEvent )


description: Called after importing property values for this object (paste, duplicate or .t3d import) Allow the object to perform any cleanup for properties which shouldn't be duplicated or are unsupported by the script serialization

code: virtual void PostEditImport()


description: Called after applying a transaction to the object. Default implementation simply calls PostEditChange.

code: virtual void PostEditUndo()


description: ~BeginUObjectinterface

code: virtual void PostLoad()


description: Called before applying a transaction to the object. Default implementation simply calls PreEditChange.

code: virtual void PreEditUndo()


description: Recursively follow downstream edges and call UpdatePins on each node that has dynamic pins.

code: [EPCGChangeType](API\Plugins\PCG\EPCGChangeType) PropagateDynamicPinTypes ( const [UPCGNode](API\Plugins\PCG\UPCGNode) * FromNode )


description: Removes an edge originating from this node

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Node) bool RemoveEdgeTo ( [FName](API\Runtime\Core\UObject\FName) FromPinLable, [UPCGNode](API\Plugins\PCG\UPCGNode) * To, [FName](API\Runtime\Core\UObject\FName) ToPinLabel )


description: Allow to change the name of a pin, to keep edges connected. You need to make sure that the underlying settings are also updated, otherwise, it will be overwritten next time the settings are updated

code: void RenameInputPin ( const [FName](API\Runtime\Core\UObject\FName) & InOldLabel, const [FName](API\Runtime\Core\UObject\FName) & InNewLabel, bool bInBroadcastUpdate )


code: void RenameOutputPin ( const [FName](API\Runtime\Core\UObject\FName) & InOldLabel, const [FName](API\Runtime\Core\UObject\FName) & InNewLabel, bool bInBroadcastUpdate )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Node) void SetNodePosition ( int32 InPositionX, int32 InPositionY )


description: Changes the default settings in the node

code: void SetSettingsInterface ( [UPCGSettingsInterface](API\Plugins\PCG\UPCGSettingsInterface) * InSettingsInterface, bool bUpdatePins )


description: Transfer all editor only properties to the other node

code: void TransferEditorProperties ( [UPCGNode](API\Plugins\PCG\UPCGNode) * OtherNode ) const


description: Triggers some uppdates after creating a new node and changing its settings


description: Updates pins based on node settings. Attempts to migrate pins via matching. Broadcasts node change events for affected nodes.


description: Updates pins based on node settings PinAllocator creates new pin objects. Attempts to migrate pins via matching. Broadcasts node change events for affected nodes.

code: [EPCGChangeType](API\Plugins\PCG\EPCGChangeType) UpdatePins ( [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< [UPCGPin](API\Plugins\PCG\UPCGPin) *([UPCGNode](API\Plugins\PCG\UPCGNode) *)> PinAllocator )


code: UPCGNode ( const [FObjectInitializer](API\Runtime\CoreUObject\UObject\FObjectInitializer) & ObjectInitializer )


className: UPCGNode

code: [UCLASS](Programming/UnrealArchitecture/Reference/Classes#classdeclaration)(ClassGroup=(Procedural)) class UPCGNode : public [UObject](API\Runtime\CoreUObject\UObject\UObject)

bCommentBubblePinned

type: uint8:  1

InputPins

type: TArray<TObject...

NodeComment

type: FString

NodeTitleColor

type: FLinearColor

OnNodeChangedDelegate

type: FOnPCGNodeChang...

SettingsInterface

description: Note: do not set this property directly from code, use SetSettingsInterface instead


description: Adds this data to Crc. Fallback implementation writes object instance UID.

code: virtual void AddToCrc ( [FArchiveCrc32](API\Runtime\CoreUObject\Serialization\FArchiveCrc32) & Ar, bool bFullDataCrc ) const


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Metadata) const [UPCGMetadata](API\Plugins\PCG\Metadata\UPCGMetadata) * ConstMetadata() const


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Params) [UPCGParamData](API\Plugins\PCG\UPCGParamData) * FilterParamsByKey ( int64 InKey ) const


description: Creates a new params that keeps only a given key/name

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Params) [UPCGParamData](API\Plugins\PCG\UPCGParamData) * FilterParamsByName ( const [FName](API\Runtime\Core\UObject\FName) & InName ) const


description: Returns the entry for the given name

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Params) int64 FindMetadataKey ( const [FName](API\Runtime\Core\UObject\FName) & InName ) const


description: Creates an entry for the given name, if not already added

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Params) int64 FindOrAddMetadataKey ( const [FName](API\Runtime\Core\UObject\FName) & InName )


code: virtual [EPCGDataType](API\Plugins\PCG\EPCGDataType) GetDataType() const


code: virtual bool HasCachedLastSelector() const


code: virtual void SetLastSelector ( const [FPCGAttributePropertySelector](API\Plugins\PCG\Metadata\FPCGAttributePropertySelector) & InSelector )


code: UPCGParamData ( const [FObjectInitializer](API\Runtime\CoreUObject\UObject\FObjectInitializer) & ObjectInitializer )


className: UPCGParamData

description: Class to hold execution parameters that will be consumed in nodes of the graph

code: [UCLASS](Programming/UnrealArchitecture/Reference/Classes#classdeclaration)(BlueprintType, ClassGroup=(Procedural), DisplayName="Attribute Set") class UPCGParamData : public [UPCGData](API\Plugins\PCG\UPCGData)

Metadata

type: TObjectPtr<UPC...

description: Not accessible through blueprint to make sure the constness is preserved.

NameMap

type: TMap<FName, in...


description: Adds edge to pin if edge does not exist. Optionally returns list of affected nodes (including the pin owner).

code: bool AddEdgeTo ( [UPCGPin](API\Plugins\PCG\UPCGPin) * OtherPin, [TSet](API\Runtime\Core\Containers\TSet)< [UPCGNode](API\Plugins\PCG\UPCGNode) * > * InTouchedNodes )


code: bool AllowMultipleConnections() const


description: Breaks all connected edges. Optionally returns list of affected nodes (including the pin owner).

code: bool BreakAllEdges ( [TSet](API\Runtime\Core\Containers\TSet)< [UPCGNode](API\Plugins\PCG\UPCGNode) * > * InTouchedNodes )


description: Break all edges the connect pins of invalid type. Optionally returns list of affected nodes (including the pin owner).

code: bool BreakAllIncompatibleEdges ( [TSet](API\Runtime\Core\Containers\TSet)< [UPCGNode](API\Plugins\PCG\UPCGNode) * > * InTouchedNodes )


description: Breaks edge to pin if edge exists. Optionally returns list of affected nodes (including the pin owner).

code: bool BreakEdgeTo ( [UPCGPin](API\Plugins\PCG\UPCGPin) * OtherPin, [TSet](API\Runtime\Core\Containers\TSet)< [UPCGNode](API\Plugins\PCG\UPCGNode) * > * InTouchedNodes )


code: bool CanConnect ( const [UPCGPin](API\Plugins\PCG\UPCGPin) * OtherPin ) const


description: Returns the current pin types, which can either be the static types from the pin properties, or a dynamic type based on connected edges.


code: [EPCGTypeConversion](API\Plugins\PCG\EPCGTypeConversion) GetRequiredTypeConversion ( const [UPCGPin](API\Plugins\PCG\UPCGPin) * InOtherPin ) const


code: bool IsCompatible ( const [UPCGPin](API\Plugins\PCG\UPCGPin) * OtherPin ) const


description: Do any object-specific cleanup required immediately after loading an object. This is not called for newly-created objects, and by default will always execute on the game thread.

code: virtual void PostLoad()