This class handles the logics of tweening the Sprite of a SpriteRenderer as a sequence of sprites
|
| RaTweenSpriteSequence (SpriteRenderer target, Sprite[] sprites, float duration) |
|
Type | GetTargetTypeRaw () |
|
void | SetTargetRaw (object value) |
|
RaTweenSpriteSequence | SetTarget (SpriteRenderer target) |
|
RaTweenSpriteSequence | SetSprites (Sprite[] sprites) |
|
| RaTween (float duration) |
|
delegate void | CallbackHandler () |
|
delegate void | LoopCallbackHandler (int loopCount) |
|
| RaTweenBase (float duration) |
|
bool | IsAlive (bool inclEnded) |
| Returns true if the tween is a living tween
Note: A living tween is one which is not State.None, State.Dead or State.Data
Note: A living tween is one which is being processed, to be processed or ended processing by a RaTweenSequence or the RaTweeningEngine
More...
|
|
bool | Pause () |
| An API Call which pauses the tween on the next processor step More...
|
|
bool | Resume () |
| An API Call which resumes the tween on the next processor step More...
|
|
bool | Stop () |
| An API Call which Ends a tween by stopping it abruptly More...
|
|
bool | Rewind (bool inclDelay=true) |
| An API Call which Rewinds the tween and evaluates its first frame
Note: This will Reset all timers and Refresh internal data
Note: This does not change the TweenState
More...
|
|
bool | Reset (bool resumeAfterReset=false) |
| An API Call which Resets the Tween
Note: This will Reset all timers and Refresh internal data
Note: This will automatically put the tween in the IsPaused state.
More...
|
|
bool | Complete () |
| An API Call which force completes the tween on the next processor step
Note: It will skip over any callbacks which would happen between the current state of the tween and complete. And only call the Completion callback and all after.
Note: Does not work on a tween that HasEnded
More...
|
|
RaTweenBase | Clone (bool inclEvents) |
| Creates a clone of the tween. Which is a completely separate instance with cleared event hooks. All other settings such as delay, duration, target and more will be copied over to the new instance More...
|
|
bool | CanBeModified () |
| Represents when modification calls will be applied to the tween or not. Modification Calls are methods such as, but not limited to; setting the Delay, Duration, Target, Loop Count, Listen to Events of a tween.
Note: All modification calls can only be made when the state is State.None or State.ToStart
More...
|
|
bool | CanUseAPI (bool inclEnded) |
| Represents when API calls will be made on the tween or not. API Calls are methods which make request to the tween, such as Pause, Resume, Stop, Complete
Note: All API calls can only be made when the tween IsAlive(bool)
More...
|
|
Type | GetTargetTypeRaw () |
|
void | SetTargetRaw (object value) |
|
|
override void | Dispose () |
|
override void | Evaluate (float normalizedValue) |
|
override RaTween | RaTweenClone () |
|
abstract RaTween | RaTweenClone () |
|
override RaTweenBase | CloneSelf () |
|
override void | OnSetDuration (float duration) |
|
override void | SetDefaultValues () |
|
override float | CalculateEvaluation () |
|
float | ApplyEvaluationModifier (float value) |
|
override void | ApplyRewind (bool resumeAfterRewind) |
|
override void | ApplyReset (bool inclDelay) |
|
abstract void | SetDefaultValues () |
|
void | SetInfiniteDuration () |
|
void | SetDuration (float duration) |
|
virtual void | OnSetup () |
|
virtual void | OnStart () |
|
virtual void | OnLoop () |
|
virtual void | ResetData () |
|
virtual void | OnSetDuration (float duration) |
|
virtual void | OnComplete () |
|
virtual void | OnEnd () |
|
virtual void | OnKill () |
| For Clean-up, use Dispose instead. This is a notification before disposal More...
|
|
abstract RaTweenBase | CloneSelf () |
|
abstract void | Evaluate (float normalizedValue) |
|
abstract void | ApplyRewind (bool inclDelay) |
|
abstract void | ApplyReset (bool resumeAfterReset) |
|
abstract void | Dispose () |
|
abstract float | CalculateEvaluation () |
|
|
override bool | IsValid [get] |
|
float | TimeScale [get] |
| A Scaler which represents at what relative speed the tween evaluates. (1 being normal speed, 2 being double speed etc)
Note: This affects both the Delay as Evaluation speed
Note: This returns the ITimeScaleChannel.ITimeScaleChannel.TimeScale * Tween.TimeScaleValue (passed with RaTweenUtilExtensions.SetTimeScale<TweenT>(TweenT, float))
Note: If there is no ITimeScaleChannel passed to the tween, this will return Tween.TimeScaleValue instead.
Note: This value will never go below 0.
|
|
object | GroupID [get] |
| The GroupID Represents the Group in which the Tween was placed within the RaTweeningProcessor
|
|
abstract bool | IsValid [get] |
| IsValid will return true when the tween is able to apply its changes to the target. If IsValid returns false, it will be killed automatically when registered to a RaTweenProcessor
|
|
float | Delay [get] |
| This value represent the duration of the delay of the tween in seconds.
Note: No evaluation is applied to the target while the delay is running
|
|
float | DelayProgress [get] |
| The Normalized Progress of the delay. 0 being at the start 1 being at the end
|
|
bool | HasNoDelayRemaining [get] |
| Returns true when the delay process has been completed (or was empty)
|
|
bool | IsInfinite [get] |
| Returns whether the tween itself is infinite. Not to be confused with IsInfiniteLoop, which returns if a finite loop is looping infinitely
|
|
float | Duration [get] |
| Represents the duration of the actual tween after the delay in seconds
|
|
float | Progress [get] |
| The Normalized Progress of the delay. 0 being at the start 1 being at the end
|
|
float | Time [get] |
| Represents the time in seconds that the tween has progressed.
|
|
float | TotalTime [get] |
| The Time that has passed in seconds in delay + the actual tween Delay Time + Time
|
|
float | TotalDuration [get] |
| Represents the duration of the delay plus the actual tween in seconds Delay + Duration
|
|
float | TotalProgress [get] |
| The Normalized Progress of the delay + the actual tween. 0 being at the start 1 being at the end
|
|
bool | IsTotalCompleted [get] |
| Returns true if the delay + actual tween has reached their end
|
|
bool | IsLoop [get] |
| Returns true if the tween is set to loop
|
|
bool | IsInfiniteLoop [get] |
| Returns true if the tween loops an infinite amount of times (unless manually stopped)
|
|
int | Loops [get] |
| Returns the amount of loops the tween desires to make before marking itself as completed.
Note: this will return InfiniteLoopingValue if IsInfiniteLoop is set to true
|
|
bool | IncludeDelayInLoops [get] |
|
float | TotalLoopingTime [get] |
| The Time of TotalTime in total of all its Passed Loops. Delay Time + Time & Loops
|
|
float | TotalLoopingDuration [get] |
| Represents the duration of TotalDuration in total of Total Loops. Delay + Duration & Loops
Note: this will return InfiniteLoopingValue if IsInfiniteLoop is set to true
|
|
float | TotalLoopingProgress [get] |
| The Normalized value of TotalProgress in total of Total Loops. 0 being at the start 1 being at the end DelayProgress + Progress & Loops
Note: this will return InfiniteLoopingValue if IsInfiniteLoop is set to true
|
|
bool | HasReachedLoopEnd [get] |
| Returns true if the the current running tween is the last of the loop cycle Returns true on the first tween when it has no loops
Note: this will always return false if IsInfiniteLoop is set to true
|
|
bool | PauseOnEnd [get] |
| When True, this pauses the Tween when it Ends This prevents it from being Killed by the RaTweeningProcessor
|
|
bool | HasEnded [get] |
| Returns True if the tween has ended. By going through the natural flow or by calling Stop
|
|
bool | IsSetup [get] |
| Returns True if the tween has been Setup. Meaning it triggered the OnSetup callback of the tween.
Note: This happens when a tween is registered to a RaTweeningProcessor and the State.ToStart state is processed.
|
|
bool | HasStarted [get] |
| Returns True if the tween has transitioned from the State.InDelay state to the State.InProgress state.
Note: This resets to False every time the tween is set back in the State.InDelay state.
|
|
bool | IsEmpty [get] |
| Returns true if Delay and Duration are both 0
|
|
State | TweenState [get] |
| The current state of the tween.
Note: A tween can only be manipulated when CanBeModified returns true.
Note: API calls on a tween can only be made when CanUseAPI returns true.
Note: To check if a tween is playing, please use IsPlaying
Note: To check if a tween is paused, please use IsPaused
Note: To check if a tween is completed, please use IsCompleted
|
|
bool | IsPlaying [get] |
| Returns true if the tween is in its delay or in its active tween evaluation
|
|
bool | IsPaused [get] |
| Returns true when a tween is in its paused state
|
|
bool | IsCompleted [get] |
| Returns true when a tween has been completed Meaning fully played or force completed using Complete
|
|
|
enum | State |
| The state in which a tween can be found
|
|
static RaTweenBase[] | GetGroup (object groupID, bool inclEnded) |
| Returns all IsAlive(bool) Tweens under a given GroupID set by RaTweenUtilExtensions.SetGroup<TweenT>(TweenT, object)
Note: When the tween is Submitted to a Processor, only then does the tween become part of the GroupID it is assigned to.
Note: A Tween is Submitted to a Processor when it is Registered to the RaTweeningEngine (When Play<TweenT>(TweenT) is called on it)
More...
|
|
static void | StopGroup (object groupID) |
| Calls Stop on all Tweens under a given GroupID set by RaTweenUtilExtensions.SetGroup<TweenT>(TweenT, object)
Note: When the tween is Submitted to a Processor, only then does the tween become part of the GroupID it is assigned to.
Note: A Tween is Submitted to a Processor when it is Registered to the RaTweeningEngine (When Play<TweenT>(TweenT) is called on it)
|
|
static void | CompleteGroup (object groupID) |
| Calls Complete on all Tweens under a given GroupID set by RaTweenUtilExtensions.SetGroup<TweenT>(TweenT, object)
Note: When the tween is Submitted to a Processor, only then does the tween become part of the GroupID it is assigned to.
Note: A Tween is Submitted to a Processor when it is Registered to the RaTweeningEngine (When Play<TweenT>(TweenT) is called on it)
|
|
static void | PauseGroup (object groupID) |
| Calls Pause on all Tweens under a given GroupID set by RaTweenUtilExtensions.SetGroup<TweenT>(TweenT, object)
Note: When the tween is Submitted to a Processor, only then does the tween become part of the GroupID it is assigned to.
Note: A Tween is Submitted to a Processor when it is Registered to the RaTweeningEngine (When Play<TweenT>(TweenT) is called on it)
|
|
static void | ResumeGroup (object groupID) |
| Calls Resume on all Tweens under a given GroupID set by RaTweenUtilExtensions.SetGroup<TweenT>(TweenT, object)
Note: When the tween is Submitted to a Processor, only then does the tween become part of the GroupID it is assigned to.
Note: A Tween is Submitted to a Processor when it is Registered to the RaTweeningEngine (When Play<TweenT>(TweenT) is called on it)
|
|
const int | InfiniteLoopingValue = -1 |
| The value used to assign and represent Infinity
|
|
This class handles the logics of tweening the Sprite of a SpriteRenderer as a sequence of sprites
Note: This can be used for sprite animations
Note: RaTweenUtilExtensions for all extension methods