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

Module

# AFM_State

The value system: boolean, float, integer, name, colour, trigger and drag state components sharing one contract, so UI can bind to any of them generically.

#### What it gives you

- Typed state components for world objects
- A shared event listener contract UI binds to
- Drag state for levers, sliders and dials
- The same contract the settings menu uses

#### Requires

None

#### Required by

None

16 assets98 API members

## Description

`AFM_State` exists so that UI never needs to know what it is displaying.

Each value type has a component — `BPC_State_Boolean`, `_Float`, `_Integer`, `_Name`, `_Color`, `_Trigger` and `_Drag` — and all of them expose a `BP_Value` event listener through `BPI_Value`, along with a title and caption. A widget binds to "a value", not to a specific object.

That indirection is why `AFM_Settings` can reuse the identical widgets: settings are just values backed by console variables and a save game instead of by an actor. Implement `BPI_Value` on anything of your own and the whole settings UI works with it unchanged.

`BPC_State_Drag` is the most substantial of the set. It converts hand or pointer movement into a constrained value along an axis, with snapping, sections and sound — this is what levers, drawers, dials and physical sliders are built from.

## Setup

1. Enable `AFM_State`.
2. Add the state component matching your value type to the actor.
3. Set **Title** and **Caption** — these appear in any UI bound to the value.
4. Bind to the component's value-changed delegate, or bind a widget to it.

## Usage

### Driving a lever

Add `BPC_State_Drag`, configure the drag type and axis, and pair it with `BPC_Interaction_Grip_Latch` or `BPC_Interaction_Overlap_Drag`. The interaction supplies the input; the state component owns the value.

### Binding UI to a value

Any widget that takes a `BPI_Value` will bind to your component. The `WBP_SettingItem_*` widgets are built for exactly this.

### Resetting

Call `Value_Reset` with Source Info to return the value to its default.

[![A lever part-way through its travel, with the bound widget showing the value](../images/AFM_State_result-1600.webp?v=2e2ce06e)](../images/AFM_State_result-1600.webp?v=2e2ce06e)

A lever part-way through its travel, with the bound widget showing the value

## Key properties

| Property | When to change |
|---|---|
| `Title` / `Caption` | Always — these are the label and helper text any bound UI displays |
| Drag type and snap mode | `BPC_State_Drag` — choose free, sectioned or snapped movement |
| Sound cues | Continuous and per-section drag feedback |

## Extending

Derive from `BPC_State` for a new value type, implement `BPI_Value` plus a typed interface, and every existing binding mechanism works with it. Implement `BPI_Value` directly on a plain object when you do not need a component.

## Multiplayer notes

Multiplayer

State components implement `IOutsidePawnRPCInterface`, so they call server RPCs directly without routing through the pawn. This requires `AFPNetDriver` to be the active net driver.

## Example map

`Map_Examples_States` demonstrates every state type driving both objects and UI.

## Troubleshooting

**State changes do not replicate.** `AFPNetDriver` is not active — see [Multiplayer guide](../guides/multiplayer.html).

**A drag feels wrong.** Check the drag type first; multi-axis and single-axis behave very differently and the axis is easy to set on the wrong component.

## API reference

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

### Blueprints

**BPC_State**2 members

extends `ActorComponent` · implements `BPI_Value`, `OutsidePawnRPCInterface`

Abstract base for every state component: the framework's way of giving an actor one named, replicated value that its parts and its widgets can agree on. Holds the title and caption shown for that value and hands out the value object widgets bind to for change notifications. Abstract, so add one of the typed variants or subclass it for a value type of your own.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Title`Content | `text` | Heading widgets show for this state, handed over whenever a widget asks the value for its title. Leave empty for a control with no label of its own. |
| var | `Caption`Content | `text` | Supporting line offered to widgets beneath the title, edited as multi-line text. Leave empty to show the title alone. |

**BPC_State_Boolean**7 members

extends `BPC_State` · implements `BPI_Value_Boolean`

