Class TweenVector4
A performance-optimized, sealed tween implementation that interpolates
UnityEngine.Vector4 values component-by-component.
Useful for animating four-component shader parameters, Rect-like float tuples,
or any other four-element float property that does not map to a more specific type.
Implements
Inherited Members
Namespace: Scylla.Core.Util.Tween
Assembly: ScyllaCore.dll
Syntax
public sealed class TweenVector4 : TweenBase, ITweenRemarks
Interpolation: Uses Vector4(Vector4, Vector4, float) for standard playback and Vector4Incremental(Vector4, Vector4, float, int) when LoopType is Incremental. Both functions perform unclamped per-component linear math so that elastic and back easing produce the correct overshoot on all four axes.
Color note: When animating RGBA colors, prefer TweenColor,
which provides dedicated alpha-only support and a cleaner API surface.
TweenVector4 can animate a UnityEngine.Vector4 representation of a color
(e.g., Material.GetVector/SetVector) but does not support
alpha-only mode.
Change value: The internal _changeValue field is precomputed as
endValue - startValue and is used only during incremental loops to avoid
repeated subtraction in the hot path.
To vs. From: By default the start value is captured from the getter when
Play() is called. Call SetFrom(Vector4) before
Play to pin an explicit starting UnityEngine.Vector4.
Pool contract: Reset() zeroes all value fields and clears the getter and setter delegates so the instance can be safely returned to TweenPool.
Constructors
TweenVector4()
Creates a new, unconfigured TweenVector4 instance.
Declaration
public TweenVector4()Remarks
Used by TweenPool when pre-allocating instances. Call Initialize(Func<Vector4>, Action<Vector4>, Vector4, float) before playing.
TweenVector4(Func<Vector4>, Action<Vector4>, Vector4, float)
Creates a fully configured TweenVector4 and immediately calls Initialize(Func<Vector4>, Action<Vector4>, Vector4, float).
Declaration
public TweenVector4(Func<Vector4> getter, Action<Vector4> setter, Vector4 endValue, float duration)Parameters
| Type | Name | Description |
|---|---|---|
| Func<Vector4> | getter | A delegate that reads the current UnityEngine.Vector4 of the target property.
Must not be |
| Action<Vector4> | setter | A delegate that writes the interpolated UnityEngine.Vector4 to the target property
each frame. Must not be |
| Vector4 | endValue | The target UnityEngine.Vector4 to animate toward. |
| float | duration | Total playback time in seconds. Negative values are clamped to zero. |
Exceptions
| Type | Condition |
|---|---|
| ArgumentNullException | Thrown if |
Properties
EndValue
Gets the UnityEngine.Vector4 target value toward which the tween interpolates.
Declaration
public Vector4 EndValue { get; }Property Value
| Type | Description |
|---|---|
| Vector4 | The end value supplied to Initialize(Func<Vector4>, Action<Vector4>, Vector4, float). |
StartValue
Gets the UnityEngine.Vector4 value from which the tween interpolates.
Declaration
public Vector4 StartValue { get; }Property Value
| Type | Description |
|---|---|
| Vector4 | The start value pinned at play time, or the value passed to SetFrom(Vector4). Returns UnityEngine.Vector4.zero before the tween has started and no explicit start value has been set. |
Methods
ApplyValue(float)
Writes the interpolated value to the target property at the given eased progress. Must be implemented by derived classes to perform type-specific interpolation.
Declaration
protected override void ApplyValue(float easedProgress)Parameters
| Type | Name | Description |
|---|---|---|
| float | easedProgress | The eased (and Yoyo-corrected) progress value computed by EasedProgress.
This value is intentionally unclamped; elastic and back easing can produce values below
|
Overrides
Remarks
On the first call when Progress is at or below zero and no start value has
been pinned, the getter is invoked, the result stored as _startValue, and
_changeValue is computed as _endValue - _startValue. For subsequent
frames, either Vector4(Vector4, Vector4, float) (Restart/Yoyo) or
Vector4Incremental(Vector4, Vector4, float, int) (Incremental) is used and the result
written via the setter.
CaptureStartValue()
Called once during Play() (for new or restarted tweens) to snapshot the current value of the target property as the tween's start value, without applying any change.
Declaration
protected override void CaptureStartValue()Overrides
Remarks
The base implementation is empty. Derived classes override this to read their getter
delegate and store the result in their start-value field, but only when a start value
has not already been pinned via a SetFrom call. This approach ensures that
the start value reflects the live property value at the moment play begins, not at
the moment the tween was created.
Initialize(Func<Vector4>, Action<Vector4>, Vector4, float)
Configures this tween with all required parameters for UnityEngine.Vector4 interpolation.
Resets the _usesFrom flag so the start value is captured from the getter at
play time (standard "To" tween behavior). Call SetFrom(Vector4) afterward to
override with an explicit starting value.
Declaration
public TweenVector4 Initialize(Func<Vector4> getter, Action<Vector4> setter, Vector4 endValue, float duration)Parameters
| Type | Name | Description |
|---|---|---|
| Func<Vector4> | getter | A delegate that reads the current UnityEngine.Vector4 of the target property each
frame. Must not be |
| Action<Vector4> | setter | A delegate that writes the interpolated UnityEngine.Vector4 to the target property
each frame. Must not be |
| Vector4 | endValue | The UnityEngine.Vector4 to animate toward. Captured by value; subsequent changes to the source variable are not reflected unless this method is called again or SetEndValue(Vector4) is used. |
| float | duration | Playback duration in seconds. Clamped to zero; a value of zero produces an instant-complete tween on the first update frame. |
Returns
| Type | Description |
|---|---|
| TweenVector4 | This tween instance for method chaining. |
Exceptions
| Type | Condition |
|---|---|
| ArgumentNullException | Thrown if |
PrepareIncrementalLoop()
Called at the end of each Incremental loop iteration to allow derived classes to update internal state before the next iteration begins.
Declaration
protected override void PrepareIncrementalLoop()Overrides
Remarks
The base implementation is empty. Derived classes that support incremental looping (e.g., TweenFloat, TweenVector3) override this to capture the current property value as the new start point, so each loop iteration adds the change amount on top of the previous iteration's result.
Reset()
Resets all tween state back to initial defaults, preparing the instance for reuse from a pool.
Declaration
public override void Reset()Overrides
Remarks
Clears all callbacks, resets timing values, generates a new TweenID,
and sets State back to Created. This is
called automatically by the tween pool (TweenPool) before returning an
instance to a caller. Derived classes that override this method must call the base
implementation.
SetEndValue(Vector4)
Updates the UnityEngine.Vector4 end value that the tween animates toward.
Declaration
public TweenVector4 SetEndValue(Vector4 endValue)Parameters
| Type | Name | Description |
|---|---|---|
| Vector4 | endValue | The new target UnityEngine.Vector4 value. |
Returns
| Type | Description |
|---|---|
| TweenVector4 | This tween instance for method chaining. |
Remarks
Safe to call while the tween is playing. The change takes effect on the next Update(float) call.
SetFrom(Vector4)
Pins an explicit start value, converting this into a "From" tween that begins at
fromValue and animates toward the configured end value.
Declaration
public TweenVector4 SetFrom(Vector4 fromValue)Parameters
| Type | Name | Description |
|---|---|---|
| Vector4 | fromValue | The UnityEngine.Vector4 from which interpolation begins. Overrides automatic start-value capture at play time. |
Returns
| Type | Description |
|---|---|
| TweenVector4 | This tween instance for method chaining. |