Skip to main content

Roadmap

Tasks in this roadmap are arranged roughly in the order in which we plan to approach them. If you urgently need one of these problems solved, or you need a feature which isn't present in the roadmap, please contact us via email or Discord to discuss custom development.

Short-Term Roadmap​

1. Longitudinal landscape adjustment​

The landscape adjustment at the start/end of a Path currently ends abruptly. We are implementing a smoother transition with falloff, controlled by a customizable curve.

image

2. Cables and attachments​

One of the first new features we plan to release is support for cables and attachments. This will include a special version of the CableComponent with options for attaching to meshes spawned by Paths (even between different Paths). We will also support stretching any mesh between two attachments, for example to create a steel wire in a suspended bridge.

image

3. Improved PathLabel painting​

In the current implementation, the cursor tends to be erratic and unreliable when painting Labels (as cursor location gets projected onto a Path). To address this, we've decided to switch to using a circular brush with an adjustable radius for more precise and consistent painting.

4. Improved UI for SpawnConditions and PathDesc​

Current UI for SpawnConditions isn't helpful in understanding the concepts behind conditional spawning. We are working on a complete redesign of this UI element. Another aspect we are working on is to make PathDescription asset more readable and intuitive.

image

5. Multiple PathLayers within a single PathTemplate​

Currently, each PathTemplate can only have a single PathLayer assigned. PathLayers determine which parts of a Path are spawned sequentially (one after another) and which can be spawned concurrently (overlapping each other).

For example:

  • "Asphalt" PathLayer includes various asphalt meshes that form a continuous road surface.
  • "Barriers" PathLayer includes guardrails and concrete walls that spawn independently of the asphalt, creating their own continuous surface.

In the current version of the plugin, only one PathLayer can be assigned per PathTemplate asset, requiring users to create multiple PathTemplates. This leads to a large number of assets and extra complexity. We are working on supporting assigning PathLayers on a per-component basis which will solve this problem.

image

Long-Term Roadmap​

1. Performance improvements​

Long Paths currently take too long to generate. We have several optimizations planned to improve performance, including:

  • Reusing components to avoid unnecessary spawning and destruction
  • Implementing multi-threaded spawning
  • Updating only the portion of the Path modified by the user (when adjusting a spline)
  • Streamlining and optimizing the code

2. Applying noise to landscape adjustment​

When making rivers or dirt roads, it would be useful to be able to add noise to the landscape adjustment. We plan to add such controls.

3. Scaling spawned content and landscape adjustment with spline point scale​

In order to make Errant Paths a good tool for making rivers, we need to add support for scaling the Paths based on spline point scale.

4. Tools for "painting" PathTemplates over a Path​

Currently, users must rely on procedural logic (PathLabels and SpawnConditions) to control which PathTemplates are spawned along a Path. This approach requires a solid understanding of various systems in Errant Paths, which can be challenging for new users. To improve ease of use, we plan to introduce a tool that allows users to manually select a PathTemplate and paint or fill the Path with it. This will simplify the learning curve while providing more manual artistic control. Additionally, procedural generation can still influence these manually placed PathTemplates, preserving programmability.

5. Advanced Path Labels that affect landscape/biomes/width/tilt and much more​

Path Labels used for conditional spawning currently can only have two states at a given position along a Path - either true or false. This limits their use to making binary choices about the Path. We would like to add support for storing all kinds of data in Labels, including floats and custom structures, as well as providing ways to customize the Label visualization and input handling depending on the stored data.

Through these improvements, Labels would become a universal way of controlling all aspects of a Path, including its width, landscape adjustment, tilt/roll, the amount of spawned objects, dirt, snow, and much more.

6. More examples in the ErrantPathsAssetLibrary​

We'll also be adding examples to the Asset Library to showcase existing plugin features. We will certainly add more versions of the asphalt roads, with various intersections, roundabouts, transitions between 1-2-3 lane variants, additional turn lanes, etc.

We will also add new types of Paths, such as powerlines, rivers, fences, etc.

