Curved World

Part 1 — Using Curved World

What the plugin does, whether you need it, and how to use it.

What it does

Curved World bends the picture of your level away from the camera, so the ground drops towards a horizon like a small planet. Close to the camera nothing changes; further away, the world curves down out of sight. It gives a stylised, storybook look, and distant scenery disappears over the horizon instead of into fog.

Only the picture bends. Collision, physics, navigation and your gameplay code stay in the flat world you built, so nothing in your game has to change, and the effect costs very little.

The bend comes from one material function, MF_CurvedWorld, that every curved material uses. That leaves one problem: lights aren't drawn by materials, so they stay put while the ground under them drops, and their pools of light slide across the ground as the camera moves. Curved World fixes that with the Curved World Follower component, which moves each light with the surface it lights, every frame, so the pool stays where you put it.

Around that core, the plugin gives you:

• Curved Point, Spot and Rect Lights, ready to drag in from Place Actors → Lights;
• Check Level, which lists everything in a level that doesn't bend or follow the curve, and fixes most of it;
• Make Curved, which adds the curve to your existing materials, and Remove Curved World, which takes it out;
• presets for third-person and top-down cameras, and Blueprint functions to change the curve while the game runs;
• a demo map that shows it all.

Is it right for your project?

Likely a good fit if

• you want the rolling horizon look in a third-person, top-down or exploration game;
• you'd like distant scenery to disappear over the horizon instead of into fog;
• your level is lit by Movable lights (Lumen, Virtual Shadow Maps, ray-traced shadows or MegaLights);
• you want to change or fade the curve during play, for example around a cutscene or when the camera zooms.

Probably not right if

• your gameplay must happen on a curved world: characters walking around a planet, physics on the bend. Curved World bends only the picture; collision and movement stay flat;
• your level relies on baked (static) lighting. A curved world can't be baked;
• your game uses an orthographic camera (common in isometric games). Orthographic views show the world flat;
• your project isn't on UE 5.8 for Windows.

Before you start

• Every visible material needs the curve. A mesh whose material doesn't bend stays flat and floats above the dropping ground in the distance. Check Level finds those materials and Make Curved fixes them.
• Lights must be Movable to follow the curve. Static and Stationary lights keep their light and shadows where they were built.
• Characters are not curved. Keep them inside Flat Distance, where nothing bends. With a top-down camera, turn on Keep Ground Flat Around Player.
• Make Curved changes your materials. It adds nodes and, when you agree, saves them. Remove Curved World puts them back exactly as they were.
• Curved World is a code plugin and ships with its C++ source. To package a game you need Visual Studio with the C++ tools, also in a Blueprint-only project (see Packaging your game).

Quick start

1. Install Curved World, enable it in Edit → Plugins, and restart the editor.
2. See it working: open the demo map and press Play.
3. Curve your level: open your level, click the Curved World button on the level editor toolbar and choose Check This Level. In the window that opens, use Make Curved... on the materials it lists.
4. Make your lights follow: use Make Follow on the lights Check Level lists, or select your own lights and choose Make Selected Follow the Curve, or place new ones from Place Actors → Lights → Curved Point Light (or Spot, or Rect).
5. Tune the curve in the Curve section of the same window, or pick a preset for your camera.
6. Press Play. Lights follow the curve when you play; in the editor they stay where you put them.

In the editor, the curve is measured from the viewport camera, so a level seen from far away drops out of sight after Make Curved. Move the camera closer, or turn off Show Curve in Editor in the toolbar's Curved World menu while you edit.

The Curved World window

