- Spark AR Studio
- Spark AR Hub
- Features
- Learn
- Gallery
- Partners
- Blog
- Forum
- Create AR effects for Instagram and Facebook.Get Started

The `ReactiveModule`

class exposes methods for reactive programming.

//========================================================================== // The following example demonstrates how to perform mathematical operations // on signals and constant values. //========================================================================== // Load in the required modules const Diagnostics = require('Diagnostics'); const FaceTracking = require('FaceTracking'); const Reactive = require('Reactive'); // Create a reference to the mouth openness scalar signal of a detected // face const mouthOpenness = FaceTracking.face(0).mouth.openness; // Add 1 to the signal using the scalarSignal add() method const mouthOpennessPlusOne = mouthOpenness.add(1); // Multiply the signal by 2 using the reactive mul() method const doubleMouthOpenness = Reactive.mul(mouthOpenness,2); // Create a reference to the constant mouth openness value when this code // is executed const lastMouthOpenness = mouthOpenness.pinLastValue(); // Watch the signal values in the Console Diagnostics.watch('Mouth Openness =>', mouthOpenness); Diagnostics.watch('Mouth Openness + 1 =>', mouthOpennessPlusOne); Diagnostics.watch('Mouth Openness * 2 =>', doubleMouthOpenness); // Log the constant value in the Console Diagnostics.log(lastMouthOpenness);

This module exposes no properties.

Method | Description |
---|---|

` abs ` | abs(x: ScalarSignal): ScalarSignal Returns a signal with the value that is the absolute value of the given signal. See Also: `ScalarSignal.abs` |

` acos ` | acos(x: ScalarSignal): ScalarSignal Returns a signal with the value that is the inverse cosine of the value of the given signal (interpreted as radians). |

` add ` | add(x: ScalarSignal, y: ScalarSignal): ScalarSignal Returns a signal with the value that is the sum of the values of the given signals. Note: `add` and `sum` functions are synonyms, the behavior they provide is equivalent.See Also: `ReactiveModule.sum` , `ScalarSignal.add` , `PointSignal.add` , `VectorSignal.add` |

` and ` | and(lhs: BoolSignal, rhs: BoolSignal): BoolSignal Returns a signal with the value that is the logical conjunction of the values of the given signals. It is `true` every time both input signals are `true` and `false` at all other times.See Also: `BoolSignal.and` |

` andList ` | andList(x: Array<BoolSignal>): BoolSignal Returns a signal with the value that is the logical and of the values in an array |

` antiderivative ` | antiderivative(signal: ScalarSignal, config: {initialValue: number, max: number, min: number, overflowBehaviour: ReactiveModule.AntiderivativeOverflowBehaviour}): ScalarSignal Returns a signal that estimates the anti derivative of the given signal with respect to time (measured in milliseconds). Note: Since the antiderivative is inherently unbound the min/max parameters must be provided to prevent overflow. when `overflowBehaviour` is CLAMP the output is clamped at the min/max. When `overflowBehaviour` is WRAP the output is wrapped. This is useful when the output represents something that is cyclic like an angle in this case min might be 0, max might be 2*PI. |

` asin ` | asin(x: ScalarSignal): ScalarSignal Returns a signal with the value that is the inverse sine of the value of the given signal (interpreted as radians). |

` atan ` | atan(x: ScalarSignal): ScalarSignal Returns a signal with the value that is the inverse tangent of the value of the given signal (interpreted as radians). |

` atan2 ` | atan2(x: ScalarSignal, y: ScalarSignal): ScalarSignal Returns a signal with the value that is the angle in radians between the x-axis and the ray from (0, 0) to (x, y) where x and y are the values of the specified signals. The range is -PI to +PI. See Also: `ScalarSignal.atan2` |

` boolSignalSource ` | boolSignalSource(sourceId: string): BoolSignalSource Creates a new `BoolSignalSource` object, which allows for the value of a `BoolSignal` object to be updated without rebinding the signal.The signal provided by the source contains a value of `false` until a value is assigned via `BoolSignalSource.set()` .When calling the method, avoid reusing the `sourceId` of an object that you've called `dispose()` on.* `sourceId` - the unique ID of the signal to create or retrieve. |

