DOTween

Types of autoPlay behaviours

No tween is automatically played

Only Sequences are automatically played

Only Tweeners are automatically played

All tweens are automatically played

What axis to constrain in case of Vector tweens

Called the first time the tween is set in a playing state, after any eventual delay

Used in place of System.Func, which is not available in mscorlib.

Used in place of System.Action.

Public so it can be used by lose scripts related to DOTween (like DOTweenAnimation)

Used to separate DOTween class from the MonoBehaviour instance (in order to use static constructors on DOTween). Contains all instance-based methods

Used internally inside Unity Editor, as a trick to update DOTween's inspector at every frame

Directly sets the current max capacity of Tweeners and Sequences (meaning how many Tweeners and Sequences can be running at the same time), so that DOTween doesn't need to automatically increase them in case the max is reached (which might lead to hiccups when that happens). Sequences capacity must be less or equal to Tweeners capacity (if you pass a low Tweener capacity it will be automatically increased to match the Sequence's). Beware: use this method only when there are no tweens running.

Max Tweeners capacity. Default: 200 Max Sequences capacity. Default: 50

This class contains a C# port of the easing equations created by Robert Penner (http://robertpenner.com/easing).

Easing equation function for a bounce (exponentially decaying parabolic bounce) easing in: accelerating from zero velocity.

Current time (in frames or seconds). Expected easing duration (in frames or seconds). Unused: here to keep same delegate for all ease types. Unused: here to keep same delegate for all ease types. The eased value.

Easing equation function for a bounce (exponentially decaying parabolic bounce) easing out: decelerating from zero velocity.

Easing equation function for a bounce (exponentially decaying parabolic bounce) easing in/out: acceleration until halfway, then deceleration.

Returns a value between 0 and 1 (inclusive) based on the elapsed time and ease selected

Used to interpret AnimationCurves as eases. Public so it can be used by external ease factories

Behaviour in case a tween nested inside a Sequence fails and is captured by safe mode

If the Sequence contains other elements, kill the failed tween but preserve the rest

Kill the whole Sequence

Log types thrown by errors captured and prevented by safe mode

No logs. NOT RECOMMENDED

Throw a normal log

Throw a warning log (default)

Throw an error log

Additional notices passed to plugins when updating. Public so it can be used by custom plugins. Internally, only PathPlugin uses it

None

Lets the plugin know that we restarted or rewinded