Open it with Tools → Curved World (under the menu's Rendering heading), or Open Curved World Window in the toolbar's Curved World menu. It has a Quick Start; the Curve settings and presets; Lights, to place the Curved lights; Check Level; Materials, for Make Curved; and Advanced: a debug view of the followers in Play, and links to the plugin's settings. The header links to this guide, the demo map and support.

The demo map

1. In the Content Browser, open Settings and tick Show Plugin Content.
2. Open Curved World Content → Demo → Maps → CurvedWorldDemo and press Play.

The map brings its own game mode, so it works in any project.

What each area shows:

• the start plaza has four boards: what bends and why, the lights, the top-down camera, and how to set up your own level;
• the avenue has two lanes of identical lamps: Curved Point Lights on the left, normal lights on the right. Walk down it: the right-hand pools fall behind their posts while the left-hand ones stay put. The avenue has its own, longer curve (Flat Distance 500 cm, Curve Distance 250 cm, Curve Exponent 2), switched on while you're inside it — an example of changing the curve at runtime;
• the wall section has Curved Spot Lights and Curved Rect Lights on curved walls;
• the square is laid out for the top-down camera (press 2).

Keys: W A S D or the arrow keys move · the mouse looks · the mouse wheel zooms (flying speed in free fly) · Q / E down / up in free fly · 1 third-person · 2 top-down · 3 free fly · C curve on / off (fades) · F lights follow the curve on / off · N bent shading on / off · G shows where each light is attached · R back to the start · H hides or shows the help. The demo reads the keys directly, so it needs no input settings and works with Enhanced Input or the legacy input.

The demo changes the curve of the play world only. Your project settings, the MPC_CurvedWorld asset and the editor viewport don't change, and when you stop playing everything is as it was.

Try your own character: open World Settings and clear GameMode Override. Your project's game mode, pawn and camera then show the curve and the following lights. The map has a nav mesh, so a click-to-move character (like the Top Down template's) can walk it. To get the demo back, pick Curved World Demo Game Mode in the same field.

Tuning the curve

Project Settings → Plugins → Curved World → Curve, or the Curve section of the Curved World window (Tools → Curved World). Changes show at once in the viewport and in Play.

How far the ground drops: at a distance d from the camera, ((d − Flat Distance) ÷ Curve Distance) raised to the Curve Exponent, in cm. With the defaults that's about 11 cm at 10 m, 46 cm at 15 m and 1.3 m at 20 m.

Presets (window → Curve):

Reset to Defaults puts the curve settings back to the plugin's defaults.

Top-down cameras: the curve is measured from the camera, so Flat Distance has to reach past the character: about the camera's distance from the character plus 300 cm. Keep Ground Flat Around Player does that for you every frame and keeps working when the camera zooms. Without it, the ground under your character bends while the character doesn't.

The settings are saved in your project's Config/DefaultGame.ini, so they go into source control with the project. To change the curve while the game runs, see Blueprint and C++.

Lights that follow the curve

Curved Point Light, Curved Spot Light, Curved Rect Light (Place Actors → Lights, after the standard lights) are normal lights, Movable, with a Curved World Follower built in. Drag one in; there's nothing to set up. The Details panel is a normal light's, plus a Curved World section. The toolbar menu and the window's Lights section also place them in front of the camera: a point light 150 cm above the surface you're looking at, spot and rect lights 300 cm above it, aimed at it.

Your own lights: select them and choose Make Selected Follow the Curve in the toolbar menu, or right-click them in the viewport or the Outliner → Curved World → Follow the Curve. This adds a Curved World Follower for each point, spot and rect light and each decal of the selected actors, and sets those lights to Movable. Directional and sky lights are skipped: they light everything alike, so there's nothing to follow. One Undo reverts it. On a Blueprint actor it changes the placed actor only; add the component in the Blueprint to cover every instance. Stop Following removes followers added this way.

Decals need a follower too: a decal's material can't bend, so far away it projects onto the ground where it used to be. The follower moves it with the surface it projects onto.

In Play, each follower moves its light rigidly with the surface it's attached to, every frame after the camera has moved, keeping the light's distance and angle to that surface. In the editor viewport, lights stay where you placed them, so judge pools of light in Play. Nothing is ever saved at its bent position.

Most lights never need the follower's settings (Details → Curved World):

Making materials curved

Make Curved adds the curve to existing materials. Select materials, or material instances, in the Content Browser and right-click → Curved World → Make Curved...; use Make Curved... on a Check Level finding; or use Make Selected Curved... in the window's Materials section. The window also takes a selection that mixes materials and instances; for such a mix, the right-click menu doesn't offer Curved World.