` boundingBox ` | boundingBox(x: ScalarSignal, y: ScalarSignal, width: ScalarSignal, height: ScalarSignal): Box2DSignal Constructs a `Box2DSignal` with the dimensions specified by `width` and `height` , positioned at the location specified by `x` and `y` .All arguments should be provided as normalized screen space units. * `x` - the x position of the top left corner of the bounding box.* `y` - the y position of the top left corner of the bounding box.* `width` - the width of the bounding box.* `height` - the height of the bounding box. |

` box2d ` | box2d(x: ScalarSignal, y: ScalarSignal, width: ScalarSignal, height: ScalarSignal): Box2DSignal Constructs a `Box2DSignal` with the dimensions specified by `width` and `height` , positioned at the location specified by `x` and `y` .All arguments should be provided as normalized screen space units. * `x` - the x position of the top left corner of the bounding box.* `y` - the y position of the top left corner of the bounding box.* `width` - the width of the bounding box.* `height` - the height of the bounding box. |

` box3d ` | box3d(min: PointSignal, max: PointSignal): Box3DSignal Constructs a `Box3DSignal` with the provided `min` and `max` points.* `min` - the minimum point of the bounding box.* `max` - the maximum point of the bounding box. |

` ceil ` | ceil(x: ScalarSignal): ScalarSignal Returns a signal with the value that is the smallest integer that is greater than or equal to the value of the given signal. See Also: `ScalarSignal.ceil` |

` clamp ` | clamp(x: ScalarSignal, min: ScalarSignal, max: ScalarSignal): ScalarSignal Returns a signal with the value that is the value of the given `x` signal constrained to lie between the values of the given `min` and `max` signals.Note: The behavior is undefined if `min` is greater than `max` . |

` concat ` | concat(lhs: StringSignal, rhs: StringSignal): StringSignal Returns a `StringSignal` containing the concatenation of the values specified by the input signals.See Also: `StringSignal.concat` |

` cos ` | cos(x: ScalarSignal): ScalarSignal Returns a signal with the value that is the cosine of the value of the given signal (interpreted as radians). |

` cross ` | cross(v1: VectorSignal, v2: VectorSignal): PointSignal Returns a vector signal with the value that is the cross product of the given signals. See Also: `VectorSignal.dot` , `ScalarSignal.mul` , `VectorSignal.mul` |

` derivative ` | derivative(signal: ScalarSignal): ScalarSignal Returns a signal that estimates the derivative of the given signal with respect to time (measured in milliseconds). Note: the value of the derivative at the initial point of time is always set to zero.Note: the returned signal might be noisy for certain types of input signals, especially those received from the face tracking. It is recommended to pass the input signal to `expSmooth` first with a damping constant in the range between 100 and 500. |

` distance ` | distance(v1: PointSignal, v2: PointSignal): ScalarSignal Returns the distance from the point to another point as a `ScalarSignal` . |

` div ` | div(x: ScalarSignal, y: ScalarSignal): ScalarSignal Returns a signal with the value that is the value of the first signal divided by the value of the second signal. See Also: `ScalarSignal.div` |

` dot ` | dot(v1: VectorSignal, v2: VectorSignal): ScalarSignal Returns a scalar signal with the value that is the dot product of the given signals. See Also: `VectorSignal.cross` , `ScalarSignal.mul` , `VectorSignal.mul` |

` eq ` | eq(lhs: ScalarSignal, rhs: ScalarSignal): BoolSignal Returns a Boolean signal that takes the value of `true` every time when the value of the left-hand-side signal is equal to the value of the right-hand-side one, and the value of `false` all other time.Note: the scalar values are tested for exact equality. For some applications it might be reasonable to perform a non-strict comparison allowing the values to be within a small distance one from another.See Also: `ScalarSignal.eq` , `StringSignal.eq` , `BoolSignal.eq` |

