Pool vs Lake

Both BP_DRW_Pool and BP_DRW_Lake are discrete WaterBody actors: bounded, calm-surface, independent of the ocean. They share the same buoyancy, caustics, interaction, and underwater pipeline. The difference is shape, scale, and how the water terminates at its edge.

If you haven’t yet picked between a discrete water body and the ocean, read Discrete water bodies vs ocean first: this page assumes you’ve already decided you want a discrete body.

At a glance

	Pool (BP_DRW_Pool)	Lake (BP_DRW_Lake)
Shape	Rectangular	Circular
Dimensions	Width × Length × Depth	Radius × Depth
Default size	500 × 500 × 200 cm	5000 cm radius × 500 cm depth
Minimum size	50 cm per axis	100 cm radius, 50 cm depth
Boundary masking	GDF-based: waves and ripples clip to the pool walls	None: the surface ends at the disc edge
Project requirement	r.GenerateMeshDistanceFields enabled	None beyond DRW itself
Replication	Width / Length / Depth replicated with RepNotify	Inherits base WaterBody replication

Everything else: visuals via WBVisualDataAsset, interaction tuning, caustics, buoyancy, underwater post-process: is identical between the two.

Shape and scale

A pool is a rectangular box. You set three dimensions independently: handy for narrow channels, square fountains, swimming pools that aren’t square. Defaults are deliberately small (5 m × 5 m × 2 m) because that’s the typical “swimming pool” gameplay scale.

A lake is a circular disc. One radius, one depth. The defaults are roughly 50 m across: large enough that you’d typically use one for a scenic inland body of water, not a backyard pool. Use multiple lakes if you need irregular outlines (a lake “lobe” plus another lobe, with the joins hidden under terrain).

Note

Neither shape is curved underwater: both are flat-bottom volumes at the depth you set. Use landscape geometry for any non-flat floor.

Boundary masking: the headline difference

The pool’s distinctive feature is GDF-based boundary masking. The pool reads the project’s Global Distance Field and clips water rendering, ripples, and interactions to the walls of any solid geometry inside the pool’s volume. That’s how a hand-modelled pool basin (curved sides, jacuzzi steps, an irregular harbour wall) keeps water inside the basin instead of bleeding through the mesh.

Two properties control this:

• BoundaryDistanceThreshold (default 25.0, range 1–200): how close a GDF surface must be before the pool considers itself “bounded” there.
• BoundaryBakeIntervalSeconds (default 2.0, range 0–30): how often the boundary mask is re-baked. Higher = cheaper but slower to react when basin geometry moves.

Call InvalidateBoundaryMask() at runtime to force a re-bake immediately (after dynamically spawning or moving basin geometry, for example).

Lakes do not read the GDF. The water surface ends at the disc edge, period. Trying to push a lake against an irregular shoreline will reveal the disc: hide that boundary under terrain, foliage, or geometry, or pick a pool instead.

Caution

Pool boundary masking requires r.GenerateMeshDistanceFields=1 in the project settings. Without it, the pool will render as an unbounded rectangle. Lakes don’t need it.

Multiplayer behaviour

Both bodies replicate their visual / interaction / underwater enable flags. The pool also replicates its dimensions (Width, Length, Depth) with RepNotify, so clients rebuild the pool when you resize it server-side. The lake’s Radius / Depth aren’t replicated as RepNotifies: set them in the level or in BeginPlay; don’t expect runtime mutation to propagate.

When to pick each

Reach for a pool when…

• The water has clear walls: swimming pool, fountain, indoor cistern, harbour basin.
• You need waves and ripples to stop at hand-modelled boundary geometry.
• The body is small enough that a few-metre rectangular footprint fits.
• You need to resize it at runtime and have it sync across the network.

Reach for a lake when…

• The body is large and roughly round: a forest tarn, mountain lake, scenic background water.
• You don’t have basin geometry (or don’t need water clipped to it).
• You want the cheapest discrete body: no GDF queries, no boundary baking.
• Multiple lakes can stand in for an irregular outline (you cluster a few discs and hide the seams).

Common gotchas

• Pool with no boundary geometry: the pool’s GDF mask has nothing to clip against, so the surface fills the full rectangle. That’s correct behaviour, but it means you don’t get the “walls” effect for free; you need actual mesh inside the pool’s volume.
• Lake against an irregular shore: the disc edge will show. Cover the boundary with landscape sculpting or static-mesh shoreline geometry.
• Sizing for buoyancy tests: both bodies route the BuoyancyComponent automatically when an actor overlaps them. If a test cube falls through, check that the body’s Depth is enough to keep the cube’s lowest shape inside the volume.
• Stacking pools or lakes: overlapping bodies are supported, but actors inside the overlap sample whichever they entered last. Avoid relying on overlap behaviour for gameplay; design the bodies so they don’t overlap.