Holoville.HOTween  1.2.010
HOTween Class Reference

Main tween manager. Controls all tween types (Tweener and Sequence), and is used to directly create Tweeners (to create Sequences, directly create a new Sequence instead). More...

List of all members.

Static Public Member Functions

static void Init ()
 Initializes HOTween and sets it as non-permanent (meaning HOTween instance will be destroyed when all tweens are killed, and re-created when needed). Call this method once when your application starts up, to avoid auto-initialization when the first tween is started or created, and to set options.
static void Init (bool p_permanentInstance)
 Initializes HOTween. Call this method once when your application starts up, to avoid auto-initialization when the first tween is started or created, and to set options.
static void Init (bool p_permanentInstance, bool p_renameInstanceToCountTweens, bool p_allowOverwriteManager)
 Initializes HOTween. Call this method once when your application starts up, to avoid auto-initialization when the first tween is started or created, and to set options.
static Tweener To (object p_target, float p_duration, string p_propName, object p_endVal)
 Creates a new absolute tween with default values, and returns the Tweener representing it, or null if the tween was invalid (no valid property to tween was given).
static Tweener To (object p_target, float p_duration, string p_propName, object p_endVal, bool p_isRelative)
 Creates a new tween with default values, and returns the Tweener representing it, or null if the tween was invalid (no valid property to tween was given).
static Tweener To (object p_target, float p_duration, TweenParms p_parms)
 Creates a new tween and returns the Tweener representing it, or null if the tween was invalid (no valid property to tween was given).
static Tweener From (object p_target, float p_duration, string p_propName, object p_fromVal)
 Creates a new absolute FROM tween with default values, and returns the Tweener representing it, or null if the tween was invalid (no valid property to tween was given).
static Tweener From (object p_target, float p_duration, string p_propName, object p_fromVal, bool p_isRelative)
 Creates a new FROM tween with default values, and returns the Tweener representing it, or null if the tween was invalid (no valid property to tween was given).
static Tweener From (object p_target, float p_duration, TweenParms p_parms)
 Creates a new FROM tween and returns the Tweener representing it, or null if the tween was invalid (no valid property to tween was given).
static Tweener Punch (object p_target, float p_duration, string p_propName, object p_fromVal, float p_punchAmplitude=0.5f, float p_punchPeriod=0.1f)
 Creates a new absolute PUNCH tween, and returns the Tweener representing it, or null if the tween was invalid (no valid property to tween was given).
static Tweener Punch (object p_target, float p_duration, string p_propName, object p_fromVal, bool p_isRelative, float p_punchAmplitude=0.5f, float p_punchPeriod=0.1f)
 Creates a new PUNCH tween, and returns the Tweener representing it, or null if the tween was invalid (no valid property to tween was given).
static Tweener Punch (object p_target, float p_duration, TweenParms p_parms, float p_punchAmplitude=0.5f, float p_punchPeriod=0.1f)
 Creates a new PUNCH tween and returns the Tweener representing it, or null if the tween was invalid (no valid property to tween was given). Any ease type passed won't be considered, since punch uses its own one.
static Tweener Shake (object p_target, float p_duration, string p_propName, object p_fromVal, float p_shakeAmplitude=0.1f, float p_shakePeriod=0.12f)
 Creates a new absolute SHAKE tween, and returns the Tweener representing it, or null if the tween was invalid (no valid property to tween was given).
static Tweener Shake (object p_target, float p_duration, string p_propName, object p_fromVal, bool p_isRelative, float p_shakeAmplitude=0.1f, float p_shakePeriod=0.12f)
 Creates a new SHAKE tween, and returns the Tweener representing it, or null if the tween was invalid (no valid property to tween was given).
static Tweener Shake (object p_target, float p_duration, TweenParms p_parms, float p_shakeAmplitude=0.1f, float p_shakePeriod=0.12f)
 Creates a new SHAKE tween and returns the Tweener representing it, or null if the tween was invalid (no valid property to tween was given). Any ease type passed won't be considered, since shake uses its own one.
static void EnableOverwriteManager (bool logWarnings=true)
 Enables the overwrite manager (disabled by default).
static void DisableOverwriteManager ()
 Disables the overwrite manager (disabled by default).
static int Pause (object p_target)
 Pauses all the tweens for the given target, and returns the total number of paused Tweeners.
static int Pause (string p_id)
 Pauses all the Tweeners/Sequences with the given ID, and returns the total number of paused Tweeners/Sequences.
static int Pause (int p_intId)
 Pauses all the Tweeners/Sequences with the given intId, and returns the total number of paused Tweeners/Sequences.
static int Pause (Tweener p_tweener)
 Pauses the given Tweener, and returns the total number of paused ones (1 if the Tweener existed, otherwise 0).
static int Pause (Sequence p_sequence)
 Pauses the given Sequence, and returns the total number of paused ones (1 if the Sequence existed, otherwise 0).
static int Pause ()
 Pauses all Tweeners/Sequences, and returns the total number of paused Tweeners/Sequences.
static int Play (object p_target)
 Resumes all the tweens (delays included) for the given target, and returns the total number of resumed Tweeners.
static int Play (object p_target, bool p_skipDelay)
 Resumes all the tweens for the given target, and returns the total number of resumed Tweeners.
static int Play (string p_id)
 Resumes all the Tweeners (delays included) and Sequences with the given ID, and returns the total number of resumed Tweeners/Sequences.
static int Play (string p_id, bool p_skipDelay)
 Resumes all the Tweeners/Sequences with the given ID, and returns the total number of resumed Tweeners/Sequences.
static int Play (int p_intId)
 Resumes all the Tweeners (delays included) and Sequences with the given intId, and returns the total number of resumed Tweeners/Sequences.
static int Play (int p_intId, bool p_skipDelay)
 Resumes all the Tweeners/Sequences with the given intId, and returns the total number of resumed Tweeners/Sequences.
static int Play (Tweener p_tweener)
 Resumes the given Tweener (delays included), and returns the total number of resumed ones (1 if the Tweener existed, otherwise 0).
static int Play (Tweener p_tweener, bool p_skipDelay)
 Resumes the given Tweener, and returns the total number of resumed ones (1 if the Tweener existed, otherwise 0).
static int Play (Sequence p_sequence)
 Resumes the given Sequence, and returns the total number of resumed ones (1 if the Sequence existed, otherwise 0).
static int Play ()
 Resumes all Tweeners (delays included) and Sequences, and returns the total number of resumed Tweeners/Sequences.
static int Play (bool p_skipDelay)
 Resumes all Tweeners/Sequences, and returns the total number of resumed Tweeners/Sequences.
static int PlayForward (object p_target)
 Resumes all the tweens (delays included) for the given target, sets the tweens so that they move forward and not backwards, and returns the total number of resumed Tweeners.
static int PlayForward (object p_target, bool p_skipDelay)
 Resumes all the tweens for the given target, sets the tweens so that they move forward and not backwards, and returns the total number of resumed Tweeners.
static int PlayForward (string p_id)
 Resumes all the Tweeners (delays included) and Sequences with the given ID, sets the tweens so that they move forward and not backwards, and returns the total number of resumed Tweeners/Sequences.
static int PlayForward (string p_id, bool p_skipDelay)
 Resumes all the Tweeners/Sequences with the given ID, sets the tweens so that they move forward and not backwards, and returns the total number of resumed Tweeners/Sequences.