` exp ` | exp(x: ScalarSignal): ScalarSignal Returns a signal with the value that is e (the Euler's constant 2.718...) to the power of the value of the given signal. |

` expSmooth ` | expSmooth(signal: ScalarSignal, dampFactor: number): ScalarSignal Smoothes a variable signal using exponential averaging over time. The argument specifies the dampening time constant in milliseconds. Note: See also `ScalarSignal.expSmooth` , `PointSignal.expSmooth` , `VectorSignal.expSmooth` , `TransformSignal.expSmooth` .Note: The smoothed transformation for a signal that specifies a rigid body transformation is guaranteed to be a rigid body transformation. The rotation component is smoothed in spherical coordinates using Slerp (spherical linear interpolation). |

` floor ` | floor(x: ScalarSignal): ScalarSignal Returns a signal with the value that is the largest integer that is less than or equal to the value of the given signal. See Also: `ScalarSignal.floor` |

` fromRange ` | fromRange(x: ScalarSignal, min: ScalarSignal, max: ScalarSignal): ScalarSignal Maps x from [min, max] range to [0.0, 1.0] range. |

` ge ` | ge(lhs: ScalarSignal, rhs: ScalarSignal): BoolSignal Returns a Boolean signal that takes the value of `true` every time when the value of the left-hand-side signal is greater than or equal to the value of the right-hand-side one, and the value of `false` all other time.See Also: `ScalarSignal.ge` |

` gt ` | gt(lhs: ScalarSignal, rhs: ScalarSignal): BoolSignal Returns a Boolean signal that takes the value of `true` every time when the value of the left-hand-side signal is strictly greater than the value of the right-hand-side one, and the value of `false` all other time.See Also: `ScalarSignal.gt` |

` HSVA ` | HSVA(h: ScalarSignal | number, s: ScalarSignal | number, v: ScalarSignal | number, a: ScalarSignal | number): HsvaSignal Combines four signals and returns the result as an `HsvaSignal` . Each value should be in the range between 0.0 and 1.0.Note: Hue value is also specified in the range between 0.0 and 1.0. |

` ifThenElse ` | ifThenElse<T, U>(condition: BoolSignal | boolean, thenValue: EventSource<T>, elseValue: EventSource<U>): EventSource<T | U> Returns a signal or an `EventSource` which at any point of time takes the value (passes the events in case of `EventSource` ) of one or another inputs, depending on the momentary value of the given condition `BoolSignal` . |

` le ` | le(lhs: ScalarSignal, rhs: ScalarSignal): BoolSignal Returns a Boolean signal that takes the value of `true` every time when the value of the left-hand-side signal is less than or equal to the value of the right-hand-side one, and the value of `false` all other time.See Also: `ScalarSignal.le` |

` log ` | log(x: ScalarSignal): ScalarSignal Returns a signal with the value that is the natural logarithm of the value of the given signal. |

` lookAt ` | lookAt(eyeTransform: TransformSignal, targetPosition: PointSignal, eyeUp?: VectorSignal): TransformSignal Creates a scene object transform with rotation in direction of target. Default `eyeUp` is `ReactiveModule.vector(0, 1, 0)` .Note: The eyeTransform needs to be pointing the scene object alongside the X axis. |

` lt ` | lt(lhs: ScalarSignal, rhs: ScalarSignal): BoolSignal Returns a Boolean signal that takes the value of `true` every time when the value of the left-hand-side signal is strictly less than the value of the right-hand-side one, and the value of `false` all other time.See Also: `ScalarSignal.lt` |

` magnitude ` | magnitude(v: VectorSignal): ScalarSignal Returns the magnitude of the vector as a `ScalarSignal` . |

` magnitudeSquared ` | magnitudeSquared(signal: ScalarSignal): ScalarSignal Returns the squared length (magnitude) of a given signal. Calculating the squared magnitude instead of the magnitude is much faster. Often if you are comparing magnitudes of two vectors you can just compare their squared magnitudes. |

` max ` | max(x: ScalarSignal, y: ScalarSignal): ScalarSignal Returns a signal with the value that is the greater of the values of the given signals. |

` min ` | min(x: ScalarSignal, y: ScalarSignal): ScalarSignal Returns a signal with the value that is the lesser of the values of the given signals. |

` mix ` | mix(x: ScalarSignal, y: ScalarSignal, alpha: ScalarSignal): ScalarSignal Returns a signal with the value that is the interpolation of the values of the given signals. |

` mod ` | mod(x: ScalarSignal, y: ScalarSignal): ScalarSignal Returns a signal with the value that is the floating-point remainder of the division of the value of the first signal by the value of the second signal. See Also: `ScalarSignal.mod` |

` monitorMany ` | monitorMany(signals: {[name: string]: ScalarSignal}, config?: {fireOnInitialValue?: false | true}): EventSource<{newValues: {[key: string]: number}, oldValues: {[key: string]: number}}> Returns an `EventSource` that emits an event every time when any value of the input signals change. The event contains a JSON object with the old and new values in the format:{ "oldValues": oldValues, "newValues": newValues } where `oldValues` and `newValues` are the JSON objects where keys are the names of the signals and values are old or new values of that signals correspondingly.Note: By default, there is no event fired for the initial value of the signal. If `config.fireOnInitialValue` is set to `true` then an event for initial signal value is also emitted. `oldValues` is unset for this initial event.See Also: `ReactiveModule.monitor` |

` mul ` | mul(x: ScalarSignal, y: ScalarSignal): ScalarSignal Returns a signal with the value that is the product of the values of the given signals. See Also: `ScalarSignal.mul` , `VectorSignal.mul` |

` mulList ` | mulList(x: Array<number | ScalarSignal>): ScalarSignal Returns a signal with the value that is the product of the values in an array |

` ne ` | ne(lhs: ScalarSignal, rhs: ScalarSignal): BoolSignal Returns a Boolean signal that takes the value of `true` every time when the value of the left-hand-side signal is not equal to the value of the right-hand-side one, and the value of `false` all other time.Note: the scalar values are tested for exact equality. For some applications it might be reasonable to perform a non-strict comparison allowing the values to be within a small distance one from another.See Also: `ScalarSignal.ne` , `StringSignal.ne` , `BoolSignal.ne` |

` neg ` | neg(x: ScalarSignal): ScalarSignal Returns a signal with the negated value of the given signal. See Also: `ScalarSignal.neg` , `VectorSignal.neg` |

` normalize ` | normalize(v: VectorSignal): VectorSignal Returns the normalized (unit) vector in the direction of the original vector as a `VectorSignal` . |

` not ` | not(signal: BoolSignal): BoolSignal Returns a signal with the logically negated value of the given signal. See Also: `BoolSignal.not` |

` once ` | once(): EventSource<void> Returns an `EventSource` that emits exactly one empty event as soon as possible. |

` or ` | or(lhs: BoolSignal, rhs: BoolSignal): BoolSignal Returns a signal with the value that is the logical disjunction of the values of the given signals. It is `true` every time at least one of the input signals is `true` and `false` at all other times.See Also: `BoolSignal.or` |

` orList ` | orList(x: Array<BoolSignal>): BoolSignal Returns a signal with the value that is the logical or of the values in an array |

` pack2 ` | pack2(x: ScalarSignal, y: ScalarSignal): Vec2Signal Packs two Scalar or Point signals into a bigger Point signal. |

` pack3 ` | pack3(x: ScalarSignal, y: ScalarSignal, z: ScalarSignal): PointSignal Packs three Scalar or Point signals into a bigger Point signal. |

` pack4 ` | pack4(x: ScalarSignal, y: ScalarSignal, z: ScalarSignal, w: ScalarSignal): Vec4Signal Packs four `ScalarSignals` into a `Vec4Signal` . |

` point ` | point(x: ScalarSignal | number, y: ScalarSignal | number, z: ScalarSignal | number): PointSignal Combines three signals and returns the result as a `PointSignal` . |

` point2d ` | point2d(x: ScalarSignal | number, y: ScalarSignal | number): Vec2Signal Combines two signals and returns the result as a `Vec2Signal` . |

` pow ` | pow(base: ScalarSignal, exponent: ScalarSignal): ScalarSignal Returns a signal with the value that is the base signal raised to the power of the exponent signal. The result is undefined if the base is negative, or if the base is zero and the exponent is not positive. See Also: `ScalarSignal.pow` |

` quaternion ` | quaternion(w: ScalarSignal, x: ScalarSignal, y: ScalarSignal, z: ScalarSignal): QuaternionSignal Construct a new quaternion signal with w, x, y, z components. |

` quaternionFromAngleAxis ` | quaternionFromAngleAxis(angle: ScalarSignal, axis: VectorSignal): QuaternionSignal Construct a new quaternion from an angle and normalized axis. |

` quaternionFromEuler ` | quaternionFromEuler(x: ScalarSignal, y: ScalarSignal, z: ScalarSignal): QuaternionSignal Construct a new quaternion signal from euler angles, representing pitch, yaw, roll respectively. |

` quaternionFromTo ` | quaternionFromTo(from: VectorSignal, to: VectorSignal): QuaternionSignal Construct a new quaternion signal that represents required rotation to rotate vector `from` to vector `to` . |

` quaternionIdentity ` | quaternionIdentity(): QuaternionSignal Construct a new quaternion signal that represents an identity quaternion. |

` quaternionLookAt ` | quaternionLookAt(targetPosition: PointSignal, selfUp?: VectorSignal): QuaternionSignal Creates a new quaternion signal representing rotation in the direction of a normalized target direction vector. Default selfUp is ReactiveModule.vector(0, 1, 0). |

` reflect ` | reflect(incident: VectorSignal, normal: VectorSignal): VectorSignal Calculates the reflection direction for an incident vector and a normal as a `VectorSignal` . |

` RGBA ` | RGBA(r: ScalarSignal | number, g: ScalarSignal | number, b: ScalarSignal | number, a: ScalarSignal | number): RgbaSignal Combines four signals and returns the result as an `RgbaSignal` . Each value should be in the range between 0.0 and 1.0.Note: RGB components are interpreted in sRGB space. |

` rotation ` | rotation(w: number, x: number, y: number, z: number): Rotation Creates 'Rotation' from quaternion components |

` round ` | round(x: ScalarSignal): ScalarSignal Returns a signal with the value that is the rounded value of the given signal. Note: When the fractional part is 0.5, it rounds the number away from zero, which is at odds with JavaScript standard behavior of rounding it always up in such cases. Therefore, this function is NOT exactly the reactive counterpart of the standard JavaScript `Math.round` utility.See Also: `ScalarSignal.round` |

` scalarSignalSource ` | scalarSignalSource(sourceId: string): ScalarSignalSource Creates a new `ScalarSignalSource` object, which allows for the value of a `ScalarSignal` object to be updated without rebinding the signal.The signal provided by the source contains a value of `0` until a value is assigned via `ScalarSignalSource.set()` .When calling the method, avoid reusing the `sourceId` of an object that you've called `dispose()` on.* `sourceId` - the unique ID of the signal to create or retrieve. |

` scale ` | scale(x: ScalarSignal | number, y: ScalarSignal | number, z: ScalarSignal | number): PointSignal Combines three signals and returns the result as a `PointSignal` . |

` schmittTrigger ` | schmittTrigger(signal: ScalarSignal, config: {high: number, initialValue?: false | true, low: number}): BoolSignal Returns a Boolean signal that is `true` when the input is strictly greater than the upper threshold, and `false` when it is strictly less than the lower threshold.For input values between and including the thresholds, the Shmitt trigger returns the same value as at the previous update, or initialValue if this is the first update.Note: The initialValue is assumed to be `false` if it isn't specified. |

` sign ` | sign(x: ScalarSignal): ScalarSignal Returns a signal with the value that is the sign of the given signal. Possible sign values: NaN, -0.0, 0.0, -1.0, 1.0. Note: this function is the reactive counterpart of the standard JavaScript `Math.sign` utility.See Also: `ScalarSignal.sign` |

` signalHistory ` | signalHistory<T>(source: EventSource<T>, count: number): EventSourceHistory<T> Returns an object used to access signal values from past frames. The amount of frames tracked is customizable via framesCount parameter. Historical signal values are going to be initialized with signal value at call time or using initialValues if provided. |

` sin ` | sin(x: ScalarSignal): ScalarSignal Returns a signal with the value that is the sine of the value of the given signal (interpreted as radians). |

` smoothStep ` | smoothStep(x: ScalarSignal, edge0: ScalarSignal, edge1: ScalarSignal): ScalarSignal Returns 0.0 if x is less than edge0, and 1.0 if x is greater than edge1. If x is between edge0 and edge1, smooth Hermite interpolation is performed. |

` sqrt ` | sqrt(x: ScalarSignal): ScalarSignal Returns a signal with the value that is the square root of the value of the given signal. See Also: `ScalarSignal.sqrt` |

` step ` | step(x: ScalarSignal, edge: ScalarSignal): ScalarSignal Returns 0.0 if x is less than edge, and 1.0 is returned otherwise. |

` stringSignalSource ` | stringSignalSource(sourceId: string): StringSignalSource Creates a new `StringSignalSource` object, which allows for the value of a `StringSignal` object to be updated without rebinding the signal.The signal provided by the source contains an empty string until a value is assigned via `StringSignalSource.set()` .When calling the method, avoid reusing the `sourceId` of an object that you've called `dispose()` on.* `sourceId` - the unique ID of the signal to create or retrieve. |

` sub ` | sub(x: ScalarSignal, y: ScalarSignal): ScalarSignal Returns a signal with the value that is the difference of the values of the given signals. See Also: `ScalarSignal.sub` , `VectorSignal.sub` , `PointSignal.sub` |

` sum ` | sum(x: ScalarSignal, y: ScalarSignal): ScalarSignal Returns a signal with the value that is the sum of the values of the given signals. Note: `add` and `sum` functions are synonyms, the behavior they provide is equivalent.See Also: `ReactiveModule.sum` , `ScalarSignal.add` , `PointSignal.add` , `VectorSignal.add` |

` sumList ` | sumList(x: Array<number | ScalarSignal>): ScalarSignal Returns a signal with the value that is the sum of the values in an array |

` switch ` | switch(condition: StringSignal, map: {[key: string]: string}, defaultValue: string): StringSignal Returns a signal which at any point of time takes the value of one of the elements in the provided map, or the provided default value, depending on the momentary value of the given condition Signal. |

` tan ` | tan(x: ScalarSignal): ScalarSignal Returns a signal with the value that is the tangent of the value of the given signal (interpreted as radians). |

` toRange ` | toRange(x: ScalarSignal, min: ScalarSignal, max: ScalarSignal): ScalarSignal Maps x from [0.0, 1.0] range to [min, max] range. |

` val ` | val(constant: number): ScalarSignal Returns a signal that has a constant value which is specified by the argument. Note: Primitive types are implicitly converted to constant signals when passed as function or property-setter arguments, therefore using `val` in such scenarios is not required. |

` vector ` | vector(x: ScalarSignal | number, y: ScalarSignal | number, z: ScalarSignal | number): VectorSignal Combines three signals and returns the result as a `VectorSignal` . |

` xor ` | xor(lhs: BoolSignal | boolean, rhs: BoolSignal | boolean): BoolSignal Returns a signal with the value that is the logical exclusive disjunction of the values of the given signals. It is `true` every time exactly one of the input signals is `true` and `false` at all other times.Note: It is equivalent to `ReactiveModule.ne` .See Also: `BoolSignal.xor` |

` xorList ` | xorList(x: Array<BoolSignal>): BoolSignal Returns a signal with the value that is the logical xor of the values in an array |

Class | Description |
---|---|

BoolSignal | The `BoolSignal` class monitors a boolean value. |

BoolSignalSource | Represents a source used to get and set the value of a `BoolSignal` . |

Box2DSignal | The `Box2DSignal` class monitors 2D bounding box value. |

Box3DSignal | The `Box3DSignal` class describes the bounds in 3D space. |

ColorSignal | The `ColorSignal` class monitors a color. |

EventSource | The `EventSource` class provides methods for monitoring signals. |

EventSourceHistory | The `EventSourceHistory` encapsulates methods for accessing values of `EventSource` from previous frames. |

HsvaSignal | The `HsvaSignal` class monitors a HSVA color value. |

ISignal | The `ISignal` interface. The base class for `ScalarSignal` , `PointSignal` , `VectorSignal` , `BoolSignal` , and `StringSignal` . |

Point2D | The `Point2D` class contains a 2D coordinate. |

Point3D | The `Point3D` class contains a 3D coordinate. |

PointSignal | The `PointSignal` class monitors a 3D coordinate. |

PrimitiveOrShaderSignal | The `PrimitiveOrShader` represents a primitive or shader signal. |

QuaternionSignal | The `QuaternionSignal` class monitors rotation in a quaternion representation. |

RgbaSignal | The `RgbaSignal` class monitors a RGBA color value. |

Rotation | The `Rotation` class encapsulates an object's rotation in a quaternion representation. |

ScalarSignal | The `ScalarSignal` class monitors a numerical value. |

ScalarSignalSource | Represents a source used to get and set the value of a `ScalarSignal` . |

ShaderSignal | The `ShaderSignal` represents a shader signal. Scalar and Vector signals can automatically be converted to a ShaderSignal. |

SignalHistory | The `SignalHistory<T>` encapsulates methods for accessing values from previous frames. |

StringSignal | The `StringSignal` class monitors a string value. |

StringSignalSource | Represents a source used to get and set the value of a `StringSignal` . |

Subscription | The `Subscription` class implements object value monitoring. |

TransformSignal | The `TransformSignal` class monitors a scene transform. |

Vec2Signal | The `Vec2Signal` class monitors a 2D coordinate. |

Vec4Signal | The `Vec4Signal` class monitors a 4D coordinate. |

VectorSignal | The `VectorSignal` class monitors a vector. |

Enum | Description |
---|---|

AntiderivativeOverflowBehaviour | The `AntiderivativeOverflowBehaviour` enum describes the recovery technique used when anantiderivative overflows. |