PCG

Create a new empty PCG Graph asset

Creates a new UPCGGraph at the given content path. Uses UPCGGraphFactory with bSkipTemplateSelection=true to avoid the template picker dialog. Pass force=true to overwrite an existing asset at the same path.

cfa create_pcg_graph --asset-path /Game/PCG/PCG_Forest

Create a PCG Graph Instance bound to a parent graph

Creates a UPCGGraphInstance whose ParentGraph is set to the given source graph. The instance inherits the parent's nodes and exposes its UserParameters as overridable values via ParametersOverrides.

cfa create_pcg_graph_instance --parent-graph-path /Game/PCG/PCG_Forest --asset-path /Game/PCG/PCG_Forest_Inst

Create a new PCG Builder Settings asset

Creates a UPCGBuilderSettings asset used to configure how PCG components build their output (e.g. partitioning, runtime generation). Empty settings on creation; modify via set_object_property afterward.

cfa create_pcg_builder_settings --asset-path /Game/PCG/BS_Default

Create a new PCG Compute Source asset

Creates a UPCGComputeSource asset, an HLSL source bundle consumed by PCG compute graph nodes. Empty source on creation; edit via set_pcg_compute_source afterward.

cfa create_pcg_compute_source --asset-path /Game/PCG/CS_NoiseField

Read the HLSL source and AdditionalSources of a PCG Compute Source asset

Loads a UPCGComputeSource and returns its Source FString plus the AdditionalSources array (each entry: index, path, name). Use this to inspect or copy shader text.

cfa get_pcg_compute_source --asset-path /Game/PCG/CS_NoiseField

Write the HLSL source text on a PCG Compute Source asset

Replaces the Source FString on a UPCGComputeSource asset. Saves the asset on success. Sets the value reflectively via FStrProperty (no engine SetSource link dependency).

cfa set_pcg_compute_source --asset-path /Game/PCG/CS_NoiseField --source "float Noise() { return 0.0; }"

Append a UComputeSource to a PCG Compute Source's AdditionalSources

Adds an entry to the inherited AdditionalSources TArray on a UPCGComputeSource. Idempotent, returns already_present=true if the entry is already in the array.

cfa add_pcg_compute_source_additional --asset-path /Game/PCG/CS_Main --additional-source-path /Game/PCG/CS_Helpers

Remove an entry from a PCG Compute Source's AdditionalSources

Removes by index, or by additional_source_path if index is omitted/negative. Returns the index that was removed.

cfa remove_pcg_compute_source_additional --asset-path /Game/PCG/CS_Main --index 0
cfa remove_pcg_compute_source_additional --asset-path /Game/PCG/CS_Main --additional-source-path /Game/PCG/CS_Helpers

List all UPCGComputeSource assets via Asset Registry

Asset Registry query for UPCGComputeSource assets. Returns asset_path, asset_name, package_path. Optionally scope by package path and substring filter.

cfa list_pcg_compute_sources
cfa list_pcg_compute_sources --path /Game/PCG --filter Noise

List EPCGKernelType enum values for the Custom HLSL node

Enumerates EPCGKernelType (Custom, PointProcessor, PointGenerator, TextureProcessor, TextureGenerator, AttributeSetProcessor) with display names and tooltips. Use the returned 'name' values when assigning the KernelType property on a Custom HLSL node.

cfa list_pcg_kernel_types

List PCG Graph assets marked as templates

Scans the Asset Registry for UPCGGraph assets with bIsTemplate=true. Filters tag-only so no assets are loaded. Returns name, path, category, and description for each template.

cfa list_pcg_templates
cfa list_pcg_templates --filter Forest --category Vegetation

Create a new PCG Graph by duplicating a template

Duplicates a template UPCGGraph into a new asset using UPCGGraphFactory's TemplateGraph path (StaticDuplicateObject). Clears bIsTemplate on the resulting asset so it functions as a regular graph. Use list_pcg_templates to discover candidates.