A preview shows what will happen to each material before anything changes: changed in place; copied (engine and plugin materials can't be changed, so a curved copy is made in /Game/CurvedWorld/Converted/ and used in the current level); already curved; or not supported, with the reason. Two options, both on by default:

• Set Max World Position Offset Displacement to 0. Any other value stops the surface bending past that distance. Instances that override the value are listed and set to 0 too.
• Keep textures fixed to the surface (unbent position). Textures placed by world position (triplanar, world-aligned) use the unbent position, so they don't slide up and down distant walls.

What it changes, on the root material (its instances follow):

• adds MF_CurvedWorld to World Position Offset, on top of any offset already there (wind, vertex animation);
• bends the shading normal with MF_CurvedWorldNormal; your normal map goes through it;
• turns on Always Evaluate World Position Offset, so the curve keeps working on meshes that turn World Position Offset (WPO) off or use a WPO disable distance;
• places the new nodes below your graph, in a blue comment box labelled Curved World.

While it runs, a progress window with a Cancel button shows which material is being changed (with only a few materials it may close before you notice it); after Cancel, what's done stays done. Each material is compiled before the next one starts, and a material that doesn't compile afterwards is put back unchanged. The results, one line per material, appear in the Materials section of the Curved World window, and a notification tells you when it's done; then Unreal offers to save the assets that changed. With ray tracing on, the results end with a Ray tracing line and a Turn On button for the level's meshes that use the converted materials without Evaluate World Position Offset in Ray Tracing. Copies are named like the original, with a number added when the name is taken.

Converting a curved material again changes nothing. Remove Curved World (same menus) asks first, then puts the original wiring and settings back exactly, with the same notification, results and save prompt. Edit → Undo reverts either. After Remove, materials and actors that were switched to a copy stay on it; to go back to the engine material, assign it again.

Remove uses the record Make Curved keeps in each material (see What Make Curved records). A copy made with Duplicate doesn't carry that record: Remove takes the curve's nodes out of the copy but leaves Always Evaluate World Position Offset on and Max World Position Offset Displacement at 0, so set those back by hand if you need the old values.

Make Curved handles ordinary, masked, translucent, unlit, two-sided foliage and skeletal-mesh materials, material attributes, Substrate materials (Slab and layered) and Material Layers; your layer and blend assets aren't changed. Decal materials can't bend: give the decal actor a Curved World Follower instead.

Curving a material by hand: add two functions from the palette (category Curved World):

• MF_CurvedWorld → World Position Offset. If the material already has an offset, Add the two.
• MF_CurvedWorldNormal → Normal. Plug your normal map into its TangentNormal input, or leave it empty for the surface's own normal. In material-attribute graphs use the Normal pin of Make Material Attributes. If the material uses world-space normals (Tangent Space Normal off), transform the normal to tangent space before MF_CurvedWorldNormal and back to world space after it; Make Curved does this for you.

Keep Max World Position Offset Displacement at 0 and tick Always Evaluate World Position Offset. M_CurvedWorld_Base in Curved World Content → Materials is the smallest working example. The same folder has ready-made curved materials for blockout: M_CurvedWorld_Base and M_CurvedWorld_Grid (a grid that stays fixed to the bending surface), each with Light, Dark, Orange and Blue instances (for example MI_CurvedWorld_Grid_Light).

Meshes need vertices to bend. Only vertices move, so long edges show the curve as flat facets: keep a vertex at least every 250 cm, and every 100 cm for ground and anything a pool of light falls on. The plugin's SM_CurvedWorld_Floor_1000 (a 10 m floor tile), SM_CurvedWorld_Wall_1000x400 and SM_CurvedWorld_Pillar_400 are built that way. M_CurvedWorld_Text is a curved material for Text Render components: set it as the component's Text Material.

Check Level

Choose Curved World → Check This Level on the toolbar, Check This Level in the window, or type cw.CheckLevel in the console. It checks the open level (all loaded levels; with World Partition, the loaded regions) and shows a headline such as "3 of 41 materials in this level don't bend with the curve", followed by findings sorted by severity. Each finding says what's wrong, why it matters, and which objects it affects.

• Select selects the objects; the fix button (Make Curved..., Make Follow, Turn On and so on) fixes them; Ignore hides that material, or that check, from now on.
• Fix All Safe applies every fix that only changes actors and components in this level and asks nothing. One Undo reverts them all.
• Fixes that change an asset or your project's config ask first. Ray-tracing settings are written to Config/DefaultEngine.ini, which is checked out or made writable if needed.
• Ignored materials and checks are kept in Project Settings → Plugins → Curved World Tools (saved in Config/DefaultEditor.ini). To skip one actor, give it the tag CurvedWorldIgnore.

It finds materials that don't bend, lights and decals that don't follow the curve, settings that stop meshes and landscapes bending, ray-tracing settings that don't suit curved meshes, and more: the full list is in the Check Level reference. Sky materials and very large meshes such as sky domes are left out of the count; they must never be curved. Check Level runs only when you ask for it.

Landscapes

Curved World bends landscapes like any other surface: give the landscape material the curve and check four settings.

1. Give the landscape material the curve. Select the material in the Content Browser and use Curved World → Make Curved..., or add MF_CurvedWorld to World Position Offset and MF_CurvedWorldNormal to Normal yourself. Layer blends and painted layers keep working: the curve only changes where the finished surface is drawn.
2. Check the landscape's settings (select the landscape, Details panel):
   • Enable Nanite: off (the default). Unreal doesn't run World Position Offset on Nanite landscapes, so a Nanite landscape stays flat.
   • Bake Material Position Offset Into Collision: off (the default). Collision stays flat, like everything else in Curved World; your characters and the Curved World Follower rely on that.
   • Use Material Position Offset In Static Lighting: off (the default).
   • LOD Distribution: keep the defaults or make them finer. Coarser settings show as a polygonal horizon. A larger LOD 0 Screen Size means less detail; larger LOD 0 and Other LODs values keep detail further away.
3. Match the curve to the landscape's resolution. With 1 m between landscape vertices (a landscape Scale of 100) and the default LOD settings, every preset looks smooth. A much steeper curve of your own (a short Curve Distance with a high Curve Exponent) can show small steps on the horizon: use finer LOD settings (above) or a finer landscape (Scale 50).
4. Grass and foliage. Give every grass and foliage mesh the curve too (Make Curved on their materials), or they float above the curved ground in the distance. Leave Instance World Position Offset Disable Distance at 0 on your grass types. Wind animation keeps working: the curve is added to it. Landscape grass grows on curved landscapes and sits on the bent ground. After you curve a landscape material, the editor may keep showing the old grass: type grass.FlushCache in the console to grow it again.

Nothing else to set up. Lumen (software or hardware), Virtual Shadow Maps and ray-traced shadows all follow the curved landscape. With ray tracing, grass and other instanced meshes are traced without the curve (see Compatibility).

Runtime virtual textures work: they store the landscape before it bends, so everything that reads them by world position stays stable. If your landscape writes its normal into a runtime virtual texture, don't bend that normal; bend it in the material that reads the virtual texture.

Show Curve in Editor

Show Curve in Editor (a checkbox in the toolbar menu and in the window; also Editor Preferences → Plugins → Curved World) bends the level viewport like the game does. Turn it off to edit in a flat world. It's your own preference, saved for you only. Play in Editor (PIE), Simulate, packaged games, your levels and the MPC_CurvedWorld asset are never affected, and switching it never marks anything as changed.

The editor's Top, Side and Front viewports always show the world flat; see Known limitations.

Blueprint and C++

Category Curved World. Changes apply to the world you call them in and last until that world ends; your project settings don't change, and Curved World Followers follow every change in the same frame.

The Curved World Follower has nodes too: to look for its surface again (for example after you moved the surface under the light), to put the light back where you placed it, and to read where it was placed, what it's attached to and whether it's following.

Gameplay can also set the parameters of MPC_CurvedWorld directly with Set Scalar Parameter Value; followers follow those changes as well. Every world starts from your project settings.

C++: add "CurvedWorld" to your module's dependencies and include the headers from CurvedWorld/Source/CurvedWorld/Public. The generated headers come with the plugin.

Compatibility

Curved World is tested on UE 5.8 for Windows, in new projects with the default rendering settings (Lumen, Virtual Shadow Maps, Substrate, ray tracing support on) and in projects that use ray-traced shadows.

Performance

The curve itself is cheap: in our tests, about 0.1–0.2 ms of GPU time for 7,200 curved instances and a landscape at 1920 × 1080. Curved meshes redraw their Virtual Shadow Map pages every frame, so each shadow-casting light over curved ground costs a little more than usual: give shadows only to the lights that need them. Each Curved World Follower costs a few microseconds of game-thread time per frame while the camera moves (about 0.2 ms for 100 followers in a packaged game).

Packaging your game

The curve lives in your materials, so a packaged game looks the same as Play in Editor. The plugin's runtime code (followers, settings, Blueprint functions and the demo's game mode) is compiled into your game; the editor tools aren't.

