Various documentation updates

jankrassnigg · jankrassnigg · commit 542b92c00453 · 2026-03-01T16:42:28.000+01:00
diff --git a/pages/docs/animation/paths/media/spline-mesh.jpg b/pages/docs/animation/paths/media/spline-mesh.jpg
diff --git a/pages/docs/animation/paths/spline-component.md b/pages/docs/animation/paths/spline-component.md
@@ -83,3 +83,4 @@ Also see the [spline node component](spline-node-component.md) for options on ea
 
 * [Spline Node Component](spline-node-component.md)
 * [Follow Path Component](follow-path-component.md)
+* [Spline Mesh Component](spline-mesh-component.md)
diff --git a/pages/docs/animation/paths/spline-mesh-component.md b/pages/docs/animation/paths/spline-mesh-component.md
@@ -0,0 +1,42 @@
+# Spline Mesh Component
+
+The *spline mesh component* generates a mesh that follows a [spline](spline-component.md). It tiles one or more mesh pieces along the spline, making it easy to create things like pipes, roads, fences, cables or rails without manually placing individual segments.
+
+![Spline Mesh](media/spline-mesh.jpg)
+
+## Setting up a Spline Mesh
+
+1. Add a [spline component](spline-component.md) to a game object and configure the spline shape.
+1. Attach a *spline mesh component* to the same object.
+1. Set at least one **Middle Part** — this mesh is tiled along the spline.
+1. Optionally set a **Start Part** and/or **End Part** to cap the spline with specialized meshes (e.g. a pipe end-cap).
+
+## Distribution Modes
+
+The **Distribution Mode** controls how many mesh pieces are placed and how they are scaled:
+
+* **Fit to Segment**: Each middle part is stretched to fill exactly one spline segment (the span between two spline nodes). Use this when your mesh should align with the spline node positions.
+* **Scale Evenly** *(default)*: The number of tiles is derived from the total spline length and the mesh length. All tiles are scaled uniformly.
+* **Scale Evenly Per Segment**: Like *Scale Evenly*, but computed independently for each spline segment. This keeps tiles aligned to segment boundaries.
+
+When multiple middle parts are specified, either a random piece or the best-fitting piece is selected at each position, depending on the distribution mode and the relative lengths of the available parts.
+
+## Component Properties
+
+* **Start Part**: Optional mesh placed at the beginning of the spline.
+* **Middle Parts**: One or more meshes tiled along the spline body. Each entry has optional **Padding Front** / **Padding Back** values (can be negative to create overlaps).
+* **End Part**: Optional mesh placed at the end of the spline.
+* **Distribution Mode**: How tiles are counted and scaled (see above).
+* **Seed**: Random seed used when picking among multiple middle parts. A negative value uses the owner object's stable random seed; zero or positive sets an explicit seed.
+* **Offset Y**: Shifts the entire generated mesh sideways (along the spline's local Y axis).
+* **Offset Z**: Shifts the entire generated mesh up/down (along the spline's local Z axis).
+
+## Collision
+
+To add physics collision to a spline mesh, add a [Jolt Generate Collision Component](../../physics/jolt/special/jolt-generate-collision-component.md) to the same game object. It reads the render meshes produced by the spline mesh component and generates a matching Jolt collision mesh on scene export.
+
+## See Also
+
+* [Spline Component](spline-component.md)
+* [Spline Node Component](spline-node-component.md)
+* [Jolt Generate Collision Component](../../physics/jolt/special/jolt-generate-collision-component.md)
diff --git a/pages/docs/assets/asset-browser.md b/pages/docs/assets/asset-browser.md
@@ -20,7 +20,11 @@ The asset browser can show all files that are on disk in the selected [data dire
 
 **Non-Importable files** are all other files. The editor can't do anything with them, other than to open the default application associated with this file type.
 
-You can also move and delete files and assets. Note that deleting a file moves it to the trash folder, so you can restore the file through the operating system functionality, if necessary. 
+You can also move and delete files and assets. Note that deleting a file moves it to the trash folder, so you can restore the file through the operating system functionality, if necessary.
+
+### Delete & Replace
+
+Right-clicking a single asset reveals a **Delete & Replace...** option. This opens an asset picker where you select a replacement asset. The editor then rewrites every asset document that referenced the deleted asset so that it now points to the replacement, and finally deletes the original asset. This is useful when consolidating duplicate assets.
 
 ## Search Field
 
@@ -50,7 +54,7 @@ On the left the asset browser displays all [data directories](../projects/data-d
 
 The **eye button** to the right of the search field, toggles which assets are shown. If it shows the *open eye*, the asset browser displays *all assets* below the currently selected folder, if it shows the *closed eye*, only the files directly inside the selected folder are shown. The former mode makes it easy to find assets for which you only roughly know where they are, the latter mode is more useful when you have many assets and you only want to see the ones from a specific folder.
 
-When any search term is entered into the text box, automatically all files are displayed. 
+When any search term is entered into the text box, automatically all files are displayed.
 
 Some people prefer one mode or the other as their default, which is why this setting is saved and restored between editor runs.
 
diff --git a/pages/docs/assets/asset-curator.md b/pages/docs/assets/asset-curator.md
@@ -6,9 +6,7 @@ The *asset curator panel* is a tool to help find and fix problems with [assets](
 
 ## Activity
 
-At its top the asset curator panel displays an activity log. If *background transform* is active, this shows which assets have been transformed recently. Whether background transform is enabled can be seen from the progress bar at the bottom:
-
-![Transform Progress](media/transform-progress.png)
+At its top the asset curator panel displays a timeline of recently processed assets. Each bar represents one asset being transformed, with the Y-axis showing the individual worker processes and the X-axis showing time. Periods of inactivity are compressed to keep the view compact, indicated by a diagonal pattern. This makes it easy to see how many assets were processed in parallel and how long each one took.
 
 ## Transform Issues
 
diff --git a/pages/docs/custom-code/angelscript/as-messaging.md b/pages/docs/custom-code/angelscript/as-messaging.md
@@ -47,7 +47,14 @@ If you need to send a message from one component and handle it in another compon
 
 ### AngelScript Event Messages
 
-At the moment it is not supported to send AngelScript messages as event messages.
+AngelScript messages can be sent as event messages using `ezGameObject::SendEventMessage()` and `ezGameObject::PostEventMessage()`, just like C++ event messages:
+
+```cpp
+AsMyEventMsg msg;
+GetOwner().SendEventMessage(msg, GetOwnerComponent());
+```
+
+Event messages travel up the object hierarchy. If intermediate objects have script components that do not handle the message, those components must have the **Pass-Through Unhandled Events** option enabled on their [script component](as-components.md), otherwise the event will stop propagating at that object.
 
 ## See Also
 
diff --git a/pages/docs/debugging/tracing.md b/pages/docs/debugging/tracing.md
@@ -1,14 +1,16 @@
 # Tracing
 
-ezEngine provides a cross-platform tracing system that emits structured events to the operating system's tracing infrastructure. Tracing is different from [profiling](../performance/profiling.md) and [logging](../performance/logging.md) as it allows for different debugging aproaches:
-1. Unlike [profiling](../performance/profiling.md), which stores data in an in-process ring buffer, tracing sends events to an external OS-level backend for capture by dedicated tools. This enables correlation with e.g.kernel events (scheduling, I/O).
+ezEngine provides a cross-platform tracing system that emits structured events to the operating system's tracing infrastructure. Tracing is different from [profiling](../performance/profiling.md) and [logging](logging.md) as it allows for different debugging approaches:
+
+1. Unlike [profiling](../performance/profiling.md), which stores data in an in-process ring buffer, tracing sends events to an external OS-level backend for capture by dedicated tools. This enables correlation with e.g. kernel events (scheduling, I/O).
 1. Traces are system wide so you can capture events from multiple threads / processes, even those you don't own.
 1. You can attach data fields to a trace event which are structured, allowing tools to aggregate or filter by them.
-1. Each trace event stores process and thread information, allowing to filter by various dimensions unlike [logging](../performance/logging.md) which is always linear.
+1. Each trace event stores process and thread information, allowing to filter by various dimensions unlike [logging](logging.md) which is always linear.
 
 When you should not use tracing:
-1. If you need instant feedback in the debugger, use [logging](../performance/logging.md) instead.
-1. If you want to do performance profiling on CPU / GPU, use [profiling](../performance/profiling.md) for capturing or [tracy](../performance/profiling.md) for real-time observation instead.
+
+1. If you need instant feedback in the debugger, use [logging](logging.md) instead.
+1. If you want to do performance profiling on CPU / GPU, use [profiling](../performance/profiling.md) for capturing or [tracy](tracy.md) for real-time observation instead.
 
 
 The tracing system uses:
diff --git a/pages/docs/physics/jolt/special/jolt-generate-collision-component.md b/pages/docs/physics/jolt/special/jolt-generate-collision-component.md
@@ -0,0 +1,28 @@
+# Jolt Generate Collision Component
+
+The *Jolt generate collision component* automatically creates a static collision mesh from the render meshes produced by a [spline mesh component](../../../animation/paths/spline-mesh-component.md) on the same game object.
+
+Because spline meshes are procedurally generated from a set of render mesh pieces, there is no single pre-authored collision asset that can be assigned by hand. This component solves that by mapping each render mesh piece to a corresponding Jolt collision mesh asset, then assembling the collision geometry to match the generated spline mesh exactly.
+
+## Setup
+
+1. Add a [spline mesh component](../../../animation/paths/spline-mesh-component.md) to a game object.
+1. Add a *Jolt generate collision component* to the same object.
+1. For each render mesh piece used by the spline mesh component, add an entry to the **Mesh Mappings** list:
+   * **Render Mesh**: The render mesh asset used in the spline mesh component.
+   * **Collision Mesh**: The corresponding [Jolt collision mesh](../collision-shapes/jolt-collision-meshes.md) asset (triangle mesh).
+1. Set the **Collision Layer** to the appropriate [collision layer](../collision-shapes/jolt-collision-layers.md).
+
+Render mesh pieces that have no mapping entry will not produce any collision geometry.
+
+## Component Properties
+
+* **Mesh Mappings**: List of render-mesh-to-collision-mesh pairs. Each entry maps one render mesh to one Jolt triangle collision mesh.
+* **Collision Layer**: The [collision layer](../collision-shapes/jolt-collision-layers.md) assigned to the generated static actor.
+
+## See Also
+
+* [Spline Mesh Component](../../../animation/paths/spline-mesh-component.md)
+* [Jolt Collision Meshes](../collision-shapes/jolt-collision-meshes.md)
+* [Jolt Static Actor Component](../actors/jolt-static-actor-component.md)
+* [Jolt Collision Layers](../collision-shapes/jolt-collision-layers.md)
diff --git a/pages/docs/terrain/procedural/procgen-graph-output-placement.md b/pages/docs/terrain/procedural/procgen-graph-output-placement.md
@@ -30,15 +30,22 @@ More elaborate filtering can be achieved with [modifier nodes](procgen-graph-mod
   ![Different cull distances](media/procgen-cull-distance.jpg)
 
 * `PlacementMode`: How to determine the location where to place objects.
-  1. *Raycast:* In this mode a physics ray is cast downwards from the volume of the [placement component](procgen-placement-component.md). Using the `CollisionLayer` and `Surface` as filters, the closest intersection point is used.
+  1. *Raycast:* A physics ray is cast downwards from the volume of the [placement component](procgen-placement-component.md). Using the `CollisionLayer` and `Surface` as filters, the closest intersection point is used.
 
      ![Placement mode: raycast](media/procgen-placement-raycast.jpg)
 
-  1. *Fixed:* In this mode objects are always placed at the height of the [placement component](procgen-placement-component.md). No ray is cast, and no location is filtered out. This can be used for 2D games where no [collision geometry](../../physics/jolt/collision-shapes/jolt-collision-meshes.md) exists. Custom filtering can still be achieved through [image volumes](procgen-volume-image-component.md) and other [modifiers](procgen-graph-modifiers.md).
+  1. *Raycast High Quality:* Like *Raycast*, but additionally fires `NumAdditionalRays` extra rays in a circle of radius `RaySpread * Footprint` around the initial hit point. If any of the surrounding rays misses (e.g. the object would be placed too close to a ledge or overhang), the placement is rejected. The normals of all successful hits are averaged to produce a smoother surface orientation for `AlignToNormal`. Use this mode when visual quality matters more than raw performance.
+
+  1. *Fixed:* Objects are always placed at the height of the [placement component](procgen-placement-component.md). No ray is cast and no location is filtered out. This can be used for 2D games where no [collision geometry](../../physics/jolt/collision-shapes/jolt-collision-meshes.md) exists. Custom filtering can still be achieved through [image volumes](procgen-volume-image-component.md) and other [modifiers](procgen-graph-modifiers.md).
 
      ![Placement mode: fixed](media/procgen-placement-fixed.jpg)
 
-* `CollisionLayer`: The [collision layer](../../physics/jolt/collision-shapes/jolt-collision-layers.md) to use when `PlacementMode` is set to *Raycast*. The collision layer decides which physical objects will be hit by the raycast and thus on which surfaces objects may get spawned at all. Note that in *Raycast* mode objects can only be placed, if a [collision meshes](../../physics/jolt/collision-shapes/jolt-collision-meshes.md) exist in the scene at all ([greyboxes](../../scenes/greyboxing.md) and [heightfields](../heightfield-component.md) set these up automatically).
+* `CollisionLayer`: The [collision layer](../../physics/jolt/collision-shapes/jolt-collision-layers.md) to use when `PlacementMode` is set to *Raycast* or *Raycast High Quality*. The collision layer decides which physical objects will be hit by the raycast and thus on which surfaces objects may get spawned at all. Note that in raycast modes objects can only be placed, if [collision meshes](../../physics/jolt/collision-shapes/jolt-collision-meshes.md) exist in the scene ([greyboxes](../../scenes/greyboxing.md) and [heightfields](../heightfield-component.md) set these up automatically).
+
+* `NumAdditionalRays`: Only used in *Raycast High Quality* mode. The number of extra rays fired around the initial hit in a circle. Minimum 3, default 4. More rays improve accuracy at the cost of performance.
+
+* `RaySpread`: Only used in *Raycast High Quality* mode. Scales the radius of the surrounding ray circle relative to the object's `Footprint`. A value of `1` means the circle has the same radius as the footprint.
+
 * `Surface`: An optional [surface](../../materials/surfaces.md) that's used to filter object placement. Objects will only be placed on surfaces of this type (or derived). This is used to only plant certain vegetation on each type of ground.
 
   ![Filter by surface type](media/procgen-surface.jpg)
diff --git a/pages/docs/toc.md b/pages/docs/toc.md
@@ -131,6 +131,7 @@
 #### [Jolt Breakable Slab Component](physics/jolt/special/jolt-breakable-slab-component.md)
 #### [Character Controller](physics/jolt/special/jolt-character-controller.md)
 #### [Jolt Cloth Sheet Component](physics/jolt/special/jolt-cloth-sheet-component.md)
+#### [Jolt Generate Collision Component](physics/jolt/special/jolt-generate-collision-component.md)
 #### [Jolt Grab Object Component](physics/jolt/special/jolt-grab-object-component.md)
 #### [Jolt Rope Component](physics/jolt/special/jolt-rope-component.md)
 # Effects
@@ -184,6 +185,7 @@
 ## Paths
 ### [Follow Path Component](animation/paths/follow-path-component.md)
 ### [Spline Component](animation/paths/spline-component.md)
+### [Spline Mesh Component](animation/paths/spline-mesh-component.md)
 ### [Spline Node Component](animation/paths/spline-node-component.md)
 ## Property Animation
 ### [Color Animation Component](animation/property-animation/color-animation-component.md)
diff --git a/pages/docs/ui/rmlui.md b/pages/docs/ui/rmlui.md
@@ -22,15 +22,37 @@ The sample uses multiple *RmlUi Canvas 2D* components in its scene to place the
 
 Using `ezRmlUiCanvas2DComponent::GetRmlContext()` you get access to the `ezRmlUiContext`. This class implements `Rml::Core::Context`. This gives you access to all the RmlUi features. See the RmlUi [documentation](https://mikke89.github.io/RmlUiDoc/index.html) for details.
 
-## Work in Progress
+## 2D and 3D Canvases
 
-The integration of RmlUi into ezEngine is functional, but still a work-in-progress. At the moment you can only build 2D GUIs that appear on top of the screen. In the future we plan to also support placing GUI elements inside the 3D environment.
+The *RmlUi Canvas 2D* component (`ezRmlUiCanvas2DComponent`) renders the UI as a screen-space overlay. This is the standard choice for HUDs and menus.
 
-Also, currently you need to work directly with the RmlUi C++ code to interact with the UI. We may add convenience functionality to make simple use cases of GUIs easier.
+The *RmlUi Canvas 3D* component (`ezRmlUiCanvas3DComponent`) renders the UI into a texture that is applied to a mesh in the scene, allowing UI panels to exist as physical objects in the 3D world — for example interactive terminals, noticeboards, or in-world displays. Set the **Proxy Mesh** to define the surface used for hit-testing, the **Base Material** to control the look of the panel, and the **Texture Slot Name** to the material's texture parameter that should receive the rendered UI. Interaction is driven by raycasting: call `RaycastInput()` with a world-space ray (e.g. from a player's line-of-sight or crosshair) to deliver mouse position and click events to the UI. Disable the **Interactive** property to make the panel a non-interactive display.
 
-There is no script binding for RmlUi. Most likely this will never change, however, if we get around to adding some convenience features, that may make it possible to use a limited feature set from script code.
+## Blackboard Data Binding
+
+The [blackboard](../misc/blackboards.md) of an object can be automatically bound to the RmlUi data model, making blackboard entries accessible as RmlUi data model variables. Enable the **Autobind Blackboards** property on the canvas component to have it search the owner object's hierarchy for a blackboard component and bind it automatically. The blackboard's name is used as the RmlUi model name.
+
+You can also bind blackboards manually from C++ using `ezRmlUiCanvasComponentBase::AddBlackboardBinding()`.
+
+Both scalar values and [variant arrays](https://mikke89.github.io/RmlUiDoc/pages/data_bindings.html) stored in the blackboard are supported.
+
+## UI Events
+
+By default, reacting to RmlUi events (such as button clicks) requires registering C++ event handlers via `ezRmlUiContext::RegisterEventHandler()`.
+
+As a simpler alternative, enable the **Send Event Message** property on the canvas component. When enabled, every RmlUi event fires an `ezMsgRmlUiEvent` message on the component's owner object. The message carries:
+
+* `m_sIdentifier` — the identifier string configured on the RmlUi element (e.g. via the `data-event-id` attribute or the event listener identifier).
+* `m_sType` — the RmlUi event type (e.g. `click`, `change`).
+
+This message can be handled in [visual scripts](../custom-code/visual-script/visual-script-overview.md) or C++ components attached to the same object, enabling script-driven UI logic without writing a custom C++ event handler.
+
+## Localization
+
+All text content in RmlUi documents is automatically passed through ezEngine's localization system (`ezTranslate`). That means you can set up translation tables for different languages.
 
 ## See Also
 
 * [Ingame UI](ui.md)
-* [ImGui](imgui.md)
+* [ImGui](imgui.md)
+* [Blackboards](../misc/blackboards.md)

Original file line number	Diff line number	Diff line change
`@@ -83,3 +83,4 @@ Also see the [spline node component](spline-node-component.md) for options on ea`
`83`	`83`
`84`	`84`	`* [Spline Node Component](spline-node-component.md)`
`85`	`85`	`* [Follow Path Component](follow-path-component.md)`
	`86`	`+* [Spline Mesh Component](spline-mesh-component.md)`