public static void animFloatCallbacks(DOGetter<float> getter, DOSetter<float> setter, float duration, float animTo, TweenCallback onUpd, TweenCallback onComp, Ease easeType = Ease.Linear) {
DOTween.To(getter, setter, animTo, duration).SetEase(easeType).SetUpdate(false).OnUpdate(onUpd).OnComplete(onComp);
}
public override float GetSpeedBasedDuration(VectorOptions options, float unitsXSecond, Vector2 changeValue) => default; // 0x004D3FC0-0x004D3FF0
public override void EvaluateAndApply(VectorOptions options, Tween t, bool isRelative, DOGetter <Vector2> getter, DOSetter <Vector2> setter, float elapsed, Vector2 startValue, Vector2 changeValue, float duration, bool usingInversePosition, UpdateNotice updateNotice)
{
} // 0x004D3FF0-0x004D44C0
public override void EvaluateAndApply(NoOptions options, Tween t, bool isRelative, DOGetter <VertexGradient> getter, DOSetter <VertexGradient> setter, float elapsed,
VertexGradient startValue, VertexGradient changeValue, float duration, bool usingInversePosition,
UpdateNotice updateNotice)
{
var easeVal = EaseManager.Evaluate(t, elapsed, duration, t.easeOvershootOrAmplitude, t.easePeriod);
setter(Add(startValue, Multiply(changeValue, easeVal)));
}
public override float GetSpeedBasedDuration(ColorOptions options, float unitsXSecond, Color changeValue) => default; // 0x004CEDB0-0x004CEDC0
public override void EvaluateAndApply(ColorOptions options, Tween t, bool isRelative, DOGetter <Color> getter, DOSetter <Color> setter, float elapsed, Color startValue, Color changeValue, float duration, bool usingInversePosition, UpdateNotice updateNotice)
{
} // 0x004CEDC0-0x004CF000
public override void EvaluateAndApply(PathOptions options, Tween t, bool isRelative, DOGetter <Vector3> getter, DOSetter <Vector3> setter, float elapsed, Path startValue, Path changeValue, float duration, bool usingInversePosition, UpdateNotice updateNotice)
{
if (t.loopType == LoopType.Incremental && !options.isClosedPath)
{
int increment = (t.isComplete ? t.completedLoops - 1 : t.completedLoops);
if (increment > 0)
{
changeValue = changeValue.CloneIncremental(increment);
}
}
float pathPerc = EaseManager.Evaluate(t.easeType, t.customEase, elapsed, duration, t.easeOvershootOrAmplitude, t.easePeriod);
float constantPathPerc = changeValue.ConvertToConstantPathPerc(pathPerc);
Vector3 newPos = changeValue.GetPoint(constantPathPerc);
changeValue.targetPosition = newPos; // Used to draw editor gizmos
setter(newPos);
if (options.mode != PathMode.Ignore && options.orientType != OrientType.None)
{
SetOrientation(options, t, changeValue, constantPathPerc, newPos, updateNotice);
}
// Determine if current waypoint changed and eventually dispatch callback
bool isForward = !usingInversePosition;
if (t.isBackwards)
{
isForward = !isForward;
}
int newWaypointIndex = changeValue.GetWaypointIndexFromPerc(pathPerc, isForward);
if (newWaypointIndex != t.miscInt)
{
int prevWPIndex = t.miscInt;
t.miscInt = newWaypointIndex;
if (t.onWaypointChange != null)
{
// If more than one waypoint changed, dispatch multiple callbacks
bool isBackwards = newWaypointIndex < prevWPIndex;
if (isBackwards)
{
for (int i = prevWPIndex - 1; i > newWaypointIndex - 1; --i)
{
Tween.OnTweenCallback(t.onWaypointChange, i);
}
}
else
{
for (int i = prevWPIndex + 1; i < newWaypointIndex + 1; ++i)
{
Tween.OnTweenCallback(t.onWaypointChange, i);
}
}
}
}
}
public static void animFloatCallbackU(DOGetter<float> getter, DOSetter<float> setter, float duration, float animTo, TweenCallback onUpd)
{
DOTween.To(getter, setter, animTo, duration).SetUpdate(false).OnUpdate(onUpd);
}
public override void EvaluateAndApply(RectOptions options, Tween t, bool isRelative, DOGetter <Rect> getter, DOSetter <Rect> setter, float elapsed, Rect startValue, Rect changeValue, float duration, bool usingInversePosition, UpdateNotice updateNotice)
{
if (t.loopType == LoopType.Incremental)
{
int num = t.isComplete ? (t.completedLoops - 1) : t.completedLoops;
startValue.x += changeValue.x * (float)num;
startValue.y += changeValue.y * (float)num;
startValue.width += changeValue.width * (float)num;
startValue.height += changeValue.height * (float)num;
}
if (t.isSequenced && t.sequenceParent.loopType == LoopType.Incremental)
{
int num2 = ((t.loopType == LoopType.Incremental) ? t.loops : 1) * (t.sequenceParent.isComplete ? (t.sequenceParent.completedLoops - 1) : t.sequenceParent.completedLoops);
startValue.x += changeValue.x * (float)num2;
startValue.y += changeValue.y * (float)num2;
startValue.width += changeValue.width * (float)num2;
startValue.height += changeValue.height * (float)num2;
}
float num3 = EaseManager.Evaluate(t.easeType, t.customEase, elapsed, duration, t.easeOvershootOrAmplitude, t.easePeriod);
startValue.x += changeValue.x * num3;
startValue.y += changeValue.y * num3;
startValue.width += changeValue.width * num3;
startValue.height += changeValue.height * num3;
if (options.snapping)
{
startValue.x = (float)Math.Round((double)startValue.x);
startValue.y = (float)Math.Round((double)startValue.y);
startValue.width = (float)Math.Round((double)startValue.width);
startValue.height = (float)Math.Round((double)startValue.height);
}
setter(startValue);
}
public override void EvaluateAndApply(NoOptions options, Tween t, bool isRelative, DOGetter <ulong> getter, DOSetter <ulong> setter, float elapsed, ulong startValue, ulong changeValue, float duration, bool usingInversePosition, UpdateNotice updateNotice)
{
if (t.loopType == LoopType.Incremental)
{
startValue += changeValue * (uint)(t.isComplete ? (t.completedLoops - 1) : t.completedLoops);
}
if (t.isSequenced && t.sequenceParent.loopType == LoopType.Incremental)
{
startValue += changeValue * (uint)((t.loopType != LoopType.Incremental) ? 1 : t.loops) * (uint)(t.sequenceParent.isComplete ? (t.sequenceParent.completedLoops - 1) : t.sequenceParent.completedLoops);
}
setter((ulong)((decimal)startValue + (decimal)changeValue * (decimal)EaseManager.Evaluate(t.easeType, t.customEase, elapsed, duration, t.easeOvershootOrAmplitude, t.easePeriod)));
}
public abstract void EvaluateAndApply(TPlugOptions options, Tween t, bool isRelative, DOGetter <T1> getter, DOSetter <T1> setter, float elapsed, T2 startValue, T2 changeValue, float duration, bool usingInversePosition, UpdateNotice updateNotice);
public override void EvaluateAndApply(ColorOptions options, Tween t, bool isRelative, DOGetter <Color> getter, DOSetter <Color> setter, float elapsed, Color startValue, Color changeValue, float duration, bool usingInversePosition, UpdateNotice updateNotice)
{
if (t.loopType == LoopType.Incremental)
{
startValue += changeValue * (float)(t.isComplete ? (t.completedLoops - 1) : t.completedLoops);
}
if (t.isSequenced && t.sequenceParent.loopType == LoopType.Incremental)
{
startValue += changeValue * (float)((t.loopType == LoopType.Incremental) ? t.loops : 1) * (float)(t.sequenceParent.isComplete ? (t.sequenceParent.completedLoops - 1) : t.sequenceParent.completedLoops);
}
float num = EaseManager.Evaluate(t.easeType, t.customEase, elapsed, duration, t.easeOvershootOrAmplitude, t.easePeriod);
if (!options.alphaOnly)
{
startValue.r += changeValue.r * num;
startValue.g += changeValue.g * num;
startValue.b += changeValue.b * num;
startValue.a += changeValue.a * num;
setter(startValue);
return;
}
Color pNewValue = getter();
pNewValue.a = startValue.a + changeValue.a * num;
setter(pNewValue);
}
public override void EvaluateAndApply(NoOptions options, Tween t, bool isRelative, DOGetter <RectOffset> getter, DOSetter <RectOffset> setter, float elapsed, RectOffset startValue, RectOffset changeValue, float duration, bool usingInversePosition)
{
_r.left = startValue.left;
_r.right = startValue.right;
_r.top = startValue.top;
_r.bottom = startValue.bottom;
if (t.loopType == LoopType.Incremental)
{
int iterations = t.isComplete ? t.completedLoops - 1 : t.completedLoops;
_r.left += changeValue.left * iterations;
_r.right += changeValue.right * iterations;
_r.top += changeValue.top * iterations;
_r.bottom += changeValue.bottom * iterations;
}
if (t.isSequenced && t.sequenceParent.loopType == LoopType.Incremental)
{
int iterations = (t.loopType == LoopType.Incremental ? t.loops : 1)
* (t.sequenceParent.isComplete ? t.sequenceParent.completedLoops - 1 : t.sequenceParent.completedLoops);
_r.left += changeValue.left * iterations;
_r.right += changeValue.right * iterations;
_r.top += changeValue.top * iterations;
_r.bottom += changeValue.bottom * iterations;
}
float easeVal = EaseManager.Evaluate(t, elapsed, duration, t.easeOvershootOrAmplitude, t.easePeriod);
setter(
new RectOffset(
(int)Math.Round(_r.left + changeValue.left * easeVal),
(int)Math.Round(_r.right + changeValue.right * easeVal),
(int)Math.Round(_r.top + changeValue.top * easeVal),
(int)Math.Round(_r.bottom + changeValue.bottom * easeVal)
)
);
}
public override void EvaluateAndApply(SpiralOptions options, Tween t, bool isRelative, DOGetter <Vector3> getter, DOSetter <Vector3> setter, float elapsed, Vector3 startValue, Vector3 changeValue, float duration, bool usingInversePosition, UpdateNotice updateNotice)
{
float num = EaseManager.Evaluate(t, elapsed, duration, t.easeOvershootOrAmplitude, t.easePeriod);
float num2 = (options.mode == SpiralMode.ExpandThenContract && num > 0.5f) ? (0.5f - (num - 0.5f)) : num;
if (t.loopType == LoopType.Incremental)
{
num += (float)(t.isComplete ? (t.completedLoops - 1) : t.completedLoops);
}
float num3 = duration * options.speed * num;
options.unit = duration * options.speed * num2;
Vector3 vector = new Vector3(options.unit * Mathf.Cos(num3 * options.frequency), options.unit * Mathf.Sin(num3 * options.frequency), options.depth * num);
vector = options.axisQ * vector + startValue;
if (options.snapping)
{
vector.x = (float)Math.Round((double)vector.x);
vector.y = (float)Math.Round((double)vector.y);
vector.z = (float)Math.Round((double)vector.z);
}
setter(vector);
}
public override void EvaluateAndApply(UintOptions options, Tween t, bool isRelative, DOGetter <uint> getter, DOSetter <uint> setter, float elapsed, uint startValue, uint changeValue, float duration, bool usingInversePosition, UpdateNotice updateNotice)
{
uint v;
if (t.loopType == LoopType.Incremental)
{
v = (uint)(changeValue * (t.isComplete ? t.completedLoops - 1 : t.completedLoops));
if (options.isNegativeChangeValue)
{
startValue -= v;
}
else
{
startValue += v;
}
}
if (t.isSequenced && t.sequenceParent.loopType == LoopType.Incremental)
{
v = (uint)(changeValue * (t.loopType == LoopType.Incremental ? t.loops : 1)
* (t.sequenceParent.isComplete ? t.sequenceParent.completedLoops - 1 : t.sequenceParent.completedLoops));
if (options.isNegativeChangeValue)
{
startValue -= v;
}
else
{
startValue += v;
}
}
v = (uint)Math.Round(changeValue * EaseManager.Evaluate(t.easeType, t.customEase, elapsed, duration, t.easeOvershootOrAmplitude, t.easePeriod));
if (options.isNegativeChangeValue)
{
setter(startValue - v);
}
else
{
setter(startValue + v);
}
}
public override void EvaluateAndApply(StringOptions options, Tween t, bool isRelative, DOGetter <string> getter, DOSetter <string> setter, float elapsed, string startValue, string changeValue, float duration, bool usingInversePosition, UpdateNotice updateNotice)
{
StringPlugin._Buffer.Remove(0, StringPlugin._Buffer.Length);
if (isRelative && t.loopType == LoopType.Incremental)
{
int num = t.isComplete ? (t.completedLoops - 1) : t.completedLoops;
if (num > 0)
{
StringPlugin._Buffer.Append(startValue);
for (int i = 0; i < num; i++)
{
StringPlugin._Buffer.Append(changeValue);
}
startValue = StringPlugin._Buffer.ToString();
StringPlugin._Buffer.Remove(0, StringPlugin._Buffer.Length);
}
}
int num2 = options.richTextEnabled ? options.startValueStrippedLength : startValue.Length;
int num3 = options.richTextEnabled ? options.changeValueStrippedLength : changeValue.Length;
int num4 = (int)Math.Round((double)((float)num3 * EaseManager.Evaluate(t.easeType, t.customEase, elapsed, duration, t.easeOvershootOrAmplitude, t.easePeriod)));
if (num4 > num3)
{
num4 = num3;
}
else if (num4 < 0)
{
num4 = 0;
}
if (isRelative)
{
StringPlugin._Buffer.Append(startValue);
if (options.scrambleMode != ScrambleMode.None)
{
setter(this.Append(changeValue, 0, num4, options.richTextEnabled).AppendScrambledChars(num3 - num4, this.ScrambledCharsToUse(options)).ToString());
return;
}
setter(this.Append(changeValue, 0, num4, options.richTextEnabled).ToString());
return;
}
else
{
if (options.scrambleMode != ScrambleMode.None)
{
setter(this.Append(changeValue, 0, num4, options.richTextEnabled).AppendScrambledChars(num3 - num4, this.ScrambledCharsToUse(options)).ToString());
return;
}
int num5 = num2 - num3;
int num6 = num2;
if (num5 > 0)
{
float num7 = (float)num4 / (float)num3;
num6 -= (int)((float)num6 * num7);
}
else
{
num6 -= num4;
}
this.Append(changeValue, 0, num4, options.richTextEnabled);
if (num4 < num3 && num4 < num2)
{
this.Append(startValue, num4, options.richTextEnabled ? (num4 + num6) : num6, options.richTextEnabled);
}
setter(StringPlugin._Buffer.ToString());
return;
}
}
public static TweenerCore<Color, Color, ColorOptions> To( DOGetter<Color> getter, DOSetter<Color> setter, Color endValue, DOTData data )
{
return DOTween.To( getter, setter, endValue, data.duration ).SetEase( data.ease );
}
public override void EvaluateAndApply(VectorOptions options, Tween t, bool isRelative, DOGetter <Vector4> getter, DOSetter <Vector4> setter, float elapsed, Vector4 startValue, Vector4 changeValue, float duration)
{
if (t.loopType == LoopType.Incremental)
{
startValue += changeValue * (t.isComplete ? t.completedLoops - 1 : t.completedLoops);
}
if (t.isSequenced && t.sequenceParent.loopType == LoopType.Incremental)
{
startValue += changeValue * (t.loopType == LoopType.Incremental ? t.loops : 1)
* (t.sequenceParent.isComplete ? t.sequenceParent.completedLoops - 1 : t.sequenceParent.completedLoops);
}
switch (options.axisConstraint)
{
case AxisConstraint.X:
Vector4 resX = getter();
resX.x = EaseManager.Evaluate(t, elapsed, startValue.x, changeValue.x, duration, t.easeOvershootOrAmplitude, t.easePeriod);
if (options.snapping)
{
resX.x = (float)Math.Round(resX.x);
}
setter(resX);
break;
case AxisConstraint.Y:
Vector4 resY = getter();
resY.y = EaseManager.Evaluate(t, elapsed, startValue.y, changeValue.y, duration, t.easeOvershootOrAmplitude, t.easePeriod);
if (options.snapping)
{
resY.y = (float)Math.Round(resY.y);
}
setter(resY);
break;
case AxisConstraint.Z:
Vector4 resZ = getter();
resZ.z = EaseManager.Evaluate(t, elapsed, startValue.z, changeValue.z, duration, t.easeOvershootOrAmplitude, t.easePeriod);
if (options.snapping)
{
resZ.z = (float)Math.Round(resZ.z);
}
setter(resZ);
break;
case AxisConstraint.W:
Vector4 resW = getter();
resW.w = EaseManager.Evaluate(t, elapsed, startValue.w, changeValue.w, duration, t.easeOvershootOrAmplitude, t.easePeriod);
if (options.snapping)
{
resW.w = (float)Math.Round(resW.w);
}
setter(resW);
break;
default:
startValue.x = EaseManager.Evaluate(t, elapsed, startValue.x, changeValue.x, duration, t.easeOvershootOrAmplitude, t.easePeriod);
startValue.y = EaseManager.Evaluate(t, elapsed, startValue.y, changeValue.y, duration, t.easeOvershootOrAmplitude, t.easePeriod);
startValue.z = EaseManager.Evaluate(t, elapsed, startValue.z, changeValue.z, duration, t.easeOvershootOrAmplitude, t.easePeriod);
startValue.w = EaseManager.Evaluate(t, elapsed, startValue.w, changeValue.w, duration, t.easeOvershootOrAmplitude, t.easePeriod);
if (options.snapping)
{
startValue.x = (float)Math.Round(startValue.x);
startValue.y = (float)Math.Round(startValue.y);
startValue.z = (float)Math.Round(startValue.z);
startValue.w = (float)Math.Round(startValue.w);
}
setter(startValue);
break;
}
}
public static TweenerCore<Vector3, Vector3, VectorOptions> To( DOGetter<Vector3> getter, DOSetter<Vector3> setter, Vector3 endValue, DOTData data )
{
return DOTween.To( getter, setter, endValue, data.duration ).SetEase( data.ease );
}
TweenerCore <float, float, FloatOptions> Fade(DOGetter <float> getter, DOSetter <float> setter,
float duration, float to)
{
return(DOTween.To(getter, setter, to, duration));
}
public override float GetSpeedBasedDuration(NoOptions options, float unitsXSecond, double changeValue) => default; // 0x004CF730-0x004CF750
public override void EvaluateAndApply(NoOptions options, Tween t, bool isRelative, DOGetter <double> getter, DOSetter <double> setter, float elapsed, double startValue, double changeValue, float duration, bool usingInversePosition, UpdateNotice updateNotice)
{
} // 0x004CF750-0x004CF890
TweenerCore <float, float, FloatOptions> FadeOut(DOGetter <float> getter, DOSetter <float> setter,
float duration)
{
return(Fade(getter, setter, duration, 0f).SetEase(fadeOutEase));
}
public override void EvaluateAndApply(Vector3ArrayOptions options, Tween t, bool isRelative, DOGetter <Vector3> getter, DOSetter <Vector3> setter, float elapsed, Vector3[] startValue, Vector3[] changeValue, float duration, bool usingInversePosition, UpdateNotice updateNotice)
{
Vector3 a = Vector3.zero;
if (t.loopType == LoopType.Incremental)
{
int num = t.isComplete ? (t.completedLoops - 1) : t.completedLoops;
if (num > 0)
{
int num2 = startValue.Length - 1;
a = (startValue[num2] + changeValue[num2] - startValue[0]) * (float)num;
}
}
if (t.isSequenced && t.sequenceParent.loopType == LoopType.Incremental)
{
int num3 = ((t.loopType == LoopType.Incremental) ? t.loops : 1) * (t.sequenceParent.isComplete ? (t.sequenceParent.completedLoops - 1) : t.sequenceParent.completedLoops);
if (num3 > 0)
{
int num4 = startValue.Length - 1;
a += (startValue[num4] + changeValue[num4] - startValue[0]) * (float)num3;
}
}
int num5 = 0;
float num6 = 0f;
float num7 = 0f;
int num8 = options.durations.Length;
float num9 = 0f;
for (int i = 0; i < num8; i++)
{
num7 = options.durations[i];
num9 += num7;
if (elapsed <= num9)
{
num5 = i;
num6 = elapsed - num6;
break;
}
num6 += num7;
}
float num10 = EaseManager.Evaluate(t.easeType, t.customEase, num6, num7, t.easeOvershootOrAmplitude, t.easePeriod);
AxisConstraint axisConstraint = options.axisConstraint;
Vector3 pNewValue;
switch (axisConstraint)
{
case AxisConstraint.X:
pNewValue = getter();
pNewValue.x = startValue[num5].x + a.x + changeValue[num5].x * num10;
if (options.snapping)
{
pNewValue.x = (float)Math.Round((double)pNewValue.x);
}
setter(pNewValue);
return;
case (AxisConstraint)3:
break;
case AxisConstraint.Y:
pNewValue = getter();
pNewValue.y = startValue[num5].y + a.y + changeValue[num5].y * num10;
if (options.snapping)
{
pNewValue.y = (float)Math.Round((double)pNewValue.y);
}
setter(pNewValue);
return;
default:
if (axisConstraint == AxisConstraint.Z)
{
pNewValue = getter();
pNewValue.z = startValue[num5].z + a.z + changeValue[num5].z * num10;
if (options.snapping)
{
pNewValue.z = (float)Math.Round((double)pNewValue.z);
}
setter(pNewValue);
return;
}
break;
}
pNewValue.x = startValue[num5].x + a.x + changeValue[num5].x * num10;
pNewValue.y = startValue[num5].y + a.y + changeValue[num5].y * num10;
pNewValue.z = startValue[num5].z + a.z + changeValue[num5].z * num10;
if (options.snapping)
{
pNewValue.x = (float)Math.Round((double)pNewValue.x);
pNewValue.y = (float)Math.Round((double)pNewValue.y);
pNewValue.z = (float)Math.Round((double)pNewValue.z);
}
setter(pNewValue);
}
public override void EvaluateAndApply(RectOptions options, Tween t, bool isRelative, DOGetter <Rect> getter, DOSetter <Rect> setter, float elapsed, Rect startValue, Rect changeValue, float duration, bool usingInversePosition)
{
if (t.loopType == LoopType.Incremental)
{
int iterations = t.isComplete ? t.completedLoops - 1 : t.completedLoops;
startValue.x += changeValue.x * iterations;
startValue.y += changeValue.y * iterations;
startValue.width += changeValue.width * iterations;
startValue.height += changeValue.height * iterations;
}
if (t.isSequenced && t.sequenceParent.loopType == LoopType.Incremental)
{
int iterations = (t.loopType == LoopType.Incremental ? t.loops : 1)
* (t.sequenceParent.isComplete ? t.sequenceParent.completedLoops - 1 : t.sequenceParent.completedLoops);
startValue.x += changeValue.x * iterations;
startValue.y += changeValue.y * iterations;
startValue.width += changeValue.width * iterations;
startValue.height += changeValue.height * iterations;
}
float easeVal = EaseManager.Evaluate(t.easeType, t.customEase, elapsed, duration, t.easeOvershootOrAmplitude, t.easePeriod);
startValue.x += changeValue.x * easeVal;
startValue.y += changeValue.y * easeVal;
startValue.width += changeValue.width * easeVal;
startValue.height += changeValue.height * easeVal;
if (options.snapping)
{
startValue.x = (float)Math.Round(startValue.x);
startValue.y = (float)Math.Round(startValue.y);
startValue.width = (float)Math.Round(startValue.width);
startValue.height = (float)Math.Round(startValue.height);
}
setter(startValue);
}
public static Tweener DoTweenTo(DOGetter <float> getter, DOSetter <float> setter, float endValue, float duration)
{
return(DOTween.To(getter, setter, endValue, duration));
}
public override void EvaluateAndApply(ColorOptions options, Tween t, bool isRelative, DOGetter <Color> getter, DOSetter <Color> setter, float elapsed, Color startValue, Color changeValue, float duration, bool usingInversePosition)
{
if (t.loopType == LoopType.Incremental)
{
startValue += changeValue * (t.isComplete ? t.completedLoops - 1 : t.completedLoops);
}
if (t.isSequenced && t.sequenceParent.loopType == LoopType.Incremental)
{
startValue += changeValue * (t.loopType == LoopType.Incremental ? t.loops : 1)
* (t.sequenceParent.isComplete ? t.sequenceParent.completedLoops - 1 : t.sequenceParent.completedLoops);
}
float easeVal = EaseManager.Evaluate(t, elapsed, duration, t.easeOvershootOrAmplitude, t.easePeriod);
if (!options.alphaOnly)
{
startValue.r += changeValue.r * easeVal;
startValue.g += changeValue.g * easeVal;
startValue.b += changeValue.b * easeVal;
startValue.a += changeValue.a * easeVal;
setter(startValue);
return;
}
// Alpha only
Color res = getter();
res.a = startValue.a + changeValue.a * easeVal;
setter(res);
}
public override void EvaluateAndApply(VectorOptions options, Tween t, bool isRelative, DOGetter <Vector2> getter, DOSetter <Vector2> setter, float elapsed, Vector2 startValue, Vector2 changeValue, float duration, bool usingInversePosition, UpdateNotice updateNotice)
{
if (t.loopType == LoopType.Incremental)
{
startValue += changeValue * (t.isComplete ? t.completedLoops - 1 : t.completedLoops);
}
if (t.isSequenced && t.sequenceParent.loopType == LoopType.Incremental)
{
startValue += changeValue * (t.loopType == LoopType.Incremental ? t.loops : 1)
* (t.sequenceParent.isComplete ? t.sequenceParent.completedLoops - 1 : t.sequenceParent.completedLoops);
}
float easeVal = EaseManager.Evaluate(t.easeType, t.customEase, elapsed, duration, t.easeOvershootOrAmplitude, t.easePeriod);
switch (options.axisConstraint)
{
case AxisConstraint.X:
Vector2 resX = getter();
resX.x = startValue.x + changeValue.x * easeVal;
if (options.snapping)
{
resX.x = (float)Math.Round(resX.x);
}
setter(resX);
break;
case AxisConstraint.Y:
Vector2 resY = getter();
resY.y = startValue.y + changeValue.y * easeVal;
if (options.snapping)
{
resY.y = (float)Math.Round(resY.y);
}
setter(resY);
break;
default:
startValue.x += changeValue.x * easeVal;
startValue.y += changeValue.y * easeVal;
if (options.snapping)
{
startValue.x = (float)Math.Round(startValue.x);
startValue.y = (float)Math.Round(startValue.y);
}
setter(startValue);
break;
}
}
public override float GetSpeedBasedDuration(RectOptions options, float unitsXSecond, Rect changeValue) => default; // 0x004D1E30-0x004D1F00
public override void EvaluateAndApply(RectOptions options, Tween t, bool isRelative, DOGetter <Rect> getter, DOSetter <Rect> setter, float elapsed, Rect startValue, Rect changeValue, float duration, bool usingInversePosition, UpdateNotice updateNotice)
{
} // 0x004D1F00-0x004D24F0
public override void EvaluateAndApply(NoOptions options, Tween t, bool isRelative, DOGetter <int> getter, DOSetter <int> setter, float elapsed, int startValue, int changeValue, float duration, bool usingInversePosition)
{
if (t.loopType == LoopType.Incremental)
{
startValue += changeValue * (t.isComplete ? t.completedLoops - 1 : t.completedLoops);
}
setter((int)Math.Round(startValue + changeValue * EaseManager.Evaluate(t.easeType, t.customEase, elapsed, duration, t.easeOvershootOrAmplitude, t.easePeriod)));
}
public static void animFloatCallbackU(DOGetter <float> getter, DOSetter <float> setter, float duration, float animTo, TweenCallback onUpd)
{
DOTween.To(getter, setter, animTo, duration).SetUpdate(false).OnUpdate(onUpd);
}
public override void EvaluateAndApply(TweenPlugValueSetOptions options, Tween t, bool isRelative, DOGetter <float> getter, DOSetter <float> setter, float elapsed, float startValue, float changeValue, float duration, bool usingInversePosition, UpdateNotice updateNotice)
{
if (updateNotice == UpdateNotice.RewindStep)
{
mCounter = -1;
}
else if (options.Refresh(ref mCounter))
{
setter(elapsed);
}
}
public static void animFloatCallbacks(DOGetter <float> getter, DOSetter <float> setter, float duration, float animTo, TweenCallback onUpd, TweenCallback onComp, Ease easeType = Ease.Linear)
{
DOTween.To(getter, setter, animTo, duration).SetEase(easeType).SetUpdate(false).OnUpdate(onUpd).OnComplete(onComp);
}
public static void animVec2CallbackU(DOGetter<Vector2> getter, DOSetter<Vector2> setter, float duration, Vector2 animTo, TweenCallback onUpd, Ease easeType = Ease.Linear) {
DOTween.To(getter, setter, animTo, duration).SetEase(easeType).SetUpdate(false).OnUpdate(onUpd);
}
public static void animVec2CallbackU(DOGetter <Vector2> getter, DOSetter <Vector2> setter, float duration, Vector2 animTo, TweenCallback onUpd, Ease easeType = Ease.Linear)
{
DOTween.To(getter, setter, animTo, duration).SetEase(easeType).SetUpdate(false).OnUpdate(onUpd);
}
public static TweenerCore<float, float, FloatOptions> To( DOGetter<float> getter, DOSetter<float> setter, float endValue, DOTData data )
{
return DOTween.To( getter, setter, endValue, data.duration ).SetEase( data.ease );
}
public static void animInt(DOGetter <int> getter, DOSetter <int> setter, float duration, int animTo)
{
DOTween.To(getter, setter, animTo, duration).SetUpdate(false);
}
public static void animVec2(DOGetter<Vector2> getter, DOSetter<Vector2> setter, float duration, Vector2 animTo)
{
DOTween.To(getter, setter, animTo, duration).SetUpdate(false);
}
public CustomTargetTween <T> DOGetter(DOGetter <T> getter)
{
this.getter = getter;
return(this);
}
public static void animInt(DOGetter<int> getter, DOSetter<int> setter, float duration, int animTo)
{
DOTween.To(getter, setter, animTo, duration).SetUpdate(false);
}
// Token: 0x060001BE RID: 446 RVA: 0x00009DA8 File Offset: 0x00007FA8
public override void EvaluateAndApply(NoOptions options, Tween t, bool isRelative, DOGetter <RectOffset> getter, DOSetter <RectOffset> setter, float elapsed, RectOffset startValue, RectOffset changeValue, float duration, bool usingInversePosition, UpdateNotice updateNotice)
{
RectOffsetPlugin._r.left = startValue.left;
RectOffsetPlugin._r.right = startValue.right;
RectOffsetPlugin._r.top = startValue.top;
RectOffsetPlugin._r.bottom = startValue.bottom;
if (t.loopType == LoopType.Incremental)
{
int num = t.isComplete ? (t.completedLoops - 1) : t.completedLoops;
RectOffsetPlugin._r.left += changeValue.left * num;
RectOffsetPlugin._r.right += changeValue.right * num;
RectOffsetPlugin._r.top += changeValue.top * num;
RectOffsetPlugin._r.bottom += changeValue.bottom * num;
}
if (t.isSequenced && t.sequenceParent.loopType == LoopType.Incremental)
{
int num2 = ((t.loopType == LoopType.Incremental) ? t.loops : 1) * (t.sequenceParent.isComplete ? (t.sequenceParent.completedLoops - 1) : t.sequenceParent.completedLoops);
RectOffsetPlugin._r.left += changeValue.left * num2;
RectOffsetPlugin._r.right += changeValue.right * num2;
RectOffsetPlugin._r.top += changeValue.top * num2;
RectOffsetPlugin._r.bottom += changeValue.bottom * num2;
}
float num3 = EaseManager.Evaluate(t.easeType, t.customEase, elapsed, duration, t.easeOvershootOrAmplitude, t.easePeriod);
setter(new RectOffset((int)Math.Round((double)((float)RectOffsetPlugin._r.left + (float)changeValue.left * num3)), (int)Math.Round((double)((float)RectOffsetPlugin._r.right + (float)changeValue.right * num3)), (int)Math.Round((double)((float)RectOffsetPlugin._r.top + (float)changeValue.top * num3)), (int)Math.Round((double)((float)RectOffsetPlugin._r.bottom + (float)changeValue.bottom * num3))));
}
