---
title: AFL_Libraries
product: Advanced Framework Pro
version: 1.0
engine: Unreal Engine 5.8
updated: 2026-10-05
canonical: https://docs.human-codeable.com/plugins/afl-libraries.html
---

System

# AFL_Libraries

Shared Blueprint libraries plus the C++ foundations: the net driver, global event bus, object registry, render-target replication and input helpers.

#### What it gives you

- Macro and function libraries used throughout the framework
- `AFPNetDriver`, enabling server RPCs from non-pawn objects
- An object registry for lookup without hard references
- Render-target replication for shared UI

#### Requires

None

#### Required by

None

29 assets48 API members

## Description

This is the framework's foundation layer. It has no gameplay of its own; everything else builds on it.

The Blueprint side is a set of macro and function libraries — math, sorting, arrays, flow control, gates, transforms, interpolation, replication helpers, widget helpers. The `ML_Object_*` libraries in particular provide flow-control patterns the rest of the framework leans on heavily, such as `OnlyIfDifferent` gates and timeout switches.

The C++ side is small and deliberate. `UAFPNetDriver` is the important one: it lets any object implementing `IOutsidePawnRPCInterface` call server RPCs, which Unreal normally restricts to the player's pawn. `UObjectRegistrySubsystem` gives Blueprints a keyed lookup so systems can find each other without hard references. `UGlobalEventBusSubsystem` is a keyed broadcast channel. `URenderTargetReplicatorComponent` compresses and multicasts a render target, which is what makes replicated UI possible.

## Setup

1. Enable `AFL_Libraries`. It brings in Online Subsystem Utils.
2. Confirm the net driver took effect — its `Engine.ini` replaces `GameNetDriver` with `AFPNetDriver`.

Warning

This is the single most important setup step in the framework. If the net driver is not active, server RPCs from state and select components are dropped without any error.

## Usage

### Calling a server RPC from a component

Implement `IOutsidePawnRPCInterface` on your component class and call the server RPC normally.

### Registering an object for lookup

Use `ObjectRegistrySubsystem.RegisterObject` with a name key, and `GetObject` to retrieve it. The loading system uses this to cache the current level data asset.

### Broadcasting a global event

Use `GlobalEventBusSubsystem.BroadcastEvent` with a key and payload, and bind to `OnEvent`.

### Common macro libraries

`ML_Object_Gate` for change-only execution, `ML_Object_FlowControl` for sequencing, `ML_Actors.WaitForTrue` and `WhileLoopWithDelay` for polling without ticking.

## Key properties

| Item | Notes |
|---|---|
| `JPEG Quality` | On `URenderTargetReplicatorComponent`, trades UI fidelity against bandwidth |
| Registry keys | Plain names; the framework uses `LevelInfo` for the active level data asset |

## Extending

Add your own macro libraries alongside these rather than editing them, so framework updates do not conflict.

## Multiplayer notes

Multiplayer

Everything network-critical in the framework depends on this plugin. See the [Multiplayer guide](../guides/multiplayer.html).

## Example map

No dedicated map; used by every other plugin.

## Troubleshooting

**Server RPCs do nothing.** Either the net driver is not active or the calling class does not implement `IOutsidePawnRPCInterface`.

## API reference

Every blueprint asset in this plugin. Expand an asset to see its members.

### Blueprints

**BP_Value**0 members

extends `Object`

Bare event listener for a value that changes: an object carrying nothing but the On Value Updated delegate. A state component creates one and hands it out through the value interface, so anything watching the value can bind to it without knowing what produces it. Subclass it when the value needs data of its own, as the settings value does; it is created in code, never placed.

No editor-visible members; this asset configures defaults only.

### Components

**BPC_GameState_ProjectInfo**4 members

extends `ActorComponent`