cfa create_pcg_graph_from_template --template-path /PCG/Templates/Forest --asset-path /Game/PCG/PCG_MyForest

Search PCG node types (UPCGSettings subclasses) by name or category

Iterates exposed UPCGSettings classes (bExposeToLibrary, non-abstract) and returns node metadata (title, class path, category, type, description, has_preconfigured_variants). Requires at least one of filter or category to avoid flooding results.

cfa search_pcg_nodes --filter Sampler
cfa search_pcg_nodes --category Metadata

List EPCGSettingsType category values for search_pcg_nodes

Enumerates all values of the EPCGSettingsType enum (Spatial, Sampler, Metadata, etc.).

cfa list_pcg_node_categories

List PCG nodes with advanced or preconfigured-only behavior

Returns nodes that have at least one Advanced pin or whose CDO returns OnlyExposePreconfiguredSettings()=true. Useful for discovering hidden nodes.

cfa list_pcg_advanced_nodes --filter Math

List preconfigured variants for a PCG settings class

Returns the GetPreconfiguredInfo() array for a given UPCGSettings subclass, each entry is a preconfigured variant (label, tooltip, preconfigured_index) sharing the same UClass.

cfa list_pcg_node_preconfigured_variants --class-path /Script/PCG.PCGAttributeRemapSettings

Get full schema for a PCG node type

Returns title, category, type, description, dynamic-input flag, full input/output pin schema (label, allowed_types, usage, status, multiple, invisible, tooltip), exposed properties (with PCG_Overridable flag and enum values), and preconfigured variants.

cfa get_pcg_node_type_info --class-path /Script/PCG.PCGAttributeFilterSettings

Get valid values for a PCG settings property (enums, attribute pickers, extractors)

Returns the values selectable for a PCG settings property. Response 'kind' field: 'enum' (UEnumProperty/FByteProperty entries), 'attribute_input_selector' / 'attribute_output_selector' (FPCGAttributePropertySelector pickers, values[] includes @Last, @Source/@LastCreated for output, plus $Density, $Position, $Rotation, $Scale, $Transform, $BoundsMin, $BoundsMax, $Color, $Seed, $Index etc.; extractors[] lists per-type suffix groups like Vector→X/Y/Z/Length, Rotator→Roll/Pitch/Yaw/Up/Forward/Right, Transform→Location/Rotation/Scale, chain with '.': '$Rotation.Up', '$Position.X'), 'attribute_preset' (legacy FName), or 'non_enumerable'. Call BEFORE writing attribute-selector values to avoid garbage strings.

cfa get_pcg_property_valid_values --class-path /Script/PCG.PCGAttributeFilterSettings --property-path Operator

Read a PCG graph at a chosen verbosity

Reads a UPCGGraph and returns its node list. Verbosity controls payload size: 'summary' (index/name/title/type/position only), 'connections' (adds per-pin link details), 'full' (adds per-node properties with PCG_Overridable flag and graph parameters). Optional filter narrows nodes by title/class/name substring.

cfa read_pcg_graph --graph-path /Game/PCG/PCG_Forest --verbosity connections

Get full info on one PCG node

Returns pins, per-pin connections, properties (with values from the settings instance), and subgraph info if the node is a subgraph node.

cfa get_pcg_node --graph-path /Game/PCG/PCG_Forest --node-index 3

Get pin-by-pin connections for one node

Returns input_pins / output_pins arrays where each pin has its connections list with from_index/to_index and from_pin/to_pin labels.

cfa get_pcg_node_connections --graph-path /Game/PCG/PCG_Forest --node-index 3

Trace reachable nodes from a starting node

BFS traversal up to max_depth, cycle-safe. Direction selects upstream, downstream, or both. Returns visited nodes with depth and parent_index.

cfa trace_pcg_connection --graph-path /Game/PCG/PCG_Forest --node-index 0 --direction downstream --max-depth 5

Enumerate UserParameters on a PCG graph

Lists graph-level user parameters (FInstancedPropertyBag) with name, type, default_value, and description for each entry.

