/// <summary> /// Factory creating a new instantaneous interpolation (thus this is not /// really an interpolation). /// </summary> /// <remarks> /// Factory creating a new instantaneous interpolation (thus this is not /// really an interpolation). /// <br/><br/> /// <b>You need to set the target values of the interpolation by using one /// of the target() methods</b>. The interpolation will set the target /// attribute to these values after the delay (if any). /// <br/><br/> /// The common use of Tweens is "fire-and-forget": you do not need to care /// for tweens once you added them to a TweenManager, they will be updated /// automatically, and cleaned once finished. Common call: /// <br/><br/> /// <pre> /// <code> /// Tween.set(myObject, POSITION) /// .target(50, 70) /// .delay(1.0f) /// .start(myManager); /// </code> /// </pre> /// Several options such as delay, repetitions and callbacks can be added to /// the tween. /// </remarks> /// <param name="target">The target object of the interpolation.</param> /// <param name="tweenType">The desired type of interpolation.</param> /// <returns>The generated Tween.</returns> public static TweenEngine.Tween Set(object target, int tweenType) { TweenEngine.Tween tween = pool.Get(); tween.Setup(target, tweenType, 0); tween.Ease(Quad.INOUT); return(tween); }
/// <summary>Factory creating a new timer.</summary> /// <remarks> /// Factory creating a new timer. The given callback will be triggered on /// each iteration start, after the delay. /// <br/><br/> /// The common use of Tweens is "fire-and-forget": you do not need to care /// for tweens once you added them to a TweenManager, they will be updated /// automatically, and cleaned once finished. Common call: /// <br/><br/> /// <pre> /// <code> /// Tween.call(myCallback) /// .delay(1.0f) /// .repeat(10, 1000) /// .start(myManager); /// </code> /// </pre> /// </remarks> /// <param name="callback"> /// The callback that will be triggered on each iteration /// start. /// </param> /// <returns>The generated Tween.</returns> /// <seealso cref="TweenCallback">TweenCallback</seealso> public static TweenEngine.Tween Call(TweenCallback callback) { TweenEngine.Tween tween = pool.Get(); tween.Setup(null, -1, 0); tween.SetCallback(callback); tween.SetCallbackTriggers(TweenCallback.START); return(tween); }
// ------------------------------------------------------------------------- // Static -- factories // ------------------------------------------------------------------------- /// <summary>Factory creating a new standard interpolation.</summary> /// <remarks> /// Factory creating a new standard interpolation. This is the most common /// type of interpolation. The starting values are retrieved automatically /// after the delay (if any). /// <br/><br/> /// <b>You need to set the target values of the interpolation by using one /// of the target() methods</b>. The interpolation will run from the /// starting values to these target values. /// <br/><br/> /// The common use of Tweens is "fire-and-forget": you do not need to care /// for tweens once you added them to a TweenManager, they will be updated /// automatically, and cleaned once finished. Common call: /// <br/><br/> /// <pre> /// <code> /// Tween.to(myObject, POSITION, 1.0f) /// .target(50, 70) /// .ease(Quad.INOUT) /// .start(myManager); /// </code> /// </pre> /// Several options such as delay, repetitions and callbacks can be added to /// the tween. /// </remarks> /// <param name="target">The target object of the interpolation.</param> /// <param name="tweenType">The desired type of interpolation.</param> /// <param name="duration">The duration of the interpolation, in milliseconds.</param> /// <returns>The generated Tween.</returns> public static TweenEngine.Tween To(object target, int tweenType, float duration) { TweenEngine.Tween tween = pool.Get(); tween.Setup(target, tweenType, duration); tween.Ease(Quad.INOUT); tween.Path(TweenPaths.catmullRom); return(tween); }
/// <summary>Convenience method to create an empty tween.</summary> /// <remarks> /// Convenience method to create an empty tween. Such object is only useful /// when placed inside animation sequences (see /// <see cref="Timeline">Timeline</see> /// ), in which /// it may act as a beacon, so you can set a callback on it in order to /// trigger some action at the right moment. /// </remarks> /// <returns>The generated Tween.</returns> /// <seealso cref="Timeline">Timeline</seealso> public static TweenEngine.Tween Mark() { TweenEngine.Tween tween = pool.Get(); tween.Setup(null, -1, 0); return(tween); }