static int PlayForward (int p_intId)
 Resumes all the Tweeners (delays included) and Sequences with the given intId, sets the tweens so that they move forward and not backwards, and returns the total number of resumed Tweeners/Sequences.
static int PlayForward (int p_intId, bool p_skipDelay)
 Resumes all the Tweeners/Sequences with the given intId, sets the tweens so that they move forward and not backwards, and returns the total number of resumed Tweeners/Sequences.
static int PlayForward (Tweener p_tweener)
 Resumes the given Tweener (delays included), sets it so that it moves forward and not backwards, and returns the total number of resumed ones (1 if the Tweener existed, otherwise 0).
static int PlayForward (Tweener p_tweener, bool p_skipDelay)
 Resumes the given Tweener, sets it so that it moves forward and not backwards, and returns the total number of resumed ones (1 if the Tweener existed, otherwise 0).
static int PlayForward (Sequence p_sequence)
 Resumes the given Sequence, sets it so that it moves forward and not backwards, and returns the total number of resumed ones (1 if the Sequence existed, otherwise 0).
static int PlayForward ()
 Resumes all Tweeners (delays included) and Sequences, sets the tweens so that they move forward and not backwards, and returns the total number of resumed Tweeners/Sequences.
static int PlayForward (bool p_skipDelay)
 Resumes all Tweeners/Sequences, sets the tweens so that they move forward and not backwards, and returns the total number of resumed Tweeners/Sequences.
static int PlayBackwards (object p_target)
 Resumes all the tweens for the given target, sets the tweens so that they move backwards instead than forward, and returns the total number of resumed Tweeners.
static int PlayBackwards (string p_id)
 Resumes all the Tweeners/Sequences with the given ID, sets the tweens so that they move backwards instead than forward, and returns the total number of resumed Tweeners/Sequences.
static int PlayBackwards (int p_intId)
 Resumes all the Tweeners/Sequences with the given intId, sets the tweens so that they move backwards instead than forward, and returns the total number of resumed Tweeners/Sequences.
static int PlayBackwards (Tweener p_tweener)
 Resumes the given Tweener, sets it so that it moves backwards instead than forward, and returns the total number of resumed ones (1 if the Tweener existed, otherwise 0).
static int PlayBackwards (Sequence p_sequence)
 Resumes the given Sequence, sets it so that it moves backwards instead than forward, and returns the total number of resumed ones (1 if the Sequence existed, otherwise 0).
static int PlayBackwards ()
 Resumes all Tweeners/Sequences, sets the tweens so that they move backwards instead than forward, and returns the total number of resumed Tweeners/Sequences.
static int Rewind (object p_target)
 Rewinds all the tweens (delays included) for the given target, and returns the total number of rewinded Tweeners.
static int Rewind (object p_target, bool p_skipDelay)
 Rewinds all the tweens for the given target, and returns the total number of rewinded Tweeners.
static int Rewind (string p_id)
 Rewinds all the Tweeners (delays included) and Sequences with the given ID, and returns the total number of rewinded Tweeners/Sequences.
static int Rewind (string p_id, bool p_skipDelay)
 Rewinds all the Tweeners/Sequences with the given ID, and returns the total number of rewinded Tweeners/Sequences.
static int Rewind (int p_intId)
 Rewinds all the Tweeners (delays included) and Sequences with the given intId, and returns the total number of rewinded Tweeners/Sequences.
static int Rewind (int p_intId, bool p_skipDelay)
 Rewinds all the Tweeners/Sequences with the given intId, and returns the total number of rewinded Tweeners/Sequences.
static int Rewind (Tweener p_tweener)
 Rewinds the given Tweener (delays included), and returns the total number of rewinded ones (1 if the Tweener existed, otherwise 0).
static int Rewind (Tweener p_tweener, bool p_skipDelay)
 Rewinds the given Tweener, and returns the total number of rewinded ones (1 if the Tweener existed, otherwise 0).
static int Rewind (Sequence p_sequence)
 Rewinds the given Sequence, and returns the total number of rewinded ones (1 if the Sequence existed, otherwise 0).
static int Rewind ()
 Rewinds all Tweeners (delay included) and Sequences, and returns the total number of rewinded Tweeners/Sequences.
static int Rewind (bool p_skipDelay)
 Rewinds all Tweeners/Sequences, and returns the total number of rewinded Tweeners/Sequences.
static int Restart (object p_target)
 Restarts all the tweens (delays included) for the given target, and returns the total number of restarted Tweeners.
static int Restart (object p_target, bool p_skipDelay)
 Restarts all the tweens for the given target, and returns the total number of restarted Tweeners.
static int Restart (string p_id)
 Restarts all the Tweeners (delays included) and Sequences with the given ID, and returns the total number of restarted Tweeners/Sequences.
static int Restart (string p_id, bool p_skipDelay)
 Restarts all the Tweeners/Sequences with the given ID, and returns the total number of restarted Tweeners/Sequences.
static int Restart (int p_intId)
 Restarts all the Tweeners (delays included) and Sequences with the given intId, and returns the total number of restarted Tweeners/Sequences.
static int Restart (int p_intId, bool p_skipDelay)
 Restarts all the Tweeners/Sequences with the given intId, and returns the total number of restarted Tweeners/Sequences.
static int Restart (Tweener p_tweener)
 Restarts the given Tweener (delays included), and returns the total number of restarted ones (1 if the Tweener existed, otherwise 0).
static int Restart (Tweener p_tweener, bool p_skipDelay)
 Restarts the given Tweener, and returns the total number of restarted ones (1 if the Tweener existed, otherwise 0).
static int Restart (Sequence p_sequence)
 Restarts the given Sequence, and returns the total number of restarted ones (1 if the Sequence existed, otherwise 0).
static int Restart ()
 Restarts all Tweeners (delay included) and Sequences, and returns the total number of restarted Tweeners/Sequences.
static int Restart (bool p_skipDelay)
 Restarts all Tweeners/Sequences and returns the total number of restarted Tweeners/Sequences.
static int Reverse (object p_target, bool p_forcePlay=false)
 Reverses all the tweens for the given target, animating them from their current value back to the starting one, and returns the total number of reversed Tweeners.
static int Reverse (string p_id, bool p_forcePlay=false)
 Reverses all the Tweeners/Sequences with the given ID, animating them from their current value back to the starting one, and returns the total number of reversed Tweeners/Sequences.
static int Reverse (int p_intId, bool p_forcePlay=false)
 Reverses all the Tweeners/Sequences with the given intId, animating them from their current value back to the starting one, and returns the total number of reversed Tweeners/Sequences.
static int Reverse (Tweener p_tweener, bool p_forcePlay=false)
 Reverses the given Tweener, animating it from its current value back to the starting one, and returns the total number of reversed Tweeners (1 if the Tweener existed, otherwise 0).
static int Reverse (Sequence p_sequence, bool p_forcePlay=false)
 Reverses the given Sequence, and returns the total number of reversed ones (1 if the Sequence existed, otherwise 0).
static int Reverse (bool p_forcePlay=false)
 Reverses all Tweeners/Sequences, animating them from their current value back to the starting one, and returns the total number of reversed Tweeners/Sequences.
static int Complete (object p_target)
 Completes all the tweens for the given target, and returns the total number of completed Tweeners. Where a loop was involved and not infinite, the relative tween completes at the position where it would actually be after the set number of loops. If there were infinite loops, this method will have no effect.