State component holding one replicated on/off value, along with the labels shown for false and true. Add it to an actor whose parts need to agree on a switch: interactions set it through Set Boolean or Toggle Boolean, widgets read and drive it, and the owner reacts to On Value Updated. Apply and Toggle push the default value from the editor so you can preview it.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Default Value`Value | `bool` | Setting a reset returns to, and the one Apply and Toggle broadcast from the editor. It is not written to the live value at start-up, so the state begins false until something sets it. |
| var | `Text False`Content | `text` | Caption offered to widgets for the off position, returned as the first of the pair of texts. Buttons bound to this state show it while the value is false. |
| var | `Text True`Content | `text` | Caption offered to widgets for the on position, returned as the second of the pair of texts. Buttons bound to this state show it while the value is true. |
| fn | `Toggle`Value | `()` | Flips Default Value and broadcasts the new setting to On Value Updated. An editor button for previewing both positions; the replicated runtime value is left alone. |
| fn | `Apply`Value | `()` | Broadcasts Default Value to everything bound to On Value Updated without storing it or telling the server. An editor button, so meshes and widgets in the level preview the default. |
| event | `Server_SetValue` | `(Source Info: ST_SourceInfo, InValue: bool)` | Server RPC that stores the setting and its source info as the replicated value, whose notify then updates the other machines. Called by the boolean setter after the local update rather than directly. |
| event | `Value_Reset`Value | `(Source Info: ST_SourceInfo)` | Implemented by a value to put itself back to its configured default. Called on every value of an actor by configurator and settings screens; the colour and drag states deliberately do nothing. |

**BPC_State_Color**5 members

extends `BPC_State` · implements `BPI_Value_Color`

State component holding one replicated linear colour, plus an interpolated copy that ticks towards the target at Interpolation Speed. Add it where a colour has to be shared and animated rather than set once, as the highlight examples do when they drive their materials, and read either the exact value or the smoothed one.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Default Value`Value | `LinearColor` | Colour recorded as the intended starting point of this state. Nothing in the graph reads it, since the reset here is deliberately empty, so setting it does not on its own push a colour to listeners. |
| var | `Interpolation Speed`Config | `float` | Rate at which the smoothed colour chases the current one while the component ticks, which is what materials should read to fade rather than jump. Higher values arrive sooner. |
| var | `Error Tolerance`Config | `float` | Difference below which the smoothed colour counts as having reached the current one, ending the per-frame chase. Raise it to settle sooner, lower it for a closer match. |
| event | `Server_SetValue` | `( Source Info: ST_SourceInfo, InValue: LinearColor)` | Server RPC that stores the colour and its source info as the replicated value, whose notify then updates the other machines. Called by the colour setter rather than directly. |
| event | `Value_Reset`Value | `(Source Info: ST_SourceInfo)` | Implemented by a value to put itself back to its configured default. Called on every value of an actor by configurator and settings screens; the colour and drag states deliberately do nothing. |

**BPC_State_Drag**35 members

extends `BPC_State` · implements `BPI_Value_Name`, `BPI_Value_Float`

