Interface for devices that implement their own state update handling.
public interface IInputStateCallbackReceiver
The input system has built-in logic to automatically handle the state buffers that store input values for devices. This means that if an input event containing input state is processed, its data will be copied automatically into the state memory for the device.
However, some devices need to apply custom logic whenever new input is received. An example of this is delta which needs to accumulate deltas as they are received within a frame and then reset the delta at the beginning of a new frame.
Also, devices like Touchscreen extensively customize event handling in order to implement features such as tap detection and primary touch handling. This is what allows the device to receive state events in TouchState format even though that is not the format of the device itself (which is mainly a composite of several TouchStates).
This interface allows to bypass the built-in logic and instead intercept and manually handle state updates.
GetStateOffsetForEvent(InputControl, InputEventPtr, ref UInt32)
Compute an offset that correlates
control with the state in
bool GetStateOffsetForEvent(InputControl control, InputEventPtr eventPtr, ref uint offset)
Control the state of which we want to access within
False if the correlation failed or true if
This method will only be called if the given state event has a state format different than that of the device. In that case, the memory of the input state captured in the given state event cannot be trivially correlated with the control.
The input system calls the method to know which offset (if any) in the device's state block to consider the state
eventPtr relative to when accessing the state for
control as found in
An example of when this is called is for touch events. These are normally sent in TouchState format
which, however, is not the state format of Touchscreen (which uses a composite of several TouchStates).
When trying to access the state in
eventPtr to, for example, read out the touch position,
A new input update begins. This means that the current state of the device is being carried over into the next frame.
This is called without the front and back buffer for the device having been flipped. You can use Change(InputDevice, InputEventPtr, InputUpdateType) to write values into the device's state (e.g. to reset a given control to its default state) which will implicitly perform the buffer flip.
A new state event has been received and is being processed.
void OnStateEvent(InputEventPtr eventPtr)
Use Change(InputDevice, InputEventPtr, InputUpdateType) to write state updates into the device state buffers. While nothing will prevent a device from writing directly into the memory buffers retrieved with currentStatePtr, doing so will bypass the buffer flipping logic as well as change detection from change monitors (IInputStateChangeMonitor; this will cause InputAction to not work with the device) and thus lead to incorrect behavior.