cfa get_pcg_graph_parameters --graph-path /Game/PCG/PCG_Forest

List editable UPROPERTYs on the UPCGGraph asset

Returns the graph's editable properties (name, type, category, current value) for discovering version-specific graph-setting names (e.g. the HiGen multiplier differs across 5.6/5.7/5.8) before calling set_pcg_graph_property. Distinct from graph USER parameters.

cfa get_pcg_graph_properties --graph-path /Game/PCG/PCG_Forest --filter HiGen

Set a graph-level UPROPERTY on the UPCGGraph (HiGen, landscape, cosmetic)

Sets a property on the UPCGGraph asset (e.g. bUseHierarchicalGeneration, HiGenGridSize, bUse2DGrid) and fires the graph's real PostEditChangeChainProperty, so grid linkage / compilation rebuilds and open editors refresh, exactly like editing Graph Settings by hand (raw set_asset_property skips this). Some names differ by engine version; use get_pcg_graph_properties to discover. Not a graph USER parameter.

cfa set_pcg_graph_property --graph-path /Game/PCG/PCG_Forest --property-name bUseHierarchicalGeneration --property-value true

Add a node to a PCG graph

Creates a new UPCGSettings instance via NewObject and registers it with the graph via AddNode.

cfa add_pcg_node --graph-path /Game/PCG/PCG_Forest --settings-class PCGAttributeFilterSettings

Delete a node from a PCG graph

Delete a node identified by stable name (node_name, preferred, survives deletes) OR by index (node_index, legacy).

Connect two PCG pins (add edge)

Connect a source node's output pin to a destination node's input pin. Identify each node by stable name (from_node_name / to_node_name, preferred, survives deletes) OR by index (from_node_index / to_node_index, legacy, shifts when nodes are deleted).

Atomically build a PCG graph (nodes + edges + auto-layout) in one call

Creates multiple nodes and edges in a single transaction with one save and one editor refresh, then auto-lays-out (topological columns) unless node x/y are supplied. More robust and token-efficient than add_pcg_node + connect_pcg_pins per element (no index-shift corruption, no half-built graph on failure). nodes: [{id, settings_class, params?(object), x?, y?, comment?}]; edges: [{from(id), from_pin, to(id), to_pin}]. Returns each node's stable name + index.

cfa build_pcg_graph --json '{"graph_path":"/Game/PCG/PCG_X","nodes":[{"id":"a","settings_class":"PCGSurfaceSamplerSettings"},{"id":"b","settings_class":"PCGStaticMeshSpawnerSettings"}],"edges":[{"from":"a","from_pin":"Out","to":"b","to_pin":"In"}]}'

Remove all edges from one pin

Remove a specific edge

Set a property on a node's UPCGSettings

Uses ImportText_Direct on the live settings UObject. Supports any UPROPERTY exportable type.

Move a node

Set a node's comment string

Add a dynamic input pin

Calls UPCGSettingsWithDynamicInputs::OnUserAddDynamicInputPin on the node.

Remove a dynamic input pin

Add a graph-level user parameter

Type ∈ bool|int|float|double|name|string|text|enum:<EnumPath>|object:<ClassPath>|struct:<StructPath>|soft_object:<ClassPath>

Remove a graph parameter

Rename a graph parameter

Set a graph parameter's default value

Change a graph parameter's type

May invalidate existing connections inside the graph; engine handles cleanup.

Re-target a subgraph node

Calls UPCGSubgraphSettings::SetSubgraph to repoint the SubgraphInstance at a new UPCGGraphInterface.

List subgraph parameter overrides

Override a subgraph parameter

Reset a subgraph parameter to default

Validate a PCG graph

Primes the graph compilation cache and returns graph-structure findings (unconnected required pins, dangling edges).

Read cached graph validation findings

Auto-layout the graph

Modes: auto (topological lanes), grid (NxN), compact.

Attach a comment to the graph

Editor-graph comment boxes are editor-only; this binds the comment to the input node as a fallback.