State component turning a dragged handle into a value. It moves the child component named by Tag To Controlled Component along an axis, around an axis or along a spline as an interaction drags it, clamped to the value range and optionally snapping to sections that report as names as well as numbers. Add it to levers, drawers, dials, buttons and sliders.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Tag to Controlled Component`References | `name` | Component tag naming the scene component this drag moves; the first tagged component on the owner is found once and cached. Leave it as None and nothing is found, so the drag has nothing to move. |
| var | `Drag Type`Config | `E_Drag_Type` | Path the handle travels: a slide along local X, Y or Z, a roll, pitch or yaw angle, or a distance along the owner's spline with or without following its rotation. None leaves the handle where it is. |
| var | `Value Range`Config | `InputRange` | Lowest and highest drag position, in centimetres for the sliding types and degrees for the turning ones. Positions are clamped to it, and the percentage broadcast with each move is the position mapped across it. |
| var | `Default Value`Config | `float` | Position Apply moves the handle to, in the units of Value Range. It gives the object its resting pose in the editor and is not applied again at start-up. |
| var | `Snap`Config\|Snap | `E_Drag_Snap` | What happens once the hand lets go: Free Movement leaves the handle where it was released, while the other modes run it on to a section snap value or back to the start at Snapping Speed. |
| var | `Snapping Speed`Config\|Snap | `float` | Rate at which the handle travels to its snap target after release. Higher values snap sooner; it has no effect while Snap is Free Movement. |
| var | `Follow Speed`Config | `float` | Rate at which the drag position chases the hand while it is held, used by the per-frame interpolation. Lower values let the object lag behind the hand, higher values make it stick to it. |
| var | `Invert Percent`Config | `bool` | Whether the percentage broadcast with each move is flipped, so the minimum of Value Range reads as 1 rather than 0. Only that broadcast changes; the drag position itself is untouched. |
| var | `Section Seed`Sections | `ST_Drag_SectionSeed[]` | Recipe for generating sections: each entry gives a name, a share of Value Range and a justification placing its snap value at the start, middle or end. Pressing Create Sections turns it into Section Set and overwrites what was there. |
| var | `Section Set`Sections | `ST_Drag_Section[]` | Sections the drag range is divided into, each with a range, a snap value, a pull strength, an identifier and a label. Entering or leaving one raises a section trigger, and the identifiers are the options widgets see. Author it directly or generate it from Section Seed. |
| var | `Sound Tick Distance`Sound | `float` | Distance the handle must travel since the last tick sound before another one plays, in the units of Value Range. Raise it for a coarser ratchet; this governs the one-shot cue, not the looping sound. |
| var | `Looping Sound`Sound | `SoundBase` | Continuous sound spawned attached to the dragged component the first time the drag needs audio, and destroyed again once movement stops. It starts at zero volume, so something has to raise it. Leave empty for a silent drag. |
| var | `Display Range`Content | `InputRange` | Range reported to widgets in place of Value Range, letting a slider read 0 to 100 while the handle travels a few centimetres. Section snap values are mapped into it before being handed over as segment marks. |
| var | `Units`Content | `text` | Suffix widgets append to the displayed value, per cent by default. Presentation only; it has no bearing on the drag itself. |
| var | `Fractional Digits`Content | `int` | Largest number of decimal places widgets show for the value. Passed to them together with the display range and the segment marks. |
| var | `Attenuation`Sound | `SoundAttenuation` | Sound attenuation applied to both the looping drag sound and the tick cue played as the handle moves. Leave empty to have both play unattenuated. |
| fn | `getCurrentSection`Sections | `(out Section: name, out Index: int)` | Returns the identifier and index of the first section whose range contains the current drag position. Reports None and -1 while the handle sits between sections. |
| fn | `getAudioComponent`Sound | `(out AudioComponent: AudioComponent)` | Returns the audio component carrying the looping drag sound, spawning it attached to the dragged component on first use and caching it. It spawns at zero volume, so it stays inaudible until something raises the volume. |
| fn | `CreateSections`Sections | `()` | Rebuilds Section Set from Section Seed, splitting Value Range between the seeds in proportion to their shares and placing each snap value at the start, middle or end of its slice according to its justification. An editor button that overwrites Section Set. |
| fn | `FindSection`Drag | `(SectionName: name, out Value: float, out Found: bool)` | Returns the snap value of the section with the given identifier and whether one was found. The value comes back as zero when the identifier matches nothing. |
| fn | `Apply`Config | `()` | Moves the handle to Default Value by running an ordinary position change with no source info. An editor button, so the object sits at its resting position in the level. |
| fn | `SearchForBestPointToOffset`Drag | `(Location: Vector, RotationDelta: Rotator, TakeLocationForRotationReference: bool, out ClosestPosition: float)` | Returns the drag position that best matches the hand's location and rotation, by stepping the helper's offset handle along the drag and comparing. Inside a section the answer is pulled towards that section's snap value by its pull strength, which gives the drag its magnetism. |
| fn | `getClosestSegment`Drag | `(out Segment: ST_Drag_Section, out Index: int)` | Returns the section whose range contains the current drag position, together with its index. The index is -1 when the handle sits outside every section. |
| fn | `getSplineComponent`Drag | `(out SplineComponent: SplineComponent)` | Returns the first spline component on the owning actor, which the two spline drag types sample for their transforms. Returns nothing when the actor has no spline. |
| fn | `getTransformFromPosition`Drag | `(NewPosition: float, NewTransform: Transform)` | Builds the relative transform the handle should have at a given position, branching on the drag type: the sliding types replace one location axis, the turning ones replace one rotation axis, and the spline types sample the owner's spline at that distance. Pitch is clamped to plus or minus 90 degrees. |
| fn | `getControlledComponent`Drag | `(out HandleComponent: SceneComponent)` | Returns the scene component the drag moves, taking the first component on the owner that carries Tag To Controlled Component and caching it for later calls. Returns nothing when no component matches. |
| event | `SetNewDragPosition` | `(SourceInfo: ST_SourceInfo, Position: float)` | Moves the handle to a new position and, when the acting pawn is the local one and the owning actor replicates, forwards the position to the server. The entry point interactions use while a hand is dragging. |
| event | `CallTriggerConstant` | `(SourceInfo: ST_SourceInfo, Distance: float, Percent: float, Velocity: float)` | Broadcasts On Drag State Changed Constant with the position, the percentage across Value Range and the movement since the last update. Raised on every change; bind to the delegate rather than calling it. |
| event | `CallTriggerSingle` | `(SourceInfo: ST_SourceInfo, SectionIdentifier: name, Set: bool)` | Broadcasts On Drag State Changed Section as the handle enters or leaves a section, saying which section and whether it is now inside. Internal; bind to the delegate instead. |
| event | `InitiateDrag` | `(LocationOffset: Vector)` | Places the helper's offset handle on the dragged component and its location offset at the grab point, then cancels any automatic movement under way. Called by the overlap drag interaction the moment a hand takes hold. |
| event | `ReleaseDrag` | `(Source Info: ST_SourceInfo)` | Publishes the position the handle was let go at as the replicated position and switches ticking back on so snapping can run. Called by the interaction that was dragging when the hand releases. |
| event | `AdjustPositionToReferenceLocation` | `(SourceInfo: ST_SourceInfo, Location: Vector, RotationDelta: Rotator, DeltaTime: float, TakeLocationForRotationReference: bool)` | Interpolates the handle at Follow Speed towards the position that best matches the hand's location and rotation, and plays continuous haptics scaled by how far it moved. Called each frame by the dragging interaction. |
| event | `MoveToSection` | `(Source Info: ST_SourceInfo, SectionIdentifier: name)` | Starts an automatic move to the snap value of the named section, but only on the machine whose pawn is described by the source info. Nothing happens when the identifier matches no section. |
| event | `Value_Reset`Value | `(Source Info: ST_SourceInfo)` | Implemented by a value to put itself back to its configured default. Called on every value of an actor by configurator and settings screens; the colour and drag states deliberately do nothing. |
| event | `Server_SetValue` | `( Source Info: ST_SourceInfo, InValue: float)` | Server event publishing a dragged value: it writes the value with notify, which is what tells every client the handle has moved. Raised from the drag itself as the handle is pulled rather than called directly. |

**BPC_State_Float**8 members

extends `BPC_State` · implements `BPI_Value_Float`, `BPI_Value_Boolean`

State component holding one replicated number, with a range, units and an interpolated copy that eases towards the target each tick. Add it wherever a continuous value has to be shared: a dimmer, a speed, a slider's position. It also answers as a boolean, true above 0.5, so a toggle widget can drive it.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Default Value`Value | `float` | Value a reset writes back. It is not applied at start-up, and the reset passes it on without source info, so the change appears to come from no pawn in particular. |
| var | `Interpolation Speed`Config | `float` | Rate at which the smoothed reading chases the current value while the component ticks, for meshes and materials that should ease rather than jump. Higher values settle sooner. |
| var | `Range`Config | `InputRange` | Lowest and highest meaningful value, handed to sliders as their range and used to map the smoothed reading into real units. Incoming values are not clamped to it, so anything may set a value outside it. |
| var | `Units`Content | `text` | Suffix widgets append to the displayed value, such as a per cent or second marker. Leave empty for a bare number. |
| var | `Segments`Content | `float[]` | Marks along the range, given as values, that sliders draw as notches. Leave empty for a plain unmarked slider. |
| var | `Display Fractional Digits`Content | `int` | Largest number of decimal places widgets show for the value. Presentation only; the stored value keeps its full precision. |
| event | `Server_SetValue` | `( Source Info: ST_SourceInfo, InValue: float)` | Server RPC that stores the value and its source info as the replicated value, whose notify then updates the other machines. Called by the float setter rather than directly. |
| event | `Value_Reset`Value | `(Source Info: ST_SourceInfo)` | Implemented by a value to put itself back to its configured default. Called on every value of an actor by configurator and settings screens; the colour and drag states deliberately do nothing. |