You need Visual Studio with the C++ tools to package a game, also for a Blueprint-only project. Unreal compiles the plugin into your game, so when it packages, it treats every project that uses Curved World as a C++ project. Set Visual Studio up as Unreal's Setting Up Visual Studio page describes. An engine-installed plugin does not need a project C++ class.

If you copied the plugin into your project's Plugins folder and the project has no C++ code, Unreal packages the game without the plugin, and the game stops at start with Plugin 'CurvedWorld' failed to load because module 'CurvedWorld' could not be found. Add a C++ class to the project (Tools → New C++ Class..., any class), then package again.

If your project doesn't list which maps to package, Unreal packages every map and asset it can find, and that includes the demo map. To leave it out, add /CurvedWorld/Demo to Project Settings → Packaging → Directories to never cook.

Troubleshooting

Meshes float above the ground, or sink, in the distance

Their material doesn't have the curve, or something stops it bending. Run Check Level: it finds materials without the curve, a Max World Position Offset Displacement above 0, and meshes with World Position Offset turned off or a WPO disable distance.

Pools of light slide across the ground as the camera moves

The light has no Curved World Follower, or isn't Movable. Run Check Level and use Make Follow (or Fix All Safe).

The curve shows as flat facets on distant ground

The mesh has too few vertices: keep one at least every 100 cm on ground. On landscapes, see the LOD settings in Landscapes.