Generate() all components bound to a graph

CancelGeneration() on all components

Toggle UPCGComponent::bActivated for a graph

Set a nested PCG node property via dotted path with [N] indexers

Auto-creates null instanced UObject sub-properties along the path. Supports struct fields, array indices, and FObjectProperty deref.

cfa set_pcg_node_property_path --graph-path /Game/PCG/PCG_Forest --node-index 2 \
  --property-path "MeshSelectorParameters.MeshEntries[0].Descriptor.StaticMesh" \
  --property-value '"/Game/Meshes/SM_Tree.SM_Tree"'

Read a nested PCG node property value

Discover nested property paths on a PCG node

Walks reflected properties recursively. Requires 'filter' or 'root_path' to keep responses small.

Append or insert an element into a PCG node TArray property

Remove an element from a PCG node TArray property

Replace an instanced FObjectProperty with a NewObject of a specified class

When the property has a sibling '<Name>Type' TSubclassOf property (PCG MeshSelectorType convention), it is mirrored automatically.

Switch a Custom HLSL node's kernel type (mirrors the engine's SetKernelType)

Sets KernelType on a UPCGCustomHLSLSettings node and, for generator kernels, clears the required input pins (a no-input generator with a dangling required pin is silently culled by the GPU compiler). Use this instead of set_pcg_node_property KernelType, which leaves pins inconsistent. Processors keep their input pin (feed it a point source).

cfa set_pcg_custom_hlsl_kernel_type --graph-path /Game/PCG/PCG_X --node-name CustomHLSL_0 --kernel-type PointGenerator

Set a Static Mesh Spawner's weighted mesh list in one call

Ensures the node uses a Weighted mesh selector, clears existing entries, and adds one weighted entry per mesh path, replacing the verbose set_pcg_node_property_class -> add_array_element -> set_path sequence. Fires the faithful notify so entry display names and the selector refresh like a hand edit.

cfa set_pcg_static_mesh_spawner_meshes --graph-path /Game/PCG/PCG_X --node-name StaticMeshSpawner_0 --meshes '["/Game/Meshes/SM_Tree_A_01.SM_Tree_A_01","/Game/Meshes/SM_Tree_A_02.SM_Tree_A_02"]'

Call UPCGComponent::Generate on the named actor

Wraps UPCGComponent::Generate(bForce). Triggers a delayed generation. NetMulticast Reliable on UE 5.8.

cfa pcg_generate_component --actor-label PCG_Forest_01 --force

Call UPCGComponent::Cleanup on the named actor

Wraps UPCGComponent::Cleanup(bRemoveComponents).

cfa pcg_cleanup_component --actor-label PCG_Forest_01

Call UPCGComponent::GenerateLocal(Trigger, bForce, Grid)

Trigger: 0=OnLoad, 1=OnDemand, 2=AtRuntime. Grid: hierarchical grid size (0 = uninitialized). UE 5.7 takes EPCGHiGenGrid enum, 5.8 takes uint32, handled internally.

cfa pcg_generate_local --actor-label PCG_Forest_01 --trigger 1 --force

Call UPCGComponent::CleanupLocal(bRemoveComponents)

Scheduled (non-immediate) cleanup on the local component.

cfa pcg_cleanup_local --actor-label PCG_Forest_01

Call UPCGComponent::CleanupLocalImmediate, synchronous, no delayed tasks

If cleanup_local_components=true, also cleans up per-grid local PCG components.

cfa pcg_cleanup_local_immediate --actor-label PCG_Forest_01 --cleanup-local-components

Call UPCGComponent::CancelGeneration on the named actor

Cancels any in-flight generation for this single component (unlike cancel_pcg_generation which works on all components bound to a graph).

cfa pcg_cancel_component_generation --actor-label PCG_Forest_01

Call UPCGComponent::SetGraph to assign a PCG graph to a component

NetMulticast Reliable, replicates to clients. Wraps UPCGComponent::SetGraph(UPCGGraphInterface*).

