XGRIDSDocs

ALCCLoadVolume: Load Volume

Derives from AVolume, shown in the panel as LCC Load Volume.

The key difference from a clipping volume or a section plane is the stage it acts in: clipping and sectioning only change the final rendering while the data still loads and uploads to video memory as usual; a load volume acts during node traversal, and rejected nodes are never read at all. It is therefore the only one of the three that lowers the load amount and video memory usage.

HeaderTools/LCCLoadVolume.h
Base classAVolume
BlueprintBlueprintable / BlueprintType
LicenseA Pro edition feature; without a license it has no effect

One load volume can affect multiple LCC Actors in the scene at the same time.

Properties

PropertyTypeDescription
bEnabledboolWhether it is enabled
ModeELoadRegionInside (load only what is inside) or Outside (exclude what is inside)
VolumeTypeELoadVolumeTypeBox or Sphere

For the values see ELoadRegion and ELoadVolumeType.

None of the three properties has a setter; assign them directly. Filtering happens at load time, so the data has to be reloaded after a change.

Border Precision

The test works per node rather than per splat, so the border is coarser than a clipping volume's: an edge node is dropped entirely as soon as it fails the condition.

The two modes use different tests:

ModeConditionBorder behavior
InsideA node loads only when it lies entirely inside the volumeThe kept range is slightly smaller than the volume
OutsideA node is excluded as soon as it overlaps the volumeThe excluded range is slightly larger than the volume

Both sides are deliberately conservative to keep LOD switching stable. In an octree the bounds of a child node always sit inside its parent's, and the LOD switches from child to parent as the camera moves away. If Inside used an intersection test, the parent would load because it partially overlaps, bringing back regions the children had already excluded — visually a block of content popping in as you zoom out. Outside would have the symmetric problem with a containment test.

When a precise border is needed, stack a clipping volume on the same transform: the load volume reduces the load amount and the clipping volume trims the edge.

Creating at Runtime

ALCCLoadVolume* Volume = GetWorld()->SpawnActor<ALCCLoadVolume>(
    ALCCLoadVolume::StaticClass(), Location, FRotator::ZeroRotator);

Volume->VolumeType = ELoadVolumeType::Box;
Volume->Mode = ELoadRegion::Inside;
Volume->bEnabled = true;
Volume->SetActorScale3D(FVector(20.0f, 20.0f, 10.0f));

Component->AddLoadVolume(Volume);
Component->Load(Path);   // must be configured before loading

Order matters: filtering happens during loading, so adding or removing a load volume or changing a property after Load() does not change the data already loaded; a reload is required.

// Reload after changing the filtered range
Volume->SetActorLocation(NewLocation);
Component->Refresh();   // internally UnLoad then Load

Refresh() costs as much as a full reload, see ALCCActorBase::Refresh.

Choosing Between This and a Clipping Volume

NeedWhich to use
Take a small part out of a large scene and save video memory and load timeLoad volume
Cut holes or open a shell, where a precise border mattersClipping volume
Both save video memory and a precise borderStack both with the same transform
Toggle the effect frequently at runtimeClipping volume (changing bEnabled applies on the next frame, no reload)

See Also