Packaged game: "Plugin 'CurvedWorld' failed to load because module 'CurvedWorld' could not be found"

The plugin is in the project's Plugins folder and the project has no C++ code, so the game was packaged without it. Add a C++ class (Tools → New C++ Class...) and package again. See Packaging your game.

Landscape grass doesn't appear, or doesn't change, after you curve the landscape material

Type grass.FlushCache in the console to grow the grass again. Give the grass mesh's material the curve too, or the grass floats where the ground drops.

Curved meshes look as if they shadow themselves in the editor viewport (ray tracing)

Their Evaluate World Position Offset in Ray Tracing is off. Play turns it on for you; Check Level offers a fix that saves it with the level.

Shadows of curved Nanite meshes from point, spot or rect lights look detached in the distance

See the Nanite row in Compatibility: ray-traced shadows on those lights, MegaLights, or Nanite off on the mesh.

Log: "Curved World: the parameter collection ... can't be found" or "... has no parameter named ..."

Project Settings → Plugins → Curved World → Advanced points to a collection or parameter names that don't exist. Put them back to the defaults (/CurvedWorld/Core/MPC_CurvedWorld and its parameter names), or reinstall the plugin if the collection is missing.

Log: "... is Static, so it can't follow the curve. Set its Mobility to Movable." (or Stationary)

Set the light to Movable. Baked light and shadows can't follow the curve.

Log: "... is a directional or sky light; those are never followed"

Remove the Curved World Follower from that actor: directional and sky lights don't need one.

Log: "... has nothing to move"

The follower is on an actor without a point, spot or rect light or a decal. Set its Target, or remove it.

Log: "... found no surface to follow"

Aim the light at a surface, raise Trace Distance, or set Anchor Mode to Self or Manual. A light that finds no surface uses its own position, which is harmless for lights that spin or move freely.

Log: "... has a child ... with a curved material, so it bends twice"

A mesh with a curved material is attached under the component the follower moves, so it's moved by the follower and bent by its material as well. Attach it so it isn't under that component, for example by making the light a child of the mesh instead.

Log: "r.RayTracing.Geometry.InstancedStaticMeshes.EvaluateWPO is ... in your project" or "...WPO.Culling is 1..."

Your project sets a ray-tracing value that doesn't suit curved meshes. Check Level offers to write the right value to Config/DefaultEngine.ini.

"The curve settings couldn't be saved to Config/DefaultGame.ini"

The file is read-only or checked in. Make it writable (or check it out), then change a value again.

Make Curved stays on one material for minutes, or the editor stops while compiling shaders

Make Curved compiles each material before moving on, so large materials take a while. In UE 5.8.3, a large batch of shaders sent to a distributed build system (Incredibuild / XGE) can stall. If that happens, add this to your project's Config/DefaultEngine.ini and restart the editor:

[ConsoleVariables]
r.ShaderCompiler.AllowDistributedCompilation=0

