World Building

Paint every landscape layer in one normalised pass

Paints all layers together with per-vertex weights normalised to sum to exactly 255. This exists because painting layers one at a time is wrong: LandscapeLayerBlend normalises internally, so several layers each written at 255 average into a washed-out mix instead of resolving to a dominant material, and any vertex no rule claims ends up with zero total weight and renders black. Slope is measured on a box-blurred heightfield (--slope-smoothing), because central differences over adjacent samples are high frequency and alias into a stipple that no amount of weight blending repairs. Layer syntax is "Name:rule:threshold:blend", semicolon separated. Rules: all, above_height, below_height, slope_above, slope_below. Include one 'all' layer as a base so every vertex is covered. Weights are read back per layer and reported, so engine renormalisation is visible rather than assumed.

  cfa paint_landscape_layers --layers "Rock:all; Grass:below_height:3000:2600; Snow:above_height:5400:1800"
  cfa paint_landscape_layers --layers "Rock:all; Grass:slope_below:200:180; Snow:above_height:6000:1500" --slope-smoothing 3

Spawn a volume with real brush geometry at a given size

Spawns any AVolume subclass and builds its brush at the size you ask for, mirroring the editor's own drag-and-drop path (UCubeBuilder + UActorFactory::CreateBrushForVolumeActor). spawn_actor_by_class also produces a volume, but always with the actor factory's fixed 200x200x200 brush, so sizing it afterwards means scaling the actor rather than rebuilding the brush the collision is derived from. --size is the full box size in world units, not half-extents. Use --unbound for a post-process volume that should affect the whole level regardless of shape. Verified identical on UE 5.6, 5.7 and 5.8 (CubeBuilder.h:18/28/32/36, ActorFactory.h:99).

  cfa create_volume --class-path /Script/Engine.PostProcessVolume --name Grade_Main --size 4000,4000,2000
  cfa create_volume --class-path NavMeshBoundsVolume --name Nav_Bounds --size 8000,8000,2000
  cfa create_volume --class-path PostProcessVolume --name Grade_Global --unbound

Verify a volume has brush geometry and actually does something

Checks that a volume works rather than merely exists: brush geometry present, bounds non-zero, and for post-process volumes how many bOverride_ flags are actually active. A post-process volume with zero active overrides changes nothing, which is the most common silent no-op in the domain. Returns verdict pass / pass_with_warnings / fail plus an issues list.

  cfa validate_volume --actor-label Grade_Main

Create a landscape at a chosen resolution

Spawns an ALandscape and imports a flat heightfield at the requested resolution. Resolution comes from section_size x sections_per_component x component_count, giving (component_count * section_size * sections_per_component) + 1 vertices per axis. Defaults produce 8x8 components of 63 quads = 505x505 vertices, 50400x50400 world units at scale 100. Scale is applied BEFORE import because ULandscapeInfo captures DrawScale when it is created, which import does. Uses the TArrayView Import overload, the older TArray* form is deprecated on 5.6/5.7 and gone in 5.8.

  cfa create_landscape --name Terrain --component-count-x 8 --component-count-y 8
  cfa create_landscape --name Small --section-size 31 --component-count-x 2 --component-count-y 2 --scale 100,100,100

Sculpt landscape heights with a shape

Writes heights through FLandscapeEditDataInterface, which is public in all three versions (the interactive brush FEdModeLandscape is Private/ and unreachable). Shapes: flat, hill, valley, ramp, terrace, noise, ridge, mountain (ridged multifractal, sharp crests rather than a dome), plateau, crater. Two passes reshape existing terrain and therefore REQUIRE --additive: erosion (thermal, material above the talus angle slides downhill, producing scree slopes and flat valley floors) and river (carves a meandering channel with smooth banks; --height is the cut depth, --radius sets the channel width). --additive adds to existing heights instead of replacing, so shapes can be layered. --seed makes noise and ridge reproducible. Heights are read back after the write, so the reported min/max world height is measured, not predicted. The edit layer is addressed by explicit GUID rather than the default constructor, which would target whatever layer the editor happens to have selected.

  cfa sculpt_landscape --shape hill --height 4000 --radius 120
  cfa sculpt_landscape --shape noise --height 800 --seed 7 --additive
  cfa sculpt_landscape --shape ridge --height 2500 --additive

Paint a landscape weight layer

