public override void SetFrom(TweenerCore <Quaternion, Vector3, QuaternionOptions> t, bool isRelative)
{
Vector3 prevEndVal = t.endValue;
t.endValue = t.getter().eulerAngles;
if (t.plugOptions.rotateMode == RotateMode.Fast && !t.isRelative)
{
t.startValue = prevEndVal;
}
else if (t.plugOptions.rotateMode == RotateMode.FastBeyond360)
{
t.startValue = t.endValue + prevEndVal;
}
else
{
Quaternion rot = t.getter();
if (t.plugOptions.rotateMode == RotateMode.WorldAxisAdd)
{
t.startValue = (rot * Quaternion.Inverse(rot) * Quaternion.Euler(prevEndVal) * rot).eulerAngles;
}
else
{
t.startValue = (rot * Quaternion.Euler(prevEndVal)).eulerAngles;
}
t.endValue = -prevEndVal;
}
t.setter(Quaternion.Euler(t.startValue));
}
public override void SetFrom(TweenerCore <Vector2, Vector2, VectorOptions> t, Vector2 fromValue, bool setImmediately)
{
t.startValue = fromValue;
if (setImmediately)
{
Vector2 to;
switch (t.plugOptions.axisConstraint)
{
case AxisConstraint.X:
to = t.getter();
to.x = fromValue.x;
break;
case AxisConstraint.Y:
to = t.getter();
to.y = fromValue.y;
break;
default:
to = fromValue;
break;
}
if (t.plugOptions.snapping)
{
to.x = (float)Math.Round(to.x);
to.y = (float)Math.Round(to.y);
}
t.setter(to);
}
}
public override void SetFrom(TweenerCore <Quaternion, Vector3, QuaternionOptions> t, bool isRelative)
{
Vector3 endValue = t.endValue;
t.endValue = t.getter().eulerAngles;
if (t.plugOptions.rotateMode == RotateMode.Fast && !t.isRelative)
{
t.startValue = endValue;
}
else if (t.plugOptions.rotateMode == RotateMode.FastBeyond360)
{
t.startValue = t.endValue + endValue;
}
else
{
Quaternion quaternion = t.getter();
if (t.plugOptions.rotateMode == RotateMode.WorldAxisAdd)
{
t.startValue = (quaternion * Quaternion.Inverse(quaternion) * Quaternion.Euler(endValue) * quaternion).eulerAngles;
}
else
{
t.startValue = (quaternion * Quaternion.Euler(endValue)).eulerAngles;
}
t.endValue = -endValue;
}
t.setter(Quaternion.Euler(t.startValue));
}
// CALLED VIA Tween the moment the tween starts, AFTER any delay has elapsed
// (unless it's a FROM tween, in which case it will be called BEFORE any eventual delay).
// Returns TRUE in case of success,
// FALSE if there are missing references and the tween needs to be killed
internal static bool DoStartup <T1, T2, TPlugOptions>(TweenerCore <T1, T2, TPlugOptions> t) where TPlugOptions : struct, IPlugOptions
{
t.startupDone = true;
// Special startup operations
if (t.specialStartupMode != SpecialStartupMode.None)
{
if (!DOStartupSpecials(t))
{
return(false);
}
}
if (!t.hasManuallySetStartValue)
{
// Take start value from current target value
if (DOTween.useSafeMode)
{
try {
t.startValue = t.tweenPlugin.ConvertToStartValue(t, t.getter());
} catch (Exception e) {
if (Debugger.logPriority >= 1)
{
Debugger.LogWarning(string.Format(
"Tween startup failed (NULL target/property - {0}): the tween will now be killed ► {1}", e.TargetSite, e.Message
));
}
DOTween.safeModeReport.Add(SafeModeReport.SafeModeReportType.StartupFailure);
return(false); // Target/field doesn't exist: kill tween
}
}
else
{
t.startValue = t.tweenPlugin.ConvertToStartValue(t, t.getter());
}
}
if (t.isRelative)
{
t.tweenPlugin.SetRelativeEndValue(t);
}
t.tweenPlugin.SetChangeValue(t);
// Duration based startup operations
DOStartupDurationBased(t);
// Applied here so that the eventual duration derived from a speedBased tween has been set
if (t.duration <= 0)
{
t.easeType = Ease.INTERNAL_Zero;
}
return(true);
}
// CALLED BY TweenerCore
internal static TweenerCore <T1, T2, TPlugOptions> DoChangeEndValue <T1, T2, TPlugOptions>(
TweenerCore <T1, T2, TPlugOptions> t, T2 newEndValue, float newDuration, bool snapStartValue
) where TPlugOptions : struct, IPlugOptions
{
t.endValue = newEndValue;
t.isRelative = false;
if (t.startupDone)
{
if (t.specialStartupMode != SpecialStartupMode.None)
{
if (!DOStartupSpecials(t))
{
return(null);
}
}
if (snapStartValue)
{
// Reassign startValue with current target's value
if (DOTween.useSafeMode)
{
try {
t.startValue = t.tweenPlugin.ConvertToStartValue(t, t.getter());
} catch {
// Target/field doesn't exist: kill tween
TweenManager.Despawn(t);
DOTween.safeModeReport.Add(SafeModeReport.SafeModeReportType.TargetOrFieldMissing);
return(null);
}
}
else
{
t.startValue = t.tweenPlugin.ConvertToStartValue(t, t.getter());
}
}
t.tweenPlugin.SetChangeValue(t);
}
if (newDuration > 0)
{
t.duration = newDuration;
if (t.startupDone)
{
DOStartupDurationBased(t);
}
}
// Force rewind
DoGoto(t, 0, 0, UpdateMode.IgnoreOnUpdate);
return(t);
}
// CALLED VIA Tween the moment the tween starts, AFTER any delay has elapsed
// (unless it's a FROM tween, in which case it will be called BEFORE any eventual delay).
// Returns TRUE in case of success,
// FALSE if there are missing references and the tween needs to be killed
internal static bool DoStartup <T1, T2, TPlugOptions>(TweenerCore <T1, T2, TPlugOptions> t) where TPlugOptions : struct
{
t.startupDone = true;
// Special startup operations
if (t.specialStartupMode != SpecialStartupMode.None)
{
if (!DOStartupSpecials(t))
{
return(false);
}
}
if (!t.hasManuallySetStartValue)
{
// Take start value from current target value
if (DOTween.useSafeMode)
{
try {
t.startValue = t.tweenPlugin.ConvertToStartValue(t, t.getter());
} catch {
return(false); // Target/field doesn't exist: kill tween
}
}
else
{
t.startValue = t.tweenPlugin.ConvertToStartValue(t, t.getter());
}
}
if (t.isRelative)
{
t.tweenPlugin.SetRelativeEndValue(t);
}
t.tweenPlugin.SetChangeValue(t);
// Duration based startup operations
DOStartupDurationBased(t);
// Applied here so that the eventual duration derived from a speedBased tween has been set
if (t.duration <= 0)
{
t.easeType = Ease.INTERNAL_Zero;
}
return(true);
}
public override void SetFrom(TweenerCore <Vector3, Vector3, VectorOptions> t, bool isRelative)
{
Vector3 prevEndVal = t.endValue;
t.endValue = t.getter();
t.startValue = isRelative ? t.endValue + prevEndVal : prevEndVal;
Vector3 to = t.endValue;
switch (t.plugOptions.axisConstraint)
{
case AxisConstraint.X:
to.x = t.startValue.x;
break;
case AxisConstraint.Y:
to.y = t.startValue.y;
break;
case AxisConstraint.Z:
to.z = t.startValue.z;
break;
default:
to = t.startValue;
break;
}
if (t.plugOptions.snapping)
{
to.x = (float)Math.Round(to.x);
to.y = (float)Math.Round(to.y);
to.z = (float)Math.Round(to.z);
}
t.setter(to);
}
// Recreates waypoints with correct control points and eventual additional starting point
// then sets the final path version
public override void SetChangeValue(TweenerCore <Vector3, Path, PathOptions> t)
{
Transform trans = (Transform)t.target;
if (t.plugOptions.orientType == OrientType.ToPath && t.plugOptions.useLocalPosition)
{
t.plugOptions.parent = trans.parent;
}
if (t.endValue.isFinalized)
{
t.changeValue = t.endValue;
return;
}
Vector3 currVal = t.getter();
Path path = t.endValue;
int unmodifiedWpsLen = path.wps.Length;
int additionalWps = 0;
bool hasAdditionalStartingP = false, hasAdditionalEndingP = false;
// Create final wps and add eventual starting/ending waypoints
if (path.wps[0] != currVal)
{
hasAdditionalStartingP = true;
additionalWps += 1;
}
if (t.plugOptions.isClosedPath && path.wps[unmodifiedWpsLen - 1] != currVal)
{
hasAdditionalEndingP = true;
additionalWps += 1;
}
int wpsLen = unmodifiedWpsLen + additionalWps;
Vector3[] wps = new Vector3[wpsLen];
int indMod = hasAdditionalStartingP ? 1 : 0;
if (hasAdditionalStartingP)
{
wps[0] = currVal;
}
for (int i = 0; i < unmodifiedWpsLen; ++i)
{
wps[i + indMod] = path.wps[i];
}
if (hasAdditionalEndingP)
{
wps[wps.Length - 1] = wps[0];
}
path.wps = wps;
// Finalize path
path.FinalizePath(t.plugOptions.isClosedPath, t.plugOptions.lockPositionAxis, currVal);
t.plugOptions.startupRot = trans.rotation;
t.plugOptions.startupZRot = trans.eulerAngles.z;
// Set changeValue as a reference to endValue
t.changeValue = t.endValue;
}
// Token: 0x060001D2 RID: 466 RVA: 0x0000A5D8 File Offset: 0x000087D8
public override void SetFrom(TweenerCore <Vector2, Vector2, VectorOptions> t, bool isRelative)
{
Vector2 endValue = t.endValue;
t.endValue = t.getter();
t.startValue = (isRelative ? (t.endValue + endValue) : endValue);
Vector2 vector = t.endValue;
AxisConstraint axisConstraint = t.plugOptions.axisConstraint;
if (axisConstraint != AxisConstraint.X)
{
if (axisConstraint != AxisConstraint.Y)
{
vector = t.startValue;
}
else
{
vector.y = t.startValue.y;
}
}
else
{
vector.x = t.startValue.x;
}
if (t.plugOptions.snapping)
{
vector.x = (float)Math.Round((double)vector.x);
vector.y = (float)Math.Round((double)vector.y);
}
t.setter(vector);
}
// Returns TRUE if it's successful, FALSE otherwise
// Behaves like a regular shake, but also changes the endValues so that they reflect the local axis rotation of the camera
internal static bool SetCameraShakePosition(TweenerCore <Vector3, Vector3[], Vector3ArrayOptions> t)
{
if (!SetShake(t))
{
return(false);
}
Camera target = t.target as Camera;
if (target == null)
{
return(false);
}
Vector3 startupVal = t.getter();
Transform trans = target.transform;
int len = t.endValue.Length;
for (int i = 0; i < len; i++)
{
Vector3 endVal = t.endValue[i];
t.endValue[i] = (trans.localRotation * (endVal - startupVal)) + startupVal;
}
return(true);
}
public override void SetFrom(TweenerCore <Color2, Color2, ColorOptions> t, bool isRelative)
{
Color2 prevEndVal = t.endValue;
t.endValue = t.getter();
if (isRelative)
{
t.startValue = new Color2(t.endValue.ca + prevEndVal.ca, t.endValue.cb + prevEndVal.cb);
}
else
{
t.startValue = new Color2(prevEndVal.ca, prevEndVal.cb);
}
Color2 to = t.endValue;
if (!t.plugOptions.alphaOnly)
{
to = t.startValue;
}
else
{
to.ca.a = t.startValue.ca.a;
to.cb.a = t.startValue.cb.a;
}
t.setter(to);
}
public override void SetFrom(TweenerCore <Vector3, Vector3, VectorOptions> t, bool isRelative)
{
Vector3 endValue = t.endValue;
t.endValue = t.getter();
t.startValue = (isRelative ? (t.endValue + endValue) : endValue);
Vector3 vector = t.endValue;
switch (t.plugOptions.axisConstraint)
{
case AxisConstraint.X:
vector.x = t.startValue.x;
break;
case AxisConstraint.Y:
vector.y = t.startValue.y;
break;
case AxisConstraint.Z:
vector.z = t.startValue.z;
break;
default:
vector = t.startValue;
break;
}
if (t.plugOptions.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);
}
t.setter(vector);
}
public override void SetFrom(TweenerCore <Vector2, Vector2, VectorOptions> t, bool isRelative)
{
Vector2 endValue = t.endValue;
t.endValue = t.getter();
t.startValue = (isRelative ? (t.endValue + endValue) : endValue);
Vector2 pNewValue = t.endValue;
switch (t.plugOptions.axisConstraint)
{
case AxisConstraint.X:
pNewValue.x = t.startValue.x;
goto IL_88;
case AxisConstraint.Y:
pNewValue.y = t.startValue.y;
goto IL_88;
}
pNewValue = t.startValue;
IL_88:
if (t.plugOptions.snapping)
{
pNewValue.x = (float)Math.Round((double)pNewValue.x);
pNewValue.y = (float)Math.Round((double)pNewValue.y);
}
t.setter(pNewValue);
}
public override void SetFrom(TweenerCore <Color2, Color2, ColorOptions> t, bool isRelative)
{
Color2 endValue = t.endValue;
t.endValue = t.getter();
if (isRelative)
{
t.startValue = new Color2(t.endValue.ca + endValue.ca, t.endValue.cb + endValue.cb);
}
else
{
t.startValue = new Color2(endValue.ca, endValue.cb);
}
Color2 pNewValue = t.endValue;
if (!t.plugOptions.alphaOnly)
{
pNewValue = t.startValue;
}
else
{
pNewValue.ca.a = t.startValue.ca.a;
pNewValue.cb.a = t.startValue.cb.a;
}
t.setter(pNewValue);
}
public override void SetFrom(TweenerCore <Quaternion, Quaternion, NoOptions> t, bool isRelative)
{
Quaternion endValue = t.endValue;
t.endValue = t.getter();
t.startValue = isRelative ? (t.endValue * endValue) : endValue;
t.setter(t.startValue);
}
public override void SetFrom(TweenerCore <float, float, FloatOptions> t, bool isRelative)
{
float prevEndVal = t.endValue;
t.endValue = t.getter();
t.startValue = isRelative ? t.endValue + prevEndVal : prevEndVal;
t.setter(!t.plugOptions.snapping ? t.startValue : (float)Math.Round(t.startValue));
}
public override void SetFrom(TweenerCore <int, int, NoOptions> t, bool isRelative)
{
int endValue = t.endValue;
t.endValue = t.getter();
t.startValue = (isRelative ? (t.endValue + endValue) : endValue);
t.setter(t.startValue);
}
public override void SetFrom(TweenerCore <ulong, ulong, NoOptions> t, bool isRelative)
{
ulong prevEndVal = t.endValue;
t.endValue = t.getter();
t.startValue = isRelative ? t.endValue + prevEndVal : prevEndVal;
t.setter(t.startValue);
}
// Token: 0x060001F0 RID: 496 RVA: 0x0000B574 File Offset: 0x00009774
public override void SetFrom(TweenerCore <float, float, FloatOptions> t, bool isRelative)
{
float endValue = t.endValue;
t.endValue = t.getter();
t.startValue = (isRelative ? (t.endValue + endValue) : endValue);
t.setter((!t.plugOptions.snapping) ? t.startValue : ((float)Math.Round((double)t.startValue)));
}
public override void SetFrom(TweenerCore <string, string, StringOptions> t, bool isRelative)
{
string endValue = t.endValue;
t.endValue = t.getter();
t.startValue = endValue;
t.setter(t.startValue);
}
// Sets the values in case of a From tween
public override void SetFrom(TweenerCore <CustomRange, CustomRange, NoOptions> t, bool isRelative)
{
CustomRange prevEndVal = t.endValue;
t.endValue = t.getter();
t.startValue = isRelative ? t.endValue + prevEndVal : prevEndVal;
t.setter(t.startValue);
}
public override void SetFrom(TweenerCore <Quaternion, Vector3, QuaternionOptions> t, bool isRelative)
{
Vector3 prevEndVal = t.endValue;
t.endValue = t.getter().eulerAngles;
t.startValue = isRelative ? t.endValue + prevEndVal : prevEndVal;
t.setter(Quaternion.Euler(t.startValue));
}
public override void SetFrom(TweenerCore <Angle, Angle, AngleOptions> t, bool isRelative)
{
//開始値と終了値を反転させる
Angle prevEndAngle = t.endValue;
t.endValue = t.getter();
t.startValue = isRelative ? t.endValue + prevEndAngle : prevEndAngle;
t.setter(t.startValue);
}
public override void SetFrom(TweenerCore <VertexGradient, VertexGradient, NoOptions> t, bool isRelative)
{
var prevEndVal = t.endValue;
t.endValue = t.getter();
t.startValue = isRelative ? Add(t.endValue, prevEndVal) : prevEndVal;
t.startValue = prevEndVal;
t.setter(t.startValue);
}
public override void SetFrom(TweenerCore <Vector3, Vector3, TweenPlugVector3LookAtOptions> t, bool isRelative)
{
Vector3 prevEndVal = t.endValue;
t.endValue = t.getter();
t.startValue = isRelative ? t.endValue + prevEndVal : prevEndVal;
Vector3 to = t.startValue;
t.setter(to);
}
public override void SetRelativeEndValue(TweenerCore <Vector3, Path, PathOptions> t)
{
Vector3 startP = t.getter();
int count = t.endValue.wps.Length;
for (int i = 0; i < count; ++i)
{
t.endValue.wps[i] += startP;
}
}
internal static Tweener DoChangeEndValue <T1, T2, TPlugOptions>(TweenerCore <T1, T2, TPlugOptions> t, T2 newEndValue, float newDuration, bool snapStartValue) where TPlugOptions : struct
{
t.endValue = newEndValue;
t.isRelative = false;
if (!t.startupDone)
{
goto Label_0086;
}
if ((t.specialStartupMode != SpecialStartupMode.None) && !DOStartupSpecials <T1, T2, TPlugOptions>(t))
{
return(null);
}
if (snapStartValue)
{
if (DOTween.useSafeMode)
{
try
{
t.startValue = t.tweenPlugin.ConvertToStartValue(t, t.getter());
goto Label_007A;
}
catch
{
TweenManager.Despawn(t, true);
return(null);
}
}
t.startValue = t.tweenPlugin.ConvertToStartValue(t, t.getter());
}
Label_007A:
t.tweenPlugin.SetChangeValue(t);
Label_0086:
if (newDuration > 0f)
{
t.duration = newDuration;
if (t.startupDone)
{
DOStartupDurationBased <T1, T2, TPlugOptions>(t);
}
}
Tween.DoGoto(t, 0f, 0, UpdateMode.IgnoreOnUpdate);
return(t);
}
public override void SetRelativeEndValue(TweenerCore <Vector3, Path, PathOptions> t)
{
if (!t.endValue.isFinalized)
{
Vector3 b = t.getter();
int num = t.endValue.wps.Length;
for (int i = 0; i < num; i++)
{
ref Vector3 val = ref t.endValue.wps[i];
val += b;
}
}
public override void SetChangeValue(TweenerCore <Vector3, Path, PathOptions> t)
{
Transform transform = (Transform)t.target;
if (t.plugOptions.orientType == OrientType.ToPath && t.plugOptions.useLocalPosition)
{
t.plugOptions.parent = transform.parent;
}
if (t.endValue.isFinalized)
{
t.changeValue = t.endValue;
return;
}
Vector3 vector = t.getter();
Path endValue = t.endValue;
int num = endValue.wps.Length;
int num2 = 0;
bool flag = false;
bool flag2 = false;
if (endValue.wps[0] != vector)
{
flag = true;
num2++;
}
if (t.plugOptions.isClosedPath && endValue.wps[num - 1] != vector)
{
flag2 = true;
num2++;
}
int num3 = num + num2;
Vector3[] array = new Vector3[num3];
int num4 = flag ? 1 : 0;
if (flag)
{
array[0] = vector;
}
for (int i = 0; i < num; i++)
{
array[i + num4] = endValue.wps[i];
}
if (flag2)
{
array[array.Length - 1] = array[0];
}
endValue.wps = array;
endValue.FinalizePath(t.plugOptions.isClosedPath, t.plugOptions.lockPositionAxis, vector);
t.plugOptions.startupRot = transform.rotation;
t.plugOptions.startupZRot = transform.eulerAngles.z;
t.changeValue = t.endValue;
}
public override void SetFrom(TweenerCore <Color, Color, ColorOptions> t, Color fromValue, bool setImmediately)
{
t.startValue = fromValue;
if (setImmediately)
{
Color to = fromValue;
if (t.plugOptions.alphaOnly)
{
to = t.getter();
to.a = fromValue.a;
}
t.setter(to);
}
}
// Returns TRUE if it's successful, FALSE otherwise
// Behaves like a regular shake, but also changes the endValues so that they reflect the local axis rotation of the camera
internal static bool SetCameraShakePosition(TweenerCore<Vector3, Vector3[], Vector3ArrayOptions> t)
{
if (!SetShake(t)) return false;
Camera target = t.target as Camera;
if (target == null) return false;
Vector3 startupVal = t.getter();
Transform trans = target.transform;
int len = t.endValue.Length;
for (int i = 0; i < len; i++) {
Vector3 endVal = t.endValue[i];
t.endValue[i] = (trans.localRotation * (endVal - startupVal)) + startupVal;
}
return true;
}
// Returns TRUE if it's successful, FALSE otherwise
internal static bool SetPunch(TweenerCore<Vector3, Vector3[], Vector3ArrayOptions> t)
{
Vector3 startupVal;
try {
startupVal = t.getter();
} catch { return false; }
// Force specific settings
t.isRelative = t.isSpeedBased = false;
t.easeType = Ease.OutQuad;
t.customEase = null;
int len = t.endValue.Length;
for (int i = 0; i < len; i++) t.endValue[i] = t.endValue[i] + startupVal;
return true;
}