OnRewind callback behaviour (can only be set via DOTween's Utility Panel)

When calling Rewind or PlayBackwards/SmoothRewind, OnRewind callbacks will be fired only if the tween isn't already rewinded

When calling Rewind, OnRewind callbacks will always be fired, even if the tween is already rewinded. When calling PlayBackwards/SmoothRewind instead, OnRewind callbacks will be fired only if the tween isn't already rewinded

When calling Rewind or PlayBackwards/SmoothRewind, OnRewind callbacks will always be fired, even if the tween is already rewinded

Public only so custom shortcuts can access some of these methods

INTERNAL: used by DO shortcuts and Modules to set special startup mode

INTERNAL: used by DO shortcuts and Modules to set the tween as blendable

INTERNAL: used by DO shortcuts and Modules to prevent a tween from using a From setup even if passed

Used to dispatch commands that need to be captured externally, usually by Modules

Returns a Vector3 with z = 0

Returns the 2D angle between two vectors

Returns a point on a circle with the given center and radius, using Unity's circle coordinates (0° points up and increases clockwise)

Uses approximate equality on each axis instead of Unity's Vector3 equality, because the latter fails (in some cases) when assigning a Vector3 to a transform.position and then checking it.

Looks for the type within all possible project assembly names

NO-GC METHOD: changes the start value of a tween and rewinds it (without pausing it). Has no effect with tweens that are inside Sequences

The new start value If bigger than 0 applies it as the new tween duration

NO-GC METHOD: changes the end value of a tween and rewinds it (without pausing it). Has no effect with tweens that are inside Sequences

The new end value If TRUE the start value will become the current target's value, otherwise it will stay the same

NO-GC METHOD: changes the end value of a tween and rewinds it (without pausing it). Has no effect with tweens that are inside Sequences

The new end value If bigger than 0 applies it as the new tween duration If TRUE the start value will become the current target's value, otherwise it will stay the same

NO-GC METHOD: changes the start and end value of a tween and rewinds it (without pausing it). Has no effect with tweens that are inside Sequences

The new start value The new end value If bigger than 0 applies it as the new tween duration

Struct that stores two colors (used for LineRenderer tweens)

Used for tween callbacks

Used for custom and animationCurve-based ease functions. Must return a value between 0 and 1.

Straight Quaternion plugin. Instead of using Vector3 values accepts Quaternion values directly. Beware: doesn't work with LoopType.Incremental (neither directly nor if inside a LoopType.Incremental Sequence). To use it, call DOTween.To with the plugin parameter overload, passing it PureQuaternionPlugin.Plug() as first parameter (do not use any of the other public PureQuaternionPlugin methods):

DOTween.To(PureQuaternionPlugin.Plug(), ()=> myQuaternionProperty, x=> myQuaternionProperty = x, myQuaternionEndValue, duration);

Plug this plugin inside a DOTween.To call. Example:

DOTween.To(PureQuaternionPlugin.Plug(), ()=> myQuaternionProperty, x=> myQuaternionProperty = x, myQuaternionEndValue, duration);

INTERNAL: do not use

Extra non-tweening-related curve methods

Cubic bezier curve methods

Calculates a point along the given Cubic Bezier segment-curve.

Segment start point Start point's control point/handle Segment end point End point's control point/handle 0-1 percentage along which to retrieve point

Returns an array containing a series of points along the given Cubic Bezier segment-curve.

Start point Start point's control point/handle End point End point's control point/handle Cloud resolution (min: 2)

Calculates a series of points along the given Cubic Bezier segment-curve and adds them to the given list.

Start point Start point's control point/handle End point End point's control point/handle Cloud resolution (min: 2)

Main DOTween class. Contains static methods to create and control tweens in a generic way

DOTween's version

If TRUE (default) makes tweens slightly slower but safer, automatically taking care of a series of things (like targets becoming null while a tween is playing). Default: TRUE

Log type when safe mode reports capturing an error and preventing it

Behaviour in case a tween nested inside a Sequence fails (and is caught by safe mode). Default: NestedTweenFailureBehaviour.TryToPreserveSequence

If TRUE you will get a DOTween report when exiting play mode (only in the Editor). Useful to know how many max Tweeners and Sequences you reached and optimize your final project accordingly. Beware, this will slightly slow down your tweens while inside Unity Editor. Default: FALSE

Global DOTween timeScale. Default: 1

If TRUE, DOTween will use Time.smoothDeltaTime instead of Time.deltaTime for UpdateType.Normal and UpdateType.Late tweens (unless they're set as timeScaleIndependent, in which case a value between the last timestep and will be used instead). Setting this to TRUE will lead to smoother animations. Default: FALSE

If is TRUE, this indicates the max timeStep that an independent update call can last. Setting this to TRUE will lead to smoother animations. Default: FALSE

DOTween's log behaviour. Default: LogBehaviour.ErrorsOnly

Used to intercept DOTween's logs. If this method isn't NULL, DOTween will call it before writing a log via Unity's own Debug log methods. Return TRUE if you want DOTween to proceed with the log, FALSE otherwise. This method must return a bool and accept two parameters: - LogType: the type of Unity log that DOTween is trying to log - object: the log message that DOTween wants to log

If TRUE draws path gizmos in Unity Editor (if the gizmos button is active). Deactivate this if you want to avoid gizmos overhead while in Unity Editor

If TRUE activates various debug options

Stores the target id so it can be used to give more info in case of safeMode error capturing. Only active if both debugMode and useSafeMode are TRUE

Default updateType for new tweens. Default: UpdateType.Normal

Sets whether Unity's timeScale should be taken into account by default or not. Default: false

Default autoPlay behaviour for new tweens. Default: AutoPlay.All

Default autoKillOnComplete behaviour for new tweens. Default: TRUE

Default loopType applied to all new tweens. Default: LoopType.Restart

If TRUE all newly created tweens are set as recyclable, otherwise not. Default: FALSE

Default ease applied to all new Tweeners (not to Sequences which always have Ease.Linear as default). Default: Ease.InOutQuad

Default overshoot/amplitude used for eases Default: 1.70158f

Default period used for eases Default: 0

Used internally. Assigned/removed by DOTweenComponent.Create/DestroyInstance

Must be called once, before the first ever DOTween call/reference, otherwise it will be called automatically and will use default options. Calling it a second time won't have any effect. You can chain SetCapacity to this method, to directly set the max starting size of Tweeners and Sequences: DOTween.Init(false, false, LogBehaviour.Default).SetCapacity(100, 20);

If TRUE all new tweens will be set for recycling, meaning that when killed, instead of being destroyed, they will be put in a pool and reused instead of creating new tweens. This option allows you to avoid GC allocations by reusing tweens, but you will have to take care of tween references, since they might result active even if they were killed (since they might have been respawned and are now being used for other tweens). If you want to automatically set your tween references to NULL when a tween is killed you can use the OnKill callback like this: .OnKill(()=> myTweenReference = null) You can change this setting at any time by changing the static property, or you can set the recycling behaviour for each tween separately, using: SetRecyclable(bool recyclable) Default: FALSE If TRUE makes tweens slightly slower but safer, automatically taking care of a series of things (like targets becoming null while a tween is playing). You can change this setting at any time by changing the static property. Default: FALSE Type of logging to use. You can change this setting at any time by changing the static property. Default: ErrorsOnly

Max Tweeners capacity. Default: 200 Max Sequences capacity. Default: 50

Kills all tweens, clears all cached tween pools and plugins and resets the max Tweeners/Sequences capacities to the default values.

If TRUE also destroys DOTween's gameObject and resets its initializiation, default settings and everything else (so that next time you use it it will need to be re-initialized)

Clears all cached tween pools.

Checks all active tweens to find and remove eventually invalid ones (usually because their targets became NULL) and returns the total number of invalid tweens found and removed. IMPORTANT: this will cause an error on UWP platform, so don't use it there BEWARE: this is a slightly expensive operation so use it with care

Updates all tweens that are set to .

Manual deltaTime Unscaled delta time (used with tweens set as timeScaleIndependent)

Tweens a property or field to the given value using default plugins

Tweens a property or field to the given value using a custom plugin

The plugin to use. Each custom plugin implements a static Get() method you'll need to call to assign the correct plugin in the correct way, like this: CustomPlugin.Get() A getter for the field or property to tween. Example usage with lambda:()=> myProperty A setter for the field or property to tween Example usage with lambda:x=> myProperty = x The end value to reachThe tween's duration

Tweens only one axis of a Vector3 to the given value using default plugins.

Tweens only the alpha of a Color to the given value using default plugins

Tweens a virtual property from the given start to the given end value and implements a setter that allows to use that value with an external method or a lambda Example: To(MyMethod, 0, 12, 0.5f); Where MyMethod is a function that accepts a float parameter (which will be the result of the virtual tween)

The action to perform with the tweened value The value to start from The end value to reach The duration of the virtual tween

Punches a Vector3 towards the given direction and then back to the starting one as if it was connected to the starting position via an elastic. This tween type generates some GC allocations at startup

A getter for the field or property to tween. Example usage with lambda:()=> myProperty A setter for the field or property to tween Example usage with lambda:x=> myProperty = x The direction and strength of the punch The duration of the tween Indicates how much will the punch vibrate Represents how much (0 to 1) the vector will go beyond the starting position when bouncing backwards. 1 creates a full oscillation between the direction and the opposite decaying direction, while 0 oscillates only between the starting position and the decaying direction

Shakes a Vector3 with the given values.

A getter for the field or property to tween. Example usage with lambda:()=> myProperty A setter for the field or property to tween Example usage with lambda:x=> myProperty = x The duration of the tween The shake strength Indicates how much will the shake vibrate Indicates how much the shake will be random (0 to 180 - values higher than 90 kind of suck, so beware). Setting it to 0 will shake along a single direction and behave like a random punch. If TRUE only shakes on the X Y axis (looks better with things like cameras). If TRUE the shake will automatically fadeOut smoothly within the tween's duration, otherwise it will not

Shakes a Vector3 with the given values.

A getter for the field or property to tween. Example usage with lambda:()=> myProperty A setter for the field or property to tween Example usage with lambda:x=> myProperty = x The duration of the tween The shake strength on each axis Indicates how much will the shake vibrate Indicates how much the shake will be random (0 to 180 - values higher than 90 kind of suck, so beware). Setting it to 0 will shake along a single direction and behave like a random punch. If TRUE the shake will automatically fadeOut smoothly within the tween's duration, otherwise it will not

Tweens a property or field to the given values using default plugins. Ease is applied between each segment and not as a whole. This tween type generates some GC allocations at startup

A getter for the field or property to tween. Example usage with lambda:()=> myProperty A setter for the field or property to tween Example usage with lambda:x=> myProperty = x The end values to reach for each segment. This array must have the same length as durations The duration of each segment. This array must have the same length as endValues

Returns a new to be used for tween groups. Mind that Sequences don't have a target applied automatically like Tweener creation shortcuts, so if you want to be able to kill this Sequence when calling DOTween.Kill(target) you'll have to add the target manually; you can do that directly by using the overload instead of this one

Returns a new to be used for tween groups, and allows to set a target (because Sequences don't have their target set automatically like Tweener creation shortcuts). That way killing/controlling tweens by target will apply to this Sequence too.

The target of the Sequence. Relevant only for static target-based methods like DOTween.Kill(target), useless otherwise

Completes all tweens and returns the number of actual tweens completed (meaning tweens that don't have infinite loops and were not already complete)

For Sequences only: if TRUE also internal Sequence callbacks will be fired, otherwise they will be ignored

Completes all tweens with the given ID or target and returns the number of actual tweens completed (meaning the tweens that don't have infinite loops and were not already complete)

For Sequences only: if TRUE internal Sequence callbacks will be fired, otherwise they will be ignored

Flips all tweens (changing their direction to forward if it was backwards and viceversa), then returns the number of actual tweens flipped

Flips the tweens with the given ID or target (changing their direction to forward if it was backwards and viceversa), then returns the number of actual tweens flipped

Sends all tweens to the given position (calculating also eventual loop cycles) and returns the actual tweens involved

Sends all tweens with the given ID or target to the given position (calculating also eventual loop cycles) and returns the actual tweens involved

Kills all tweens and returns the number of actual tweens killed

If TRUE completes the tweens before killing them

Kills all tweens and returns the number of actual tweens killed

If TRUE completes the tweens before killing them Eventual IDs or targets to exclude from the killing

Kills all tweens with the given ID or target and returns the number of actual tweens killed

If TRUE completes the tweens before killing them

Kills all tweens with the given target and the given ID, and returns the number of actual tweens killed

If TRUE completes the tweens before killing them

Pauses all tweens and returns the number of actual tweens paused

Pauses all tweens with the given ID or target and returns the number of actual tweens paused (meaning the tweens that were actually playing and have been paused)

Plays all tweens and returns the number of actual tweens played (meaning tweens that were not already playing or complete)

Plays all tweens with the given ID or target and returns the number of actual tweens played (meaning the tweens that were not already playing or complete)

Plays all tweens with the given target and the given ID, and returns the number of actual tweens played (meaning the tweens that were not already playing or complete)

Plays backwards all tweens and returns the number of actual tweens played (meaning tweens that were not already started, playing backwards or rewinded)

Plays backwards all tweens with the given ID or target and returns the number of actual tweens played (meaning the tweens that were not already started, playing backwards or rewinded)

Plays backwards all tweens with the given target and ID and returns the number of actual tweens played (meaning the tweens that were not already started, playing backwards or rewinded)

Plays forward all tweens and returns the number of actual tweens played (meaning tweens that were not already playing forward or complete)

Plays forward all tweens with the given ID or target and returns the number of actual tweens played (meaning the tweens that were not already playing forward or complete)

Plays forward all tweens with the given target and ID and returns the number of actual tweens played (meaning the tweens that were not already started, playing backwards or rewinded)

Restarts all tweens, then returns the number of actual tweens restarted

Restarts all tweens with the given ID or target, then returns the number of actual tweens restarted

If TRUE includes the eventual tweens delays, otherwise skips them If >= 0 changes the startup delay of all involved tweens to this value, otherwise doesn't touch it

Restarts all tweens with the given target and the given ID, and returns the number of actual tweens played (meaning the tweens that were not already playing or complete)

If TRUE includes the eventual tweens delays, otherwise skips them If >= 0 changes the startup delay of all involved tweens to this value, otherwise doesn't touch it

Rewinds and pauses all tweens, then returns the number of actual tweens rewinded (meaning tweens that were not already rewinded)

Rewinds and pauses all tweens with the given ID or target, then returns the number of actual tweens rewinded (meaning the tweens that were not already rewinded)

Smoothly rewinds all tweens (delays excluded), then returns the number of actual tweens rewinding/rewinded (meaning tweens that were not already rewinded). A "smooth rewind" animates the tween to its start position, skipping all elapsed loops (except in case of LoopType.Incremental) while keeping the animation fluent. Note that a tween that was smoothly rewinded will have its play direction flipped

Smoothly rewinds all tweens (delays excluded) with the given ID or target, then returns the number of actual tweens rewinding/rewinded (meaning the tweens that were not already rewinded). A "smooth rewind" animates the tween to its start position, skipping all elapsed loops (except in case of LoopType.Incremental) while keeping the animation fluent. Note that a tween that was smoothly rewinded will have its play direction flipped

Toggles the play state of all tweens and returns the number of actual tweens toggled (meaning tweens that could be played or paused, depending on the toggle state)

Toggles the play state of all tweens with the given ID or target and returns the number of actual tweens toggled (meaning the tweens that could be played or paused, depending on the toggle state)

Returns TRUE if a tween with the given ID or target is active. You can also use this to know if a shortcut tween is active for a given target. Example: transform.DOMoveX(45, 1); // transform is automatically added as the tween target DOTween.IsTweening(transform); // Returns true

The target or ID to look for If FALSE (default) returns TRUE as long as a tween for the given target/ID is active, otherwise also requires it to be playing

Returns the total number of active tweens. A tween is considered active if it wasn't killed, regardless if it's playing or paused

Returns the total number of active and playing tweens. A tween is considered as playing even if its delay is actually playing

Returns a list of all active tweens in a playing state. Returns NULL if there are no active playing tweens. Beware: each time you call this method a new list is generated, so use it for debug only

If NULL creates a new list, otherwise clears and fills this one (and thus saves allocations)

Returns a list of all active tweens in a paused state. Returns NULL if there are no active paused tweens. Beware: each time you call this method a new list is generated, so use it for debug only

If NULL creates a new list, otherwise clears and fills this one (and thus saves allocations)

Returns a list of all active tweens with the given id. Returns NULL if there are no active tweens with the given id. Beware: each time you call this method a new list is generated

If TRUE returns only the tweens with the given ID that are currently playing If NULL creates a new list, otherwise clears and fills this one (and thus saves allocations)

Returns a list of all active tweens with the given target. Returns NULL if there are no active tweens with the given target. Beware: each time you call this method a new list is generated If TRUE returns only the tweens with the given target that are currently playing If NULL creates a new list, otherwise clears and fills this one (and thus saves allocations)

Creates virtual tweens that can be used to change other elements via their OnUpdate calls

Tweens a virtual float. You can add regular settings to the generated tween, but do not use SetUpdate or you will overwrite the onVirtualUpdate parameter

The value to start from The value to tween to The duration of the tween A callback which must accept a parameter of type float, called at each update

Tweens a virtual int. You can add regular settings to the generated tween, but do not use SetUpdate or you will overwrite the onVirtualUpdate parameter

The value to start from The value to tween to The duration of the tween A callback which must accept a parameter of type int, called at each update

Tweens a virtual Vector3. You can add regular settings to the generated tween, but do not use SetUpdate or you will overwrite the onVirtualUpdate parameter

The value to start from The value to tween to The duration of the tween A callback which must accept a parameter of type Vector3, called at each update

Tweens a virtual Color. You can add regular settings to the generated tween, but do not use SetUpdate or you will overwrite the onVirtualUpdate parameter

The value to start from The value to tween to The duration of the tween A callback which must accept a parameter of type Color, called at each update

Returns a value based on the given ease and lifetime percentage (0 to 1)

The value to start from when lifetimePercentage is 0 The value to reach when lifetimePercentage is 1 The time percentage (0 to 1) at which the value should be taken The type of ease

Returns a value based on the given ease and lifetime percentage (0 to 1)

The value to start from when lifetimePercentage is 0 The value to reach when lifetimePercentage is 1 The time percentage (0 to 1) at which the value should be taken The type of ease Eventual overshoot to use with Back ease

Returns a value based on the given ease and lifetime percentage (0 to 1)

The value to start from when lifetimePercentage is 0 The value to reach when lifetimePercentage is 1 The time percentage (0 to 1) at which the value should be taken The AnimationCurve to use for ease

Fires the given callback after the given time.

Callback delay Callback to fire when the delay has expired If TRUE (default) ignores Unity's timeScale

Don't assign this! It's assigned automatically when creating 0 duration tweens

Don't assign this! It's assigned automatically when setting the ease to an AnimationCurve or to a custom ease function

Allows to wrap ease method in special ways, adding extra features

Converts the given ease so that it also creates a stop-motion effect, by playing the tween at the given FPS

FPS at which the tween should be played Ease type

Converts the given ease so that it also creates a stop-motion effect, by playing the tween at the given FPS

FPS at which the tween should be played AnimationCurve to use for the ease

Converts the given ease so that it also creates a stop-motion effect, by playing the tween at the given FPS

FPS at which the tween should be played Custom ease function to use

Used to allow method chaining with DOTween.Init

Max Tweeners capacity. Default: 200 Max Sequences capacity. Default: 50

Behaviour that can be assigned when chaining a SetLink to a tween

Pauses the tween when the link target is disabled

Pauses the tween when the link target is disabled, plays it when it's enabled

Pauses the tween when the link target is disabled, restarts it when it's enabled

Plays the tween when the link target is enabled

Restarts the tween when the link target is enabled

Kills the tween when the link target is disabled

Kills the tween when the link target is destroyed (becomes NULL). This is always active even if another behaviour is chosen

Completes the tween when the link target is disabled

Completes and kills the tween when the link target is disabled

Rewinds the tween (delay excluded) when the link target is disabled

Rewinds and kills the tween when the link target is disabled

Path mode (used to determine correct LookAt orientation)

Ignores the path mode (and thus LookAt behaviour)

Regular 3D path

2D top-down path

2D side-scroller path

Type of path to use with DOPath tweens

Linear, composed of straight segments between each waypoint

Curved path (which uses Catmull-Rom curves)

EXPERIMENTAL: Curved path (which uses Cubic Bezier curves, where each point requires two extra control points)

Tweens a Vector2 along a circle. EndValue represents the center of the circle, start and end value degrees are inside options ChangeValue x is changeValue°, y is unused

Path control point

Path waypoints (modified by PathPlugin when setting relative end/change value or by CubicBezierDecoder) and by DOTweenPathInspector

Minimum input points necessary to create the path (doesn't correspond to actual waypoints required)

Gets the point on the path at the given percentage (0 to 1)

The percentage (0 to 1) at which to get the point If TRUE constant speed is taken into account, otherwise not

Base interface for all tween plugins options

Resets the plugin

This plugin generates some GC allocations at startup

Path plugin works exclusively with Transforms

Rotation mode used with DORotate methods

Fastest way that never rotates beyond 360°

Fastest way that rotates beyond 360°

Adds the given rotation to the transform using world axis and an advanced precision mode (like when using transform.Rotate(Space.World)). In this mode the end value is is always considered relative

Adds the given rotation to the transform's local axis (like when rotating an object with the "local" switch enabled in Unity's editor or using transform.Rotate(Space.Self)). In this mode the end value is is always considered relative

Type of scramble to apply to string tweens

No scrambling of characters

A-Z + a-z + 0-9 characters

A-Z characters

a-z characters

0-9 characters

Custom characters

Methods that extend Tween objects and allow to control or get data from them

Completes the tween

For Sequences only: if TRUE also internal Sequence callbacks will be fired, otherwise they will be ignored

Flips the direction of this tween (backwards if it was going forward or viceversa)

Forces the tween to initialize its settings immediately

Send the tween to the given position in time

Time position to reach (if higher than the whole tween duration the tween will simply reach its end) If TRUE will play the tween after reaching the given position, otherwise it will pause it

Send the tween to the given position in time while also executing any callback between the previous time position and the new one

Time position to reach (if higher than the whole tween duration the tween will simply reach its end) If TRUE will play the tween after reaching the given position, otherwise it will pause it

Kills the tween

If TRUE completes the tween before killing it

Forces this tween to update manually, regardless of the set via SetUpdate. Note that the tween will still be subject to normal tween rules, so if for example it's paused this method will do nothing. Also note that if you only want to update this tween instance manually you'll have to set it to anyway, so that it's not updated automatically.

Manual deltaTime Unscaled delta time (used with tweens set as timeScaleIndependent)

Pauses the tween

Plays the tween

Sets the tween in a backwards direction and plays it

Sets the tween in a forward direction and plays it

Restarts the tween from the beginning

Ignored in case of Sequences. If TRUE includes the eventual tween delay, otherwise skips it Ignored in case of Sequences. If >= 0 changes the startup delay to this value, otherwise doesn't touch it

Rewinds and pauses the tween

Ignored in case of Sequences. If TRUE includes the eventual tween delay, otherwise skips it

Smoothly rewinds the tween (delays excluded). A "smooth rewind" animates the tween to its start position, skipping all elapsed loops (except in case of LoopType.Incremental) while keeping the animation fluent. If called on a tween who is still waiting for its delay to happen, it will simply set the delay to 0 and pause the tween. Note that a tween that was smoothly rewinded will have its play direction flipped

Plays the tween if it was paused, pauses it if it was playing

Send a path tween to the given waypoint. Has no effect if this is not a path tween. BEWARE, this is a special utility method: it works only with Linear eases. Also, the lookAt direction might be wrong after calling this and might need to be set manually (because it relies on a smooth path movement and doesn't work well with jumps that encompass dramatic direction changes)

Waypoint index to reach (if higher than the max waypoint index the tween will simply go to the last one) If TRUE will play the tween after reaching the given waypoint, otherwise it will pause it

Creates a yield instruction that waits until the tween is killed or complete. It can be used inside a coroutine as a yield. Example usage:yield return myTween.WaitForCompletion();

Creates a yield instruction that waits until the tween is killed or rewinded. It can be used inside a coroutine as a yield. Example usage:yield return myTween.WaitForRewind();

Creates a yield instruction that waits until the tween is killed. It can be used inside a coroutine as a yield. Example usage:yield return myTween.WaitForKill();

Creates a yield instruction that waits until the tween is killed or has gone through the given amount of loops. It can be used inside a coroutine as a yield. Example usage:yield return myTween.WaitForElapsedLoops(2);

Elapsed loops to wait for

Creates a yield instruction that waits until the tween is killed or has reached the given position (loops included, delays excluded). It can be used inside a coroutine as a yield. Example usage:yield return myTween.WaitForPosition(2.5f);

Position (loops included, delays excluded) to wait for

Creates a yield instruction that waits until the tween is killed or started (meaning when the tween is set in a playing state the first time, after any eventual delay). It can be used inside a coroutine as a yield. Example usage:yield return myTween.WaitForStart();

Returns the total number of loops completed by this tween

Returns the eventual delay set for this tween

Returns the eventual elapsed delay set for this tween

Returns the duration of this tween (delays excluded). NOTE: when using settings like SpeedBased, the duration will be recalculated when the tween starts

If TRUE returns the full duration loops included, otherwise the duration of a single loop cycle

Returns the elapsed time for this tween (delays exluded)

If TRUE returns the elapsed time since startup loops included, otherwise the elapsed time within the current loop cycle

Returns the elapsed percentage (0 to 1) of this tween (delays exluded)

If TRUE returns the elapsed percentage since startup loops included, otherwise the elapsed percentage within the current loop cycle

Returns the elapsed percentage (0 to 1) of this tween (delays exluded), based on a single loop, and calculating eventual backwards Yoyo loops as 1 to 0 instead of 0 to 1

Returns FALSE if this tween has been killed or is NULL, TRUE otherwise. BEWARE: if this tween is recyclable it might have been spawned again for another use and thus return TRUE anyway. When working with recyclable tweens you should take care to know when a tween has been killed and manually set your references to NULL. If you want to be sure your references are set to NULL when a tween is killed you can use the OnKill callback like this: .OnKill(()=> myTweenReference = null)

Returns TRUE if this tween was reversed and is set to go backwards

Returns TRUE if the tween is complete (silently fails and returns FALSE if the tween has been killed)

Returns TRUE if this tween has been initialized

Returns TRUE if this tween is playing

Returns the total number of loops set for this tween (returns -1 if the loops are infinite)

Returns a point on a path based on the given path percentage. Returns Vector3.zero if this is not a path tween, if the tween is invalid, or if the path is not yet initialized. A path is initialized after its tween starts, or immediately if the tween was created with the Path Editor (DOTween Pro feature). You can force a path to be initialized by calling myTween.ForceInit().

Percentage of the path (0 to 1) on which to get the point

Returns an array of points that can be used to draw the path. Note that this method generates allocations, because it creates a new array. Returns NULL if this is not a path tween, if the tween is invalid, or if the path is not yet initialized. A path is initialized after its tween starts, or immediately if the tween was created with the Path Editor (DOTween Pro feature). You can force a path to be initialized by calling myTween.ForceInit().

How many points to create for each path segment (waypoint to waypoint). Only used in case of non-Linear paths

Returns the length of a path. Returns -1 if this is not a path tween, if the tween is invalid, or if the path is not yet initialized. A path is initialized after its tween starts, or immediately if the tween was created with the Path Editor (DOTween Pro feature). You can force a path to be initialized by calling myTween.ForceInit().

Types of loop

Each loop cycle restarts from the beginning

The tween moves forward and backwards at alternate cycles

Continuously increments the tween at the end of each loop cycle (A to B, B to B+(A-B), and so on), thus always moving "onward". In case of String tweens works only if the tween is set as relative

Controls other tweens as a group

Methods that extend known Unity objects and allow to directly create and control tweens from their instances

Tweens a Camera's aspect to the given value. Also stores the camera as the tween's target so it can be used for filtered operations

The end value to reachThe duration of the tween

Tweens a Camera's backgroundColor to the given value. Also stores the camera as the tween's target so it can be used for filtered operations

The end value to reachThe duration of the tween

Tweens a Camera's farClipPlane to the given value. Also stores the camera as the tween's target so it can be used for filtered operations

The end value to reachThe duration of the tween

Tweens a Camera's fieldOfView to the given value. Also stores the camera as the tween's target so it can be used for filtered operations

The end value to reachThe duration of the tween

Tweens a Camera's nearClipPlane to the given value. Also stores the camera as the tween's target so it can be used for filtered operations

The end value to reachThe duration of the tween

Tweens a Camera's orthographicSize to the given value. Also stores the camera as the tween's target so it can be used for filtered operations

The end value to reachThe duration of the tween

Tweens a Camera's pixelRect to the given value. Also stores the camera as the tween's target so it can be used for filtered operations

The end value to reachThe duration of the tween

Tweens a Camera's rect to the given value. Also stores the camera as the tween's target so it can be used for filtered operations

The end value to reachThe duration of the tween

Shakes a Camera's localPosition along its relative X Y axes with the given values. Also stores the camera as the tween's target so it can be used for filtered operations

The duration of the tween The shake strength Indicates how much will the shake vibrate Indicates how much the shake will be random (0 to 180 - values higher than 90 kind of suck, so beware). Setting it to 0 will shake along a single direction. If TRUE the shake will automatically fadeOut smoothly within the tween's duration, otherwise it will not

Shakes a Camera's localPosition along its relative X Y axes with the given values. Also stores the camera as the tween's target so it can be used for filtered operations

The duration of the tween The shake strength on each axis Indicates how much will the shake vibrate Indicates how much the shake will be random (0 to 180 - values higher than 90 kind of suck, so beware). Setting it to 0 will shake along a single direction. If TRUE the shake will automatically fadeOut smoothly within the tween's duration, otherwise it will not

Shakes a Camera's localRotation. Also stores the camera as the tween's target so it can be used for filtered operations

Tweens a Light's color to the given value. Also stores the light as the tween's target so it can be used for filtered operations

The end value to reachThe duration of the tween

Tweens a Light's intensity to the given value. Also stores the light as the tween's target so it can be used for filtered operations

The end value to reachThe duration of the tween

Tweens a Light's shadowStrength to the given value. Also stores the light as the tween's target so it can be used for filtered operations

The end value to reachThe duration of the tween

Tweens a LineRenderer's color to the given value. Also stores the LineRenderer as the tween's target so it can be used for filtered operations. Note that this method requires to also insert the start colors for the tween, since LineRenderers have no way to get them.

The start value to tween from The end value to reachThe duration of the tween

Tweens a Material's color to the given value. Also stores the material as the tween's target so it can be used for filtered operations

The end value to reachThe duration of the tween

Tweens a Material's named color property to the given value. Also stores the material as the tween's target so it can be used for filtered operations

The end value to reach The name of the material property to tween (like _Tint or _SpecColor) The duration of the tween

Tweens a Material's named color property with the given ID to the given value. Also stores the material as the tween's target so it can be used for filtered operations

The end value to reach The ID of the material property to tween (also called nameID in Unity's manual) The duration of the tween

Tweens a Material's alpha color to the given value (will have no effect unless your material supports transparency). Also stores the material as the tween's target so it can be used for filtered operations

The end value to reachThe duration of the tween

The end value to reach The name of the material property to tween (like _Tint or _SpecColor) The duration of the tween

Tweens a Material's alpha color with the given ID to the given value (will have no effect unless your material supports transparency). Also stores the material as the tween's target so it can be used for filtered operations

The end value to reach The ID of the material property to tween (also called nameID in Unity's manual) The duration of the tween

Tweens a Material's named float property to the given value. Also stores the material as the tween's target so it can be used for filtered operations

The end value to reach The name of the material property to tween The duration of the tween

Tweens a Material's named float property with the given ID to the given value. Also stores the material as the tween's target so it can be used for filtered operations

The end value to reach The ID of the material property to tween (also called nameID in Unity's manual) The duration of the tween

Tweens a Material's texture offset to the given value. Also stores the material as the tween's target so it can be used for filtered operations

The end value to reach The duration of the tween

Tweens a Material's named texture offset property to the given value. Also stores the material as the tween's target so it can be used for filtered operations

The end value to reach The name of the material property to tween The duration of the tween

Tweens a Material's texture scale to the given value. Also stores the material as the tween's target so it can be used for filtered operations

The end value to reach The duration of the tween

Tweens a Material's named texture scale property to the given value. Also stores the material as the tween's target so it can be used for filtered operations

The end value to reach The name of the material property to tween The duration of the tween

Tweens a Material's named Vector property to the given value. Also stores the material as the tween's target so it can be used for filtered operations

The end value to reach The name of the material property to tween The duration of the tween

Tweens a Material's named Vector property with the given ID to the given value. Also stores the material as the tween's target so it can be used for filtered operations

The end value to reach The ID of the material property to tween (also called nameID in Unity's manual) The duration of the tween

Tweens a TrailRenderer's startWidth/endWidth to the given value. Also stores the TrailRenderer as the tween's target so it can be used for filtered operations

The end startWidth to reachThe end endWidth to reach The duration of the tween

Tweens a TrailRenderer's time to the given value. Also stores the TrailRenderer as the tween's target so it can be used for filtered operations

The end value to reachThe duration of the tween

Tweens a Transform's position to the given value. Also stores the transform as the tween's target so it can be used for filtered operations

The end value to reachThe duration of the tween If TRUE the tween will smoothly snap all values to integers

Tweens a Transform's X position to the given value. Also stores the transform as the tween's target so it can be used for filtered operations

The end value to reachThe duration of the tween If TRUE the tween will smoothly snap all values to integers

Tweens a Transform's Y position to the given value. Also stores the transform as the tween's target so it can be used for filtered operations

The end value to reachThe duration of the tween If TRUE the tween will smoothly snap all values to integers

Tweens a Transform's Z position to the given value. Also stores the transform as the tween's target so it can be used for filtered operations

The end value to reachThe duration of the tween If TRUE the tween will smoothly snap all values to integers

Tweens a Transform's localPosition to the given value. Also stores the transform as the tween's target so it can be used for filtered operations

The end value to reachThe duration of the tween If TRUE the tween will smoothly snap all values to integers

Tweens a Transform's X localPosition to the given value. Also stores the transform as the tween's target so it can be used for filtered operations

The end value to reachThe duration of the tween If TRUE the tween will smoothly snap all values to integers

Tweens a Transform's Y localPosition to the given value. Also stores the transform as the tween's target so it can be used for filtered operations

The end value to reachThe duration of the tween If TRUE the tween will smoothly snap all values to integers

Tweens a Transform's Z localPosition to the given value. Also stores the transform as the tween's target so it can be used for filtered operations

The end value to reachThe duration of the tween If TRUE the tween will smoothly snap all values to integers

Tweens a Transform's rotation to the given value. Also stores the transform as the tween's target so it can be used for filtered operations

The end value to reachThe duration of the tween Rotation mode

Tweens a Transform's rotation to the given value using pure quaternion values. Also stores the transform as the tween's target so it can be used for filtered operations. PLEASE NOTE: DORotate, which takes Vector3 values, is the preferred rotation method. This method was implemented for very special cases, and doesn't support LoopType.Incremental loops (neither for itself nor if placed inside a LoopType.Incremental Sequence)

The end value to reachThe duration of the tween

Tweens a Transform's localRotation to the given value. Also stores the transform as the tween's target so it can be used for filtered operations

The end value to reachThe duration of the tween Rotation mode

Tweens a Transform's rotation to the given value using pure quaternion values. Also stores the transform as the tween's target so it can be used for filtered operations. PLEASE NOTE: DOLocalRotate, which takes Vector3 values, is the preferred rotation method. This method was implemented for very special cases, and doesn't support LoopType.Incremental loops (neither for itself nor if placed inside a LoopType.Incremental Sequence)

The end value to reachThe duration of the tween

Tweens a Transform's localScale to the given value. Also stores the transform as the tween's target so it can be used for filtered operations

The end value to reachThe duration of the tween

Tweens a Transform's localScale uniformly to the given value. Also stores the transform as the tween's target so it can be used for filtered operations

The end value to reachThe duration of the tween

Tweens a Transform's X localScale to the given value. Also stores the transform as the tween's target so it can be used for filtered operations

The end value to reachThe duration of the tween

Tweens a Transform's Y localScale to the given value. Also stores the transform as the tween's target so it can be used for filtered operations

The end value to reachThe duration of the tween

Tweens a Transform's Z localScale to the given value. Also stores the transform as the tween's target so it can be used for filtered operations

The end value to reachThe duration of the tween

Tweens a Transform's rotation so that it will look towards the given world position. Also stores the transform as the tween's target so it can be used for filtered operations

The position to look atThe duration of the tween Eventual axis constraint for the rotation The vector that defines in which direction up is (default: Vector3.up)

EXPERIMENTAL Tweens a Transform's rotation so that it will look towards the given world position, while also updating the lookAt position every frame (contrary to which calculates the lookAt rotation only once, when the tween starts). Also stores the transform as the tween's target so it can be used for filtered operations

The position to look atThe duration of the tween Eventual axis constraint for the rotation The vector that defines in which direction up is (default: Vector3.up)

Punches a Transform's localPosition towards the given direction and then back to the starting one as if it was connected to the starting position via an elastic.

The direction and strength of the punch (added to the Transform's current position) The duration of the tween Indicates how much will the punch vibrate Represents how much (0 to 1) the vector will go beyond the starting position when bouncing backwards. 1 creates a full oscillation between the punch direction and the opposite direction, while 0 oscillates only between the punch and the start position If TRUE the tween will smoothly snap all values to integers

Punches a Transform's localScale towards the given size and then back to the starting one as if it was connected to the starting scale via an elastic.

The punch strength (added to the Transform's current scale) The duration of the tween Indicates how much will the punch vibrate Represents how much (0 to 1) the vector will go beyond the starting size when bouncing backwards. 1 creates a full oscillation between the punch scale and the opposite scale, while 0 oscillates only between the punch scale and the start scale

Punches a Transform's localRotation towards the given size and then back to the starting one as if it was connected to the starting rotation via an elastic.

The punch strength (added to the Transform's current rotation) The duration of the tween Indicates how much will the punch vibrate Represents how much (0 to 1) the vector will go beyond the starting rotation when bouncing backwards. 1 creates a full oscillation between the punch rotation and the opposite rotation, while 0 oscillates only between the punch and the start rotation

Shakes a Transform's localPosition with the given values.

The duration of the tween The shake strength Indicates how much will the shake vibrate Indicates how much the shake will be random (0 to 180 - values higher than 90 kind of suck, so beware). Setting it to 0 will shake along a single direction. If TRUE the tween will smoothly snap all values to integers If TRUE the shake will automatically fadeOut smoothly within the tween's duration, otherwise it will not

Shakes a Transform's localPosition with the given values.

The duration of the tween The shake strength on each axis Indicates how much will the shake vibrate Indicates how much the shake will be random (0 to 180 - values higher than 90 kind of suck, so beware). Setting it to 0 will shake along a single direction. If TRUE the tween will smoothly snap all values to integers If TRUE the shake will automatically fadeOut smoothly within the tween's duration, otherwise it will not

Shakes a Transform's localRotation.

Shakes a Transform's localScale.

Tweens a Transform's position to the given value, while also applying a jump effect along the Y axis. Returns a Sequence instead of a Tweener. Also stores the transform as the tween's target so it can be used for filtered operations

The end value to reach Power of the jump (the max height of the jump is represented by this plus the final Y offset) Total number of jumps The duration of the tween If TRUE the tween will smoothly snap all values to integers

Tweens a Transform's localPosition to the given value, while also applying a jump effect along the Y axis. Returns a Sequence instead of a Tweener. Also stores the transform as the tween's target so it can be used for filtered operations

Tweens a Transform's position through the given path waypoints, using the chosen path algorithm. Also stores the transform as the tween's target so it can be used for filtered operations

The waypoints to go through The duration of the tween The type of path: Linear (straight path), CatmullRom (curved CatmullRom path) or CubicBezier (curved with control points) The path mode: 3D, side-scroller 2D, top-down 2D The resolution of the path (useless in case of Linear paths): higher resolutions make for more detailed curved paths but are more expensive. Defaults to 10, but a value of 5 is usually enough if you don't have dramatic long curves between waypoints The color of the path (shown when gizmos are active in the Play panel and the tween is running)

Tweens a Transform's localPosition through the given path waypoints, using the chosen path algorithm. Also stores the transform as the tween's target so it can be used for filtered operations

The waypoint to go through The duration of the tween The type of path: Linear (straight path), CatmullRom (curved CatmullRom path) or CubicBezier (curved with control points) The path mode: 3D, side-scroller 2D, top-down 2D The resolution of the path: higher resolutions make for more detailed curved paths but are more expensive. Defaults to 10, but a value of 5 is usually enough if you don't have dramatic long curves between waypoints The color of the path (shown when gizmos are active in the Play panel and the tween is running)

IMPORTANT: Unless you really know what you're doing, you should use the overload that accepts a Vector3 array instead. Tweens a Transform's position via the given path. Also stores the transform as the tween's target so it can be used for filtered operations

The path to use The duration of the tween The path mode: 3D, side-scroller 2D, top-down 2D

IMPORTANT: Unless you really know what you're doing, you should use the overload that accepts a Vector3 array instead. Tweens a Transform's localPosition via the given path. Also stores the transform as the tween's target so it can be used for filtered operations

The path to use The duration of the tween The path mode: 3D, side-scroller 2D, top-down 2D

Tweens a Tween's timeScale to the given value. Also stores the Tween as the tween's target so it can be used for filtered operations

The end value to reachThe duration of the tween

Tweens a Light's color to the given value, in a way that allows other DOBlendableColor tweens to work together on the same target, instead than fight each other as multiple DOColor would do. Also stores the Light as the tween's target so it can be used for filtered operations

The value to tween toThe duration of the tween

Tweens a Material's color to the given value, in a way that allows other DOBlendableColor tweens to work together on the same target, instead than fight each other as multiple DOColor would do. Also stores the Material as the tween's target so it can be used for filtered operations

The value to tween toThe duration of the tween

Tweens a Material's named color property to the given value, in a way that allows other DOBlendableColor tweens to work together on the same target, instead than fight each other as multiple DOColor would do. Also stores the Material as the tween's target so it can be used for filtered operations

The value to tween to The name of the material property to tween (like _Tint or _SpecColor) The duration of the tween

Tweens a Material's named color property with the given ID to the given value, in a way that allows other DOBlendableColor tweens to work together on the same target, instead than fight each other as multiple DOColor would do. Also stores the Material as the tween's target so it can be used for filtered operations

The value to tween to The ID of the material property to tween (also called nameID in Unity's manual) The duration of the tween

Tweens a Transform's position BY the given value (as if you chained a SetRelative), in a way that allows other DOBlendableMove tweens to work together on the same target, instead than fight each other as multiple DOMove would do. Also stores the transform as the tween's target so it can be used for filtered operations

The value to tween byThe duration of the tween If TRUE the tween will smoothly snap all values to integers

Tweens a Transform's localPosition BY the given value (as if you chained a SetRelative), in a way that allows other DOBlendableMove tweens to work together on the same target, instead than fight each other as multiple DOMove would do. Also stores the transform as the tween's target so it can be used for filtered operations

The value to tween byThe duration of the tween If TRUE the tween will smoothly snap all values to integers

EXPERIMENTAL METHOD - Tweens a Transform's rotation BY the given value (as if you chained a SetRelative), in a way that allows other DOBlendableRotate tweens to work together on the same target, instead than fight each other as multiple DORotate would do. Also stores the transform as the tween's target so it can be used for filtered operations

The value to tween byThe duration of the tween Rotation mode

EXPERIMENTAL METHOD - Tweens a Transform's lcoalRotation BY the given value (as if you chained a SetRelative), in a way that allows other DOBlendableRotate tweens to work together on the same target, instead than fight each other as multiple DORotate would do. Also stores the transform as the tween's target so it can be used for filtered operations

The value to tween byThe duration of the tween Rotation mode

Punches a Transform's localRotation BY the given value and then back to the starting one as if it was connected to the starting rotation via an elastic. Does it in a way that allows other DOBlendableRotate tweens to work together on the same target

Tweens a Transform's localScale BY the given value (as if you chained a SetRelative), in a way that allows other DOBlendableScale tweens to work together on the same target, instead than fight each other as multiple DOScale would do. Also stores the transform as the tween's target so it can be used for filtered operations

The value to tween byThe duration of the tween

Completes all tweens that have this target as a reference (meaning tweens that were started from this target, or that had this target added as an Id) and returns the total number of tweens completed (meaning the tweens that don't have infinite loops and were not already complete)

For Sequences only: if TRUE also internal Sequence callbacks will be fired, otherwise they will be ignored

Kills all tweens that have this target as a reference (meaning tweens that were started from this target, or that had this target added as an Id) and returns the total number of tweens killed.

If TRUE completes the tween before killing it

Kills all tweens that have this target as a reference (meaning tweens that were started from this target, or that had this target added as an Id) and returns the total number of tweens killed.

If TRUE completes the tween before killing it

Flips the direction (backwards if it was going forward or viceversa) of all tweens that have this target as a reference (meaning tweens that were started from this target, or that had this target added as an Id) and returns the total number of tweens flipped.

Sends to the given position all tweens that have this target as a reference (meaning tweens that were started from this target, or that had this target added as an Id) and returns the total number of tweens involved.

Time position to reach (if higher than the whole tween duration the tween will simply reach its end) If TRUE will play the tween after reaching the given position, otherwise it will pause it

Pauses all tweens that have this target as a reference (meaning tweens that were started from this target, or that had this target added as an Id) and returns the total number of tweens paused.

Plays all tweens that have this target as a reference (meaning tweens that were started from this target, or that had this target added as an Id) and returns the total number of tweens played.

Plays backwards all tweens that have this target as a reference (meaning tweens that were started from this target, or that had this target added as an Id) and returns the total number of tweens played.

Plays forward all tweens that have this target as a reference (meaning tweens that were started from this target, or that had this target added as an Id) and returns the total number of tweens played.

Restarts all tweens that have this target as a reference (meaning tweens that were started from this target, or that had this target added as an Id) and returns the total number of tweens restarted.

Rewinds all tweens that have this target as a reference (meaning tweens that were started from this target, or that had this target added as an Id) and returns the total number of tweens rewinded.

Smoothly rewinds all tweens that have this target as a reference (meaning tweens that were started from this target, or that had this target added as an Id) and returns the total number of tweens rewinded.

Toggles the paused state (plays if it was paused, pauses if it was playing) of all tweens that have this target as a reference (meaning tweens that were started from this target, or that had this target added as an Id) and returns the total number of tweens involved.

This class serves only as a utility class to store tween settings to apply on multiple tweens. It is in no way needed otherwise, since you can directly apply tween settings to a tween via chaining

A variable you can eventually Clear and reuse when needed, to avoid instantiating TweenParams objects

Creates a new TweenParams object, which you can use to store tween settings to pass to multiple tweens via myTween.SetAs(myTweenParms)

Clears and resets this TweenParams instance using default values, so it can be reused without instantiating another one

Sets the autoKill behaviour of the tween. Has no effect if the tween has already started

If TRUE the tween will be automatically killed when complete

Sets an ID for the tween, which can then be used as a filter with DOTween's static methods.

The ID to assign to this tween. Can be an int, a string, an object or anything else.

Sets the target for the tween, which can then be used as a filter with DOTween's static methods. IMPORTANT: use it with caution. If you just want to set an ID for the tween use SetId instead. When using shorcuts the shortcut target is already assigned as the tween's target, so using this method will overwrite it and prevent shortcut-operations like myTarget.DOPause from working correctly.

The target to assign to this tween. Can be an int, a string, an object or anything else.

Sets the looping options for the tween. Has no effect if the tween has already started

Number of cycles to play (-1 for infinite - will be converted to 1 in case the tween is nested in a Sequence) Loop behaviour type (default: LoopType.Restart)

Sets the ease of the tween. If applied to Sequences eases the whole sequence animation

Eventual overshoot or amplitude to use with Back or Elastic easeType (default is 1.70158) Eventual period to use with Elastic easeType (default is 0)

Sets the ease of the tween using an AnimationCurve. If applied to Sequences eases the whole sequence animation

Sets the ease of the tween using a custom ease function. If applied to Sequences eases the whole sequence animation

Sets the recycling behaviour for the tween.

If TRUE the tween will be recycled after being killed, otherwise it will be destroyed.

Sets the update type to the one defined in DOTween.defaultUpdateType (UpdateType.Normal unless changed) and lets you choose if it should be independent from Unity's Time.timeScale

If TRUE the tween will ignore Unity's Time.timeScale

Sets the type of update (default or independent) for the tween

The type of update (default: UpdateType.Normal) If TRUE the tween will ignore Unity's Time.timeScale

Sets the onStart callback for the tween. Called the first time the tween is set in a playing state, after any eventual delay

Sets the onPlay callback for the tween. Called when the tween is set in a playing state, after any eventual delay. Also called each time the tween resumes playing from a paused state

Sets the onRewind callback for the tween. Called when the tween is rewinded, either by calling Rewind or by reaching the start position while playing backwards. Rewinding a tween that is already rewinded will not fire this callback

Sets the onUpdate callback for the tween. Called each time the tween updates

Sets the onStepComplete callback for the tween. Called the moment the tween completes one loop cycle, even when going backwards

Sets the onComplete callback for the tween. Called the moment the tween reaches its final forward position, loops included

Sets the onKill callback for the tween. Called the moment the tween is killed

Sets the onWaypointChange callback for the tween. Called when a path tween reaches a new waypoint

Sets a delayed startup for the tween. Has no effect on Sequences or if the tween has already started

If isRelative is TRUE sets the tween as relative (the endValue will be calculated as startValue + endValue instead than being used directly). Has no effect on Sequences or if the tween has already started

If isSpeedBased is TRUE sets the tween as speed based (the duration will represent the number of units the tween moves x second). Has no effect on Sequences, nested tweens, or if the tween has already started

Methods that extend Tween objects and allow to set their parameters

Sets the autoKill behaviour of the tween to TRUE. Has no effect if the tween has already started or if it's added to a Sequence

Sets the autoKill behaviour of the tween. Has no effect if the tween has already started or if it's added to a Sequence

If TRUE the tween will be automatically killed when complete

Sets an ID for the tween (), which can then be used as a filter with DOTween's static methods.

The ID to assign to this tween. Can be an int, a string, an object or anything else.

Sets a string ID for the tween (), which can then be used as a filter with DOTween's static methods. Filtering via string is 2X faster than using an object as an ID (using the alternate obejct overload)

The string ID to assign to this tween.

Sets an int ID for the tween (), which can then be used as a filter with DOTween's static methods. Filtering via int is 4X faster than via object, 2X faster than via string (using the alternate object/string overloads)

The int ID to assign to this tween.

Allows to link this tween to a GameObject so that it will be automatically killed when the GameObject is destroyed. Has no effect if the tween is added to a Sequence

The link target (unrelated to the target set via SetTarget)

Allows to link this tween to a GameObject and assign a behaviour depending on it. This will also automatically kill the tween when the GameObject is destroyed. Has no effect if the tween is added to a Sequence

The link target (unrelated to the target set via SetTarget) The behaviour to use ( is always evaluated even if you choose another one)

The target to assign to this tween. Can be an int, a string, an object or anything else.

Sets the looping options for the tween. Has no effect if the tween has already started

Number of cycles to play (-1 for infinite - will be converted to 1 in case the tween is nested in a Sequence)

Sets the looping options for the tween. Has no effect if the tween has already started

Number of cycles to play (-1 for infinite - will be converted to 1 in case the tween is nested in a Sequence) Loop behaviour type (default: LoopType.Restart)

Sets the ease of the tween. If applied to Sequences eases the whole sequence animation

Eventual overshoot to use with Back or Flash ease (default is 1.70158 - 1 for Flash). In case of Flash ease it must be an intenger and sets the total number of flashes that will happen. Using an even number will complete the tween on the starting value, while an odd one will complete it on the end value.

Sets the ease of the tween. If applied to Sequences eases the whole sequence animation

Eventual amplitude to use with Elastic easeType or overshoot to use with Flash easeType (default is 1.70158 - 1 for Flash). In case of Flash ease it must be an integer and sets the total number of flashes that will happen. Using an even number will complete the tween on the starting value, while an odd one will complete it on the end value. Eventual period to use with Elastic or Flash easeType (default is 0). In case of Flash ease it indicates the power in time of the ease, and must be between -1 and 1. 0 is balanced, 1 weakens the ease with time, -1 starts the ease weakened and gives it power towards the end.

Sets the ease of the tween using an AnimationCurve. If applied to Sequences eases the whole sequence animation

Sets the ease of the tween using a custom ease function (which must return a value between 0 and 1). If applied to Sequences eases the whole sequence animation

Allows the tween to be recycled after being killed.

Sets the recycling behaviour for the tween.

If TRUE the tween will be recycled after being killed, otherwise it will be destroyed.

Sets the update type to UpdateType.Normal and lets you choose if it should be independent from Unity's Time.timeScale

If TRUE the tween will ignore Unity's Time.timeScale

Sets the type of update for the tween

The type of update (defalt: UpdateType.Normal)

Sets the type of update for the tween and lets you choose if it should be independent from Unity's Time.timeScale

The type of update If TRUE the tween will ignore Unity's Time.timeScale

EXPERIMENTAL: inverts this tween, so that it will play from the end to the beginning (playing it backwards will actually play it from the beginning to the end). Has no effect if the tween has already started or if it's added to a Sequence

If TRUE the tween will be inverted, otherwise it won't

Sets the onStart callback for the tween, clearing any previous onStart callback that was set. Called the first time the tween is set in a playing state, after any eventual delay

Sets the onPlay callback for the tween, clearing any previous onPlay callback that was set. Called when the tween is set in a playing state, after any eventual delay. Also called each time the tween resumes playing from a paused state

Sets the onPause callback for the tween, clearing any previous onPause callback that was set. Called when the tween state changes from playing to paused. If the tween has autoKill set to FALSE, this is called also when the tween reaches completion.

Sets the onRewind callback for the tween, clearing any previous onRewind callback that was set. Called when the tween is rewinded, either by calling Rewind or by reaching the start position while playing backwards. Rewinding a tween that is already rewinded will not fire this callback

Sets the onUpdate callback for the tween, clearing any previous onUpdate callback that was set. Called each time the tween updates

Sets the onStepComplete callback for the tween, clearing any previous onStepComplete callback that was set. Called the moment the tween completes one loop cycle, even when going backwards

Sets the onComplete callback for the tween, clearing any previous onComplete callback that was set. Called the moment the tween reaches its final forward position, loops included

Sets the onKill callback for the tween, clearing any previous onKill callback that was set. Called the moment the tween is killed

Sets the onWaypointChange callback for the tween, clearing any previous onWaypointChange callback that was set. Called when a path tween's current waypoint changes

Sets the parameters of the tween (id, ease, loops, delay, timeScale, callbacks, etc) as the parameters of the given one. Doesn't copy specific SetOptions settings: those will need to be applied manually each time. Has no effect if the tween has already started. NOTE: the tween's target will not be changed

Tween from which to copy the parameters

Sets the parameters of the tween (id, ease, loops, delay, timeScale, callbacks, etc) as the parameters of the given TweenParams. Has no effect if the tween has already started.

TweenParams from which to copy the parameters

Adds the given tween to the end of the Sequence. Has no effect if the Sequence has already started

The tween to append

Adds the given tween to the beginning of the Sequence, pushing forward the other nested content. Has no effect if the Sequence has already started

The tween to prepend

Inserts the given tween at the same time position of the last tween, callback or intervale added to the Sequence. Note that, in case of a Join after an interval, the insertion time will be the time where the interval starts, not where it finishes. Has no effect if the Sequence has already started

Inserts the given tween at the given time position in the Sequence, automatically adding an interval if needed. Has no effect if the Sequence has already started

The time position where the tween will be placed The tween to insert

Adds the given interval to the end of the Sequence. Has no effect if the Sequence has already started

The interval duration

Adds the given interval to the beginning of the Sequence, pushing forward the other nested content. Has no effect if the Sequence has already started

The interval duration

Adds the given callback to the end of the Sequence. Has no effect if the Sequence has already started

The callback to append

Adds the given callback to the beginning of the Sequence, pushing forward the other nested content. Has no effect if the Sequence has already started

The callback to prepend

Inserts the given callback at the given time position in the Sequence, automatically adding an interval if needed. Has no effect if the Sequence has already started

The time position where the callback will be placed The callback to insert

Changes a TO tween into a FROM tween: sets the current target's position as the tween's endValue then immediately sends the target to the previously set endValue.

If TRUE the FROM value will be calculated as relative to the current one

Changes a TO tween into a FROM tween: sets the current value of the target as the endValue, and the previously passed endValue as the actual startValue.

If TRUE sets the target to from value immediately, otherwise waits for the tween to start If TRUE the FROM value will be calculated as relative to the current one

Changes a TO tween into a FROM tween: sets the tween's starting value to the given one and eventually sets the tween's target to that value immediately.

Value to start from If TRUE sets the target to from value immediately, otherwise waits for the tween to start If TRUE the FROM/TO values will be calculated as relative to the current ones

Changes a TO tween into a FROM tween: sets the tween's starting value to the given one and eventually sets the tween's target to that value immediately.

Alpha value to start from (in case of Fade tweens) If TRUE sets the target to from value immediately, otherwise waits for the tween to start If TRUE the FROM/TO values will be calculated as relative to the current ones

Changes a TO tween into a FROM tween: sets the tween's starting value to the given one and eventually sets the tween's target to that value immediately.

Value to start from (in case of Vector tweens that act on a single coordinate or scale tweens) If TRUE sets the target to from value immediately, otherwise waits for the tween to start If TRUE the FROM/TO values will be calculated as relative to the current ones

Changes a TO tween into a FROM tween: sets the tween's starting value to the given one and eventually sets the tween's target to that value immediately.

Sets a delayed startup for the tween. In case of Sequences behaves the same as , which means the delay will repeat in case of loops (while with tweens it's ignored after the first loop cycle). Has no effect if the tween has already started

EXPERIMENTAL: implemented in v1.2.340. Sets a delayed startup for the tween with options to choose how the delay is applied in case of Sequences. Has no effect if the tween has already started

Only used by types: If FALSE sets the delay as a one-time occurrence (defaults to this for types), otherwise as a Sequence interval which will repeat at the beginning of every loop cycle

Sets the tween as relative (the endValue will be calculated as startValue + endValue instead than being used directly). Has no effect on Sequences or if the tween has already started

Options for float tweens

If TRUE the tween will smoothly snap all values to integers

Options for Vector2 tweens

If TRUE the tween will smoothly snap all values to integers

Options for Vector2 tweens

Selecting an axis will tween the vector only on that axis, leaving the others untouched If TRUE the tween will smoothly snap all values to integers

Options for Vector3 tweens

If TRUE the tween will smoothly snap all values to integers

Options for Vector3 tweens

Selecting an axis will tween the vector only on that axis, leaving the others untouched If TRUE the tween will smoothly snap all values to integers

Options for Vector4 tweens

If TRUE the tween will smoothly snap all values to integers

Options for Vector4 tweens

Selecting an axis will tween the vector only on that axis, leaving the others untouched If TRUE the tween will smoothly snap all values to integers

Options for Quaternion tweens

If TRUE (default) the rotation will take the shortest route, and will not rotate more than 360°. If FALSE the rotation will be fully accounted. Is always FALSE if the tween is set as relative

Options for Color tweens

If TRUE only the alpha value of the color will be tweened

Options for Vector4 tweens

If TRUE the tween will smoothly snap all values to integers

Options for Vector4 tweens

If TRUE, rich text will be interpreted correctly while animated, otherwise all tags will be considered as normal text The type of scramble to use, if any A string containing the characters to use for scrambling. Use as many characters as possible (minimum 10) because DOTween uses a fast scramble mode which gives better results with more characters. Leave it to NULL to use default ones

Options for Vector3Array tweens

If TRUE the tween will smoothly snap all values to integers

Options for Vector3Array tweens

If TRUE the tween will smoothly snap all values to integers

Options for ShapeCircle tweens

If TRUE the center you set in the DOTween.To method will be considered as relative to the starting position of the target If TRUE the tween will smoothly snap all values to integers

Options for Path tweens (created via the DOPath shortcut)

The eventual movement axis to lock. You can input multiple axis if you separate them like this: AxisConstrain.X | AxisConstraint.Y The eventual rotation axis to lock. You can input multiple axis if you separate them like this: AxisConstrain.X | AxisConstraint.Y

Options for Path tweens (created via the DOPath shortcut)

If TRUE the path will be automatically closed The eventual movement axis to lock. You can input multiple axis if you separate them like this: AxisConstrain.X | AxisConstraint.Y The eventual rotation axis to lock. You can input multiple axis if you separate them like this: AxisConstrain.X | AxisConstraint.Y

Additional LookAt options for Path tweens (created via the DOPath shortcut). Orients the target towards the given position. Must be chained directly to the tween creation method or to a SetOptions

The position to look at The eventual direction to consider as "forward". If left to NULL defaults to the regular forward side of the transform The vector that defines in which direction up is (default: Vector3.up)

Additional LookAt options for Path tweens (created via the DOPath shortcut). Orients the target towards the given position with options to keep the Z rotation stable. Must be chained directly to the tween creation method or to a SetOptions

The position to look at If TRUE doesn't rotate the target along the Z axis

Additional LookAt options for Path tweens (created via the DOPath shortcut). Orients the target towards another transform. Must be chained directly to the tween creation method or to a SetOptions

The transform to look at The eventual direction to consider as "forward". If left to NULL defaults to the regular forward side of the transform The vector that defines in which direction up is (default: Vector3.up)

Additional LookAt options for Path tweens (created via the DOPath shortcut). Orients the target towards another transform with options to keep the Z rotation stable. Must be chained directly to the tween creation method or to a SetOptions

The transform to look at If TRUE doesn't rotate the target along the Z axis

Additional LookAt options for Path tweens (created via the DOPath shortcut). Orients the target to the path, with the given lookAhead. Must be chained directly to the tween creation method or to a SetOptions

The percentage of lookAhead to use (0 to 1) The eventual direction to consider as "forward". If left to NULL defaults to the regular forward side of the transform The vector that defines in which direction up is (default: Vector3.up)

Additional LookAt options for Path tweens (created via the DOPath shortcut). Orients the path with options to keep the Z rotation stable. Must be chained directly to the tween creation method or to a SetOptions

The percentage of lookAhead to use (0 to 1) If TRUE doesn't rotate the target along the Z axis

Types of log behaviours

Log only warnings and errors

Log warnings, errors and additional infos

Log only errors

Indicates either a Tweener or a Sequence

TimeScale for the tween

If TRUE the tween will play backwards

If TRUE the tween is completely inverted but without playing it backwards (play backwards will actually play the tween in the original direction)

Object ID (usable for filtering with DOTween static methods). Can be anything except a string or an int (use or for those)

String ID (usable for filtering with DOTween static methods). 2X faster than using an object id

Int ID (usable for filtering with DOTween static methods). 4X faster than using an object id, 2X faster than using a string id. Default is -999 so avoid using an ID like that or it will capture all unset intIds

Tween target (usable for filtering with DOTween static methods). Automatically set by tween creation shortcuts

Called when the tween is set in a playing state, after any eventual delay. Also called each time the tween resumes playing from a paused state

Called when the tween state changes from playing to paused. If the tween has autoKill set to FALSE, this is called also when the tween reaches completion.

Called when the tween is rewinded, either by calling Rewind or by reaching the start position while playing backwards. Rewinding a tween that is already rewinded will not fire this callback

Called each time the tween updates

Called the moment the tween completes one loop cycle

Called the moment the tween reaches completion (loops included)

Called the moment the tween is killed

Called when a path tween's current waypoint changes

Tweeners-only (ignored by Sequences), returns TRUE if the tween was set as relative

Set by SetTarget if DOTween's Debug Mode is on (see DOTween Utility Panel -> "Store GameObject's ID" debug option

FALSE when tween is (or should be) despawned - set only by TweenManager

Gets and sets the time position (loops included, delays excluded) of the tween

Returns TRUE if the tween is set to loop (either a set number of times or infinitely)

TRUE after the tween was set in a play state at least once, AFTER any delay is elapsed

Time position within a single loop cycle

Animates a single value

Changes the start value of a tween and rewinds it (without pausing it). Has no effect with tweens that are inside Sequences

The new start value If bigger than 0 applies it as the new tween duration

Changes the end value of a tween and rewinds it (without pausing it). Has no effect with tweens that are inside Sequences

The new end value If bigger than 0 applies it as the new tween duration If TRUE the start value will become the current target's value, otherwise it will stay the same

Changes the end value of a tween and rewinds it (without pausing it). Has no effect with tweens that are inside Sequences

The new end value If TRUE the start value will become the current target's value, otherwise it will stay the same

Changes the start and end value of a tween and rewinds it (without pausing it). Has no effect with tweens that are inside Sequences

The new start value The new end value If bigger than 0 applies it as the new tween duration

Used internally

Update type

Updates every frame during Update calls

Updates every frame during LateUpdate calls

Updates using FixedUpdate calls

Updates using manual update calls