Paints a target layer, creating its layer info asset if needed via UE::Landscape::CreateTargetLayerInfo, present in 5.6, 5.7 and 5.8, unlike ALandscapeProxy::CreateLayerInfo which 5.8 removed. Rules select which vertices get weight: all, above_height, below_height, slope_above, slope_below (--threshold sets the cutoff). Weights are always read back afterwards and reported as vertices_verified_nonzero, because on 5.8 SetAlphaData's weight-adjust arguments are silently discarded, so the write cannot be trusted to have renormalized. A material must be assigned for painted layers to be visible.

  cfa paint_landscape_layer --layer-name Grass
  cfa paint_landscape_layer --layer-name Rock --rule slope_above --threshold 300
  cfa paint_landscape_layer --layer-name Snow --rule above_height --threshold 2500

Read a landscape's resolution, scale, height range and layers

Reports resolution, component sizing, scale, world size, the measured min/max world height read from the heightfield, the assigned material and the target layer list.

  cfa get_landscape_info

Remove all landscape splines

Removes every control point and segment from the landscape's spline component and re-rasterises the splines edit layer. Clearing the objects alone is not enough: the deformation lives in that layer and stays baked in until it is re-applied from the empty set.

  cfa clear_landscape_splines

Deform the landscape along a spline

Places a Landscape Spline that raises or lowers the terrain along a path. Unlike carving heights directly this is NON-DESTRUCTIVE: the deformation lives in the landscape's own spline edit layer, and the control points stay editable by hand in the Landscape tool afterwards. Heights are sampled from the terrain at each point, so the corridor follows the ground unless you offset it. Optionally paints a target layer along the corridor, which is how road beds and riverbanks are normally authored.

  cfa add_landscape_spline --points "-20000,0; -5000,3000; 8000,-2000; 20000,1000" --width 500
  cfa add_landscape_spline --points "0,0; 10000,0" --width 300 --layer-name "Gravel" --height-offset 120

Edit one region of an existing landscape

Applies a single operation to a circular region of the landscape that is already there, or to the whole landscape if no centre is given. The operation runs over the full heightfield and is then blended into the region through a smoothstep falloff, so erosion never sees an artificial boundary to erode against and the edit welds into the surrounding terrain with no visible rim. flatten with no explicit height targets the region's own mean, which lands the plateau where the ground already is instead of stepping.

  cfa edit_terrain_region --operation flatten --center "0,0" --radius 6000
  cfa edit_terrain_region --operation mountain --center "-12000,4000" --radius 9000 --amount 2500
  cfa edit_terrain_region --operation smooth --center "5000,5000" --radius 4000 --iterations 6

Carve a river into an existing landscape

Edits the landscape that is already there, without regenerating it. The river's path is traced by following the terrain's own steepest descent from the start point, so it physically cannot run uphill or over a summit whatever start you give it. Width and depth are sized from the drainage each cell carries, so headwaters are a shallow notch and the trunk cuts deep and wide. Depressions are filled first, otherwise the trace stops in the first pit it meets. Reports total descent from source to mouth as proof the channel actually falls.

  cfa add_river
  cfa add_river --start "25000,25000" --depth 400
  cfa add_river --from-peak --tributaries

Generate a complete eroded terrain into a landscape

Builds the whole terrain in one pass: a ridged multifractal base shape with domain warping, then droplet hydraulic erosion which carves dendritic drainage networks, then thermal talus slippage which stops the ridges hydraulic erosion sharpens from becoming knife edges. Reports the slope distribution, because that is what actually distinguishes plausible terrain from procedural-looking terrain: real mountains run about 20-30 degrees median with under one percent above 60. Erosion cost is linear in droplets and quadratic in brush radius.

  cfa generate_terrain --amplitude 5000 --erosion 1.0
  cfa generate_terrain --sharpness 0.3 --erosion 0.5 --feature-scale 400

Verify a landscape is usable

Checks the landscape has ULandscapeInfo (absent means it was never imported), a readable extent, non-flat heights, an assigned material (without one, painted layers are invisible), target layers, and registered components. Returns verdict pass / pass_with_warnings / fail.

  cfa validate_landscape

Start a Lightmass lighting build

Starts GEditor->BuildLighting at the chosen quality. Lightmass runs out of process, so this returns immediately, poll lighting_build_status. Refuses when Auto Apply Lighting is disabled in Editor Preferences, because in that state Lightmass finishes and then parks forever waiting for a human to click Apply Now, with the build reporting in_progress true and no completion delegate ever firing. Progress percentage is not available: FStaticLightingManager is engine-private, so only a running/not-running state exists.

  cfa build_lighting --quality preview
  cfa build_lighting --quality production --current-level-only

