11. Limits

The ground is a heightfield

The terrain has one height at each point on the map. It cannot make caves, overhangs, arches or floating islands.

Use meshes for anything else. Tunnels work like this: the terrain cuts the hill and opens a hole at the mouth (see plates and corridors), and your game places the tunnel mesh. The same goes for bridges, retaining walls and building shells. The terrain makes the ground and the gap, and your meshes fill them.

No Nanite

The terrain does not use Nanite. Nanite geometry cannot be rebuilt while the game runs, which a terrain that changes needs. The terrain draws with its own vertex factory and continuous level of detail.

Ray tracing

With hardware ray tracing on, the near terrain within r.OrreryTerrain.RayTracing.Radius (400 m by default) of each view is traced with a simplified version of the ground (every fourth ground point by default), so Lumen global illumination and reflections, ray-traced shadows and the path tracer all see it. Limits:

• Beyond the radius the near chunks are not in the ray-tracing scene. The far field has one coarse triangle grid of its own, which Lumen’s far-field traces (r.LumenScene.FarField 1) and MegaLights’ far-field traces hit. Without that, Lumen sees the ground out there only where it is on screen, and it casts no ray-traced shadow.
• Lumen’s hit lighting (r.Lumen.HardwareRayTracing.LightingMode 1 or 2) and the path tracer shade the terrain with its own material at the hit, with the paint layers directly and never the runtime virtual texture.
• The simplified ground used for ray tracing is coarser than the drawn surface, so each chunk’s copy sits below it by up to that chunk’s height error at the chosen level (a few centimetres on gentle ground, more on rough ground). Ray-traced shadows of the terrain on itself can start slightly late on steep ground. Farther out, where the drawn surface is coarser than the copy, the copy can stand a little above it. Lower r.OrreryTerrain.RayTracing.Level for a finer, closer copy at more memory.

When hit lighting is active, the terrain writes a warning to the log once. With r.OrreryTerrain.RayTracing 0 the terrain stays out of the ray-tracing scene, and the log warns once about what that leaves out. Software Lumen and virtual shadow maps remain a fully supported lighting path.

Platforms

Platform	Status
Windows 64-bit	Built and tested: editor, game, and multiplayer on a listen server with four players. Listen server only in 1.0: a dedicated server is still being tested (What 1.0 leaves out).
Linux	The runtime modules build, but no Linux server has been run yet: not supported in this release. The editor module is Windows only.
Mac, iOS, Android, consoles	Not supported.

The heightfield renderer needs Shader Model 5 or higher. Hardware below that uses the mesh tier. Lumen and virtual shadow maps are Unreal features that need Shader Model 6 on DirectX 12.

A dedicated server is not a supported setup in 1.0. What the code does today: it does not render, it creates no grass, it keeps no far data, and it keeps the ground resident around each player’s link (Reading the ground on a server).

Size and detail

• One terrain per world.
• The largest world tested is 64 km by 64 km at a 1 m cell (the World64 sample, and the hero map). The New tool accepts more (below); anything beyond 64 km has not been run.
• Heightfield only: one height per point, square tiles of 127 cells (128 posts) a side, no overhangs (above).
• Up to 2048 tiles along one edge in the New tool. Each tile is 127 cells wide, so at a 1 m cell that is 260 km. The cell size is 0.25 to 16 m.
• The grid origin is set in the source asset, not by moving the actor.
• Edit detail can be finer than the natural ground: set Edit Subdivision to 1, 2 or 4 to edit at the natural spacing, at half of it or at a quarter of it.

Paint and layers

• Paint layer ids 0 to 255. A layer set’s Slice field (which slice of the material’s arrays a layer draws) takes 0 to 255.
• Each post holds up to four layers. Painting a fifth replaces the lightest.
• The Landscape importer takes up to 256 paint layers. Without a layer map they keep the Landscape’s order; a layer map must name every layer, and may name any index 0 to 255.
• Painted layers show on the near terrain. The far field draws only the automatic rules of the material, so painted ground far away falls back to the rules.

Editing

• Runtime edits run on the authority (your listen server, or a single-player game) and in Play. A client’s edits go through the server (see Multiplayer). Game code cannot edit an editor world’s terrain; the editor mode’s tools do.
• The sculpt limits stop brushes beyond a set radius and strength. You can raise them.
• A commit over ground that is not loaded yet builds nothing, and the missing tiles start loading. Call it again a moment later, use the async nodes, or register an invoker, a point that keeps the ground around it loaded.
• The undo ring for sculpting is bounded (32 strokes by default).
• A save loads only over the same natural ground it was made on.

Same ground on every build