cfa pcg_set_component_graph --actor-label PCG_Forest_01 --graph-path /Game/PCG/PCG_Forest

Read the last generated FPCGDataCollection from a component

Wraps UPCGComponent::GetGeneratedGraphOutput(). Returns tagged_data: [{pin, type, tags, pinless}...].

cfa pcg_get_generated_output --actor-label PCG_Forest_01

Call UPCGComponent::ClearPCGLink, detach generated content into a standalone actor

Optional template_actor_class controls the spawned actor type (e.g. /Script/Engine.StaticMeshActor). Empty uses the engine default.

cfa pcg_clear_pcg_link --actor-label PCG_Forest_01

Check whether a UPCGComponent is partitioned

Wraps UPCGComponent::IsPartitioned() + GetGridBounds().

cfa pcg_is_partitioned --actor-label PCG_World_01

List APCGPartitionActors in the world, optionally filtered by an original PCG component

If actor_label is given, returns only partition actors serving that original. Otherwise returns ALL partition actors in the editor world. Concise output, no bounds per entry.

cfa pcg_list_partition_actors --actor-label PCG_World_01

Get detailed info on one APCGPartitionActor by name

Returns grid coord, grid size, fixed bounds, runtime/2D flags, local + original component counts, and original owner actor labels.

cfa pcg_get_partition_actor_info --partition-actor-name PCGPartitionGridActor_3200_4_8

Aggregate generated output across all partition actors of a partitioned PCG component

Iterates partition actors, collects GetLocalComponent(Original)->GetGeneratedGraphOutput(). Per-partition entries are summaries only. Pass summary_only=true to omit them entirely.

cfa pcg_aggregate_partition_output --actor-label PCG_World_01 --summary-only

Schedule a PCG graph for async execution against a component as execution source

Wraps UPCGSubsystem::ScheduleGraph(UPCGGraph*, IPCGGraphExecutionSource*...). Returns the FPCGTaskId.

cfa pcg_schedule_graph --graph-path /Game/PCG/PCG_Forest --actor-label PCG_World_01

Schedule a PCG component's own graph for async execution

Wraps UPCGSubsystem::ScheduleComponent. On 5.8 grid is uint32 (0 = uninitialized/all); on 5.7 it's the EPCGHiGenGrid enum value.

cfa pcg_schedule_component --actor-label PCG_World_01 --force

Schedule cleanup of a PCG component's graph

Wraps UPCGSubsystem::ScheduleCleanup. Returns the FPCGTaskId.

cfa pcg_schedule_cleanup --actor-label PCG_World_01

Refresh a PCG component on the current or next frame (editor only)

Wraps UPCGComponent::Refresh(EPCGChangeType, bCancelExistingRefresh). Uses the safe public component API rather than UPCGSubsystem::ScheduleRefresh directly, so the component's CurrentGenerationTask invariant is respected.

cfa pcg_schedule_refresh --actor-label PCG_World_01 --change-type Structural

Generate every registered PCG component in the world (editor only)

Wraps UPCGSubsystem::GenerateAllPCGComponents. Fires OnAllComponentsGenerated when done.

cfa pcg_generate_all_components --force

Cleanup every registered PCG component in the world (editor only)

Wraps UPCGSubsystem::CleanupAllPCGComponents(bPurge). purge=false (default) is a soft cleanup that lets components auto-regenerate. purge=true routes each component through CleanupLocalDeleteAllGeneratedObjects (PCGSubsystem.cpp:1910): deletes ALL generated objects, prevents auto-regen, you must call pcg_generate_all_components --force afterward to restore content. Mass actor deletion can race with editor actor-tracking refresh and emit a benign ensure() at PCGManagedResourceContainer.cpp:161; non-fatal.

cfa pcg_cleanup_all_components            # SAFE soft cleanup
cfa pcg_cleanup_all_components --purge    # DESTRUCTIVE, requires manual regen after

Refresh all GenerateAtRuntime PCG execution sources