Poll a lighting build

Reports in_progress, exporting, and the unbuilt-object counts. By default it also ticks UpdateBuildLighting, which is the pump that advances the build's stages, an interactively ticking editor calls it already, but an unattended one needs this to progress.

  cfa lighting_build_status

Recapture sky lights

The engine's RecaptureSky only ENQUEUES a capture; the work happens in UpdateSkyCaptureContents, which the editor tick normally drives. This command does both, so a headless run completes. Static-mobility sky lights are reported as skipped rather than counted as success: the engine refuses to capture those unless the project has ray tracing or distance fields enabled.

  cfa recapture_sky
  cfa recapture_sky --actor SkyLight

Flush or fully rebake reflection captures

By default flushes pending capture updates via UpdateReflectionCaptureContents. --full-build runs GEditor->BuildReflectionCaptures, which waits on shader compilation and recaptures sky first. That path is gated on feature level SM5 because the engine hard-asserts below it. Note per-capture resolution does not exist in any version, it is the project setting r.ReflectionCaptureResolution, reachable through set_project_settings.

  cfa update_reflection_captures
  cfa update_reflection_captures --full-build

Verify lighting is built

Reads the same unbuilt-object count that drives the viewport's LIGHTING NEEDS TO BE REBUILT banner, refreshing it from the renderer first so the number is live rather than stale. Also reports unbuilt reflection captures and how many static/stationary lights have no baked data. Returns verdict pass / pass_with_warnings / fail.

  cfa validate_lighting

Start a navigation mesh build (asynchronous)

Starts UNavigationSystemV1::Build(), which is fire-and-forget: it returns before tiles finish, so this command returns immediately rather than blocking the bridge. Poll navigation_build_status until in_progress is false, then run validate_navigation. Refuses up front when the level has no navigation bounds, since a build would silently produce nothing. Create bounds with create_volume --class-path NavMeshBoundsVolume.

  cfa create_volume --class-path NavMeshBoundsVolume --name Nav_Bounds --size 6000,6000,2000
  cfa build_navigation
  cfa navigation_build_status

Poll an in-flight navigation build

Reports in_progress, build_locked, remaining_tasks and built_tiles. Tile counting is version-aware: 5.8 has GetNumActiveTiles, while 5.6 and 5.7 count tiles with valid bounds. The engine's GetNavMeshTilesCount is deliberately NOT used, it is the tile pool size and reports non-zero on a completely empty navmesh.

  cfa navigation_build_status

Verify navigation is built and actually pathable

Checks navigation bounds exist, nav data exists, and tiles are genuinely built. Pass --test-point to additionally project a world point onto the navmesh: a navmesh can exist, report tiles, and still be unusable, and the projection is what catches that. Returns verdict pass / pass_with_warnings / fail plus an issues list.

  cfa validate_navigation
  cfa validate_navigation --test-point 0,0,200

Set or append a spline's points

Writes points through the USplineComponent function API using the editor's own mutation sequence: batch every point with bUpdateSpline=false, rebuild once, then set the construction-script override so a rerun cannot discard the edit. This deliberately does NOT go through the reflection property writer: 5.7 made the parallel FSpline member persisted state with a LastAuthority arbiter, so writing SplineCurves as a property desyncs the two copies on 5.7 and 5.8. Reading by reflection is still fine.

  cfa set_spline_points --actor Road_Spline --points "0,0,0; 1000,0,0; 2000,500,0; 3000,500,100"
  cfa set_spline_points --actor Fence --points "0,0,0; 500,0,0" --point-type linear --closed-loop

Edit one spline point: location, tangents, rotation, scale, type

Edits a single point without rebuilding the whole spline. Two engine behaviours are handled for you. First, SetRotationAtSplinePoint realigns tangents to the rotation's forward vector, so rotation is applied BEFORE tangents, otherwise your tangents would be silently discarded. Second, the engine's singular SetTangentAtSplinePoint forwards the same vector to both arrive and leave, collapsing a broken tangent; this uses the plural form so arrive and leave stay independent. Note a custom tangent only survives on a point of type curvecustomtangent.

  cfa set_spline_point --actor Road --index 2 --location 1500,700,200
  cfa set_spline_point --actor Road --index 2 --point-type curvecustomtangent --arrive-tangent 0,900,0 --leave-tangent 900,0,0