Branding for the project, held on the game state: project and company name, a version string and two logos, wide and lettering-free, each with a light and a dark variant. Add it to your own game state, as the showroom one does, and fill it in the details panel so every widget showing a title or a logo reads from one place.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Name Project`Details | `text` | Display name of the project, used wherever the interface needs to name the running application. Left at its placeholder value of Project Name until you set it on the game state. |
| var | `Logo No Text`Logo | `ST_Logo` | Mark-only logo of the project, with no wordmark, for places too narrow for the wide version. Holds a light and a dark texture; whichever suits the active theme style is the one drawn, so fill in both if the project ships both themes. |
| var | `Logo Wide`Logo | `ST_Logo` | Wide logo of the project, mark and wordmark together, for headers and navigation bars with horizontal room to spare. Holds a light and a dark texture, chosen between by the active theme style. |
| var | `Name Company`Details | `text` | Display name of the company or studio behind the project, shown alongside the project name. Left at its placeholder value of Company Name until you set it on the game state. |

### Interfaces

**BPI_Sort**1 members

extends `Interface`

Comparison contract for the sorting library: one call answering whether the first item belongs before the second. Implement it on the class you want sorted and pass one of those objects in as the comparison target, so the ordering rule lives with your data rather than in the sort.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `Sort_CompareTwoItems` | `(Item01: Object, Item02: Object, out Return: bool)` | Implemented by the object driving a sort to say whether Item01 belongs before Item02. Both sort helpers swap whenever this returns true, so the array comes back in the reverse of the order stated here; the unimplemented default returns false and leaves the order alone. |

**BPI_Trace**4 members

extends `Interface`

Contract a pawn implements to publish what it is pointing at: the latest trace hit, the focus location and direction, and the screen control mode for mouse-driven pawns. The gaze, grip, select and widget abilities, the HUD and the crosshair all read the pawn through it, so a pawn of your own must implement it before those abilities work.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `Interface_getScreenControlMode`Screen Control | `(out ScreenControl: E_ScreenControlMode)` | Implemented by the pawn to report which screen control mode it is in. The crosshair and heads-up display read it to decide whether to show themselves; pawns with no mode of their own report Game Only, and the mobile pawn always reports Game And UI. |
| fn | `Interface_setScreenControlMode`Screen Control | `(ScreenControl: E_ScreenControlMode)` | Implemented by the pawn to switch between game-only, game and UI, and UI-only control. The desktop pawn also recentres the cursor, shows or hides it and applies the matching input mode, so call this rather than setting the input mode directly. |
| fn | `Interface_getFocusLocationAndDirection`Pawn Trace | `(out HasFocus: bool, out Location: Vector, out Direction: Vector)` | Implemented by the pawn to return the world start point and direction of its focus ray, and whether it has focus at all. The desktop pawn deprojects the mouse while the cursor is free and falls back to the camera in game-only mode; the mobile pawn deprojects the first touch and reports no focus when nothing is touching. |
| fn | `Interface_getLatestTrace`Pawn Trace | `(out HitResult: HitResult)` | Implemented by the pawn to return the hit result of whatever the player is currently pointing at, so abilities can read the focus target without tracing for themselves. The desktop pawn traces on demand and caches the result for a short refresh interval; the mobile pawn returns the last trace made by its touch input. |

**BPI_TreeObject**2 members

extends `Interface`

Contract for objects that form a hierarchy: return your children, and return the object holding your visuals. Nothing in the framework implements or calls it, so treat it as a ready-made hook for tree-shaped data of your own rather than as something already wired up.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `TreeObject_GetVisualsObject` | `(out Visuals: Object)` | Implemented by a tree node to return the object carrying its visual representation, so a tree view can display something other than the node itself. Return the node when the two are one and the same. |
| fn | `TreeObject_GetChildren` | `(out Children: Object[])` | Implemented by an object that takes part in a tree to return its immediate children, which the walker then descends into. Return an empty array from a leaf; nothing else in the framework implements it, so it exists for hierarchies of your own. |

### Libraries

**BFL_Math**1 members

extends `BlueprintFunctionLibrary`

Static maths helper holding one function. Average Transforms averages an array of transforms, summing the locations and scales and blending the rotations as quaternions with a sign check, so rotations pointing opposite ways do not cancel each other out. An empty array returns an identity transform. Call it from any graph; there is nothing to place.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `AverageTransforms` | `(out Transforms: Transform[], __WorldContext: Object, out AverageTransform: Transform)` | Returns the mean of a list of transforms, averaging locations and scales component-wise and blending the rotations as accumulated quaternions, with entries pointing the opposite way negated first so they do not cancel out. An empty list gives an identity transform with unit scale, and a single-entry list is returned unchanged. |

**BFL_Save**11 members

extends `BlueprintFunctionLibrary`

Pass-through nodes, one per common type, that hand their input straight back out unchanged. They are named hooks to wrap around values a project saves and loads, so that logic can be added later without rewiring the graph; as shipped they serialise nothing, and nothing in the framework calls them.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `SaveObject`Save | `(In: Object, __WorldContext: Object, out Out: Object)` | Passes an object reference straight through unchanged, capturing the result of a pure lookup at one point in the execution flow for reuse further along. |
| fn | `SaveActor`Save | `(In: Actor, __WorldContext: Object, out Out: Actor)` | Passes an actor reference straight through unchanged, capturing the result of a pure lookup so later nodes all act on the same actor even if the lookup would now answer differently. |
| fn | `SaveVector2D`Save | `(In: Vector2D, __WorldContext: Object, out Out: Vector2D)` | Passes a two-dimensional vector straight through unchanged, so the pure expression feeding it is evaluated once and read many times. |
| fn | `SaveLinearColor`Save | `(In: LinearColor, __WorldContext: Object, out Out: LinearColor)` | Passes a linear colour straight through unchanged, capturing the result of a pure chain once so several material or widget nodes can share it. |
| fn | `SaveRotator`Save | `(In: Rotator, __WorldContext: Object, out Out: Rotator)` | Passes a rotator straight through unchanged, so a pure rotation calculation is evaluated once and reused rather than recomputed per pin. |
| fn | `SaveVector`Save | `(In: Vector, __WorldContext: Object, out Out: Vector)` | Passes a vector straight through unchanged, freezing the result of a pure calculation at this point in the execution flow so every later read gets the same value. |
| fn | `SaveString`Save | `(In: string, __WorldContext: Object, out Out: string)` | Passes a string straight through unchanged, capturing the result of a pure chain once so repeated reads do not rebuild it. |
| fn | `SaveInt`Save | `(In: int, __WorldContext: Object, out Out: int)` | Passes an integer straight through unchanged, so a pure calculation feeding it runs once rather than each time the value is read. |
| fn | `SaveBool`Save | `(In: bool, __WorldContext: Object, out Out: bool)` | Passes a boolean straight through unchanged, capturing the result of a pure test at one point in the execution flow so later branches all see the same answer. |
| fn | `SaveFloat`Save | `(In: float, __WorldContext: Object, out Out: float)` | Passes a float straight through unchanged, so the pure expression feeding it is evaluated once and the stored result can be read several times without recomputing it. |
| fn | `SaveTransform`Save | `(In: Transform, __WorldContext: Object, out Out: Transform)` | Passes a transform straight through unchanged. Its purpose is to take a snapshot on the execution wire, so an expensive pure chain such as a composed transform is worked out once instead of once for every pin that reads it. |

**BPL_Platform**1 members

extends `BlueprintFunctionLibrary`

Static platform check. Its one function, Is Editor, reports whether the game is running in a play-in-editor session by testing the current level name for the editor's prefix, which lets a graph take one path in the editor and another in a packaged build. Call it directly; nothing in the framework does.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `IsEditor`Platform | `(WorldContextObject: Object, __WorldContext: Object, out IsEditor: bool)` | Returns true when the current level name carries the UEDPIE_ prefix, which is how the engine marks a Play In Editor world. Standalone and packaged runs report false, so use it to skip shortcuts that are only safe in the editor. |

**FL_Materials**2 members

extends `BlueprintFunctionLibrary`

Static material helpers for meshes. Get Dynamic Material returns the dynamic instance in a material slot, creating one from whatever material is already there if the slot has none, which is the call to make before writing a parameter at runtime. Set All Materials replaces the material in every slot of a primitive at once.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `setAllMaterials`Materials | `(PrimitiveComponent: PrimitiveComponent, Material: MaterialInterface, __WorldContext: Object)` | Assigns the same material to every material slot of a primitive component. Use it to swap a whole mesh over to a hologram or highlight material without needing to know how many slots it has. |
| fn | `GetDynamicMaterial`Materials | `(InMeshComponent: MeshComponent, InMaterialIndex: int, __WorldContext: Object, out OutMaterialInstanceDynamic: MaterialInstanceDynamic)` | Returns the dynamic material instance in a mesh component's material slot, creating one from the material already there and assigning it back when the slot does not hold one yet. Despite being a pure node it changes the component the first time it runs, so afterwards the slot no longer references the original asset. |

**FL_Sort**3 members

extends `BlueprintFunctionLibrary`

Static sorting for arrays of objects. Bubble Sort Objects and Insert Sort Objects both order an array by asking a comparison object, one implementing the sort interface, which of any two items comes first, so the ordering rule stays in your class. A float variant is included as well. Call them directly; nothing in the framework does.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `Sort_FloatArray`Sort | `(out Array: float[], __WorldContext: Object, out SortedArray: float[])` | Meant to order a float array from highest to lowest with a bubble sort, and used by the slider to arrange its segment stops. The swapping loop is gated on a flag that starts false, so as written the array comes back in its original order — check the result before relying on it. |
| fn | `Sort_InsertSortObjects`Sort | `(InputPin: BPI_Sort, out UnsortedObjects: Object[], __WorldContext: Object, out SortedArray: Object[])` | Builds a sorted copy by taking each item in turn and inserting it in front of the first entry the comparison returns true for, appending it when there is none. Uses the same comparison contract as the bubble sort helper and leaves the input array untouched. |
| fn | `Sort_BubbleSortObjects`Sort | `(InputPin: BPI_Sort, out UnsortedObjects: Object[], __WorldContext: Object, out SortedArray: Object[])` | Sorts a copy of an object array by repeatedly comparing neighbouring pairs through the object on the Input Pin, until a full pass moves nothing. Pairs are swapped when the comparison returns true, so the result comes out in the reverse of the order Sort Compare Two Items describes. |

**FL_UI**14 members

extends `BlueprintFunctionLibrary`

Static helpers for preparing UI content. Most of it turns arrays of integers, floats, booleans, vectors or names into the string option arrays that selectors and drop-downs display, and parses them back again. The rest fits a width and height inside a maximum box while keeping the aspect ratio, and truncates text or strings to a length with three trailing dots.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `ParseOptionArrayToNameArray`Option Array | `(out OptionArray: string[], __WorldContext: Object, out NameArray: name[])` | Reads an option list back into names, one per entry, keeping the order and length of the option list. |
| fn | `LimitStringLength`Text | `(String: string, MaxLength: int, __WorldContext: Object, out NewString: string)` | Shortens a string that reaches the given length, keeping the first characters and finishing with three full stops so the result is exactly Max Length long. Strings below the limit pass through untouched, and a Max Length of zero or less turns the trimming off entirely. |
| fn | `LimitTextLength`Text | `(Text: text, MaxLength: int, __WorldContext: Object, out NewText: text)` | Shortens text that reaches the given length, keeping the first characters and finishing with three full stops so the result is exactly Max Length long. Text below the limit passes through untouched, and a Max Length of zero or less turns the trimming off entirely. |
| fn | `ScaleTextureEvenly to Dimension`Math | `(SizeX: int, SizeY: int, MaxDimensions: Vector2D, __WorldContext: Object, out ScaledVector: Vector2D)` | Fits a texture's pixel size inside the given maximum while holding its aspect ratio, dividing safely so a zero-sized texture cannot blow the result up. Give one axis of Max Dimensions a negative value to leave that axis unconstrained and scale purely by the other. |
| fn | `Scale Evenly to Dimension`Math | `(XValue: int, YValue: int, MaxDimensions: Vector2D, __WorldContext: Object, out ScaledVector: Vector2D)` | Returns the largest size an X by Y source can take inside the given maximum without distorting it: whichever axis overflows further is pinned to its maximum and the other is scaled to match. The scaling divisions are unguarded, so pass a source with a zero side to Scale Texture Evenly To Dimension instead. |
| fn | `ParseOptionArrayToVectorArray`Option Array | `(out OptionArray: string[], __WorldContext: Object, out VectorArray: Vector[])` | Returns an empty array. The branch that should rebuild a vector from three consecutive entries has never been filled in, so regroup the option list yourself until it is. |
| fn | `ParseOptionArrayToBooleanArray`Option Array | `(out OptionArray: string[], __WorldContext: Object, out IntegerArray: bool[])` | Reads an option list back into booleans. An entry is true only when it spells out the word true, whatever the case; everything else, including yes and 1, comes back false. |
| fn | `ParseOptionArrayToFloatArray`Option Array | `(out OptionArray: string[], __WorldContext: Object, out IntegerArray: float[])` | Reads an option list back into floats, one per entry. Entries that do not parse become zero rather than being dropped, so the result always has the same length as the option list. |
| fn | `ParseOptionArrayToIntegerArray`Option Array | `(out OptionArray: string[], __WorldContext: Object, out IntegerArray: int[])` | Reads an option list back into integers, one per entry. Anything that is not a number becomes zero rather than being dropped, so the result always has the same length as the option list. |
| fn | `NameArrayToOptionArray`Option Array | `(out NameArray: name[], __WorldContext: Object, out StringArray: string[])` | Converts each name to its string form for use as widget options, preserving order and length so a selected index still matches the source array. |
| fn | `VectorArrayToOptionArray`Option Array | `(out VectorArray: Vector[], __WorldContext: Object, out StringArray: string[])` | Flattens each vector into three separate entries, X then Y then Z, so the option list comes out three times as long as the vector array. Take that into account when mapping a widget's selected index back onto a vector. |
| fn | `BooleanArrayToOptionArray`Option Array | `(out BooleanArray: bool[], __WorldContext: Object, out StringArray: string[])` | Converts each boolean to the words true and false for use as widget options. Pairs with Parse Option Array To Boolean Array, which reads that same spelling back. |
| fn | `FloatArrayToOptionArray`Option Array | `(out FloatArray: float[], __WorldContext: Object, out StringArray: string[])` | Converts each float to its string form for use as widget options. Conversion follows the engine default and prints the decimals as they are, so round the values first if you want short labels. |
| fn | `IntegerArrayToOptionArray`Option Array | `(out IntegerArray: int[], __WorldContext: Object, out StringArray: string[])` | Converts each integer to its string form to give the option list a dropdown or cycle widget displays. Order and length are preserved, so the index the widget reports back still points at the same source entry. |

**FL_Utilities**5 members

extends `BlueprintFunctionLibrary`

Static odds and ends called from any graph. Find Closest Value In Array returns the entry nearest a value and its index; Get Index From Array Of Weighted Values picks a random index treating the entries as weights; Get Component By Name And Class finds one of an actor's components by object name; Project Vector Onto Plane flattens a rotation against a surface normal.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `CleanseArrayOfInvalidObjects`Array | `(out Objects: Object[], __WorldContext: Object)` | Strips every invalid entry out of an object array. The array is both the input and the output pin, so the caller's own array is the one that changes. It walks backwards through the array, which is the detail worth copying: removing an index while going forwards would skip the element that slides into its place. |
| fn | `ProjectVectorOntoPlane`Rotator | `(InNormal: Vector, InRotation: Rotator, __WorldContext: Object, out OutRotation: Rotator)` | Returns a rotation whose up axis is the given normal and whose forward is the input rotation's forward flattened onto that plane and re-scaled to unit length. Use it to lay something flat against a surface while keeping the direction it was facing; any roll in the input rotation is lost. |
| fn | `getComponentByNameAndClass`Components | `(Actor: Actor, ObjectName: string, ComponentClass: class<ActorComponent>, __WorldContext: Object, out Component: ActorComponent)` | Returns the first component of the given class on an actor whose object name matches the string, or nothing when none does. The comparison is against the internal object name, so renaming the component in the editor breaks the lookup. |
| fn | `getIndexFromArrayOfWeightedValues`Array | `(out PercentList: float[], __WorldContext: Object, out RandomIndex: int)` | Picks a random index from a list of weights, each entry's chance being its share of the total. The weights need not add up to one or to a hundred, and an empty list gives index zero. |
| fn | `findClosestValueInArray`Array | `(out Array: float[], Value: float, __WorldContext: Object, out ClosestValue: float, out Index: int)` | Returns the array entry nearest to the given value along with its index. The array need not be sorted, ties go to the earlier entry, and an empty array comes back with a value of zero and an index of minus one. |

**ML_Actor_Interpolation**0 members

extends `Actor`

Interpolation macros for use inside an actor's graph. Each eases a current value towards a target under its own loop, firing Update every step with the new float, vector, rotator, transform or colour and Completed once it is inside tolerance; two variants write the result straight into a dynamic material parameter instead. The component-parented copy carries the same set.

No editor-visible members; this asset configures defaults only.

**ML_Actor_Replication**0 members

extends `Actor`

Authority branches for actor graphs. They answer what the framework asks before running network code: does this actor replicate at all, and if so are we on the machine with authority, so one graph can serve both a single-player and a replicated setup. Parented to Actor; components and plain objects have their own copies of the same idea.

No editor-visible members; this asset configures defaults only.

**ML_Actors**0 members

extends `Actor`

Flow control and timing for actor graphs, and the most-used library in a pawn. Holds while loops with a delay, waits for an object to become valid or a condition to turn true, timed gates, an elapsed-time timer, a timer stack, continuous execution between a start and a stop, and a hold-button split into short click, hold and release. Parented to Actor.

No editor-visible members; this asset configures defaults only.

**ML_Comp_Interpolation**0 members

extends `ActorComponent`

The interpolation set again, parented to Actor Component so the macros can be used inside a component's graph. Each eases a value towards a target under its own loop, firing Update per step and Completed on arrival, with two variants driving a dynamic material parameter. Pick this copy or the actor one to match the graph you are working in.

No editor-visible members; this asset configures defaults only.

**ML_Comp_Replication**0 members

extends `ActorComponent`

Authority branches written from a component's point of view, asking about the owning actor rather than the component. Covers has authority, does the owner replicate, the two combined, and Comp Is Owner, which is true only on the machine whose player controls the owner. A wait-until-valid loop sits here too. Parented to Actor Component.

No editor-visible members; this asset configures defaults only.

**ML_Components**0 members

extends `ActorComponent`

Flow control and timing for component graphs, and the library most ability components lean on. Holds a delay-driven timeline that plays, pauses, reverses and scrubs a float curve without needing a timeline component, repeated and delayed execution, cooldown and timed exclusive gates, an elapsed-time timer and several waits for an object to validate.

No editor-visible members; this asset configures defaults only.

**ML_Object_Array**0 members

extends `Object`

Two index steppers for walking an array one entry at a time, forwards and backwards, each with the option to wrap round the ends rather than run past them. Parented to Object, so they are available in any graph. Nothing in the framework calls them.

No editor-visible members; this asset configures defaults only.

**ML_Object_Debug**0 members

extends `Object`

Debug drawing, available in any graph. Draw Gizmos takes an array of transforms and draws a red, green and blue axis cross at each one for a single frame at the size and thickness you pass in. Put it on a tick to see where spawn points, anchors or snap targets actually sit. Nothing in the framework calls it; it is there for your own diagnosis.

No editor-visible members; this asset configures defaults only.

**ML_Object_FlowControl**0 members

extends `Object`

Flow control usable in any graph, being parented to Object. Its centrepiece is the tick-free timeline, a float curve you play, pause, reverse and scrub that is advanced by a Tick pin you drive yourself, and which the component and widget timelines are both built on. Around it sit flip-flop gates with and without a reset, loops advanced by a trigger and a float compare with a deadzone.

No editor-visible members; this asset configures defaults only.

**ML_Object_Gate**0 members

extends `Object`

Gates that stop a graph acting on a value that has not changed. One Only If Different macro per common type passes execution through, and hands back the new value, only when it differs from the old, which is how the framework avoids re-broadcasting and redrawing on every set. Conditional Gate is here too. The most widely used of these libraries.

No editor-visible members; this asset configures defaults only.

**ML_Object_Math**0 members

extends `Object`

Maths macros for any graph. Interpolate With Nearly Check comes in float, vector, vector 2D, rotator, transform and colour flavours, stepping towards a target and firing Value Reached once inside the snap tolerance. Alongside are increment and decrement with modulo for cycling indices, angle between vectors, a looking-at-location test and clamping against an unordered range.

No editor-visible members; this asset configures defaults only.

**ML_Object_Replication**0 members

extends `Object`

Two replication branches parented to Object, so they can be used in graphs the actor and component copies cannot reach: does this actor replicate, and does the owner of this component replicate, the second also taking a separate exit when the component itself is not valid.

No editor-visible members; this asset configures defaults only.

**ML_Object_Transform**0 members

extends `Object`

Single-axis transform setters. Each macro writes one component of a scene component's relative location, rotation or scale and leaves the other two as they were, saving the break-and-remake that would otherwise be needed. Parented to Object, so they work in any graph; doors, floors and the pawn UI position helper use them.

No editor-visible members; this asset configures defaults only.

**ML_Object_Utility**0 members

extends `Object`

Two odd jobs available in any graph. Does Implement Interface branches on whether an object is both valid and implements a given interface, which is the check the interaction and ability code makes before calling anything on a hit object. Manipulate Timeline jumps a timeline component to its start or its end.

No editor-visible members; this asset configures defaults only.

**ML_SceneComponents**0 members

extends `SceneComponent`

Distance and angle tests measured from a scene component to the player camera. Each fires only as the reading crosses in or out of the band you set, with a deadzone either side so a value hovering on the boundary does not flicker, and each can be reset. Parented to Scene Component; labels and world widgets use it to hide themselves at range or off-angle.

No editor-visible members; this asset configures defaults only.

**ML_UserWidget**0 members

extends `UserWidget`

Flow control, timing and interpolation for widget graphs. Plays a widget animation with a Finished pin, eases a float, vector, vector 2D, rotator or transform towards a target with a Stop pin, and provides the delay-driven timeline, a timed gate and waits for an object or condition. Wait For Widget To Establish Size is the one to reach for before measuring a freshly added widget.

No editor-visible members; this asset configures defaults only.

**ML_Widget**0 members

extends `Widget`

Single macro parented to Widget rather than User Widget, so it can be used on the plain widgets inside a layout: Get Widget Coordinates converts an anchor point on a widget into absolute coordinates. Nothing in the framework calls it, so treat it as a spare part for layout maths of your own rather than as something already in play.

No editor-visible members; this asset configures defaults only.