**BPC_State_Integer**4 members

extends `BPC_State` · implements `BPI_Value_Integer`

State component holding one replicated whole number, with an optional list of texts naming each value so a drop-down or stepper can label it. Add it for discrete choices such as a quality level or a selected index; it broadcasts only when the value actually changes.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Default Value`Value | `int` | Value a reset writes back, carrying the source info of whoever asked for the reset. It is not applied at start-up. |
| var | `Texts`Content | `text[]` | Labels for the positions this state can take, in index order. Drop-downs and steppers build their entries from them, so leaving it empty gives those widgets nothing to show. |
| event | `Server_SetValue` | `(SourceInfo: ST_SourceInfo, InValue: int)` | Server RPC that stores the value and its source info as the replicated value, whose notify then updates the other machines. Called by the integer setter rather than directly. |
| event | `Value_Reset`Value | `(Source Info: ST_SourceInfo)` | Implemented by a value to put itself back to its configured default. Called on every value of an actor by configurator and settings screens; the colour and drag states deliberately do nothing. |

**BPC_State_Name**7 members

extends `BPC_State` · implements `BPI_Value_Name`

State component holding one replicated name chosen from a list of available names, with matching display texts. Add it where the state is one of several named options rather than a number; widgets step through it with Next Value and Previous Value, and Current Index gives its place in the list.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Name`State | `ST_State_Name` | Current name together with the source info of whoever last set it. The value entered here is what the state starts the level on; it is replicated, and each update raises On Value Updated on every machine. |
| var | `Available Names`Config | `name[]` | Names this state may take, in order. Drop-downs use them as their option identifiers and Current Index looks the present name up in them, so a name missing from the list reports an index of -1. |
| var | `Default Value`Value | `name` | Name a reset writes back. Leave it as None to have a reset clear the state rather than select one of the available names. |
| var | `Texts`Content | `text[]` | Labels shown for the entries of Available Names, matched to them by index. Leave empty and widgets have only the raw names to display. |
| fn | `CurrentIndex`State | `(out Index: int)` | Returns the position of the current name within Available Names, or -1 when the name is not one of them. |
| event | `Value_Reset`Value | `(Source Info: ST_SourceInfo)` | Implemented by a value to put itself back to its configured default. Called on every value of an actor by configurator and settings screens; the colour and drag states deliberately do nothing. |
| event | `Server_SetName` | `(Source Info: ST_SourceInfo, Value: name)` | Server RPC that stores the name and its source info; replication then raises On Value Updated everywhere. Every name change goes through here, so the value only ever changes on the server first. |