Wraps RefreshAllRuntimeGenExecutionSources (5.8) / deprecated RefreshAllRuntimeGenComponents (5.7). For the canonical 'refresh all runtime-gen content including partition actors' behavior, prefer pcg_runtime_generation_refresh which mirrors the pcg.RuntimeGeneration.Refresh console command (uses EPCGChangeType::GenerationGrid).

cfa pcg_refresh_runtime_gen_sources --change-type GenerationGrid

Mark all runtime-gen PCG execution sources as dirty (5.8+ only)

Wraps UPCGSubsystem::DirtyRuntimeGenExecutionSources. Returns an error on 5.7.

cfa pcg_dirty_runtime_gen_sources --change-type Structural

Refresh PCG components matching a filter predicate (editor only)

Wraps UPCGSubsystem::RefreshAllComponentsFiltered. Components must satisfy ALL non-empty filters.

cfa pcg_refresh_all_components_filtered --partitioned-only --change-type Structural

Flush PCG results cache and compiled-graph cache

Wraps IPCGBaseSubsystem::FlushCache (IPCGBaseSubsystem.h:91 in 5.8,:90 in 5.7). Mirrors `pcg.FlushCache` console command. Use before re-running graphs whose external dependencies (textures, data tables, etc.) changed.

cfa pcg_flush_cache

Clean up and re-generate all runtime-gen PCG components including partition actors

Exact mirror of `pcg.RuntimeGeneration.Refresh` console command. Calls UPCGSubsystem::RefreshAllRuntimeGenExecutionSources with EPCGChangeType::GenerationGrid (PCGSubsystem.h:220 in 5.8), triggers full partition-actor cleanup+regen. On 5.7 falls back to deprecated RefreshAllRuntimeGenComponents (PCGSubsystem.h:193) with the same change type. Use after a destructive pcg_cleanup_all_components --purge to reliably restore runtime-generated content.

cfa pcg_runtime_generation_refresh

Refresh a single GenerateAtRuntime PCG component (optionally flushing cache first)

Wraps UPCGBlueprintHelpers::RefreshPCGRuntimeComponent (PCGBlueprintHelpers.cpp:370 in both 5.7 and 5.8). Internally optionally calls FlushCache then RefreshRuntimeGenExecutionSource (5.8) / RefreshRuntimeGenComponent (5.7) with EPCGChangeType::GenerationGrid. Use when one specific runtime component (and its partition cells) needs re-evaluation.

cfa pcg_refresh_pcg_runtime_component --actor-label PCG_Test --flush-cache

Build the PCG landscape cache for the current world

Wraps UPCGSubsystem::BuildLandscapeCache (PCGSubsystem.h:364 in 5.8,:301 in 5.7). Mirrors `pcg.BuildLandscapeCache` console command.

cfa pcg_build_landscape_cache --force-build

Clear the PCG landscape cache for the current world

Wraps UPCGSubsystem::ClearLandscapeCache (PCGSubsystem.h:367 in 5.8,:304 in 5.7). Mirrors `pcg.ClearLandscapeCache` console command.

cfa pcg_clear_landscape_cache

Check whether per-node inspection is enabled on a UPCGComponent

Wraps FPCGGraphExecutionInspection::IsInspecting (PCGGraphExecutionInspection.h:44). Access path: UPCGComponent->GetExecutionState().GetInspection().IsInspecting().

cfa pcg_is_inspecting --actor-label PCG_Test

Enable per-node inspection on a UPCGComponent

Wraps FPCGGraphExecutionInspection::EnableInspection (PCGGraphExecutionInspection.h:45). Records per-node data, GPU transfers, override application, and inactive-pin masks on the next execution. Inspection is a per-component flag, so for partitioned graphs you must also enable it on each local component on partition actors -- pass --include-partitions for that, otherwise pcg_inspect_partition_node_output will find no data.

cfa pcg_enable_node_inspection --actor-label PCG_ResourceVein
cfa pcg_enable_node_inspection --actor-label PCG_Test --include-partitions

