-
-namespace TweenEngine
-{
- int Tween::combinedAttrsLimit = 3;
- int Tween::waypointsLimit = 0;
-
- /**
- * Changes the limit for combined attributes. Defaults to 3 to reduce
- * memory footprint.
- */
- void Tween::setCombinedAttributesLimit(int limit) { Tween::combinedAttrsLimit = limit; }
-
- /**
- * Changes the limit of allowed waypoints for each tween. Defaults to 0 to
- * reduce memory footprint.
- */
- void Tween::setWaypointsLimit(int limit) { Tween::waypointsLimit = limit; }
-
- /**
- * Gets the version number of the library.
- */
- const char *Tween::getVersion() { return "6.3.3"; }
-
- /**
- * Used for debug purpose. Gets the current number of objects that are
- * waiting in the Tween pool.
- */
- int Tween::getPoolSize() { return pool.size(); }
-
- /**
- * Increases the minimum capacity of the pool. Capacity defaults to 20.
- */
- void Tween::ensurePoolCapacity(int minCapacity) { pool.ensureCapacity(minCapacity); }
-
- TweenPool &Tween::pool = *(new TweenPool());
-
- // -------------------------------------------------------------------------
- // Static -- factories
- // -------------------------------------------------------------------------
-
- /**
- * 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).
- *
- *
- * You need to set the target values of the interpolation by using one
- * of the target() methods. The interpolation will run from the
- * starting values to these target values.
- *
- *
- * 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:
- *
- *
- * {@code
- * Tween.to(myObject, POSITION, 1.0f)
- * .target(50, 70)
- * .ease(Quad.INOUT)
- * .start(myManager);
- * }
- *
- * Several options such as delay, repetitions and callbacks can be added to
- * the tween.
- *
- * @param target The target object of the interpolation.
- * @param tweenType The desired type of interpolation.
- * @param duration The duration of the interpolation, in milliseconds.
- * @return The generated Tween.
- */
- Tween &Tween::to(Tweenable& target, int tweenType, float duration)
- {
- Tween &tween = *(pool.get());
- tween.setup(&target, tweenType, duration);
- tween.ease(TweenEquations::easeInOutQuad);
- tween.path(TweenPaths::catmullRom);
- return tween;
- }
-
- /**
- * Factory creating a new reversed interpolation. The ending values are
- * retrieved automatically after the delay (if any).
- *
- *
- * You need to set the starting values of the interpolation by using one
- * of the target() methods. The interpolation will run from the
- * starting values to these target values.
- *
- *
- * 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:
- *
- *
- * {@code
- * Tween.from(myObject, POSITION, 1.0f)
- * .target(0, 0)
- * .ease(Quad.INOUT)
- * .start(myManager);
- * }
- *
- * Several options such as delay, repetitions and callbacks can be added to
- * the tween.
- *
- * @param target The target object of the interpolation.
- * @param tweenType The desired type of interpolation.
- * @param duration The duration of the interpolation, in milliseconds.
- * @return The generated Tween.
- */
- Tween &Tween::from(Tweenable& target, int tweenType, float duration)
- {
- Tween &tween = *(pool.get());
- tween.setup(&target, tweenType, duration);
- tween.ease(TweenEquations::easeInOutQuad);
- tween.path(TweenPaths::catmullRom);
- tween.isFrom = true;
- return tween;
- }
-
- /**
- * Factory creating a new instantaneous interpolation (thus this is not
- * really an interpolation).
- *
- *
- * You need to set the target values of the interpolation by using one
- * of the target() methods. The interpolation will set the target
- * attribute to these values after the delay (if any).
- *
- *
- * 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:
- *
- *
- * {@code
- * Tween.set(myObject, POSITION)
- * .target(50, 70)
- * .delay(1.0f)
- * .start(myManager);
- * }
- *
- * Several options such as delay, repetitions and callbacks can be added to
- * the tween.
- *
- * @param target The target object of the interpolation.
- * @param tweenType The desired type of interpolation.
- * @return The generated Tween.
- */
- Tween &Tween::set(Tweenable& target, int tweenType)
- {
- Tween &tween = *(pool.get());
- tween.setup(&target, tweenType, 0);
- tween.ease(TweenEquations::easeInOutQuad);
- return tween;
- }
-
- /**
- * Factory creating a new timer. The given callback will be triggered on
- * each iteration start, after the delay.
- *
- *
- * 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:
- *
- *
- * {@code
- * Tween.call(myCallback)
- * .delay(1.0f)
- * .repeat(10, 1000)
- * .start(myManager);
- * }
- *
- * @param callback The callback that will be triggered on each iteration
- * start.
- * @return The generated Tween.
- * @see TweenCallback
- */
- Tween &Tween::call(TweenCallback &callback)
- {
- Tween &tween = *(pool.get());
- tween.setup(nullptr, -1, 0);
- tween.setCallback(&callback);
- tween.setCallbackTriggers(TweenCallback::START);
- return tween;
- }
-
- /**
- * Convenience method to create an empty tween. Such object is only useful
- * when placed inside animation sequences (see {@link Timeline}), 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.
- *
- * @return The generated Tween.
- * @see Timeline
- */
- Tween &Tween::mark()
- {
- Tween &tween = *(pool.get());
- tween.setup(nullptr, -1, 0);
- return tween;
- }
-
- // -------------------------------------------------------------------------
- // Setup
- // -------------------------------------------------------------------------
-
- Tween::Tween()
- {
- startValues = new float[combinedAttrsLimit];
- targetValues = new float[combinedAttrsLimit];
- waypoints = new float[waypointsLimit*combinedAttrsLimit];
- accessorBuffer = new float[combinedAttrsLimit];
- accessorBufferSize = combinedAttrsLimit;
- pathBuffer = new float[(2+waypointsLimit)*combinedAttrsLimit];
- pathBufferSize = (2+waypointsLimit)*combinedAttrsLimit;
- targetObj = nullptr;
- }
-
- Tween::~Tween()
- {
- delete startValues;
- delete targetValues;
- delete waypoints;
- delete accessorBuffer;
- delete pathBuffer;
- // if (accessor != nullptr) Block_release(accessor);
- }
-
- void Tween::reset()
- {
- BaseTween::reset();
-
- equation = nullptr;
- pathAlgorithm = nullptr;
- isFrom = isRelative = false;
- combinedAttrsCnt = waypointsCnt = 0;
-
- if (accessorBufferSize != combinedAttrsLimit) {
- accessorBuffer = new float[combinedAttrsLimit];
- }
-
- if (pathBufferSize != (2+waypointsLimit)*combinedAttrsLimit) {
- pathBuffer = new float[(2+waypointsLimit)*combinedAttrsLimit];
- }
-
- // if (accessor != nullptr)
- // {
- // Block_release(accessor);
- targetObj = nullptr;
- // }
- type = -1;
- }
-
- void Tween::setup(Tweenable *target, int tweenType, float duration)
- {
- // assert(duration >= 0);
- this->targetObj = target;
- this->type = tweenType;
- this->duration = duration;
- }
-
- // -------------------------------------------------------------------------
- // Public API
- // -------------------------------------------------------------------------
-
- /**
- * Sets the easing equation of the tween. Existing equations are located in
- * aurelienribon.tweenengine.equations package, but you can of course
- * implement your owns, see {@link TweenEquation}. You can also use the
- * {@link TweenEquations} static instances to quickly access all the
- * equations. Default equation is Quad.INOUT.
- *
- *
- * Proposed equations are:
- * - Linear.INOUT,
- * - Quad.IN | OUT | INOUT,
- * - Cubic.IN | OUT | INOUT,
- * - Quart.IN | OUT | INOUT,
- * - Quint.IN | OUT | INOUT,
- * - Circ.IN | OUT | INOUT,
- * - Sine.IN | OUT | INOUT,
- * - Expo.IN | OUT | INOUT,
- * - Back.IN | OUT | INOUT,
- * - Bounce.IN | OUT | INOUT,
- * - Elastic.IN | OUT | INOUT
- *
- * @return The current tween, for chaining instructions.
- * @see TweenEquation
- * @see TweenEquations
- */
- Tween &Tween::ease(TweenEquation &easeEquation)
- {
- this->equation = &easeEquation;
- return *this;
- }
-
- /**
- * Sets the target value of the interpolation. The interpolation will run
- * from the value at start time (after the delay, if any) to this
- * target value.
- *
- *
- * To sum-up:
- * - start value: value at start time, after delay
- * - end value: param
- *
- * @param targetValue The target value of the interpolation.
- * @return The current tween, for chaining instructions.
- */
- Tween &Tween::target(float targetValue)
- {
- targetValues[0] = targetValue;
- return *this;
- }
-
- /**
- * Sets the target values of the interpolation. The interpolation will run
- * from the values at start time (after the delay, if any) to these
- * target values.
- *
- *
- * To sum-up:
- * - start values: values at start time, after delay
- * - end values: params
- *
- * @param targetValue1 The 1st target value of the interpolation.
- * @param targetValue2 The 2nd target value of the interpolation.
- * @return The current tween, for chaining instructions.
- */
- Tween &Tween::target(float targetValue1, float targetValue2)
- {
- targetValues[0] = targetValue1;
- targetValues[1] = targetValue2;
- return *this;
- }
-
- /**
- * Sets the target values of the interpolation. The interpolation will run
- * from the values at start time (after the delay, if any) to these
- * target values.
- *
- *
- * To sum-up:
- * - start values: values at start time, after delay
- * - end values: params
- *
- * @param targetValue1 The 1st target value of the interpolation.
- * @param targetValue2 The 2nd target value of the interpolation.
- * @param targetValue3 The 3rd target value of the interpolation.
- * @return The current tween, for chaining instructions.
- */
- Tween &Tween::target(float targetValue1, float targetValue2, float targetValue3)
- {
- targetValues[0] = targetValue1;
- targetValues[1] = targetValue2;
- targetValues[2] = targetValue3;
- return *this;
- }
-
- Tween &Tween::target(float *targetValues, int len)
- {
- if (len <= combinedAttrsLimit)
- {
- for (int i=0; itargetValues[i] = targetValues[i];
- }
- return *this;
- }
-
- /**
- * Sets the target value of the interpolation, relatively to the value
- * at start time (after the delay, if any).
- *
- *
- * To sum-up:
- * - start value: value at start time, after delay
- * - end value: param + value at start time, after delay
- *
- * @param targetValue The relative target value of the interpolation.
- * @return The current tween, for chaining instructions.
- */
- Tween &Tween::targetRelative(float targetValue)
- {
- isRelative = true;
- targetValues[0] = isInitialized() ? targetValue + startValues[0] : targetValue;
- return *this;
- }
-
- /**
- * Sets the target values of the interpolation, relatively to the values
- * at start time (after the delay, if any).
- *
- *
- * To sum-up:
- * - start values: values at start time, after delay
- * - end values: params + values at start time, after delay
- *
- * @param targetValue1 The 1st relative target value of the interpolation.
- * @param targetValue2 The 2nd relative target value of the interpolation.
- * @return The current tween, for chaining instructions.
- */
- Tween &Tween::targetRelative(float targetValue1, float targetValue2)
- {
- isRelative = true;
- targetValues[0] = isInitialized() ? targetValue1 + startValues[0] : targetValue1;
- targetValues[1] = isInitialized() ? targetValue2 + startValues[1] : targetValue2;
- return *this;
- }
-
- /**
- * Sets the target values of the interpolation, relatively to the values
- * at start time (after the delay, if any).
- *
- *
- * To sum-up:
- * - start values: values at start time, after delay
- * - end values: params + values at start time, after delay
- *
- * @param targetValue1 The 1st relative target value of the interpolation.
- * @param targetValue2 The 2nd relative target value of the interpolation.
- * @param targetValue3 The 3rd relative target value of the interpolation.
- * @return The current tween, for chaining instructions.
- */
- Tween &Tween::targetRelative(float targetValue1, float targetValue2, float targetValue3)
- {
- isRelative = true;
- targetValues[0] = isInitialized() ? targetValue1 + startValues[0] : targetValue1;
- targetValues[1] = isInitialized() ? targetValue2 + startValues[1] : targetValue2;
- targetValues[2] = isInitialized() ? targetValue3 + startValues[2] : targetValue3;
- return *this;
- }
-
- /**
- * Sets the target values of the interpolation, relatively to the values
- * at start time (after the delay, if any).
- *
- *
- * To sum-up:
- * - start values: values at start time, after delay
- * - end values: params + values at start time, after delay
- *
- * @param targetValues The relative target values of the interpolation.
- * @return The current tween, for chaining instructions.
- */
- Tween &Tween::targetRelative(float *targetValues, int len)
- {
- if (len <= combinedAttrsLimit)
- {
- for (int i=0; itargetValues[i] = isInitialized() ? targetValues[i] + startValues[i] : targetValues[i];
- }
-
- isRelative = true;
- return *this;
- }
-
- /**
- * Adds a waypoint to the path. The default path runs from the start values
- * to the end values linearly. If you add waypoints, the default path will
- * use a smooth catmull-rom spline to navigate between the waypoints, but
- * you can change this behavior by using the {@link #path(TweenPath)}
- * method.
- *
- * Note that if you want waypoints relative to the start values, use one of
- * the .targetRelative() methods to define your target.
- *
- * @param targetValue The target of this waypoint.
- * @return The current tween, for chaining instructions.
- */
- Tween &Tween::waypoint(float targetValue)
- {
- if (waypointsCnt < waypointsLimit)
- {
- waypoints[waypointsCnt] = targetValue;
- waypointsCnt += 1;
- }
-
- return *this;
- }
-
- /**
- * Adds a waypoint to the path. The default path runs from the start values
- * to the end values linearly. If you add waypoints, the default path will
- * use a smooth catmull-rom spline to navigate between the waypoints, but
- * you can change this behavior by using the {@link #path(TweenPath)}
- * method.
- *
- * Note that if you want waypoints relative to the start values, use one of
- * the .targetRelative() methods to define your target.
- *
- * @param targetValue1 The 1st target of this waypoint.
- * @param targetValue2 The 2nd target of this waypoint.
- * @return The current tween, for chaining instructions.
- */
- Tween &Tween::waypoint(float targetValue1, float targetValue2)
- {
- if (waypointsCnt < waypointsLimit)
- {
- waypoints[waypointsCnt*2] = targetValue1;
- waypoints[waypointsCnt*2+1] = targetValue2;
- waypointsCnt += 1;
- }
-
- return *this;
- }
-
- /**
- * Adds a waypoint to the path. The default path runs from the start values
- * to the end values linearly. If you add waypoints, the default path will
- * use a smooth catmull-rom spline to navigate between the waypoints, but
- * you can change this behavior by using the {@link #path(TweenPath)}
- * method.
- *
- * Note that if you want waypoints relative to the start values, use one of
- * the .targetRelative() methods to define your target.
- *
- * @param targetValue1 The 1st target of this waypoint.
- * @param targetValue2 The 2nd target of this waypoint.
- * @param targetValue3 The 3rd target of this waypoint.
- * @return The current tween, for chaining instructions.
- */
- Tween &Tween::waypoint(float targetValue1, float targetValue2, float targetValue3)
- {
- if (waypointsCnt < waypointsLimit)
- {
- waypoints[waypointsCnt*3] = targetValue1;
- waypoints[waypointsCnt*3+1] = targetValue2;
- waypoints[waypointsCnt*3+2] = targetValue3;
- waypointsCnt += 1;
- }
- return *this;
- }
-
- /**
- * Adds a waypoint to the path. The default path runs from the start values
- * to the end values linearly. If you add waypoints, the default path will
- * use a smooth catmull-rom spline to navigate between the waypoints, but
- * you can change this behavior by using the {@link #path(TweenPath)}
- * method.
- *
- * Note that if you want waypoints relative to the start values, use one of
- * the .targetRelative() methods to define your target.
- *
- * @param targetValues The targets of this waypoint.
- * @return The current tween, for chaining instructions.
- */
- Tween &Tween::waypoint(float *targetValues, int len)
- {
- if (waypointsCnt < waypointsLimit)
- {
- for (int i=0; iwaypoints[waypointsCnt*len+i] = targetValues[i];
- waypointsCnt += 1;
- }
- return *this;
- }
-
- /**
- * Sets the algorithm that will be used to navigate through the waypoints,
- * from the start values to the end values. Default is a catmull-rom spline,
- * but you can find other paths in the {@link TweenPaths} class.
- *
- * @param path A TweenPath implementation.
- * @return The current tween, for chaining instructions.
- * @see TweenPath
- * @see TweenPaths
- */
- Tween &Tween::path(TweenPath &path)
- {
- this->pathAlgorithm = &path;
- return *this;
- }
-
- // -------------------------------------------------------------------------
- // Getters
- // -------------------------------------------------------------------------
-
- /**
- * Gets the easing equation.
- */
- TweenEquation *Tween::getEasing() { return equation; }
-
- /**
- * Gets the target values. The returned buffer is as long as the maximum
- * allowed combined values. Therefore, you're surely not interested in all
- * its content. Use {@link #getCombinedTweenCount()} to get the number of
- * interesting slots.
- */
- float *Tween::getTargetValues() { return targetValues; }
-
- /**
- * Gets the number of combined animations.
- */
- int Tween::getCombinedAttributesCount() { return combinedAttrsCnt; }
-
- // -------------------------------------------------------------------------
- // Base Class
- // -------------------------------------------------------------------------
-
- Tween &Tween::build()
- {
- if (targetObj != nullptr) {
- combinedAttrsCnt = targetObj->getValues(type, accessorBuffer);
- }
- // assert(combinedAttrsCnt <= combinedAttrsLimit);
- return *this;
- }
-
- void Tween::free() { pool.free(this); }
-
- void Tween::initializeOverride()
- {
- targetObj->getValues(type, startValues);
-
- for (int i=0; i lastStep)
- {
- targetObj->setValues(type, isReverse(lastStep) ? startValues : targetValues);
- return;
- }
-
- if (!isIterationStep && step < lastStep)
- {
- targetObj->setValues(type, isReverse(lastStep) ? targetValues : startValues);
- return;
- }
-
- // Validation
-
- // assert(isIterationStep);
- // assert(getCurrentTime() >= 0);
- // assert(getCurrentTime() <= duration);
-
- // Case duration equals zero
-
- if (duration < 0.00000000001f && delta > -0.00000000001f)
- {
- targetObj->setValues(type, isReverse(step) ? targetValues : startValues);
- return;
- }
-
- if (duration < 0.00000000001f && delta < 0.00000000001f) {
- targetObj->setValues(type, isReverse(step) ? startValues : targetValues);
- return;
- }
-
- // Normal behavior
-
- float time = isReverse(step) ? duration - getCurrentTime() : getCurrentTime();
- float t = equation->compute(time/duration);
-
- if (waypointsCnt == 0 || pathAlgorithm == nullptr)
- {
- for (int i=0; icompute(t, pathBuffer, waypointsCnt+2);
- }
- }
-
- targetObj->setValues(type, accessorBuffer);
- }
-
- void Tween::forceStartValues(){
- targetObj->setValues(type, startValues);
- }
-
- void Tween::forceEndValues(){
- targetObj->setValues(type, targetValues);
- }
-
- int Tween::getTweenCount() { return 1; }
-
- int Tween::getTimelineCount() { return 0; }
-
-}
\ No newline at end of file
diff --git a/external/tween-engine/src/TweenEquations.cpp b/external/tween-engine/src/TweenEquations.cpp
deleted file mode 100644
index 335b827..0000000
--- a/external/tween-engine/src/TweenEquations.cpp
+++ /dev/null
@@ -1,53 +0,0 @@
-//
-// Equations.cpp
-//
-// This code is derived from Universal Tween Engine
-// Licensed under Apache License 2.0 - http://www.apache.org/licenses/LICENSE-2.0
-//
-
-#include
-
-namespace TweenEngine
-{
- TweenEquation &TweenEquations::easeInQuad = *(new QuadIn());
- TweenEquation &TweenEquations::easeOutQuad = *(new QuadOut());
- TweenEquation &TweenEquations::easeInOutQuad = *(new QuadInOut());
-
- TweenEquation &TweenEquations::easeInOutLinear = *(new LinearInOut());
-
- TweenEquation &TweenEquations::easeInBack = *(new BackIn());
- TweenEquation &TweenEquations::easeOutBack = *(new BackOut());
- TweenEquation &TweenEquations::easeInOutBack = *(new BackInOut());
-
- TweenEquation &TweenEquations::easeInBounce = *(new BounceIn());
- TweenEquation &TweenEquations::easeOutBounce = *(new BounceOut());
- TweenEquation &TweenEquations::easeInOutBounce = *(new BounceInOut());
-
- TweenEquation &TweenEquations::easeInCirc = *(new CircIn());
- TweenEquation &TweenEquations::easeOutCirc = *(new CircOut());
- TweenEquation &TweenEquations::easeInOutCirc = *(new CircInOut());
-
- TweenEquation &TweenEquations::easeInCubic = *(new CubicIn());
- TweenEquation &TweenEquations::easeOutCubic = *(new CubicOut());
- TweenEquation &TweenEquations::easeInOutCubic = *(new CubicInOut());
-
- TweenEquation &TweenEquations::easeInElastic = *(new ElasticIn());
- TweenEquation &TweenEquations::easeOutElastic = *(new ElasticOut());
- TweenEquation &TweenEquations::easeInOutElastic = *(new ElasticInOut());
-
- TweenEquation &TweenEquations::easeInExpo = *(new ExpoIn());
- TweenEquation &TweenEquations::easeOutExpo = *(new ExpoOut());
- TweenEquation &TweenEquations::easeInOutExpo = *(new ExpoInOut());
-
- TweenEquation &TweenEquations::easeInQuart = *(new QuartIn());
- TweenEquation &TweenEquations::easeOutQuart = *(new QuartOut());
- TweenEquation &TweenEquations::easeInOutQuart = *(new QuartInOut());
-
- TweenEquation &TweenEquations::easeInQuint = *(new QuintIn());
- TweenEquation &TweenEquations::easeOutQuint = *(new QuintOut());
- TweenEquation &TweenEquations::easeInOutQuint = *(new QuintInOut());
-
- TweenEquation &TweenEquations::easeInSine = *(new SineIn());
- TweenEquation &TweenEquations::easeOutSine = *(new SineOut());
- TweenEquation &TweenEquations::easeInOutSine = *(new SineInOut());
-}
\ No newline at end of file
diff --git a/external/tween-engine/src/TweenManager.cpp b/external/tween-engine/src/TweenManager.cpp
deleted file mode 100644
index ee535f0..0000000
--- a/external/tween-engine/src/TweenManager.cpp
+++ /dev/null
@@ -1,186 +0,0 @@
-//
-// TweenManager.cpp
-//
-// This code is derived from Universal Tween Engine
-// Licensed under Apache License 2.0 - http://www.apache.org/licenses/LICENSE-2.0
-//
-
-#include
-#include
-
-namespace TweenEngine
-{
- // -------------------------------------------------------------------------
- // 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.
- */
- void TweenManager::setAutoRemove(BaseTween &object, bool 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.
- */
- void TweenManager::setAutoStart(BaseTween &object, bool value)
- {
- object.isAutoStartEnabled = value;
- }
-
- int getTweensCount(std::vector objs)
- {
- int cnt = 0;
- for (int i=0, n=objs.size(); igetTweenCount();
- }
- return cnt;
- }
-
- int getTimelinesCount(std::vector objs)
- {
- int cnt = 0;
- for (int i=0, n=objs.size(); igetTimelineCount();
- }
- return cnt;
- }
-
- bool isTweenFinished(BaseTween *obj)
- {
- if (obj->isFinished() && obj->isAutoRemoveEnabled)
- {
- obj->free();
- return true;
- }
- return false;
- }
-
- // -------------------------------------------------------------------------
- // API
- // -------------------------------------------------------------------------
-
- TweenManager::TweenManager() : objects()
- {
- objects.reserve(20);
- }
-
- /**
- * Adds a tween or timeline to the manager and starts or restarts it.
- *
- * @return The manager, for instruction chaining.
- */
- TweenManager &TweenManager::add(BaseTween &object)
- {
- bool isPresent = (std::find(objects.begin(), objects.end(), &object) != objects.end());
- if (!isPresent) objects.push_back(&object);
- if (object.isAutoStartEnabled) object.start();
- return *this;
- }
-
- /**
- * Kills every managed tweens and timelines.
- */
- void TweenManager::killAll()
- {
- for (int i=0, n=objects.size(); ikill();
- }
- }
-
- /**
- * Increases the minimum capacity of the manager. Defaults to 20.
- */
- void TweenManager::ensureCapacity(int minCapacity) { objects.reserve(minCapacity); }
-
- /**
- * Pauses the manager. Further update calls won't have any effect.
- */
- void TweenManager::pause() { isPaused = true; }
-
- /**
- * Resumes the manager, if paused.
- */
- void TweenManager::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.
- *
- *
- * 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.
- */
-
- void TweenManager::update(float delta)
- {
- // Remove tweens that are finished
- objects.erase(std::remove_if(objects.begin(),objects.end(),isTweenFinished), objects.end());
-
- if (!isPaused)
- {
- if (delta >= 0)
- {
- for (int i=0, n=objects.size(); iupdate(delta);
- }
- else
- {
- for (int i=objects.size()-1; i>=0; i--) objects[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.
- *
- * To get the count of running tweens, see {@link #getRunningTweensCount()}.
- */
- int TweenManager::size() { return objects.size(); }
-
- /**
- * Gets the number of running tweens. This number includes the tweens
- * located inside timelines (and nested timelines).
- *
- * Provided for debug purpose only.
- */
- int TweenManager::getRunningTweensCount() { return getTweensCount(objects); }
-
- /**
- * Gets the number of running timelines. This number includes the timelines
- * nested inside other timelines.
- *
- * Provided for debug purpose only.
- */
- int TweenManager::getRunningTimelinesCount() { return getTimelinesCount(objects); }
-
- /**
- * Gets a list of every managed object.
- *
- * Provided for debug purpose only.
- */
- std::vector &TweenManager::getObjects()
- {
- return objects;
- }
-
-}
diff --git a/external/tween-engine/src/TweenPaths.cpp b/external/tween-engine/src/TweenPaths.cpp
deleted file mode 100644
index b664b85..0000000
--- a/external/tween-engine/src/TweenPaths.cpp
+++ /dev/null
@@ -1,17 +0,0 @@
-//
-// TweenPaths.cpp
-//
-// This code is derived from Universal Tween Engine
-// Licensed under Apache License 2.0 - http://www.apache.org/licenses/LICENSE-2.0
-//
-
-#include
-
-#include
-#include
-
-namespace TweenEngine
-{
- TweenPath &TweenPaths::linear = *(new LinearPath());
- TweenPath &TweenPaths::catmullRom = *(new CatmullRom());
-}
\ No newline at end of file
diff --git a/external/tween-engine/src/TweenPool.cpp b/external/tween-engine/src/TweenPool.cpp
deleted file mode 100644
index f092f86..0000000
--- a/external/tween-engine/src/TweenPool.cpp
+++ /dev/null
@@ -1,39 +0,0 @@
-//
-// TweenPool.cpp
-//
-// This code is derived from Universal Tween Engine
-// Licensed under Apache License 2.0 - http://www.apache.org/licenses/LICENSE-2.0
-//
-
-#include
-#include
-
-namespace TweenEngine
-{
- void TweenPoolCallback::onPool(Tween *obj)
- {
- obj->reset();
- }
-
- void TweenPoolCallback::onUnPool(Tween *obj)
- {
- obj->reset();
- }
-
- TweenPool::TweenPool() : Pool(20, new TweenPoolCallback())
- {
- }
-
- Tween *TweenPool::create() { return new Tween(); }
-
- //TweenPoolCallback *Tween::poolCallback = new TweenPoolCallback();
- //TweenPool *Tween::pool = new TweenPool(20, Tween::poolCallback);
-
- /*
- private static final Pool pool = new Pool(20, poolCallback) {
- @Override protected Tween create() {return new Tween();}
- };
- */
-
-
-}
\ No newline at end of file
diff --git a/external/tween-engine/src/equations/Back.cpp b/external/tween-engine/src/equations/Back.cpp
deleted file mode 100644
index 5b34bf9..0000000
--- a/external/tween-engine/src/equations/Back.cpp
+++ /dev/null
@@ -1,34 +0,0 @@
-//
-// Back.cpp
-//
-// This code is derived from Universal Tween Engine
-// Licensed under Apache License 2.0 - http://www.apache.org/licenses/LICENSE-2.0
-//
-
-#include
-
-#define S (1.70158f)
-
-namespace TweenEngine
-{
- float BackIn::compute(float t) { return t*t*((S+1)*t - S); }
- const char *BackIn::toString() { return "Back.IN"; }
-
- float BackOut::compute(float t) {
- t -= 1;
- return (t*t*((S+1)*t + S) + 1);
- }
- const char *BackOut::toString() { return "Back.OUT"; }
-
- float BackInOut::compute(float t) {
- float s=S*1.525;
- t*=2;
- if (t < 1) {
- return 0.5f*(t*t*((s+1)*t - s));
- } else {
- t -= 2;
- return 0.5f*(t*t*((s+1)*t + s) + 2);
- }
- }
- const char *BackInOut::toString() { return "Back.INOUT"; }
-}
diff --git a/external/tween-engine/src/equations/Bounce.cpp b/external/tween-engine/src/equations/Bounce.cpp
deleted file mode 100644
index 8cb6b5c..0000000
--- a/external/tween-engine/src/equations/Bounce.cpp
+++ /dev/null
@@ -1,42 +0,0 @@
-//
-// Bounce.cpp
-//
-// This code is derived from Universal Tween Engine
-// Licensed under Apache License 2.0 - http://www.apache.org/licenses/LICENSE-2.0
-//
-
-#include
-
-namespace TweenEngine
-{
- inline float outBounce(float t) {
- if (t < (1/2.75)) {
- return 7.5625f*t*t;
- } else if (t < (2/2.75)) {
- t = t - (1.5 / 2.75);
- return (7.5625 * t * t + 0.75);
- } else if (t < (2.5/2.75)) {
- t = t - (2.25 / 2.75);
- return (7.5625 * t * t + 0.9375);
- } else {
- t = t - (2.625 / 2.75);
- return (7.5625 * t * t + 0.984375);
- }
- }
-
- inline float inBounce(float t) {
- return 1 - outBounce(1-t);
- }
-
- float BounceIn::compute(float t) { return inBounce(t); }
- const char *BounceIn::toString() { return "Bounce.IN"; }
-
- float BounceOut::compute(float t) { return outBounce(t); }
- const char *BounceOut::toString() { return "Bounce.OUT"; }
-
- float BounceInOut::compute(float t) {
- if (t < 0.5f) return (inBounce(t*2) * 0.5f);
- else return (outBounce(t*2-1) * 0.5f + 0.5f);
- }
- const char *BounceInOut::toString() { return "Bounce.INOUT"; }
-}
diff --git a/external/tween-engine/src/equations/Circ.cpp b/external/tween-engine/src/equations/Circ.cpp
deleted file mode 100644
index fe93f57..0000000
--- a/external/tween-engine/src/equations/Circ.cpp
+++ /dev/null
@@ -1,30 +0,0 @@
-//
-// Circ.cpp
-//
-// This code is derived from Universal Tween Engine
-// Licensed under Apache License 2.0 - http://www.apache.org/licenses/LICENSE-2.0
-//
-
-#include
-#include
-
-namespace TweenEngine
-{
- float CircIn::compute(float t) { return (float) -sqrt(1 - t*t) - 1; }
- const char *CircIn::toString() { return "Circ.IN"; }
-
- float CircOut::compute(float t) { return (float) sqrt(1 - (t-1)*(t-1)); }
- const char *CircOut::toString() { return "Circ.OUT"; }
-
- float CircInOut::compute(float t) {
- t *= 2;
- if (t < 1) {
- return (-0.5 * (sqrt(1 - t*t) - 1));
- } else {
- t -= 2;
- return (0.5 * (sqrt(1 - t*t) + 1));
- }
- }
-
- const char *CircInOut::toString() { return "Circ.INOUT"; }
-}
diff --git a/external/tween-engine/src/equations/Cubic.cpp b/external/tween-engine/src/equations/Cubic.cpp
deleted file mode 100644
index 990998e..0000000
--- a/external/tween-engine/src/equations/Cubic.cpp
+++ /dev/null
@@ -1,31 +0,0 @@
-//
-// Cubic.cpp
-//
-// This code is derived from Universal Tween Engine
-// Licensed under Apache License 2.0 - http://www.apache.org/licenses/LICENSE-2.0
-//
-
-#include
-
-namespace TweenEngine
-{
- float CubicIn::compute(float t) { return t*t*t; }
- const char *CubicIn::toString() { return "Cubic.IN"; }
-
- float CubicOut::compute(float t) {
- t -= 1;
- return t*t*t + 1;
- }
- const char *CubicOut::toString() { return "Cubic.OUT"; }
-
- float CubicInOut::compute(float t) {
- t *= 2;
- if (t < 1) {
- return 0.5f * t*t*t;
- } else {
- t -= 2;
- return 0.5f * (t*t*t + 2);
- }
- }
- const char *CubicInOut::toString() { return "Cubic.INOUT"; }
-}
diff --git a/external/tween-engine/src/equations/Elastic.cpp b/external/tween-engine/src/equations/Elastic.cpp
deleted file mode 100644
index 421f5a7..0000000
--- a/external/tween-engine/src/equations/Elastic.cpp
+++ /dev/null
@@ -1,80 +0,0 @@
-//
-// Elastic.cpp
-//
-// This code is derived from Universal Tween Engine
-// Licensed under Apache License 2.0 - http://www.apache.org/licenses/LICENSE-2.0
-//
-
-#include
-#include
-
-#define M_PI 3.14159265358979323846
-#define M_TWOPI (M_PI * 2.0)
-
-namespace TweenEngine
-{
- float ElasticIn::compute(float t) {
- float a = amplitude;
- float p = period;
- if (t == 0) return 0;
- if (t == 1) return 1;
- if (!isPeriodSet) p = 0.3;
- float s;
- if (!isAmplitudeSet || a < 1) {
- a = 1;
- s = p/4.0;
- } else {
- s = p/(M_TWOPI) * (float)asin(1/a);
- }
- t -= 1;
- return -(a*(float)pow(2,10*t) * (float)sin((t-s)*(M_TWOPI)/p ));
- }
- const char *ElasticIn::toString() { return "Elastic.IN"; }
- void ElasticIn::setAmplitude(float a) { this->amplitude = a; this->isAmplitudeSet = true; }
- void ElasticIn::setPeriod(float p) { this->period = p; this->isPeriodSet = true; }
-
- float ElasticOut::compute(float t) {
- float a = amplitude;
- float p = period;
- if (t==0) return 0;
- if (t==1) return 1;
- if (!isPeriodSet) p = 0.3f;
- float s;
- if (!isAmplitudeSet || a < 1) {
- a = 1;
- s = p/4.0;
- } else {
- s = p/(M_TWOPI) * (float)asin(1/a);
- }
- return a*(float)pow(2,-10*t) * (float)sin((t-s)*(M_TWOPI)/p ) + 1;
- }
- const char *ElasticOut::toString() { return "Elastic.OUT"; }
- void ElasticOut::setAmplitude(float a) { this->amplitude = a; this->isAmplitudeSet = true; }
- void ElasticOut::setPeriod(float p) { this->period = p; this->isPeriodSet = true; }
-
- float ElasticInOut::compute(float t) {
- float a = amplitude;
- float p = period;
- if (t==0) return 0;
- t *= 2;
- if (t==2) return 1;
- if (!isPeriodSet) p = 0.3f*1.5f;
- float s;
- if (!isAmplitudeSet || a < 1) {
- a = 1;
- s = p/4.0;
- } else {
- s = p/(M_TWOPI) * (float)asin(1/a);
- }
- if (t < 1) {
- t -= 1;
- return -0.5f*(a*(float)pow(2,10*t) * (float)sin((t-s)*(M_TWOPI)/p));
- } else {
- t -= 1;
- return a*(float)pow(2,-10*t) * (float)sin((t-s)*(M_TWOPI)/p)*0.5f + 1;
- }
- }
- const char *ElasticInOut::toString() { return "Elastic.INOUT"; }
- void ElasticInOut::setAmplitude(float a) { this->amplitude = a; this->isAmplitudeSet = true; }
- void ElasticInOut::setPeriod(float p) { this->period = p; this->isPeriodSet = true; }
-}
diff --git a/external/tween-engine/src/equations/Expo.cpp b/external/tween-engine/src/equations/Expo.cpp
deleted file mode 100644
index 4e4f9aa..0000000
--- a/external/tween-engine/src/equations/Expo.cpp
+++ /dev/null
@@ -1,35 +0,0 @@
-//
-// Expo.cpp
-//
-// This code is derived from Universal Tween Engine
-// Licensed under Apache License 2.0 - http://www.apache.org/licenses/LICENSE-2.0
-//
-
-#include
-#include
-
-namespace TweenEngine
-{
- float ExpoIn::compute(float t) {
- return (t==0) ? 0 : (float)pow(2,10*(t-1));
- }
- const char *ExpoIn::toString() { return "Expo.IN"; }
-
- float ExpoOut::compute(float t) {
- return (t==1) ? 1 : -(float)pow(2,-10*t) + 1;
- }
- const char *ExpoOut::toString() { return "Expo.OUT"; }
-
- float ExpoInOut::compute(float t) {
- if (t==0) return 0;
- if (t==1) return 1;
- t *= 2;
- if (t < 1) {
- return 0.5f * (float)pow(2,10*(t-1));
- } else {
- t -= 1;
- return 0.5f * (-(float)pow(2,-10*t) + 2);
- }
- }
- const char *ExpoInOut::toString() { return "Expo.INOUT"; }
-}
diff --git a/external/tween-engine/src/equations/Linear.cpp b/external/tween-engine/src/equations/Linear.cpp
deleted file mode 100644
index 139b809..0000000
--- a/external/tween-engine/src/equations/Linear.cpp
+++ /dev/null
@@ -1,20 +0,0 @@
-//
-// Linear.cpp
-// This code is derived from Universal Tween Engine
-// Licensed under Apache License 2.0 - http://www.apache.org/licenses/LICENSE-2.0
-//
-
-/**
- * Easing equation based on Robert Penner's work:
- * http://robertpenner.com/easing/
- * @author Aurelien Ribon | http://www.aurelienribon.com/
- */
-
-#include
-
-namespace TweenEngine
-{
- float LinearInOut::compute(float t) { return t; }
- const char *LinearInOut::toString() { return "Linear.INOUT"; }
-
-}
\ No newline at end of file
diff --git a/external/tween-engine/src/equations/Quad.cpp b/external/tween-engine/src/equations/Quad.cpp
deleted file mode 100644
index fb9bcf1..0000000
--- a/external/tween-engine/src/equations/Quad.cpp
+++ /dev/null
@@ -1,31 +0,0 @@
-//
-// Quad.cpp
-//
-// This code is derived from Universal Tween Engine
-// Licensed under Apache License 2.0 - http://www.apache.org/licenses/LICENSE-2.0
-//
-
-/**
- * Easing equation based on Robert Penner's work:
- * http://robertpenner.com/easing/
- * @author Aurelien Ribon | http://www.aurelienribon.com/
- */
-
-#include
-
-namespace TweenEngine
-{
- float QuadIn::compute(float t) { return t*t; }
- const char *QuadIn::toString() { return "Quad.IN"; }
-
- float QuadOut::compute(float t) { return -t*(t-2); }
- const char *QuadOut::toString() { return "Quad.OUT"; }
-
- float QuadInOut::compute(float t)
- {
- t*=2;
- if (t < 1) return 0.5f*t*t;
- return -0.5f * ((t-1)*(t-3) - 1);
- }
- const char *QuadInOut::toString() { return "Quad.INOUT"; }
-}
diff --git a/external/tween-engine/src/equations/Quart.cpp b/external/tween-engine/src/equations/Quart.cpp
deleted file mode 100644
index 3fc2357..0000000
--- a/external/tween-engine/src/equations/Quart.cpp
+++ /dev/null
@@ -1,31 +0,0 @@
-//
-// Quart.cpp
-//
-// This code is derived from Universal Tween Engine
-// Licensed under Apache License 2.0 - http://www.apache.org/licenses/LICENSE-2.0
-//
-
-#include
-
-namespace TweenEngine
-{
- float QuartIn::compute(float t) { return t*t*t*t; }
- const char *QuartIn::toString() { return "Quart.IN"; }
-
- float QuartOut::compute(float t) {
- t-=1;
- return -(t*t*t*t - 1);
- }
- const char *QuartOut::toString() { return "Quart.OUT"; }
-
- float QuartInOut::compute(float t) {
- t *= 2;
- if (t < 1) {
- return 0.5f*t*t*t*t;
- } else {
- t -= 2;
- return -0.5f * (t*t*t*t - 2);
- }
- }
- const char *QuartInOut::toString() { return "Quart.INOUT"; }
-}
diff --git a/external/tween-engine/src/equations/Quint.cpp b/external/tween-engine/src/equations/Quint.cpp
deleted file mode 100644
index 3f7ab67..0000000
--- a/external/tween-engine/src/equations/Quint.cpp
+++ /dev/null
@@ -1,31 +0,0 @@
-//
-// Quint.cpp
-//
-// This code is derived from Universal Tween Engine
-// Licensed under Apache License 2.0 - http://www.apache.org/licenses/LICENSE-2.0
-//
-
-#include
-
-namespace TweenEngine
-{
- float QuintIn::compute(float t) { return t*t*t*t*t; }
- const char *QuintIn::toString() { return "Quint.IN"; }
-
- float QuintOut::compute(float t) {
- t-=1;
- return -(t*t*t*t*t - 1);
- }
- const char *QuintOut::toString() { return "Quint.OUT"; }
-
- float QuintInOut::compute(float t) {
- t *= 2;
- if (t < 1) {
- return 0.5f*t*t*t*t*t;
- } else {
- t -= 2;
- return -0.5f * (t*t*t*t*t - 2);
- }
- }
- const char *QuintInOut::toString() { return "Quint.INOUT"; }
-}
diff --git a/external/tween-engine/src/equations/Sine.cpp b/external/tween-engine/src/equations/Sine.cpp
deleted file mode 100644
index 4248f2d..0000000
--- a/external/tween-engine/src/equations/Sine.cpp
+++ /dev/null
@@ -1,24 +0,0 @@
-//
-// Sine.cpp
-//
-// This code is derived from Universal Tween Engine
-// Licensed under Apache License 2.0 - http://www.apache.org/licenses/LICENSE-2.0
-//
-
-#include
-#include
-
-#define M_PI 3.14159265358979323846
-#define M_PI_2 1.57079632679489661923
-
-namespace TweenEngine
-{
- float SineIn::compute(float t) { return (float)-cos(t * (M_PI_2)) + 1; }
- const char *SineIn::toString() { return "Sine.IN"; }
-
- float SineOut::compute(float t) { return (float)sin(t * (M_PI_2)); }
- const char *SineOut::toString() { return "Sine.OUT"; }
-
- float SineInOut::compute(float t) { return -0.5f * ((float)cos(M_PI*t) - 1); }
- const char *SineInOut::toString() { return "Sine.INOUT"; }
-}
diff --git a/external/tween-engine/src/paths/CatmullRom.cpp b/external/tween-engine/src/paths/CatmullRom.cpp
deleted file mode 100644
index 11918ab..0000000
--- a/external/tween-engine/src/paths/CatmullRom.cpp
+++ /dev/null
@@ -1,47 +0,0 @@
-//
-// CatmullRom.cpp
-//
-// This code is derived from Universal Tween Engine
-// Licensed under Apache License 2.0 - http://www.apache.org/licenses/LICENSE-2.0
-//
-
-#include
-#include
-
-namespace TweenEngine
-{
- float CatmullRom::compute(float t, float *points, int pointsCnt)
- {
- int segment = (int) floor((pointsCnt-1) * t);
- segment = segment > 0 ? segment : 0;
- segment = segment < (pointsCnt-2) ? segment : pointsCnt-2;
-
- t = t * (pointsCnt-1) - segment;
-
- if (segment == 0)
- {
- return catmullRomSpline(points[0], points[0], points[1], points[2], t);
- }
-
- if (segment == pointsCnt-2)
- {
- return catmullRomSpline(points[pointsCnt-3], points[pointsCnt-2], points[pointsCnt-1], points[pointsCnt-1], t);
- }
-
- return catmullRomSpline(points[segment-1], points[segment], points[segment+1], points[segment+2], t);
- }
-
- float CatmullRom::catmullRomSpline(float a, float b, float c, float d, float t)
- {
- float t1 = (c - a) * 0.5f;
- float t2 = (d - b) * 0.5f;
-
- float h1 = +2 * t * t * t - 3 * t * t + 1;
- float h2 = -2 * t * t * t + 3 * t * t;
- float h3 = t * t * t - 2 * t * t + t;
- float h4 = t * t * t - t * t;
-
- return b * h1 + c * h2 + t1 * h3 + t2 * h4;
- }
-
-}
\ No newline at end of file
diff --git a/external/tween-engine/src/paths/LinearPath.cpp b/external/tween-engine/src/paths/LinearPath.cpp
deleted file mode 100644
index 47f9633..0000000
--- a/external/tween-engine/src/paths/LinearPath.cpp
+++ /dev/null
@@ -1,23 +0,0 @@
-//
-// Linear.cpp
-//
-// This code is derived from Universal Tween Engine
-// Licensed under Apache License 2.0 - http://www.apache.org/licenses/LICENSE-2.0
-//
-
-#include
-#include
-
-namespace TweenEngine
-{
- float LinearPath::compute(float t, float *points, int pointsCnt)
- {
- int segment = (int) floor((pointsCnt-1) * t);
- segment = segment > 0 ? segment : 0;
- segment = segment < (pointsCnt-2) ? segment : pointsCnt-2;
-
- t = t * (pointsCnt-1) - segment;
-
- return points[segment] + t * (points[segment+1] - points[segment]);
- }
-}
\ No newline at end of file