| package aurelienribon.tweenengine; |
| |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.List; |
| |
| /** |
| * A TweenManager updates all your tweens and timelines at once. |
| * Its main interest is that it handles the tween/timeline life-cycles for you, |
| * as well as the pooling constraints (if object pooling is enabled). |
| * <p/> |
| * |
| * Just give it a bunch of tweens or timelines and call update() periodically, |
| * you don't need to care for anything else! Relax and enjoy your animations. |
| * |
| * @see Tween |
| * @see Timeline |
| * @author Aurelien Ribon | http://www.aurelienribon.com/ |
| */ |
| public class TweenManager { |
| // ------------------------------------------------------------------------- |
| // Static API |
| // ------------------------------------------------------------------------- |
| |
| /** |
| * Disables or enables the "auto remove" mode of any tween manager for a |
| * particular tween or timeline. This mode is activated by default. The |
| * interest of desactivating it is to prevent some tweens or timelines from |
| * being automatically removed from a manager once they are finished. |
| * Therefore, if you update a manager backwards, the tweens or timelines |
| * will be played again, even if they were finished. |
| */ |
| public static void setAutoRemove(BaseTween<?> object, boolean value) { |
| object.isAutoRemoveEnabled = value; |
| } |
| |
| /** |
| * Disables or enables the "auto start" mode of any tween manager for a |
| * particular tween or timeline. This mode is activated by default. If it |
| * is not enabled, add a tween or timeline to any manager won't start it |
| * automatically, and you'll need to call .start() manually on your object. |
| */ |
| public static void setAutoStart(BaseTween<?> object, boolean value) { |
| object.isAutoStartEnabled = value; |
| } |
| |
| // ------------------------------------------------------------------------- |
| // Public API |
| // ------------------------------------------------------------------------- |
| |
| private final ArrayList<BaseTween<?>> objects = new ArrayList<BaseTween<?>>(20); |
| private boolean isPaused = false; |
| |
| /** |
| * Adds a tween or timeline to the manager and starts or restarts it. |
| * |
| * @return The manager, for instruction chaining. |
| */ |
| public TweenManager add(BaseTween<?> object) { |
| if (!objects.contains(object)) objects.add(object); |
| if (object.isAutoStartEnabled) object.start(); |
| return this; |
| } |
| |
| /** |
| * Returns true if the manager contains any valid interpolation associated |
| * to the given target object. |
| */ |
| public boolean containsTarget(Object target) { |
| for (int i=0, n=objects.size(); i<n; i++) { |
| BaseTween<?> obj = objects.get(i); |
| if (obj.containsTarget(target)) return true; |
| } |
| return false; |
| } |
| |
| /** |
| * Returns true if the manager contains any valid interpolation associated |
| * to the given target object and to the given tween type. |
| */ |
| public boolean containsTarget(Object target, int tweenType) { |
| for (int i=0, n=objects.size(); i<n; i++) { |
| BaseTween<?> obj = objects.get(i); |
| if (obj.containsTarget(target, tweenType)) return true; |
| } |
| return false; |
| } |
| |
| /** |
| * Kills every managed tweens and timelines. |
| */ |
| public void killAll() { |
| for (int i=0, n=objects.size(); i<n; i++) { |
| BaseTween<?> obj = objects.get(i); |
| obj.kill(); |
| } |
| } |
| |
| /** |
| * Kills every tweens associated to the given target. Will also kill every |
| * timelines containing a tween associated to the given target. |
| */ |
| public void killTarget(Object target) { |
| for (int i=0, n=objects.size(); i<n; i++) { |
| BaseTween<?> obj = objects.get(i); |
| obj.killTarget(target); |
| } |
| } |
| |
| /** |
| * Kills every tweens associated to the given target and tween type. Will |
| * also kill every timelines containing a tween associated to the given |
| * target and tween type. |
| */ |
| public void killTarget(Object target, int tweenType) { |
| for (int i=0, n=objects.size(); i<n; i++) { |
| BaseTween<?> obj = objects.get(i); |
| obj.killTarget(target, tweenType); |
| } |
| } |
| |
| /** |
| * Increases the minimum capacity of the manager. Defaults to 20. |
| */ |
| public void ensureCapacity(int minCapacity) { |
| objects.ensureCapacity(minCapacity); |
| } |
| |
| /** |
| * Pauses the manager. Further update calls won't have any effect. |
| */ |
| public void pause() { |
| isPaused = true; |
| } |
| |
| /** |
| * Resumes the manager, if paused. |
| */ |
| public void resume() { |
| isPaused = false; |
| } |
| |
| /** |
| * Updates every tweens with a delta time ang handles the tween life-cycles |
| * automatically. If a tween is finished, it will be removed from the |
| * manager. The delta time represents the elapsed time between now and the |
| * last update call. Each tween or timeline manages its local time, and adds |
| * this delta to its local time to update itself. |
| * <p/> |
| * |
| * Slow motion, fast motion and backward play can be easily achieved by |
| * tweaking this delta time. Multiply it by -1 to play the animation |
| * backward, or by 0.5 to play it twice slower than its normal speed. |
| */ |
| public void update(float delta) { |
| for (int i=objects.size()-1; i>=0; i--) { |
| BaseTween<?> obj = objects.get(i); |
| if (obj.isFinished() && obj.isAutoRemoveEnabled) { |
| objects.remove(i); |
| obj.free(); |
| } |
| } |
| |
| if (!isPaused) { |
| if (delta >= 0) { |
| for (int i=0, n=objects.size(); i<n; i++) objects.get(i).update(delta); |
| } else { |
| for (int i=objects.size()-1; i>=0; i--) objects.get(i).update(delta); |
| } |
| } |
| } |
| |
| /** |
| * Gets the number of managed objects. An object may be a tween or a |
| * timeline. Note that a timeline only counts for 1 object, since it |
| * manages its children itself. |
| * <p/> |
| * To get the count of running tweens, see {@link #getRunningTweensCount()}. |
| */ |
| public int size() { |
| return objects.size(); |
| } |
| |
| /** |
| * Gets the number of running tweens. This number includes the tweens |
| * located inside timelines (and nested timelines). |
| * <p/> |
| * <b>Provided for debug purpose only.</b> |
| */ |
| public int getRunningTweensCount() { |
| return getTweensCount(objects); |
| } |
| |
| /** |
| * Gets the number of running timelines. This number includes the timelines |
| * nested inside other timelines. |
| * <p/> |
| * <b>Provided for debug purpose only.</b> |
| */ |
| public int getRunningTimelinesCount() { |
| return getTimelinesCount(objects); |
| } |
| |
| /** |
| * Gets an immutable list of every managed object. |
| * <p/> |
| * <b>Provided for debug purpose only.</b> |
| */ |
| public List<BaseTween<?>> getObjects() { |
| return Collections.unmodifiableList(objects); |
| } |
| |
| // ------------------------------------------------------------------------- |
| // Helpers |
| // ------------------------------------------------------------------------- |
| |
| private static int getTweensCount(List<BaseTween<?>> objs) { |
| int cnt = 0; |
| for (int i=0, n=objs.size(); i<n; i++) { |
| BaseTween<?> obj = objs.get(i); |
| if (obj instanceof Tween) cnt += 1; |
| else cnt += getTweensCount(((Timeline)obj).getChildren()); |
| } |
| return cnt; |
| } |
| |
| private static int getTimelinesCount(List<BaseTween<?>> objs) { |
| int cnt = 0; |
| for (int i=0, n=objs.size(); i<n; i++) { |
| BaseTween<?> obj = objs.get(i); |
| if (obj instanceof Timeline) { |
| cnt += 1 + getTimelinesCount(((Timeline)obj).getChildren()); |
| } |
| } |
| return cnt; |
| } |
| } |