TrackMark — ground marks that cost one draw call. Footprints, paw prints, tyre marks and
tank tracks that lie on the surface, tilt with its normal, change with the physical material
under the foot, and fade out on their own.
A footprint system has exactly one hard problem: there are a lot of footprints. The obvious
implementation spawns a decal component per print — one draw call per print, plus a
component, plus an actor to own it, plus a timer to destroy it. It looks fine in a test level
with one character and falls over at a few hundred marks, which is about four seconds of a
squad walking.
📖 Full documentation — installation, quick start, the whole API, console commands and project settings.
- One draw call per profile, whatever the mark count — every mark of one profile is an
instance in a single instanced static mesh component. Ten marks or ten thousand, the
renderer sees the same batch. The demo level puts that on screen: 2048 live marks across
six profiles, six draw calls, six batches.
- A mark is written once, then forgotten — one transform and four per-instance custom
data floats. Fading happens in the material, which derives each mark's age from its spawn
time and the scene clock. There is no per-frame CPU loop walking the live marks, and no
per-mark tick, actor or component anywhere in the system.
- A hard budget, and something sensible at the cap — reaching the cap does not stop new
marks and does not stutter. The oldest mark in the world is retired, its instance slot is
handed straight to the new mark, and nothing is allocated. After warm-up the runtime
allocates nothing at all. Lower the cap while the game runs and the overlay shows it: the
live count falls, the draw call count does not move, the recycled counter climbs and the
allocated counter stays flat.
- It knows what it is standing on — the placement trace reads the physical material under
the foot and maps it to a profile, so grass, sand and snow differ in shape, size, opacity
and lifetime. A surface with no mapping, or no physical material at all, falls back to the
default profile. That is not an error: a level full of untagged geometry still produces
marks.
- Marks lie along the surface normal — a footprint on a ramp is on the ramp, not sunk into
it horizontally. Ground steeper than the profile's limit is refused and counted, because a
footprint plastered on a wall is worse than no footprint.
- Nothing to author — four profiles exist in code (Boot, Paw, Tyre, Track), so marks
appear before you have created a single asset. Add the component, press Play, walk. The
master material draws its shapes procedurally: two ellipses make a boot print, a rib pattern
makes a tyre, a cleat pattern makes a tank track. No painted textures anywhere.
- Three ways to trigger — an animation notify on the foot-plant frame for accuracy, a
distance threshold that needs no animation work at all, or an explicit call from Blueprint
or C++. In manual mode the component's tick is switched off entirely, so a thousand idle
components cost nothing.
- Numbers you can read, not claims you have to trust —
ATrackMarkHUD draws the counters
on UCanvas: live marks, draw calls, instance slots, recycled slots, traces this frame,
subsystem milliseconds and placement milliseconds. Canvas rather than UMG on purpose — it
draws in a cooked Shipping build, where DrawDebug is compiled out and a debug widget
is usually stripped. Every button label is derived from the subsystem on the frame it is
drawn and never cached, so the panel cannot disagree with the system it controls.
- Blueprint from end to end — placement, budget, profiles, surface mapping, statistics and
a runtime setter for every project default. Not one line of C++ is required. Four console
commands (TrackMark.Test, .Budget, .Clear, .Stats) plus a TrackMark.Enabled
console variable.
Stated up front, because it saves everybody a refund.
No terrain deformation. Marks are drawn, not dug. If you need real displacement in snow or
sand, this is not that plugin. No footstep audio — there are good footstep-sound plugins,
and this is the other half of the problem. No characters, animations or meshes to replace;
it works with what you already have. No network replication: marks are local and cosmetic
by design, and there is no reason to spend bandwidth on them. No tracking or trail-reading
gameplay — it draws the tracks, what you do with them is yours.
- Unreal Engine 5.8, one Runtime module (
TrackMark), no editor module
- Built and verified on Win64. Mac and Linux are not in the
.uplugin's PlatformAllowList and were not built for this release.
- 7 C++ classes: profile, settings, subsystem, component, statics library, HUD, anim notify
- No third-party libraries, no external dependencies, no plugin dependencies
- Demo level: walkers circling over sand, snow and mud patches, six profile assets, a
click-driven control panel and the Canvas statistics overlay
Available on the Fab marketplace for Unreal Engine 5.8. Publisher: Silvan Teufel (freelance).