**BPC_State_Trigger**3 members

extends `BPC_State` · implements `BPI_Value_Trigger`

State component for a value with nothing to store: a one-shot event, replicated to everyone. Add it where a button or interaction should announce that something happened rather than change a setting. Value Trigger fires On Trigger locally and multicasts to the other machines, which skip the pawn that started it so it is not heard twice.

| Kind | Name | Signature | Description |
|---|---|---|---|
| var | `Text`Content | `text` | Caption offered to widgets for the action this trigger performs. Buttons bound to a trigger state show it as their label. |
| event | `Server_Trigger` | `(Source Info: ST_SourceInfo)` | Server RPC that passes the trigger on to the multicast so every machine hears it. Raised after the local broadcast rather than called directly. |
| event | `Multicast_Trigger` | `(Source info: ST_SourceInfo)` | Raises On Trigger on each machine, skipping the one whose own player pawn set it off since that client has already fired locally. |

### Helpers

**BP_Helper_DragOffset**0 members

extends `Actor`

Invisible rig the drag state does its maths in: a handle with location and rotation offset points that it moves about to work out where a dragged component should sit. Spawned by the drag state component for its own use and tidied up through auto-destroy, so there is no reason to place or reference one.

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

### Interfaces

**BPI_Value**4 members

extends `Interface`

