#include <ComposableCameraParameterBlock.h>

Container for parameter values passed by callers when activating a camera from a type asset.

The K2Node fills this automatically from its dynamic pins. C++ callers fill it manually. DataTable callers fill it by parsing row data.

Public Attributes¶

Values¶

TMap< FName, FComposableCameraParameterValue > Values

Type-erased parameter storage, keyed by parameter name. POD-only — delegates are stored in DelegateValues instead.

ActorValues¶

TMap< FName, TObjectPtr< AActor > > ActorValues

GC-visible owners for object-valued entries mirrored in Values.

ObjectValues¶

TMap< FName, TObjectPtr< UObject > > ObjectValues

GC-visible owners for object-valued entries mirrored in Values.

DelegateValues¶

TMap< FName, FScriptDelegate > DelegateValues

Parallel storage for single-cast delegate bindings. Delegates are not POD and cannot be stored in the byte-array-based FComposableCameraParameterValue. They are applied at activation time via ApplyDelegateBindings (on the type asset), which writes them into the target node's FDelegateProperty UPROPERTY via reflection.

StructValues¶

TMap< FName, FInstancedStruct > StructValues

Parallel storage for non-POD struct values (USTRUCTs containing FString / FText / TArray / object refs / delegates – anything IsBytewiseSafeStruct rejects). The byte-array Values map cannot transport these because raw memcpy aliases heap-owned storage and makes the GC blind to embedded references; FInstancedStruct owns its memory, runs proper constructors / destructors, and surfaces UObject references via AddStructReferencedObjects. POD struct values (FVector / FRotator / FTransform / etc.) still go through the byte-array Values map – they're memcpy-safe and the existing offset tables in RuntimeDataBlock are tighter.

Public Methods¶

Reserve¶

inline

inline void Reserve(int32 Num)

StoreValue¶

inline

inline void StoreValue(FName Name, FComposableCameraParameterValue && Entry)

SetStruct¶

inline

inline void SetStruct(FName Name, const UScriptStruct * Struct, const void * Memory)

Set a non-POD struct parameter. The struct is copied into a fresh FInstancedStruct via InitializeAs(StructType, Memory), which runs the proper per-property copy (FString operator=, TArray copy, UObject ptr etc.) and owns the result for the lifetime of this map entry. The parallel Values / ActorValues / ObjectValues / DelegateValues entries under the same Name are cleared so a subsequent Get-by-name cannot read a stale POD-shaped entry for what is now a struct value.

AddReferencedObjects¶

void AddReferencedObjects(FReferenceCollector & Collector)

SetBool¶

inline

inline void SetBool(FName Name, bool Value)

Set a bool parameter.

SetInt32¶

inline

inline void SetInt32(FName Name, int32 Value)

Set an int32 parameter.

SetFloat¶

inline

inline void SetFloat(FName Name, float Value)

Set a float parameter.

SetDouble¶

inline

inline void SetDouble(FName Name, double Value)

Set a double parameter.

SetVector¶

inline

inline void SetVector(FName Name, const FVector & Value)

Set a Vector parameter.

SetRotator¶

inline

inline void SetRotator(FName Name, const FRotator & Value)

Set a Rotator parameter.

SetTransform¶

inline

inline void SetTransform(FName Name, const FTransform & Value)

Set a Transform parameter.

SetActor¶

inline

inline void SetActor(FName Name, AActor * Value)

Set an Actor pointer parameter.

SetObject¶

inline

inline void SetObject(FName Name, UObject * Value)

Set a UObject pointer parameter.

SetName¶

inline

inline void SetName(FName Name, FName Value)

Set an FName parameter. FName is POD (NAME_INDEX + NAME_NUMBER, 8 bytes) and is memcpy-safe in the type-erased data storage.

SetEnum¶

inline

inline void SetEnum(FName Name, int64 Value)

Set an enum parameter. Enums are always normalized to int64 in the data storage, regardless of the backing property's actual underlying width. The narrow-cast into the final storage happens at resolve time, where the owning FProperty is known (see WriteEnumInt64ToProperty).

SetDelegate¶

inline

inline void SetDelegate(FName Name, const FScriptDelegate & Value)

Set a single-cast delegate binding. The delegate is stored in a parallel map (not the POD byte array) and applied at activation time via ApplyDelegateBindings on the type asset.

HasValue¶

const inline

inline bool HasValue(FName Name) const

Check if a parameter exists by name (POD / actor / object / struct / delegate).

Get¶

const inline

template<typename T> inline bool Get(FName Name, T & OutValue) const

Try to get a typed value. Returns false if not found or type mismatch.

CopyRawTo¶

const inline

inline int32 CopyRawTo(FName Name, uint8 * Dest, int32 DestSize) const

Copy a parameter's raw bytes into a destination buffer. Returns the number of bytes copied, or 0 if not found.

Public Static Methods¶

ApplyStringValue¶

static

static bool ApplyStringValue(FComposableCameraParameterBlock & OutBlock, FName ParameterName, EComposableCameraPinType PinType, UScriptStruct * StructType, UEnum * EnumType, const FString & ValueString, FString * OutError)

Parse a serialized string into a typed entry and store it under ParameterName.

This is the single string→typed-value entry point shared by the DataTable activation path and the DataTable row property-type customization. The two sides must round-trip through the same parser so that anything you can type in the editor is accepted identically at runtime.

Supported types: Bool, Int32, Float, Double — LexFromString Vector2D/3D/4, Rotator, Transform — ImportText on the matching core struct Struct — ImportText on the provided StructType Object — resolved via FSoftObjectPath and sync-loaded Name — FName::FromString (no Unicode canonicalization) Enum — UEnum::GetValueByNameString, stored as int64

Unsupported (returns false, writes OutError): Actor — actors are world-scoped and cannot be resolved from a DataTable asset. Use Object with a soft path to a CDO/archetype instead if you need a class reference.

Parameters

• OutBlock Parameter block to write into.

• ParameterName Key the entry is stored under in OutBlock.Values.

• PinType Target pin type — dispatches the parse branch.

• StructType Only read when PinType == Struct; ignored otherwise.

• EnumType Only read when PinType == Enum; ignored otherwise. Used to parse the display / authored name back to an int64 value (UEnum::GetValueByNameString).

• ValueString The serialized value. Empty input is treated as a parse failure so callers can decide whether to fall back to the node pin's authored default.

• OutError Optional human-readable error written on failure.

Returns

true on success, false otherwise. On failure the OutBlock is left untouched for this key.