Each of the existing Path types will also be further developed to add detail and automation.

7. UX improvements​

There are many operations currently which take too many clicks and are too cumbersome. For example, adding an intersection to a road requires splitting the road, making a room for the intersection, then spawning the intersection and connecting both ends of the road to it.

We plan to streamline such operations significantly. For example adding a an intersection should simply require drag&dropping the intersection asset onto an exisitng Path. Then user should have a chance to rotate the intersection and spawn it. The Path should split automatically and attach to correct ends of the intersection.

We have ideas for improvements to many aspects of the plugin, including UI, visualizations, debugging, etc.

8. Integration with PCG​

We plan to add integration with PCG at different stages of the generation.

9. MultiPointSplineMesh​

When adding meshes in PathTemplates, we sometimes want to place long meshes that span over the entire template. Especially in intersections, we often want to place lane markings across the whole intersection and bend that mesh along with the asphalt meshes underneath.

Unfortunately, SplineMeshComponent in Unreal has only two control points and can't be used conveniently in such scenario. We need a mesh that can have any number of control points and repeats along the spline. These control points can then be anchored to the meshes underneath to ensure correct bending.

Such a feature would also requires additional UI and visualizations.

10. Bendable intersections​

We already support bending intersections with the main/secondary PathSplines. However, we lack tools/visualization for users to control how each part of the intersection bends with a given PathSpline (blend weights, similarly to skinning weights in skeletal animation). Currently we use a simple distance-based heuristic to calculate blend-weights, but this isn't enough.

Aside from that, we also need to add ways to ensure that certain parts of the intersection stay attached to each other. For example a curb on the corner of a street shouldn't desintegrate as you change the shape of the intersection.

11. Pathfinding​

We already have Pathfinding, but it is disabled by default (in Editor Preferences) as it lacks performance, reliability and intuitive user interface. We plan to significantly improve all of these aspects.

12. Dividing HISMs into smaller components for better culling​

We currently group StaticMeshes into a HISM (Hierarchical Instanced Static Mesh Component) even when these meshes are very far apart (within the same SubActor). This leads to large HISMs that might now work well with culling or other rendering optimizations. We plan to introduce a mechanism that only groups meshes that are close to each other.

13. Spawning/placing Paths at runtime (in-game)​

As part of our push to make all of our plugins work at runtime, Errant Paths will also undergo architectural changes to allow for spawning Paths as part of gameplay.

14. Using different mesh variants depending on the Path shape​

Curvy Paths made of SplineMeshes sometimes lead to overstretching these meshes, which doesn't look natural. We plan to add support for a SplineMesh and StaticMesh that contains several variants of the same mesh that represent various shapes (straight, 90-deg-left-turn, 45-deg-right-turn, etc). Errant Paths would then pick the variant that best matches the spline curvature, to avoid overstretching the mesh.

15. Better UI for conditional spawning in PathTemplate blueprints​

Currently, to edit a spawn condition for a mesh, user needs to click on the actor in a PathTemplate blueprint. Then the list of spawn conditions is displayed in a UI panel. We would prefer to show these conditions in mesh details panel or in the viewport. We haven't found a way to achieve that yet, but we will be trying to make that UI more intuitive.

16. Auto-conversion of straight-line spline-meshes to static-meshes​

Spline-meshes that have a straight-line shape after spawning can be replaced with static-meshes without any loss in visual fidelity. Such conversion improves the rendering performance of Paths as static-meshes are cheaper to render than spline-meshes.

Errant Paths automatically performs this conversion when spawning meshes, but it currently converts only the meshes that have no attached children. We plan to enable it also for meshes with children.

Note that this system is disabled by default and needs to be enabled in Path properties and in PathTemplateStaticMesh/PathTemplateSplineMesh properties.

17. Complex Paths - combining multiple Paths into one​

We would like to add support for combining different Path types into a single Path types. For example combining an "Asphalt", "BikeLane", "SideWalk" Paths into a single, "Street" Path.

Currently, this can be achieved via Dependant Paths, but we would like to explore this idea in much greater depth.