The plugin’s core module, which applies every edit, compiles with precise floating point on every target, so that every machine that applies the same edits gets the same ground: the editor, Development and Shipping builds, Windows and Linux. Edits replay in integer maths and the core uses precise floating point, so the edited ground is bit-identical between the Windows (MSVC) and Linux (clang) builds. A packaged Windows Game build, as a listen server and its client, bakes the same ground as the editor for the same edits (a dedicated server has not been compared yet). The plugin refuses to compile its core with fast floating point: keep the line FPSemantics = FPSemanticsMode.Precise in OrreryTerrainCore.Build.cs if you change the plugin’s build files.

What can differ between builds:

• Your own code’s maths. On Windows, game targets compile your modules with fast floating point, so a value your code derives from the ground can differ between your editor and your Shipping build. The heights and normals the plugin returns do not.
• Only two kinds of answer use the platform’s maths library: the slope angle a query returns, and ground-follow rotations. They can differ in the last digit between Windows and Linux, and they are never replicated. The edited ground itself does not differ.
• Grass and scatter are placed on each machine and are not replicated.

Brushes and stamps

Texture brushes, splats and height stamps are Experimental. See Texture brushes and stamps.

• A mask is a square, 8 to 2048 samples a side, a power of two, at 8 or 16 bits. A 16-bit mask of 2048 samples a side holds 8 MiB of samples.
• A terrain holds up to 64 MiB of masks, mips included. Past that, Register Brush answers OverBudget: unregister masks you no longer use. The registry is never saved, so register again after every load.
• A stamp has its own sculpt limits, because it is placed once, not dragged. The defaults are a radius of 1000 m, a height of 1000 m and 1024 edit tiles. A stamp over any of them is Refused, and so is every stamp when Stamps is off. Change them in Settings > Sculpt Limits. The editor’s Stamp tool takes a radius of 1 to 1000 m.
• A splat paints up to four paint layers, one per colour channel.
• Bicubic sampling (experimental) is the Bicubic option on the Blueprint brush’s mask settings and a flag on the native brush. The editor tools and the starter brush assets do not set it; it costs about 2.5 to 3 times the bilinear sampling.
• In the editor, the Stamp tool shows its result as a surface of at most 65,536 points (every post of a small stamp, every 2nd to 8th post of a big one) and a 65 x 65 wire grid; what it cuts below the ground shows through the ground. A stamp over ground that is still loading waits up to 60 s.
• In multiplayer, a server takes stamps of up to 2048 edit tiles a second from one player (Max Stamp Tiles Per Second), and the rest are refused as Rate. A join carries up to 32 MiB of masks. Players upload masks only if your edit policy allows it: at most 4 masks and 4096 KB a player, 2048 KB a mask, 256 KB/s. The refusal codes are in Multiplayer.

Live spline features

Spline features are Experimental. See Live splines (runtime).

• One component drives one corridor or one plate. A closed spline makes a plate, an open one a corridor.
• Nothing rebuilds by itself at run time: your game calls Rebuild when an edit ends. In the editor the feature follows the spline when you release the drag.
• A plate’s outline has at most 2048 vertices: the spacing widens to fit.
• Rebuild Spline Feature (Async) streams the footprint plus 300 m and fails after its Timeout (30 s by default).
• Only the server builds. A client asks the server through the async node, and your edit policy judges the request.
• The editor’s preview refreshes at most every 0.1 s, and for a long feature at most every four times as long as one preview takes.
• The editor feature relies on an Unreal notification that is itself experimental.

Grass

• Grass is Experimental. Set the terrain actor’s Layer Set to turn it on. See Grass.
• Grass is derived from the ground on each machine. It is not saved and not replicated.
• The grass system does not run on a dedicated server or under -nullrhi.

Editor tools

The Terrain editor mode has sculpt, paint and feature tools and a Bake action (The editor mode).

• Editor edits live in an authoring layer. A map with an unbaked layer does not cook cleanly: the cook drops the layer, so the cooked game lacks the authored ground, and by default it logs an error saying so until you bake (Project Settings > Orrery Terrain Editor > Unbaked Cook can lower that to a warning or nothing). The bake commandlet’s -Check fails a build script on an unbaked map (The editor mode).
• Baking changes the natural ground, so a save or a multiplayer join made over the old ground is refused: the save does not load and the client cannot join (the result is NaturalMismatch).
• Author limits (radius 2000 m, step 10 m by default) cap the editor brushes. Holes and ground class painting are allowed unless you turn them off in the same settings.
• The mode’s Manage palette has New and Bake. Import goes through New, and layers are set on the terrain actor.

Landscape import

Importing a Landscape reads its heights and paint layers once. It does not keep the Landscape and the terrain in sync afterwards. Re-import to update. The importer refuses rotated Landscapes, non-square cell scale, unloaded components and more than 256 paint layers.