Read a spline's points, length and sampled transforms

Returns each point's world location, type and distance along the spline, plus total length and the closed-loop flag. --sample-count additionally returns that many locations sampled at even distance, which is the same stepping scatter_foliage uses for its spline pattern, the engine has no spacing concept of its own, so distribution is defined here.

  cfa get_spline --actor Road_Spline
  cfa get_spline --actor Road_Spline --sample-count 20

Verify a spline is usable

Checks the spline has at least two points, non-zero length, no duplicate consecutive points (which produce zero-length segments and break distance-based sampling), and that the construction-script override flag is set, without it, a Blueprint rerun silently discards the points. Returns verdict pass / pass_with_warnings / fail plus an issues list.

  cfa validate_spline --actor Road_Spline

Add a component to a placed actor in the level

Adds a component instance to an actor already in the level (as opposed to add_component_to_blueprint, which edits a Blueprint's template). This is how you give a plain actor a SplineComponent, a BoxComponent, a light component and so on. The component's properties are then ordinary reflected properties, editable with set_actor_property --component-name.

  cfa add_component --actor Road_Spline --component-class SplineComponent --component-name Path
  cfa add_component --actor Trigger_A --component-class BoxComponent

Create a foliage type asset from a static mesh

Creates a UFoliageType_InstancedStaticMesh asset. Foliage types must be assets: the engine asserts on a non-asset type in a World Partition level, and the engine's own save helper opens a modal dialog, so this uses the dialog-free duplicate path instead. Every placement rule is an ordinary reflected property, so shape the type with set_asset_property: Density, Radius, ScaleX/ScaleY/ScaleZ (FFloatInterval min/max), ZOffset, AlignToNormal, RandomYaw, RandomPitchAngle, GroundSlopeAngle, Height, LandscapeLayers, CollisionWithWorld, CullDistance, CastShadow and the rest. scatter_foliage then applies whatever you set.

  cfa create_foliage_type --mesh-path /Game/Meshes/SM_Bush --asset-path /Game/Foliage/FT_Bush
  cfa set_asset_property --asset-path /Game/Foliage/FT_Bush --property-path AlignToNormal --property-value true

Place foliage in a reproducible pattern (the brush, without the brush)

Places foliage using the engine's own painting pipeline, with pattern generation in place of a mouse stroke. For each point it calls AInstancedFoliageActor::FoliageTrace to find the ground, then FPotentialInstance::PlaceInstance, which applies the foliage type's own scale range, random yaw and pitch, Z offset, align-to-normal, ground-slope and height rules. So shaping the type with set_asset_property changes the result here, exactly as it would when painting by hand. Patterns: random (uniform in a disc), grid (lattice), radial (concentric rings), spline (along a spline actor, with optional sideways scatter). Use --seed for a reproducible layout. Points that miss the ground or fail the type's rules are reported as missed_ground and rejected_by_type_rules rather than dropped silently.

  cfa scatter_foliage --foliage-type /Game/Foliage/FT_Bush --center 0,0,0 --radius 3000 --count 400
  cfa scatter_foliage --foliage-type /Game/Foliage/FT_Grass --pattern grid --radius 2000 --spacing 150
  cfa scatter_foliage --foliage-type /Game/Foliage/FT_Tree --pattern spline --spline-actor Road_Spline --spline-offset 400 --spacing 300

Remove placed foliage instances, keeping the types

Removes instances while leaving the foliage types in the palette. This is deliberately separate from remove_foliage_type because the engine's own AddInstances counterpart, RemoveAllInstances, actually deletes the TYPE and destroys its components rather than clearing instances.

  cfa clear_foliage_instances --foliage-type /Game/Foliage/FT_Bush
  cfa clear_foliage_instances

Remove a foliage type from the level entirely

Deletes the type from the level's foliage actors, destroying its instances and render components. Requires an explicit type, there is no remove-everything form, because this is destructive.

  cfa remove_foliage_type --foliage-type /Game/Foliage/FT_Bush

List foliage types in the level with instance counts

Reads the authoritative editor-side instance data rather than the render component, so counts are correct even while the instance tree is still rebuilding and for actor-based foliage that has no render component at all.

  cfa get_foliage_info

Verify placed foliage is actually going to render

Checks each foliage type has a source mesh, has instances, and that the render component's instance count matches the editor data, a mismatch means the instance tree is still rebuilding, which is the difference between 'the data is right' and 'the player sees it'. Returns verdict pass / pass_with_warnings / fail plus an issues list.

  cfa validate_foliage
  cfa validate_foliage --foliage-type /Game/Foliage/FT_Bush

List the editor modes this build registers, and which is active

Enumerates editor modes from FEditorModeRegistry rather than a hardcoded table, so modes added by plugins show up too. Typical ids are EM_Default (Selection), EM_Landscape, EM_Foliage, EM_MeshPaint, EM_Modeling, EM_Fracture, EM_Bsp, EM_AnimationEditMode and EM_PCGEditorMode. Hidden modes are excluded unless --include-hidden.

  cfa list_editor_modes
  cfa list_editor_modes --filter Foliage

Switch the level editor to a mode by id

Activates an editor mode (FEditorModeTools::ActivateMode). Note you do NOT need this to author anything: foliage placement, landscape edits and spline edits all go through data APIs that work in any mode, and the interactive brushes (FEdModeFoliage, FEdModeLandscape) live in Private/ and are unreachable anyway. Use this to leave the editor on the right tab for a human to inspect or continue by hand. An unknown id lists the closest matches instead of failing blindly.

  cfa set_editor_mode --mode-id EM_Foliage
  cfa set_editor_mode --mode-id EM_Default

Run one geomorphic process over an existing landscape

glacial: a shallow-ice simulation. Ice accumulates above an equilibrium line, flows under its own weight, and abrades the bed in proportion to how fast it slides. That coupling is what produces U-shaped cross sections, cirques and overdeepened basins -- shapes no amount of river erosion can make, because a river cuts at a point and a glacier cuts across its whole width. snow: lying snow with avalanching off steep faces and wind scouring the windward side into the lee. Written to the 'snow' mask, not the heightfield, so later erosion still cuts rock. coastal: a wave-cut bench at the waterline with the bluff standing behind it. stratify: tilted sedimentary bedding with alternating hard and soft beds. The tilt matters -- flat bedding gives every hill the same contour rings, which reads as a terrace filter rather than exposed geology.

  cfa apply_terrain_process --process glacial --equilibrium-line-altitude 3200
  cfa apply_terrain_process --process snow --snow-line 2600 --wind-direction-degrees 240
  cfa apply_terrain_process --process coastal --sea-level 200 --bench-width 1500
  cfa apply_terrain_process --process stratify --bed-thickness 180 --tilt-degrees 6

Regenerate one region of a landscape and merge it seamlessly

Generates fresh terrain inside a region and marries it to what is already around it. poisson (default) solves for a surface whose SLOPES are the new terrain's but whose edge heights are exactly the old terrain's, so the join is continuous by construction rather than faded: no ramp, no flattened rim, which are the two ways a crossfade gives itself away. poisson_mixed additionally keeps whichever side has the stronger local slope at each cell, so ridges and channels running in from outside continue through the patch instead of stopping at its edge. feather is a plain crossfade, honest but flattening. replace is a hard edge. The patch is generated across the whole world grid and then mean-matched to the region it replaces, so its noise lines up and it does not sit as a dome or a bowl inside the seam. Reports the seam step before and after, so the join is measured rather than assumed.

  cfa regenerate_terrain_region --center "25000,25000" --radius 8000 --seed 7
  cfa regenerate_terrain_region --center "25000,25000" --radius 8000 --blend poisson_mixed --amplitude 6000
  cfa regenerate_terrain_region --center "12000,30000" --radius 5000 --blend feather --falloff-width 3000

Report a World Partition level's grids, data layers and loaded actor counts

Reports streaming on/off, the runtime grids with their cell size and loading range, the data layer count, and how many actors exist versus how many are loaded right now. Refuses with an explanation on a non-partitioned level, where every actor is always loaded anyway.

  cfa get_world_partition_info

List every actor in a partitioned level without loading it

Reads the actor descriptions rather than the loaded actors, so it sees actors that streaming has unloaded and that find_actors therefore cannot. Reports label, class, bounds, whether the actor is spatially loaded, its data layers, and whether it is in memory right now. This is how you find an actor that seems to have vanished after reopening a partitioned map.

  cfa list_world_partition_actors --class-path WaterBodyRiver
  cfa list_world_partition_actors --filter River --loaded-only

Load a region of a partitioned level so its actors can be edited

Loads a box or sphere of the world into the editor. Loading is asynchronous, so poll with list_world_partition_actors --loaded-only. Name the region so it can be released again.

  cfa load_world_partition_region --center "12000,12000,0" --radius 20000

Release a region loaded by load_world_partition_region

  cfa unload_world_partition_region --name Valley

Keep matched actors loaded regardless of camera position

Requires a filter and/or a class, because pinning everything would load the whole map. Pass --unpin to release them back to normal streaming.

  cfa pin_world_partition_actors --class-path WaterBodyRiver

Set whether an actor streams with the grid or is always loaded

A water zone ships always-loaded and a water body does not, which is why a river vanishes from the outliner when a partitioned map is reopened. Right for a small always-relevant actor, wrong for anything numerous.

  cfa set_actor_spatially_loaded --actor-label Landscape_River --spatially-loaded=false

Create a data layer asset and an instance of it in this world

A Runtime layer can be streamed in and out during play. An Editor layer only organises the editor and is stripped from a cook, so it can never have a runtime state.

  cfa create_data_layer --asset-path /Game/DataLayers/DL_Vegetation --layer-type Runtime
  cfa create_data_layer --asset-path /Game/DataLayers/DL_Blockout --layer-type Editor --debug-color "0.9,0.4,0.1"

List data layers with type, parent, state and actor counts

Membership is counted from the actor descriptions, so unloaded actors still count.

  cfa list_data_layers

Add or remove matched actors to a data layer

Goes through the editor subsystem so the actor and the world data layers actor stay in agreement. Only LOADED actors can be assigned; load_world_partition_region first if needed.

  cfa assign_actors_to_data_layer --data-layer DL_Vegetation --class-path InstancedFoliageActor

Set a data layer's editor visibility, editor loading and initial runtime state

Asking for a runtime state on an Editor layer is refused, because such a layer is stripped from a cook and can never have one.

  cfa set_data_layer_state --data-layer DL_Vegetation --initial-runtime-state Activated
  cfa set_data_layer_state --data-layer DL_Blockout --visible false

Remove a data layer instance from this world

The data layer asset itself is left alone.

  cfa remove_data_layer --data-layer DL_Vegetation

Create an HLOD layer asset

Layer types: Instancing, MeshMerge, MeshSimplify, MeshApproximate, Custom, and CustomHLODActor on 5.7+. The parent chain is what produces more than one HLOD level. An unknown type is refused with the list this engine actually offers.

  cfa create_hlod_layer --asset-path /Game/HLOD/HLOD_Instanced --layer-type Instancing
  cfa create_hlod_layer --asset-path /Game/HLOD/HLOD_Far --layer-type MeshMerge --cell-size 25600 --parent-layer /Game/HLOD/HLOD_Instanced

List HLOD layer assets with type, cell size, loading range and parent

  cfa list_hlod_layers

Assign an HLOD layer to matched actors, or clear the override

Actors with no HLODLayer property are reported as unchanged rather than silently skipped.

  cfa set_actor_hlod_layer --class-path StaticMeshActor --hlod-layer /Game/HLOD/HLOD_Instanced

Run a World Partition builder (hlod, minimap, navigation, foliage...)

Builders: hlod, minimap, navigation, foliage, spline_meshes, static_lighting, rvt, and landscape on 5.7+. These run for minutes to hours and block the editor, so WITHOUT --confirm this only reports what the builder does and how long it is likely to take. Ask the user whether to run it here or leave it to them, then re-run with --confirm.

  cfa build_world_partition --builder hlod
  cfa build_world_partition --builder minimap --confirm

Set any editable UWorldPartition property by reflection

Whatever this engine version exposes works; anything it does not is named along with the list of what is available. Covers streaming enable, server streaming modes, the data layers logic operator and the HLOD flags.

  cfa set_world_partition_settings --property bEnableStreaming --value true

Add, edit or remove a named runtime grid

Refuses with an explanation when the world uses a runtime hash that has no named grids.

  cfa set_runtime_grid --grid-name Buildings --cell-size 25600 --loading-range 51200

Put matched actors onto a named runtime grid

  cfa set_actor_runtime_grid --class-path StaticMeshActor --grid-name Buildings

Check a partitioned world is actually partitioned

Streaming enabled, actors that genuinely stream, and runtime data layers not left unloaded in the editor where any edit would miss their actors. Returns verdict pass/pass_with_warnings/fail.

  cfa validate_world_partition