Common face of every value in the framework, whatever its type: the title and caption a widget displays, the reset call, and the value object a widget binds to so it hears about changes. Implemented by the state components and by settings objects. Implement it on anything the framework's input widgets should be able to drive.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `Value_getCaption`Value_Info | `(out Text: text)` | Implemented by a value to supply the supporting line shown beneath the title. The state components answer with their Caption. |
| fn | `Value_getTitle`Value_Info | `(out Text: text)` | Implemented by a value to supply the heading widgets show for it. The state components answer with their Title. |
| fn | `Value_Reset`Value | `(Source Info: ST_SourceInfo)` | Implemented by a value to put itself back to its configured default. Called on every value of an actor by configurator and settings screens; the colour and drag states deliberately do nothing. |
| fn | `Value_getEventListener`Value | `(out EventListener: BP_Value)` | Implemented by a value to hand out the object whose On Value Updated delegate widgets bind to. The state components create that object on the first request and keep it, so binding works before any value has been set. |

**BPI_Value_Boolean**4 members

extends `Interface`

Typed half of the value contract for on/off values: read, set, toggle, and the two texts naming false and true. A widget calls it on whatever object it was handed, which is how one toggle can drive a boolean state, a float state above half or a boolean setting without knowing which it has.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `Value_Boolean_getTexts`Value Boolean | `(out Text_False: text, out Text_True: text)` | Implemented by a boolean value to supply the captions for its off and on positions, which buttons use as their label. The float state returns neither. |
| fn | `Value_toggleBoolean`Value_Boolean | `(SourceInfo: ST_SourceInfo)` | Implemented by a boolean value to flip itself. Called by buttons that switch on press instead of being told which setting to take. |
| fn | `Value_setBoolean`Value_Boolean | `(SourceInfo: ST_SourceInfo, Value: bool)` | Implemented by a boolean value to take a new setting from the pawn described by the source info. Buttons call it when their selection changes. |
| fn | `Value_getBoolean`Value_Boolean | `(out SourceInfo: ST_SourceInfo, out Value: bool)` | Implemented by a boolean value to report its current setting and the source info of whoever last changed it. The float state answers it too, counting anything above 0.5 as true. |

**BPI_Value_Color**3 members

extends `Interface`

Typed half of the value contract for colours: read and set the current linear colour, and read the interpolated one for smooth transitions. Implemented by the colour state component; implement it on an object of your own to make it drivable by the colour picker widget.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `Value_getColor_Interpolated`Value Color | `(out InterpolatedFloat: LinearColor)` | Implemented by a colour value to report the smoothed colour chasing the one it holds. Materials should read this rather than the raw colour if they are to fade instead of jump. |
| fn | `Value_setColor`Value Color | `(SourceInfo: ST_SourceInfo, Value: LinearColor)` | Implemented by a colour value to take a new colour from the pawn described by the source info. The colour picker calls it as the user chooses. |
| fn | `Value_getColor`Value Color | `(out SourceInfo: ST_SourceInfo, out Value: LinearColor)` | Implemented by a colour value to report the colour it holds and the source info of whoever last set it. The colour picker reads it as it opens. |

**BPI_Value_Float**5 members

extends `Interface`