Disable per-node inspection on a UPCGComponent

Wraps FPCGGraphExecutionInspection::DisableInspection (PCGGraphExecutionInspection.h:46). Pair --include-partitions with the matching enable call to also disable inspection on partition locals.

cfa pcg_disable_node_inspection --actor-label PCG_Test --include-partitions

Check whether a node's task executed during the last generation

Wraps FPCGGraphExecutionInspection::WasNodeExecuted (PCGGraphExecutionInspection.h:58). Stack defaults to [Component, Graph]; pass --stack-frames for nested subgraphs/loops.

cfa pcg_was_node_executed --actor-label PCG_Test --node-name SurfaceSampler_2

Check whether a node produced data in the last execution

Wraps FPCGGraphExecutionInspection::HasNodeProducedData (PCGGraphExecutionInspection.h:72).

cfa pcg_has_node_produced_data --actor-label PCG_Test --node-name SurfaceSampler_2

Get the bitmask of output pins deactivated by dynamic branching

Wraps FPCGGraphExecutionInspection::GetNodeInactivePinMask (PCGGraphExecutionInspection.h:66). Returns raw uint64 mask plus resolved pin labels.

cfa pcg_get_node_inactive_pin_mask --actor-label PCG_Test --node-name BranchA

Check whether a node triggered a GPU->CPU readback during last execution

Wraps FPCGGraphExecutionInspection::DidNodeTriggerGPUToCPUReadback (PCGGraphExecutionInspection.h:77). Useful for perf diagnosis on GPU compute graphs.

cfa pcg_did_node_trigger_gpu_to_cpu_readback --actor-label PCG_Test --node-name GPUNode

Check whether a node triggered a CPU->GPU upload during last execution

Wraps FPCGGraphExecutionInspection::DidNodeTriggerCPUToGPUUpload (PCGGraphExecutionInspection.h:78).

cfa pcg_did_node_trigger_cpu_to_gpu_upload --actor-label PCG_Test --node-name GPUNode

Check whether data overrides were applied to a node during last execution

Wraps FPCGGraphExecutionInspection::NodeAppliedDataOverrides (PCGGraphExecutionInspection.h:84).

cfa pcg_node_applied_data_overrides --actor-label PCG_Test --node-name Spawner

Inspect a node's output data collection (compact, AI-friendly summary)

Wraps FPCGGraphExecutionInspection::InspectData (PCGGraphExecutionInspection.h:50). Stack auto-built as [Component, Graph, Node]. Returns per-tagged-data entry: pin, type, point_count, attributes, optional preview points, tags. Never dumps full point data.

cfa pcg_inspect_node_output --actor-label PCG_Test --node-name SurfaceSampler_2 --max-points-per-entry 5

Inspect a node's output across ALL partition cells of a partitioned PCG component

Use this for partitioned graphs (PCG_Test style). Use pcg_inspect_node_output for non-partitioned components. Walks every APCGPartitionActor referencing the original component, calls GetLocalComponent (PCGPartitionActor.h:126), and aggregates FPCGGraphExecutionInspection::InspectData (PCGGraphExecutionInspection.h:50) per local. Returns per-partition summary: grid_coord, grid_size, entries, points, tagged_data.

cfa pcg_inspect_partition_node_output --actor-label PCG_Test --node-name SurfaceSampler_2

List all nodes executed during last generation (compact)

Wraps FPCGGraphExecutionInspection::GetExecutedNodeStacks (PCGGraphExecutionInspection.h:63). One entry per node with stack_count (>1 means executed under multiple stacks, dynamic subgraphs or loop iterations). Does not dump stack contents.

cfa pcg_list_executed_nodes --actor-label PCG_Test

Clear cached inspection data on a UPCGComponent

Wraps FPCGGraphExecutionInspection::ClearInspectionData (PCGGraphExecutionInspection.h:55). Pass --clear-per-node-execution-data=false to keep per-node execution tracking while dropping the data cache.

cfa pcg_clear_inspection_data --actor-label PCG_Test