static int Complete (string p_id)
 Completes all the Tweeners/Sequences with the given ID, and returns the total number of completed Tweeners/Sequences. Where a loop was involved and not infinite, the relative Tweener/Sequence completes at the position where it would actually be after the set number of loops. If there were infinite loops, this method will have no effect.
static int Complete (int p_intId)
 Completes all the Tweeners/Sequences with the given intId, and returns the total number of completed Tweeners/Sequences. Where a loop was involved and not infinite, the relative Tweener/Sequence completes at the position where it would actually be after the set number of loops. If there were infinite loops, this method will have no effect.
static int Complete (Tweener p_tweener)
 Completes the given Tweener, and returns the total number of completed ones (1 if the Tweener existed, otherwise 0). Where a loop was involved and not infinite, the relative Tweener completes at the position where it would actually be after the set number of loops. If there were infinite loops, this method will have no effect.
static int Complete (Sequence p_sequence)
 Completes the given Sequence, and returns the total number of completed ones (1 if the Sequence existed, otherwise 0). Where a loop was involved and not infinite, the relative Sequence completes at the position where it would actually be after the set number of loops. If there were infinite loops, this method will have no effect.
static int Complete ()
 Completes all Tweeners/Sequences, and returns the total number of completed Tweeners/Sequences. Where a loop was involved and not infinite, the relative Tweener/Sequence completes at the position where it would actually be after the set number of loops. If there were infinite loops, this method will have no effect.
static int Kill (object p_target)
 Kills all the tweens for the given target (unless they're were created inside a Sequence), and returns the total number of killed Tweeners.
static int Kill (string p_id)
 Kills all the Tweeners/Sequences with the given ID, and returns the total number of killed Tweeners/Sequences.
static int Kill (int p_intId)
 Kills all the Tweeners/Sequences with the given intId, and returns the total number of killed Tweeners/Sequences.
static int Kill (Tweener p_tweener)
 Kills the given Tweener, and returns the total number of killed ones (1 if the Tweener existed, otherwise 0).
static int Kill (Sequence p_sequence)
 Kills the given Sequence, and returns the total number of killed ones (1 if the Sequence existed, otherwise 0).
static int Kill ()
 Kills all Tweeners/Sequences, and returns the total number of killed Tweeners/Sequences.
static List< IHOTweenComponentGetTweensById (string p_id, bool p_includeNestedTweens)
 Returns a list of the eventual existing tweens with the given Id, (empty if no Tweener/Sequence was found).
static List< IHOTweenComponentGetTweensByIntId (int p_intId, bool p_includeNestedTweens)
 Returns a list of the eventual existing tweens with the given intId, (empty if no Tweener/Sequence was found).
static List< TweenerGetTweenersByTarget (object p_target, bool p_includeNestedTweens)
 Returns a list with all the existing Tweener objects whose target is the given one, or an empty list if none was found.
static bool IsTweening (object p_target)
 Returns true if the given target is currently involved in any running Tweener or Sequence (taking into account also nested tweens). Returns false both if the given target is not inside a Tweener, than if the relative Tweener is paused. To simply check if the target is attached to a Tweener or Sequence use IsLinkedTo instead.
static bool IsTweening (string p_id)
 Returns true if the given id is involved in any running Tweener or Sequence (taking into account also nested tweens).
static bool IsTweening (int p_id)
 Returns true if the given id is involved in any running Tweener or Sequence (taking into account also nested tweens).
static bool IsLinkedTo (object p_target)
 Returns true if the given target is linked to any Tweener or Sequence (running or not, taking into account also nested tweens).
static TweenInfo[] GetTweenInfos ()
 Returns a TweenInfo list of the current tweens (paused and delayed included), or null if there are no tweens.

Public Attributes

const string VERSION = "1.2.010"
 HOTween version.
const string AUTHOR = "Daniele Giardini - Holoville"
 HOTween author - me! :P.

Static Public Attributes

static UpdateType defUpdateType = UpdateType.Update
 Default UpdateType that will be used by any new Tweener/Sequence that doesn't implement a specific ease (default = EaseType.easeOutQuad)
static float defTimeScale = 1
 Default time scale that will be used by any new Tweener/Sequence that doesn't implement a specific timeScale (default = 1).
static EaseType defEaseType = EaseType.EaseOutQuad
 Default EaseType that will be used by any new Tweener/Sequence that doesn't implement a specific ease (default = EaseType.easeOutQuad).
static float defEaseOvershootOrAmplitude = 1.70158f
 Default overshoot to use with Back easeTypes.
static float defEasePeriod = 0
 Default period to use with Elastic easeTypes.
static LoopType defLoopType = LoopType.Restart
 Default LoopType that will be used by any Tweener/Sequence that doesn't implement a specific loopType (default = LoopType.Restart).
static bool showPathGizmos
 If true, shows the eventual paths in use by PlugVector3Path while playing inside Unity's Editor (and if the Editor's Gizmos button is on).