Log, when you stop playing the demo map: "Unable to find RecastNavMesh instance while trying to create UCrowdManager instance"

That's Unreal's navigation shutting down in a level with a nav mesh, not Curved World. You can ignore it.

"UnrealEditor.exe - Bad Image ... Error status 0xc0e90002", or the plugin doesn't load on Windows 11

This is Windows Smart App Control blocking a plugin file, not a fault in the file. Smart App Control blocks program files that aren't digitally signed unless Microsoft's online service already recognises them. Unreal plugin files usually aren't signed, whether they come from Fab or are built on your computer, so this can happen with any code plugin. Its decisions can also vary: the same file can be blocked once and allowed on the next launch.

• Close the message and start the editor again. It often loads on the next try.
• If it keeps happening, the setting is in Windows Security → App & browser control → Smart App Control. Microsoft offers no way to allow individual apps, so the only choice there is on or off for the whole computer. Whether to change it is up to you.

Removing the plugin

1. Run Remove Curved World on the materials Make Curved changed (select them in the Content Browser → right-click → Curved World → Remove Curved World...). Take the two functions out of any material you curved by hand. Otherwise those materials point to functions that no longer exist.
2. Replace Curved Point, Spot and Rect Lights with standard lights, and remove Curved World Follower components from your actors and Blueprints. Levels lose them when the plugin is gone.
3. Disable the plugin in Edit → Plugins and restart the editor. Delete any copies in /Game/CurvedWorld/Converted/ you no longer use. You can also delete the Curved World sections from Config/DefaultGame.ini and Config/DefaultEditor.ini.

Roadmap

Planned updates (none of these are included in the current version):

• Curve areas: volumes that change the curve inside part of a level, like the demo's avenue.
• Planet style: an option to bend the world around the player instead of the camera, so the whole view reads as a small globe.
• Orthographic cameras: an option to bend orthographic views.
• Earlier engine versions: UE 5.0 – 5.7.

Part 2 — Technical reference

For technical artists and programmers who want to know exactly how the plugin works.

How the curve works

Every curved material calls MF_CurvedWorld, which moves each vertex by

offset = Curve Amount × g × Curve Direction
g      = max(0, (d − Flat Distance) ÷ Curve Distance) ^ Curve Exponent

where d is the 3D distance from the vertex's unbent position to the camera. With the default direction (0, 0, −1) the ground drops away from the camera like a small planet. MF_CurvedWorldNormal bends the shading normal with the same curve, scaled by Bend Normals.

• The curve is centred on the camera of the view being drawn, so every view bends around its own camera.
• Orthographic views get no curve, except in shadow passes. Unreal draws some things with straight-down orthographic views behind the scenes, such as landscape grass placement, and those must see the flat world. The sun's shadows are orthographic too, which is why shadow passes keep the curve.
• Only vertices move, and only in the picture. Collision, physics, navigation, traces and actor transforms stay in the flat world.

Where the values come from

The values live in the Curved World parameter collection, MPC_CurvedWorld (/CurvedWorld/Core), which every curved material reads. The asset only holds the plugin's defaults and is never changed: when a world starts (editor, editor previews, Play in Editor, game), Curved World writes your project settings into that world's copy of the collection, and it writes them again to every open world when you change a setting. Fab installs plugins into the engine, where the collection is shared by every project on that engine version and replaced when the plugin updates, which is why your values belong in your project's settings.

Show Curve in Editor sets Curve Amount to 0 on level-editor worlds only. The Blueprint functions change one world's copy until that world ends. Curved World Followers read the live values every frame, so they follow every change.

The Curved World Follower in detail

Every frame in Play, after the camera has been updated, each follower:

1. finds the surface its light is attached to, by tracing against collision (which isn't bent) — again only when the light has moved more than Retrace Distance (50 cm) or turned more than Retrace Angle (2°) since the last search;
2. computes where that surface point is drawn this frame, with the same formula as the material, and how the surface tilts there;
3. moves and turns the light rigidly with the surface, keeping its distance and angle to it, unless the change is below Update Threshold.

Lights must be Movable. Directional and sky lights are never moved. The follower moves lights only in Play; your level always keeps them where you placed them.

Automatic ray-tracing setup

Unreal's ray tracing (ray-traced shadows and hardware Lumen) uses its own copy of each mesh. For that copy to follow the curve, a mesh needs Evaluate World Position Offset in Ray Tracing, and Unreal must not skip World Position Offset on distant meshes. When ray tracing is on, Curved World therefore:

• at editor and game start, sets r.RayTracing.Geometry.StaticMeshes.WPO.Culling=0, unless your project sets it (then your value is kept and the log says so once);
• when you press Play and when levels stream in, turns on Evaluate World Position Offset in Ray Tracing for every static mesh whose material is curved, and logs once per level how many meshes it checked and changed.

It never changes instanced meshes and foliage, and it leaves r.RayTracing.Geometry.InstancedStaticMeshes.EvaluateWPO at Unreal's default 0: Unreal can't trace the curve per instance, so instanced meshes are traced unbent (see Known limitations).

Turning off Automatic Ray Tracing Setup (Project Settings → Plugins → Curved World → Ray Tracing, on by default) stops all of this; the change takes effect the next time the editor starts. Log Each Component adds one log line per mesh it changes. The console command cw.ApplyMeshSettings persistent applies the mesh settings to the open level and saves them with it.

Settings reference

Project Settings → Plugins → Curved World (saved in Config/DefaultGame.ini):

Project Settings → Plugins → Curved World Tools (saved in Config/DefaultEditor.ini): the materials and checks Check Level ignores.

Editor Preferences → Plugins → Curved World (per user): Show Curve in Editor.

Check Level reference

Every check can be turned off in Curved World Tools. Fixes that only change actors and components in the level are "safe" (Fix All Safe); fixes that change assets or config files always ask.

What Make Curved records

Make Curved keeps everything Remove Curved World needs in the material's package metadata: the original World Position Offset and Normal links (including their channels), and the original values of Max World Position Offset Displacement (on the material and on instances) and Always Evaluate World Position Offset. The nodes it adds are marked Curved World. Edit → Undo reverts a Make Curved or Remove run but not the metadata. That does no harm: the next Make Curved replaces the record, so Remove always restores the values from before the last run.

Console commands

Known limitations

• Only the picture bends. Collision, physics, navigation, traces and actor transforms stay flat. That's the design: gameplay keeps working, and the effect stays cheap.
• Lights follow only in Play. In the editor viewport they stay where you placed them.
• Instanced meshes and foliage in ray tracing are traced without the curve: their ray-traced shadows (and hardware Lumen) are exact near the camera and slightly offset in the distance, and a tall instance far away can cast its shadow from where it would stand unbent. Virtual Shadow Maps are exact everywhere. In the editor viewport, curved instanced meshes may show no ray-traced shadows; judge them in Play.
• Curved Nanite meshes and Virtual Shadow Maps: shadows that point, spot and rect lights cast from curved Nanite meshes come from the unbent mesh, right near the camera and offset in the distance. The sun is unaffected. Workarounds: ray-traced shadows on those lights, MegaLights, or Nanite off on the mesh.
• Nanite landscapes stay flat: Unreal doesn't run World Position Offset on them.
• Orthographic views show the world flat, and orthographic game cameras aren't supported. In the editor's Top, Side and Front viewports, shadows may not match the flat world.
• Baked lighting isn't supported: use Movable lights.
• Max World Position Offset Displacement must be 0 on curved materials.
• One curve per world. Every view in a world uses the same curve values; lights follow the first local player's camera.
• Not tested: Niagara particles, split-screen, VR, landscape splines, water bodies and landscape HLODs.
• Windows only, Unreal Engine 5.8. Tested with Epic Games Launcher engine installs; engines built from source haven't been tested.

Automation tests

The plugin ships with its automated tests. Run them from the editor console:

Automation RunTests CurvedWorld

They check the curve math against reference values, that your settings reach every kind of world, the Curved lights and the Curved World Follower, the automatic ray-tracing setup, and the editor tools: placing lights, Show Curve in Editor, Make Follow, Check Level, and Make Curved and Remove on throwaway materials. They use their own test worlds and assets.

Licence and credits

Copyright © 2026 SDProjects. Licensed under the Fab Standard License, which licenses plugins per user: each person using the plugin needs their own licence.

Unreal® Engine is a trademark of Epic Games, Inc.

This guide also ships with the plugin, as README.md in the plugin's folder.

Support: ask in the SDProjects Discord support channel: https://discord.gg/T3fcVCcBKS