Typed half of the value contract for numbers: read and set the value, read its interpolated and lerped forms, and ask for the display content a slider needs to draw itself, meaning the range, the units, the segment marks and the fractional digits. Implemented by the float, drag and settings values.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `Value_Float_getContent`Value Float | `(out Range: InputRange, out Units: text, out Segments: float[], out MaximumFractionalDigits: int)` | Implemented by a float value to describe how it should be presented: its range, its unit suffix, any segment marks and how many decimal places to show. Sliders call it once while building themselves. |
| fn | `Value_getFloat_Interpolated_Lerped`Value_Float | `(out InterpolatedFloat_Lerped: float)` | Implemented by a float value to report the smoothed reading already mapped onto its configured range, saving the caller the lerp. The drag state answers zero. |
| fn | `Value_getFloat_Interpolated`Value_Float | `(out InterpolatedFloat: float)` | Implemented by a float value to report the smoothed reading chasing the value it holds, for meshes and materials that should ease rather than jump. The drag state does no smoothing and answers zero. |
| fn | `Value_setFloat`Value_Float | `(SourceInfo: ST_SourceInfo, Value: float)` | Implemented by a float value to take a new value from the pawn described by the source info. Sliders call it as their handle moves; the drag state reads the value as 0 to 1 across its own range. |
| fn | `Value_getFloat`Value_Float | `(out SourceInfo: ST_SourceInfo, out Value: float)` | Implemented by a float value to report the value it holds and the source info of whoever last set it. Sliders read it while they are being built. |

**BPI_Value_Integer**3 members

extends `Interface`

Typed half of the value contract for whole numbers: read, set, and fetch the texts labelling each value. Implemented by the integer state and by integer settings, and spoken by the drop-down and stepper widgets, so implement it to make an object of your own editable by them.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `ValueInteger_getTexts`Value Integer | `(out Texts: text[])` | Implemented by an integer value to list the label for each position it can take, in index order. Drop-downs and steppers build their entries from the list. |
| fn | `Value_setInteger`Value_Integer | `(SourceInfo: ST_SourceInfo, Value: int)` | Implemented by an integer value to take a new value from the pawn described by the source info. Drop-downs call it when one of their options is chosen. |
| fn | `Value_getInteger`Value_Integer | `(out SourceInfo: ST_SourceInfo, out Value: int)` | Implemented by an integer value to report the value it holds and the source info of whoever last set it. Drop-downs and steppers read it to show the right entry. |

**BPI_Value_Name**6 members

extends `Interface`

Typed half of the value contract for named options: set the current name, read it, step to the next or previous one, and fetch the available IDs with their display texts. Implemented by the name state and also by the drag state, whose sections behave as names, so the same drop-down drives both.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `Value_Name_getTexts`Value Name | `(out Texts: text[])` | Implemented by a name value to supply the label for each of its names, matched to them by index. The drag state returns the text of each section. |
| fn | `Value_Name_getIDs`Value Name | `(out IDs: name[])` | Implemented by a name value to list the names it can take, in order, which drop-downs use as their option identifiers. The drag state returns the identifier of each of its sections. |
| fn | `Value_Name_PreviousValue`Value_Name | `(SourceInfo: ST_SourceInfo)` | Implemented by a name value to step back to the preceding entry of its list. Called by steppers and previous buttons bound to the value. |
| fn | `Value_Name_NextValue`Value_Name | `(SourceInfo: ST_SourceInfo)` | Implemented by a name value to step on to the following entry of its list. Called by steppers and next buttons bound to the value. |
| fn | `Value_Name_GetValue`Value_Name | `(out SourceInfo: ST_SourceInfo, out Name: name)` | Implemented by a name value to report the name it holds and the source info of whoever last set it. The drag state answers with the section its handle is currently sitting in. |
| fn | `Value_Name_Set`Value_Name | `(SourceInfo: ST_SourceInfo, Name: name)` | Implemented by a name value to take a new name from the pawn described by the source info. The drag state reads the name as the section to move to. |

**BPI_Value_Trigger**2 members

extends `Interface`

Typed half of the value contract for values that only fire: the trigger call, carrying the source info of whoever pressed it, and the text a button shows for it. Implemented by the trigger state; implement it on an object of your own that should sit wherever the framework expects a value.

| Kind | Name | Signature | Description |
|---|---|---|---|
| fn | `Value_Trigger_getText`Value Trigger | `(out Text: text)` | Implemented by a trigger value to supply the caption for the action it performs, which buttons show as their label. |
| fn | `Value_Trigger`Value_Trigger | `(SourceInfo: ST_SourceInfo)` | Implemented by a value that fires rather than holds a setting, taking the source info of the pawn that set it off. Buttons call it on press. |