static WarningLevel warningLevel = WarningLevel.Verbose
 Level of message output in case an error is encountered. Warnings are logged when HOTween encounters an error, and automatically resolves it without throwing any exception (like if you try to tween an unexisting property, in which case the tween simply won't be generated, and an eventual warning will appear in the output window).

Properties

static int totTweens [get]
 Total number of tweeners/sequences (paused and delayed ones are included). Tweeners and sequences contained into other sequences don't count: for example, if there's only one sequence that contains 2 tweeners, totTweens will be 1.

Detailed Description

Main tween manager. Controls all tween types (Tweener and Sequence), and is used to directly create Tweeners (to create Sequences, directly create a new Sequence instead).

Author: Daniele Giardini (http://www.holoville.com)


Member Function Documentation

static int Complete ( object  p_target) [static]

Completes all the tweens for the given target, and returns the total number of completed Tweeners. Where a loop was involved and not infinite, the relative tween completes at the position where it would actually be after the set number of loops. If there were infinite loops, this method will have no effect.

Parameters:
p_targetThe target whose tweens to complete.
Returns:
The total number of completed Tweeners.
static int Complete ( string  p_id) [static]

Completes all the Tweeners/Sequences with the given ID, and returns the total number of completed Tweeners/Sequences. Where a loop was involved and not infinite, the relative Tweener/Sequence completes at the position where it would actually be after the set number of loops. If there were infinite loops, this method will have no effect.

Parameters:
p_idThe ID of the Tweeners/Sequences to complete.
Returns:
The total number of completed Tweeners/Sequences.
static int Complete ( int  p_intId) [static]

Completes all the Tweeners/Sequences with the given intId, and returns the total number of completed Tweeners/Sequences. Where a loop was involved and not infinite, the relative Tweener/Sequence completes at the position where it would actually be after the set number of loops. If there were infinite loops, this method will have no effect.

Parameters:
p_intIdThe intId of the Tweeners/Sequences to complete.
Returns:
The total number of completed Tweeners/Sequences.
static int Complete ( Tweener  p_tweener) [static]

Completes the given Tweener, and returns the total number of completed ones (1 if the Tweener existed, otherwise 0). Where a loop was involved and not infinite, the relative Tweener completes at the position where it would actually be after the set number of loops. If there were infinite loops, this method will have no effect.

Parameters:
p_tweenerThe Tweener to complete.
Returns:
The total number of completed Tweeners (1 if the Tweener existed, otherwise 0).
static int Complete ( Sequence  p_sequence) [static]

Completes the given Sequence, and returns the total number of completed ones (1 if the Sequence existed, otherwise 0). Where a loop was involved and not infinite, the relative Sequence completes at the position where it would actually be after the set number of loops. If there were infinite loops, this method will have no effect.

Parameters:
p_sequenceThe Sequence to complete.
Returns:
The total number of completed Sequences (1 if the Sequence existed, otherwise 0).
static int Complete ( ) [static]

Completes all Tweeners/Sequences, and returns the total number of completed Tweeners/Sequences. Where a loop was involved and not infinite, the relative Tweener/Sequence completes at the position where it would actually be after the set number of loops. If there were infinite loops, this method will have no effect.

Returns:
The total number of completed Tweeners/Sequences.
static void DisableOverwriteManager ( ) [static]

Disables the overwrite manager (disabled by default).

static void EnableOverwriteManager ( bool  logWarnings = true) [static]

Enables the overwrite manager (disabled by default).

Parameters:
logWarningsIf TRUE, the overwriteManager will log a warning each time a tween is overwritten
static Tweener From ( object  p_target,
float  p_duration,
string  p_propName,
object  p_fromVal 
) [static]

Creates a new absolute FROM tween with default values, and returns the Tweener representing it, or null if the tween was invalid (no valid property to tween was given).

Parameters:
p_targetThe tweening target (must be the object containing the properties or fields to tween).
p_durationThe duration in seconds of the tween.
p_propNameThe name of the property or field to tween.
p_fromValThe end value the property should reach with the tween.
Returns:
The newly created Tweener, or null if the parameters were invalid.
static Tweener From ( object  p_target,
float  p_duration,
string  p_propName,
object  p_fromVal,
bool  p_isRelative 
) [static]

Creates a new FROM tween with default values, and returns the Tweener representing it, or null if the tween was invalid (no valid property to tween was given).

Parameters:
p_targetThe tweening target (must be the object containing the properties or fields to tween).
p_durationThe duration in seconds of the tween.
p_propNameThe name of the property or field to tween.
p_fromValThe end value the property should reach with the tween.
p_isRelativeIf true treats the end value as relative (tween BY instead than tween TO), otherwise as absolute.
Returns:
The newly created Tweener, or null if the parameters were invalid.
static Tweener From ( object  p_target,
float  p_duration,
TweenParms  p_parms 
) [static]

Creates a new FROM tween and returns the Tweener representing it, or null if the tween was invalid (no valid property to tween was given).

Parameters:
p_targetThe tweening target (must be the object containing the properties or fields to tween).
p_durationThe duration in seconds of the tween.
p_parmsA TweenParms representing the tween parameters. You can pass an existing one, or create a new one inline via method chaining, like new TweenParms().Prop("x",10).Loops(2).OnComplete(myFunction)
Returns:
The newly created Tweener, or null if the parameters were invalid.
static List<Tweener> GetTweenersByTarget ( object  p_target,
bool  p_includeNestedTweens 
) [static]

Returns a list with all the existing Tweener objects whose target is the given one, or an empty list if none was found.

Parameters:
p_targetTarget to look for
p_includeNestedTweensIf TRUE also searches inside nested Tweeners
Returns:
static TweenInfo [] GetTweenInfos ( ) [static]

Returns a TweenInfo list of the current tweens (paused and delayed included), or null if there are no tweens.

Returns:
static List<IHOTweenComponent> GetTweensById ( string  p_id,
bool  p_includeNestedTweens 
) [static]

Returns a list of the eventual existing tweens with the given Id, (empty if no Tweener/Sequence was found).

Parameters:
p_idId to look for
p_includeNestedTweensIf TRUE also searches inside nested tweens
Returns:
static List<IHOTweenComponent> GetTweensByIntId ( int  p_intId,
bool  p_includeNestedTweens 
) [static]

Returns a list of the eventual existing tweens with the given intId, (empty if no Tweener/Sequence was found).

Parameters:
p_intIdIntId to look for
p_includeNestedTweensIf TRUE also searches inside nested tweens
Returns:
static void Init ( ) [static]

Initializes HOTween and sets it as non-permanent (meaning HOTween instance will be destroyed when all tweens are killed, and re-created when needed). Call this method once when your application starts up, to avoid auto-initialization when the first tween is started or created, and to set options.

static void Init ( bool  p_permanentInstance) [static]

Initializes HOTween. Call this method once when your application starts up, to avoid auto-initialization when the first tween is started or created, and to set options.

Parameters:
p_permanentInstanceIf set to true, doesn't destroy HOTween manager when no tween is present, otherwise the manager is destroyed when all tweens have been killed, and re-created when needed.
static void Init ( bool  p_permanentInstance,
bool  p_renameInstanceToCountTweens,
bool  p_allowOverwriteManager 
) [static]

Initializes HOTween. Call this method once when your application starts up, to avoid auto-initialization when the first tween is started or created, and to set options.

Parameters:
p_permanentInstanceIf set to true, doesn't destroy HOTween manager when no tween is present, otherwise the manager is destroyed when all tweens have been killed, and re-created when needed.
p_renameInstanceToCountTweensIf true, renames HOTween's instance to show the current number of running tweens (only while in the Editor).
p_allowOverwriteManagerIf true, allows HOTween's instance to enable or disable the OverwriteManager to improve performance if it is never needed.
static bool IsLinkedTo ( object  p_target) [static]

Returns true if the given target is linked to any Tweener or Sequence (running or not, taking into account also nested tweens).

Parameters:
p_targetThe target to check.
Returns:
A value of true if the given target is linked to any Tweener or Sequence (running or not, taking into account also nested tweens).
static bool IsTweening ( object  p_target) [static]

Returns true if the given target is currently involved in any running Tweener or Sequence (taking into account also nested tweens). Returns false both if the given target is not inside a Tweener, than if the relative Tweener is paused. To simply check if the target is attached to a Tweener or Sequence use IsLinkedTo instead.

Parameters:
p_targetThe target to check.
Returns:
A value of true if the given target is currently involved in any running Tweener or Sequence (taking into account also nested tweens).
static bool IsTweening ( string  p_id) [static]

Returns true if the given id is involved in any running Tweener or Sequence (taking into account also nested tweens).

Parameters:
p_idThe target to check.
static bool IsTweening ( int  p_id) [static]

Returns true if the given id is involved in any running Tweener or Sequence (taking into account also nested tweens).

Parameters:
p_idThe target to check.
static int Kill ( object  p_target) [static]

Kills all the tweens for the given target (unless they're were created inside a Sequence), and returns the total number of killed Tweeners.

Parameters:
p_targetThe target whose Tweeners to kill.
Returns:
The total number of killed Tweeners.
static int Kill ( string  p_id) [static]

Kills all the Tweeners/Sequences with the given ID, and returns the total number of killed Tweeners/Sequences.

Parameters:
p_idThe ID of the Tweeners/Sequences to kill.
Returns:
The total number of killed Tweeners/Sequences.
static int Kill ( int  p_intId) [static]

Kills all the Tweeners/Sequences with the given intId, and returns the total number of killed Tweeners/Sequences.

Parameters:
p_intIdThe intId of the Tweeners/Sequences to kill.
Returns:
The total number of killed Tweeners/Sequences.
static int Kill ( Tweener  p_tweener) [static]

Kills the given Tweener, and returns the total number of killed ones (1 if the Tweener existed, otherwise 0).

Parameters:
p_tweenerThe Tweener to kill.
Returns:
The total number of killed Tweeners (1 if the Tweener existed, otherwise 0).
static int Kill ( Sequence  p_sequence) [static]

Kills the given Sequence, and returns the total number of killed ones (1 if the Sequence existed, otherwise 0).

Parameters:
p_sequenceThe Sequence to kill.
Returns:
The total number of killed Sequences (1 if the Sequence existed, otherwise 0).
static int Kill ( ) [static]

Kills all Tweeners/Sequences, and returns the total number of killed Tweeners/Sequences.

Returns:
The total number of killed Tweeners/Sequences.
static int Pause ( object  p_target) [static]

Pauses all the tweens for the given target, and returns the total number of paused Tweeners.

Parameters:
p_targetThe target whose tweens to pause.
Returns:
The total number of paused Tweeners.
static int Pause ( string  p_id) [static]

Pauses all the Tweeners/Sequences with the given ID, and returns the total number of paused Tweeners/Sequences.

Parameters:
p_idThe ID of the Tweeners/Sequences to pause.
Returns:
The total number of paused Tweeners/Sequences.
static int Pause ( int  p_intId) [static]

Pauses all the Tweeners/Sequences with the given intId, and returns the total number of paused Tweeners/Sequences.

Parameters:
p_intIdThe intId of the Tweeners/Sequences to pause.
Returns:
The total number of paused Tweeners/Sequences.
static int Pause ( Tweener  p_tweener) [static]

Pauses the given Tweener, and returns the total number of paused ones (1 if the Tweener existed, otherwise 0).

Parameters:
p_tweenerThe Tweener to pause.
Returns:
The total number of paused Tweener (1 if the Tweener existed, otherwise 0).
static int Pause ( Sequence  p_sequence) [static]

Pauses the given Sequence, and returns the total number of paused ones (1 if the Sequence existed, otherwise 0).

Parameters:
p_sequenceThe Sequence to pause.
Returns:
The total number of paused Sequence (1 if the sequence existed, otherwise 0).
static int Pause ( ) [static]

Pauses all Tweeners/Sequences, and returns the total number of paused Tweeners/Sequences.

Returns:
The total number of paused Tweeners/Sequences.
static int Play ( object  p_target) [static]

Resumes all the tweens (delays included) for the given target, and returns the total number of resumed Tweeners.

Parameters:
p_targetThe target whose tweens to resume.
Returns:
The total number of resumed Tweeners.
static int Play ( object  p_target,
bool  p_skipDelay 
) [static]

Resumes all the tweens for the given target, and returns the total number of resumed Tweeners.

Parameters:
p_targetThe target whose tweens to resume.
p_skipDelayIf true skips any initial delay.
Returns:
The total number of resumed Tweeners.
static int Play ( string  p_id) [static]

Resumes all the Tweeners (delays included) and Sequences with the given ID, and returns the total number of resumed Tweeners/Sequences.

Parameters:
p_idThe ID of the Tweeners/Sequences to resume.
Returns:
The total number of resumed Tweeners/Sequences.
static int Play ( string  p_id,
bool  p_skipDelay 
) [static]

Resumes all the Tweeners/Sequences with the given ID, and returns the total number of resumed Tweeners/Sequences.

Parameters:
p_idThe ID of the Tweeners/Sequences to resume.
p_skipDelayIf true skips any initial tween delay.
Returns:
The total number of resumed Tweeners/Sequences.
static int Play ( int  p_intId) [static]

Resumes all the Tweeners (delays included) and Sequences with the given intId, and returns the total number of resumed Tweeners/Sequences.

Parameters:
p_intIdThe intId of the Tweeners/Sequences to resume.
Returns:
The total number of resumed Tweeners/Sequences.
static int Play ( int  p_intId,
bool  p_skipDelay 
) [static]

Resumes all the Tweeners/Sequences with the given intId, and returns the total number of resumed Tweeners/Sequences.

Parameters:
p_intIdThe intId of the Tweeners/Sequences to resume.
p_skipDelayIf true skips any initial tween delay.
Returns:
The total number of resumed Tweeners/Sequences.
static int Play ( Tweener  p_tweener) [static]

Resumes the given Tweener (delays included), and returns the total number of resumed ones (1 if the Tweener existed, otherwise 0).

Parameters:
p_tweenerThe Tweener to resume.
Returns:
The total number of resumed Tweeners (1 if the Tweener existed, otherwise 0).
static int Play ( Tweener  p_tweener,
bool  p_skipDelay 
) [static]

Resumes the given Tweener, and returns the total number of resumed ones (1 if the Tweener existed, otherwise 0).

Parameters:
p_tweenerThe Tweener to resume.
p_skipDelayIf true skips any initial delay.
Returns:
The total number of resumed Tweeners (1 if the Tweener existed, otherwise 0).
static int Play ( Sequence  p_sequence) [static]

Resumes the given Sequence, and returns the total number of resumed ones (1 if the Sequence existed, otherwise 0).

Parameters:
p_sequenceThe Sequence to resume.
Returns:
The total number of resumed Sequences (1 if the Sequence existed, otherwise 0).
static int Play ( ) [static]

Resumes all Tweeners (delays included) and Sequences, and returns the total number of resumed Tweeners/Sequences.

Returns:
The total number of resumed Tweeners/Sequences.
static int Play ( bool  p_skipDelay) [static]

Resumes all Tweeners/Sequences, and returns the total number of resumed Tweeners/Sequences.

Parameters:
p_skipDelayIf true skips any initial tween delay.
Returns:
The total number of resumed Tweeners/Sequences.
static int PlayBackwards ( object  p_target) [static]

Resumes all the tweens for the given target, sets the tweens so that they move backwards instead than forward, and returns the total number of resumed Tweeners.

Parameters:
p_targetThe target whose tweens to resume.
Returns:
The total number of resumed Tweeners.
static int PlayBackwards ( string  p_id) [static]

Resumes all the Tweeners/Sequences with the given ID, sets the tweens so that they move backwards instead than forward, and returns the total number of resumed Tweeners/Sequences.

Parameters:
p_idThe ID of the Tweeners/Sequences to resume.
Returns:
The total number of resumed Tweeners/Sequences.
static int PlayBackwards ( int  p_intId) [static]

Resumes all the Tweeners/Sequences with the given intId, sets the tweens so that they move backwards instead than forward, and returns the total number of resumed Tweeners/Sequences.

Parameters:
p_intIdThe intId of the Tweeners/Sequences to resume.
Returns:
The total number of resumed Tweeners/Sequences.
static int PlayBackwards ( Tweener  p_tweener) [static]

Resumes the given Tweener, sets it so that it moves backwards instead than forward, and returns the total number of resumed ones (1 if the Tweener existed, otherwise 0).

Parameters:
p_tweenerThe Tweener to resume.
Returns:
The total number of resumed Tweeners (1 if the Tweener existed, otherwise 0).
static int PlayBackwards ( Sequence  p_sequence) [static]

Resumes the given Sequence, sets it so that it moves backwards instead than forward, and returns the total number of resumed ones (1 if the Sequence existed, otherwise 0).

Parameters:
p_sequenceThe Sequence to resume.
Returns:
The total number of resumed Sequences (1 if the Sequence existed, otherwise 0).
static int PlayBackwards ( ) [static]

Resumes all Tweeners/Sequences, sets the tweens so that they move backwards instead than forward, and returns the total number of resumed Tweeners/Sequences.

Returns:
The total number of resumed Tweeners/Sequences.
static int PlayForward ( object  p_target) [static]

Resumes all the tweens (delays included) for the given target, sets the tweens so that they move forward and not backwards, and returns the total number of resumed Tweeners.

Parameters:
p_targetThe target whose tweens to resume.
Returns:
The total number of resumed Tweeners.
static int PlayForward ( object  p_target,
bool  p_skipDelay 
) [static]

Resumes all the tweens for the given target, sets the tweens so that they move forward and not backwards, and returns the total number of resumed Tweeners.

Parameters:
p_targetThe target whose tweens to resume.
p_skipDelayIf true skips any initial delay.
Returns:
The total number of resumed Tweeners.
static int PlayForward ( string  p_id) [static]

Resumes all the Tweeners (delays included) and Sequences with the given ID, sets the tweens so that they move forward and not backwards, and returns the total number of resumed Tweeners/Sequences.

Parameters:
p_idThe ID of the Tweeners/Sequences to resume.
Returns:
The total number of resumed Tweeners/Sequences.
static int PlayForward ( string  p_id,
bool  p_skipDelay 
) [static]

Resumes all the Tweeners/Sequences with the given ID, sets the tweens so that they move forward and not backwards, and returns the total number of resumed Tweeners/Sequences.

Parameters:
p_idThe ID of the Tweeners/Sequences to resume.
p_skipDelayIf true skips any initial tween delay.
Returns:
The total number of resumed Tweeners/Sequences.
static int PlayForward ( int  p_intId) [static]

Resumes all the Tweeners (delays included) and Sequences with the given intId, sets the tweens so that they move forward and not backwards, and returns the total number of resumed Tweeners/Sequences.

Parameters:
p_intIdThe intId of the Tweeners/Sequences to resume.
Returns:
The total number of resumed Tweeners/Sequences.
static int PlayForward ( int  p_intId,
bool  p_skipDelay 
) [static]

Resumes all the Tweeners/Sequences with the given intId, sets the tweens so that they move forward and not backwards, and returns the total number of resumed Tweeners/Sequences.

Parameters:
p_intIdThe intId of the Tweeners/Sequences to resume.
p_skipDelayIf true skips any initial tween delay.
Returns:
The total number of resumed Tweeners/Sequences.
static int PlayForward ( Tweener  p_tweener) [static]

Resumes the given Tweener (delays included), sets it so that it moves forward and not backwards, and returns the total number of resumed ones (1 if the Tweener existed, otherwise 0).

Parameters:
p_tweenerThe Tweener to resume.
Returns:
The total number of resumed Tweeners (1 if the Tweener existed, otherwise 0).
static int PlayForward ( Tweener  p_tweener,
bool  p_skipDelay 
) [static]

Resumes the given Tweener, sets it so that it moves forward and not backwards, and returns the total number of resumed ones (1 if the Tweener existed, otherwise 0).

Parameters:
p_tweenerThe Tweener to resume.
p_skipDelayIf true skips any initial delay.
Returns:
The total number of resumed Tweeners (1 if the Tweener existed, otherwise 0).
static int PlayForward ( Sequence  p_sequence) [static]

Resumes the given Sequence, sets it so that it moves forward and not backwards, and returns the total number of resumed ones (1 if the Sequence existed, otherwise 0).

Parameters:
p_sequenceThe Sequence to resume.
Returns:
The total number of resumed Sequences (1 if the Sequence existed, otherwise 0).
static int PlayForward ( ) [static]

Resumes all Tweeners (delays included) and Sequences, sets the tweens so that they move forward and not backwards, and returns the total number of resumed Tweeners/Sequences.

Returns:
The total number of resumed Tweeners/Sequences.
static int PlayForward ( bool  p_skipDelay) [static]

Resumes all Tweeners/Sequences, sets the tweens so that they move forward and not backwards, and returns the total number of resumed Tweeners/Sequences.

Parameters:
p_skipDelayIf true skips any initial tween delay.
Returns:
The total number of resumed Tweeners/Sequences.
static Tweener Punch ( object  p_target,
float  p_duration,
string  p_propName,
object  p_fromVal,
float  p_punchAmplitude = 0.5f,
float  p_punchPeriod = 0.1f 
) [static]

Creates a new absolute PUNCH tween, and returns the Tweener representing it, or null if the tween was invalid (no valid property to tween was given).

Parameters:
p_targetThe tweening target (must be the object containing the properties or fields to tween).
p_durationThe duration in seconds of the tween.
p_propNameThe name of the property or field to tween.
p_fromValThe end value the property should reach with the tween.
p_punchAmplitudeDefault: 0.5f - amplitude of the punch effect
p_punchPeriodDefault: 0.1f - oscillation period of punch effect
Returns:
The newly created Tweener, or null if the parameters were invalid.
static Tweener Punch ( object  p_target,
float  p_duration,
string  p_propName,
object  p_fromVal,
bool  p_isRelative,
float  p_punchAmplitude = 0.5f,
float  p_punchPeriod = 0.1f 
) [static]

Creates a new PUNCH tween, and returns the Tweener representing it, or null if the tween was invalid (no valid property to tween was given).

Parameters:
p_targetThe tweening target (must be the object containing the properties or fields to tween).
p_durationThe duration in seconds of the tween.
p_propNameThe name of the property or field to tween.
p_fromValThe end value the property should reach with the tween.
p_isRelativeIf true treats the end value as relative (tween BY instead than tween TO), otherwise as absolute.
p_punchAmplitudeDefault: 0.5f - amplitude of the punch effect
p_punchPeriodDefault: 0.1f - oscillation period of punch effect
Returns:
The newly created Tweener, or null if the parameters were invalid.
static Tweener Punch ( object  p_target,
float  p_duration,
TweenParms  p_parms,
float  p_punchAmplitude = 0.5f,
float  p_punchPeriod = 0.1f 
) [static]

Creates a new PUNCH tween and returns the Tweener representing it, or null if the tween was invalid (no valid property to tween was given). Any ease type passed won't be considered, since punch uses its own one.

Parameters:
p_targetThe tweening target (must be the object containing the properties or fields to tween).
p_durationThe duration in seconds of the tween.
p_parmsA TweenParms representing the tween parameters. You can pass an existing one, or create a new one inline via method chaining, like new TweenParms().Prop("x",10).Loops(2).OnComplete(myFunction)
p_punchAmplitudeDefault: 0.5f - amplitude of the punch effect
p_punchPeriodDefault: 0.1f - oscillation period of punch effect
Returns:
The newly created Tweener, or null if the parameters were invalid.
static int Restart ( object  p_target) [static]

Restarts all the tweens (delays included) for the given target, and returns the total number of restarted Tweeners.

Parameters:
p_targetThe target whose tweens to restart.
Returns:
The total number of restarted Tweeners.
static int Restart ( object  p_target,
bool  p_skipDelay 
) [static]

Restarts all the tweens for the given target, and returns the total number of restarted Tweeners.

Parameters:
p_targetThe target whose tweens to restart.
p_skipDelayIf true skips any initial delay.
Returns:
The total number of restarted Tweeners.
static int Restart ( string  p_id) [static]

Restarts all the Tweeners (delays included) and Sequences with the given ID, and returns the total number of restarted Tweeners/Sequences.

Parameters:
p_idThe ID of the Tweeners/Sequences to restart.
Returns:
The total number of restarted Tweeners/Sequences.
static int Restart ( string  p_id,
bool  p_skipDelay 
) [static]

Restarts all the Tweeners/Sequences with the given ID, and returns the total number of restarted Tweeners/Sequences.

Parameters:
p_idThe ID of the Tweeners/Sequences to restart.
p_skipDelayIf true skips any initial tween delay.
Returns:
The total number of restarted Tweeners/Sequences.
static int Restart ( int  p_intId) [static]

Restarts all the Tweeners (delays included) and Sequences with the given intId, and returns the total number of restarted Tweeners/Sequences.

Parameters:
p_intIdThe intId of the Tweeners/Sequences to restart.
Returns:
The total number of restarted Tweeners/Sequences.
static int Restart ( int  p_intId,
bool  p_skipDelay 
) [static]

Restarts all the Tweeners/Sequences with the given intId, and returns the total number of restarted Tweeners/Sequences.

Parameters:
p_intIdThe intId of the Tweeners/Sequences to restart.
p_skipDelayIf true skips any initial tween delay.
Returns:
The total number of restarted Tweeners/Sequences.
static int Restart ( Tweener  p_tweener) [static]

Restarts the given Tweener (delays included), and returns the total number of restarted ones (1 if the Tweener existed, otherwise 0).

Parameters:
p_tweenerThe Tweener to restart.
Returns:
The total number of restarted Tweeners (1 if the Tweener existed, otherwise 0).
static int Restart ( Tweener  p_tweener,
bool  p_skipDelay 
) [static]

Restarts the given Tweener, and returns the total number of restarted ones (1 if the Tweener existed, otherwise 0).

Parameters:
p_tweenerThe Tweener to restart.
p_skipDelayIf true skips any initial delay.
Returns:
The total number of restarted Tweeners (1 if the Tweener existed, otherwise 0).
static int Restart ( Sequence  p_sequence) [static]

Restarts the given Sequence, and returns the total number of restarted ones (1 if the Sequence existed, otherwise 0).

Parameters:
p_sequenceThe Sequence to restart.
Returns:
The total number of restarted Sequences (1 if the Sequence existed, otherwise 0).
static int Restart ( ) [static]

Restarts all Tweeners (delay included) and Sequences, and returns the total number of restarted Tweeners/Sequences.

Returns:
The total number of restarted Tweeners/Sequences.
static int Restart ( bool  p_skipDelay) [static]

Restarts all Tweeners/Sequences and returns the total number of restarted Tweeners/Sequences.

Parameters:
p_skipDelayIf true skips any initial tween delay.
Returns:
The total number of restarted Tweeners/Sequences.
static int Reverse ( object  p_target,
bool  p_forcePlay = false 
) [static]

Reverses all the tweens for the given target, animating them from their current value back to the starting one, and returns the total number of reversed Tweeners.

Parameters:
p_targetThe target whose tweens to reverse.
p_forcePlayIf TRUE, the tween will also start playing in case it was paused, otherwise it will maintain its current play/pause state (default).
Returns:
The total number of reversed Tweeners.
static int Reverse ( string  p_id,
bool  p_forcePlay = false 
) [static]

Reverses all the Tweeners/Sequences with the given ID, animating them from their current value back to the starting one, and returns the total number of reversed Tweeners/Sequences.

Parameters:
p_idThe ID of the Tweeners/Sequences to reverse.
p_forcePlayIf TRUE, the tween will also start playing in case it was paused, otherwise it will maintain its current play/pause state (default).
Returns:
The total number of reversed Tweeners/Sequences.
static int Reverse ( int  p_intId,
bool  p_forcePlay = false 
) [static]

Reverses all the Tweeners/Sequences with the given intId, animating them from their current value back to the starting one, and returns the total number of reversed Tweeners/Sequences.

Parameters:
p_intIdThe intId of the Tweeners/Sequences to reverse.
p_forcePlayIf TRUE, the tween will also start playing in case it was paused, otherwise it will maintain its current play/pause state (default).
Returns:
The total number of reversed Tweeners/Sequences.
static int Reverse ( Tweener  p_tweener,
bool  p_forcePlay = false 
) [static]

Reverses the given Tweener, animating it from its current value back to the starting one, and returns the total number of reversed Tweeners (1 if the Tweener existed, otherwise 0).

Parameters:
p_tweenerThe Tweener to reverse.
p_forcePlayIf TRUE, the tween will also start playing in case it was paused, otherwise it will maintain its current play/pause state (default).
Returns:
The total number of reversed Tweeners (1 if the Tweener existed, otherwise 0).
static int Reverse ( Sequence  p_sequence,
bool  p_forcePlay = false 
) [static]

Reverses the given Sequence, and returns the total number of reversed ones (1 if the Sequence existed, otherwise 0).

Parameters:
p_sequenceThe Sequence to reverse.
p_forcePlayIf TRUE, the tween will also start playing in case it was paused, otherwise it will maintain its current play/pause state (default).
Returns:
The total number of reversed Sequences (1 if the Sequence existed, otherwise 0).
static int Reverse ( bool  p_forcePlay = false) [static]

Reverses all Tweeners/Sequences, animating them from their current value back to the starting one, and returns the total number of reversed Tweeners/Sequences.

Parameters:
p_forcePlayIf TRUE, the tween will also start playing in case it was paused, otherwise it will maintain its current play/pause state (default).
Returns:
The total number of reversed Tweeners/Sequences.
static int Rewind ( object  p_target) [static]

Rewinds all the tweens (delays included) for the given target, and returns the total number of rewinded Tweeners.

Parameters:
p_targetThe target whose tweens to rewind.
Returns:
The total number of rewinded Tweeners.
static int Rewind ( object  p_target,
bool  p_skipDelay 
) [static]

Rewinds all the tweens for the given target, and returns the total number of rewinded Tweeners.

Parameters:
p_targetThe target whose tweens to rewind.
p_skipDelayIf true skips any initial delay.
Returns:
The total number of rewinded Tweeners.
static int Rewind ( string  p_id) [static]

Rewinds all the Tweeners (delays included) and Sequences with the given ID, and returns the total number of rewinded Tweeners/Sequences.

Parameters:
p_idThe ID of the Tweeners/Sequences to rewind.
Returns:
The total number of rewinded Tweeners/Sequences.
static int Rewind ( string  p_id,
bool  p_skipDelay 
) [static]

Rewinds all the Tweeners/Sequences with the given ID, and returns the total number of rewinded Tweeners/Sequences.

Parameters:
p_idThe ID of the Tweeners/Sequences to rewind.
p_skipDelayIf true skips any initial tween delay.
Returns:
The total number of rewinded Tweeners/Sequences.
static int Rewind ( int  p_intId) [static]

Rewinds all the Tweeners (delays included) and Sequences with the given intId, and returns the total number of rewinded Tweeners/Sequences.

Parameters:
p_intIdThe intId of the Tweeners/Sequences to rewind.
Returns:
The total number of rewinded Tweeners/Sequences.
static int Rewind ( int  p_intId,
bool  p_skipDelay 
) [static]

Rewinds all the Tweeners/Sequences with the given intId, and returns the total number of rewinded Tweeners/Sequences.

Parameters:
p_intIdThe intId of the Tweeners/Sequences to rewind.
p_skipDelayIf true skips any initial tween delay.
Returns:
The total number of rewinded Tweeners/Sequences.
static int Rewind ( Tweener  p_tweener) [static]

Rewinds the given Tweener (delays included), and returns the total number of rewinded ones (1 if the Tweener existed, otherwise 0).

Parameters:
p_tweenerThe Tweener to rewind.
Returns:
The total number of rewinded Tweeners (1 if the Tweener existed, otherwise 0).
static int Rewind ( Tweener  p_tweener,
bool  p_skipDelay 
) [static]

Rewinds the given Tweener, and returns the total number of rewinded ones (1 if the Tweener existed, otherwise 0).

Parameters:
p_tweenerThe Tweener to rewind.
p_skipDelayIf true skips any initial delay.
Returns:
The total number of rewinded Tweeners (1 if the Tweener existed, otherwise 0).
static int Rewind ( Sequence  p_sequence) [static]

Rewinds the given Sequence, and returns the total number of rewinded ones (1 if the Sequence existed, otherwise 0).

Parameters:
p_sequenceThe Sequence to rewind.
Returns:
The total number of rewinded Sequences (1 if the Sequence existed, otherwise 0).
static int Rewind ( ) [static]

Rewinds all Tweeners (delay included) and Sequences, and returns the total number of rewinded Tweeners/Sequences.

Returns:
The total number of rewinded Tweeners/Sequences.
static int Rewind ( bool  p_skipDelay) [static]

Rewinds all Tweeners/Sequences, and returns the total number of rewinded Tweeners/Sequences.

Parameters:
p_skipDelayIf true skips any initial tween delay.
Returns:
The total number of rewinded Tweeners/Sequences.
static Tweener Shake ( object  p_target,
float  p_duration,
string  p_propName,
object  p_fromVal,
float  p_shakeAmplitude = 0.1f,
float  p_shakePeriod = 0.12f 
) [static]

Creates a new absolute SHAKE tween, and returns the Tweener representing it, or null if the tween was invalid (no valid property to tween was given).

Parameters:
p_targetThe tweening target (must be the object containing the properties or fields to tween).
p_durationThe duration in seconds of the tween.
p_propNameThe name of the property or field to tween.
p_fromValThe amount of shaking to apply.
p_shakeAmplitudeDefault: 0.1f - amplitude of the shake effect
p_shakePeriodDefault: 0.12f - oscillation period of shake effect
Returns:
The newly created Tweener, or null if the parameters were invalid.
static Tweener Shake ( object  p_target,
float  p_duration,
string  p_propName,
object  p_fromVal,
bool  p_isRelative,
float  p_shakeAmplitude = 0.1f,
float  p_shakePeriod = 0.12f 
) [static]

Creates a new SHAKE tween, and returns the Tweener representing it, or null if the tween was invalid (no valid property to tween was given).

Parameters:
p_targetThe tweening target (must be the object containing the properties or fields to tween).
p_durationThe duration in seconds of the tween.
p_propNameThe name of the property or field to tween.
p_fromValThe amount of shaking to apply.
p_isRelativeIf true treats the end value as relative (tween BY instead than tween TO), otherwise as absolute.
p_shakeAmplitudeDefault: 0.1f - amplitude of the shake effect
p_shakePeriodDefault: 0.12f - oscillation period of shake effect
Returns:
The newly created Tweener, or null if the parameters were invalid.
static Tweener Shake ( object  p_target,
float  p_duration,
TweenParms  p_parms,
float  p_shakeAmplitude = 0.1f,
float  p_shakePeriod = 0.12f 
) [static]

Creates a new SHAKE tween and returns the Tweener representing it, or null if the tween was invalid (no valid property to tween was given). Any ease type passed won't be considered, since shake uses its own one.

Parameters:
p_targetThe tweening target (must be the object containing the properties or fields to tween).
p_durationThe duration in seconds of the tween.
p_parmsA TweenParms representing the tween parameters. You can pass an existing one, or create a new one inline via method chaining, like new TweenParms().Prop("x",10).Loops(2).OnComplete(myFunction)
p_shakeAmplitudeDefault: 0.1f - amplitude of the shake effect
p_shakePeriodDefault: 0.12f - oscillation period of shake effect
Returns:
The newly created Tweener, or null if the parameters were invalid.
static Tweener To ( object  p_target,
float  p_duration,
string  p_propName,
object  p_endVal 
) [static]

Creates a new absolute tween with default values, and returns the Tweener representing it, or null if the tween was invalid (no valid property to tween was given).

Parameters:
p_targetThe tweening target (must be the object containing the properties or fields to tween).
p_durationThe duration in seconds of the tween.
p_propNameThe name of the property or field to tween.
p_endValThe end value the property should reach with the tween.
Returns:
The newly created Tweener, or null if the parameters were invalid.
static Tweener To ( object  p_target,
float  p_duration,
string  p_propName,
object  p_endVal,
bool  p_isRelative 
) [static]

Creates a new tween with default values, and returns the Tweener representing it, or null if the tween was invalid (no valid property to tween was given).

Parameters:
p_targetThe tweening target (must be the object containing the properties or fields to tween).
p_durationThe duration in seconds of the tween.
p_propNameThe name of the property or field to tween.
p_endValThe end value the property should reach with the tween.
p_isRelativeIf true treats the end value as relative (tween BY instead than tween TO), otherwise as absolute.
Returns:
The newly created Tweener, or null if the parameters were invalid.
static Tweener To ( object  p_target,
float  p_duration,
TweenParms  p_parms 
) [static]

Creates a new tween and returns the Tweener representing it, or null if the tween was invalid (no valid property to tween was given).

Parameters:
p_targetThe tweening target (must be the object containing the properties or fields to tween).
p_durationThe duration in seconds of the tween.
p_parmsA TweenParms representing the tween parameters. You can pass an existing one, or create a new one inline via method chaining, like new TweenParms().Prop("x",10).Loops(2).OnComplete(myFunction)
Returns:
The newly created Tweener, or null if the parameters were invalid.

Member Data Documentation

const string AUTHOR = "Daniele Giardini - Holoville"

HOTween author - me! :P.

float defEaseOvershootOrAmplitude = 1.70158f [static]

Default overshoot to use with Back easeTypes.

float defEasePeriod = 0 [static]

Default period to use with Elastic easeTypes.

EaseType defEaseType = EaseType.EaseOutQuad [static]

Default EaseType that will be used by any new Tweener/Sequence that doesn't implement a specific ease (default = EaseType.easeOutQuad).

LoopType defLoopType = LoopType.Restart [static]

Default LoopType that will be used by any Tweener/Sequence that doesn't implement a specific loopType (default = LoopType.Restart).

float defTimeScale = 1 [static]

Default time scale that will be used by any new Tweener/Sequence that doesn't implement a specific timeScale (default = 1).

UpdateType defUpdateType = UpdateType.Update [static]

Default UpdateType that will be used by any new Tweener/Sequence that doesn't implement a specific ease (default = EaseType.easeOutQuad)

bool showPathGizmos [static]

If true, shows the eventual paths in use by PlugVector3Path while playing inside Unity's Editor (and if the Editor's Gizmos button is on).

const string VERSION = "1.2.010"

HOTween version.

WarningLevel warningLevel = WarningLevel.Verbose [static]

Level of message output in case an error is encountered. Warnings are logged when HOTween encounters an error, and automatically resolves it without throwing any exception (like if you try to tween an unexisting property, in which case the tween simply won't be generated, and an eventual warning will appear in the output window).


Property Documentation

int totTweens [static, get]

Total number of tweeners/sequences (paused and delayed ones are included). Tweeners and sequences contained into other sequences don't count: for example, if there's only one sequence that contains 2 tweeners, totTweens will be 1.

 All Classes Namespaces Functions Variables Enumerations Properties