Interface IInputStateCallbackReceiver
Interface for devices that implement their own state update handling.
Namespace: UnityEngine.InputSystem.LowLevel
Assembly: Unity.InputSystem.dll
Syntax
public interface IInputStateCallbackReceiverRemarks
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.
Methods
GetStateOffsetForEvent(InputControl, InputEventPtr, ref uint)
Compute an offset that correlates control with the state in eventPtr.
Declaration
bool GetStateOffsetForEvent(InputControl control, InputEventPtr eventPtr, ref uint offset)Parameters
| Type | Name | Description |
|---|---|---|
| InputControl | control | Control the state of which we want to access within |
| InputEventPtr | eventPtr | An input event. Must be a StateEvent or DeltaStateEvent |
| uint | offset |
Returns
| Type | Description |
|---|---|
| bool | False if the correlation failed or true if |
Remarks
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
in eventPtr relative to when accessing the state for control as found in
the event.
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,
See Also
OnNextUpdate()
A new input update begins. This means that the current state of the device is being carried over into the next frame.
Declaration
void OnNextUpdate()Remarks
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.
See Also
OnStateEvent(InputEventPtr)
A new state event has been received and is being processed.
Declaration
void OnStateEvent(InputEventPtr eventPtr)Parameters
| Type | Name | Description |
|---|---|---|
| InputEventPtr | eventPtr | The state event. This will be either a StateEvent or a DeltaStateEvent. |
Remarks
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.