protected void UpdateTween(RectTransform p_target, float p_delta, NodeFlowData p_flowData, Vector2 p_startPosition, Quaternion p_startRotation, Vector3 p_startScale, RectTransform p_towards, EaseType p_easeType)
{
if (p_target == null)
{
if (Model.killOnNullEncounter)
{
Stop_Internal();
}
return;
}
if (Model.useToPosition)
{
Vector2 towardsPosition = TransformExtensions.FromToRectTransform(p_towards, p_target);
//towardsPosition = towardsPosition - p_target.anchoredPosition;
towardsPosition = new Vector2(DashTween.EaseValue(p_startPosition.x, towardsPosition.x, p_delta, p_easeType),
DashTween.EaseValue(p_startPosition.y, towardsPosition.y, p_delta, p_easeType));
p_target.anchoredPosition = towardsPosition;
}
if (Model.useToRotation)
{
p_target.localRotation = Quaternion.Lerp(p_startRotation, p_towards.localRotation, p_delta);
}
if (Model.useToScale)
{
p_target.localScale = Vector3.Lerp(p_startScale, p_towards.localScale, p_delta);
}
}
protected override DashTween AnimateOnTarget(Transform p_target, NodeFlowData p_flowData)
{
Vector3 fromPosition = GetParameterValue <Vector3>(Model.fromPosition, p_flowData);
Vector3 startPosition = Model.useFrom
? Model.isFromRelative
? p_target.position + fromPosition
: fromPosition
: p_target.position;
if (Model.storeToAttribute)
{
string attribute = GetParameterValue(Model.storeAttributeName, p_flowData);
p_flowData.SetAttribute <Vector3>(attribute, p_target.position);
}
Vector3 finalPosition = GetParameterValue <Vector3>(Model.toPosition, p_flowData);
EaseType easeType = GetParameterValue(Model.easeType, p_flowData);
float time = GetParameterValue(Model.time, p_flowData);
float delay = GetParameterValue(Model.delay, p_flowData);
if (time == 0)
{
UpdateTween(p_target, 1, p_flowData, startPosition, finalPosition, easeType);
return(null);
}
return(DashTween.To(p_target, 0, 1, time).SetDelay(delay)
.OnUpdate(f => UpdateTween(p_target, f, p_flowData, startPosition, finalPosition, easeType)));
}
override protected void OnExecuteStart(NodeFlowData p_flowData)
{
if (_activeTweens == null)
{
_activeTweens = new List <DashTween>();
}
float time = GetParameterValue(Model.time, p_flowData);
if (time == 0)
{
OnExecuteEnd();
OnExecuteOutput(0, p_flowData);
}
else
{
DashTween tween = DashTween.To(Graph.Controller, 0, 1, time);
tween.OnComplete(() =>
{
OnExecuteEnd();
OnExecuteOutput(0, p_flowData);
_activeTweens.Remove(tween);
});
_activeTweens.Add(tween);
tween.Start();
}
}
DashTween ExecuteAs(CanvasGroup p_target, NodeFlowData p_flowData)
{
float startAlpha = Model.useFrom
? Model.isFromRelative
? p_target.alpha + GetParameterValue(Model.fromAlpha, p_flowData)
: GetParameterValue(Model.fromAlpha, p_flowData)
: p_target.alpha;
float toAlpha = GetParameterValue(Model.toAlpha, p_flowData);
float time = GetParameterValue(Model.time, p_flowData);
float delay = GetParameterValue(Model.delay, p_flowData);
EaseType easeType = GetParameterValue(Model.easeType, p_flowData);
if (Model.storeToAttribute)
{
string attribute = GetParameterValue(Model.storeAttributeName, p_flowData);
p_flowData.SetAttribute <float>(attribute, p_target.alpha);
}
if (time == 0)
{
UpdateTween(p_target, 1, p_flowData, startAlpha, toAlpha, easeType);
return(null);
}
else
{
return(DashTween.To(p_target, 0, 1, time)
.OnUpdate(f => UpdateTween(p_target, f, p_flowData, startAlpha, toAlpha, easeType))
.SetDelay(delay));
}
}
protected override void ExecuteOnTarget(Transform p_target, NodeFlowData p_flowData)
{
if (_activeTweens == null)
{
_activeTweens = new List <DashTween>();
}
if (p_target == null)
{
ExecuteEnd(p_flowData);
return;
}
DashTween tween = AnimateOnTarget(p_target, p_flowData);
if (tween == null)
{
ExecuteEnd(p_flowData);
}
else
{
_activeTweens.Add(tween);
tween.OnComplete(() =>
{
_activeTweens.Remove(tween);
ExecuteEnd(p_flowData);
}).Start();
}
}
protected void UpdateTween(Transform p_target, float p_delta, NodeFlowData p_flowData, Quaternion p_startRotation, Vector3 p_toRotation, EaseType p_easeType)
{
if (p_target == null)
{
if (Model.killOnNullEncounter)
{
Stop_Internal();
}
return;
}
Quaternion rotation = Quaternion.Euler(p_toRotation);
if (Model.isToRelative)
{
rotation = rotation * p_startRotation;
}
//p_target.localRotation = Quaternion.Lerp(p_startRotation, rotation, DOVirtual.EasedValue(0,1, p_delta, p_easing));
p_target.localRotation = Quaternion.Lerp(p_startRotation, rotation, DashTween.EaseValue(0, 1, p_delta, p_easeType));
/*
* Debug.Log(rotation.eulerAngles + " : " + p_toRotation + " : " + p_startRotation.eulerAngles);
* Vector3 finalRotation = rotation.eulerAngles;
* finalRotation.z = finalRotation.z > 180 ? finalRotation.z - 360 : finalRotation.z;
* Vector3 easedRotation = new Vector3(DOVirtual.EasedValue(0, finalRotation.x, p_delta, Model.easing),
* DOVirtual.EasedValue(0, finalRotation.y, p_delta, Model.easing),
* DOVirtual.EasedValue(0, finalRotation.z, p_delta, Model.easing));
*
* p_target.localRotation = p_startRotation * Quaternion.Euler(easedRotation);
*/
}
protected void UpdateTransformTween(Transform p_target, float p_delta, NodeFlowData p_flowData, Vector2 p_startPosition, Quaternion p_startRotation, Vector3 p_startScale, Transform p_towards, EaseType p_easeType)
{
if (p_target == null)
{
if (Model.killOnNullEncounter)
{
Stop_Internal();
}
return;
}
if (GetParameterValue(Model.useToPosition, p_flowData))
{
Vector2 towardsPosition = p_towards.position;
towardsPosition = new Vector2(DashTween.EaseValue(p_startPosition.x, towardsPosition.x, p_delta, p_easeType),
DashTween.EaseValue(p_startPosition.y, towardsPosition.y, p_delta, p_easeType));
p_target.position = towardsPosition;
}
if (GetParameterValue(Model.useToRotation, p_flowData))
{
p_target.localRotation = Quaternion.Lerp(p_startRotation, p_towards.localRotation, p_delta);
}
if (GetParameterValue(Model.useToScale, p_flowData))
{
p_target.localScale = Vector3.Lerp(p_startScale, p_towards.localScale, p_delta);
}
}
DashTween ExecuteAs(Image p_target, NodeFlowData p_flowData)
{
Color startColor = Model.useFrom ? GetParameterValue(Model.fromColor, p_flowData) : p_target.color;
Color toColor = GetParameterValue <Color>(Model.toColor, p_flowData);
float time = GetParameterValue(Model.time, p_flowData);
float delay = GetParameterValue(Model.delay, p_flowData);
EaseType easeType = GetParameterValue(Model.easeType, p_flowData);
if (Model.storeToAttribute)
{
string attribute = GetParameterValue(Model.storeAttributeName, p_flowData);
p_flowData.SetAttribute <Color>(attribute, p_target.color);
}
if (time == 0)
{
UpdateTween(p_target, 1, p_flowData, startColor, toColor);
return(null);
}
else
{
return(DashTween.To(p_target, 0, 1, time)
.OnUpdate(f => UpdateTween(p_target, f, p_flowData, startColor, toColor))
.SetDelay(delay).SetEase(easeType));
}
}
protected override DashTween AnimateOnTarget(Transform p_target, NodeFlowData p_flowData)
{
TMP_Text text = p_target.GetComponent <TMP_Text>();
if (CheckException(text, "No TMP_Text component found on target"))
{
return(null);
}
text.ForceMeshUpdate();
for (int i = 0; i < text.text.Length; i++)
{
TextMeshTweenUtils.Scale(text, i, 0);
}
float time = GetParameterValue(Model.time, p_flowData);
EaseType easeType = GetParameterValue(Model.easeType, p_flowData);
float characterDelay = GetParameterValue(Model.characterDelay, p_flowData);
for (int i = 0; i < text.text.Length; i++)
{
int index = i; // Rescope variable to avoid modified closure trap
DashTween.To(text, 0, 1, time)
.OnUpdate(f => TextMeshTweenUtils.Scale(text, index, f))
.SetDelay(index * characterDelay)
.SetEase(easeType)
.Start();
}
return(DashTween.To(p_target, 0, 1, text.text.Length * characterDelay));
}
protected void UpdatePositionTween(Transform p_target, float p_delta, NodeFlowData p_flowData, Vector3 p_startPosition, Vector3 p_finalPosition, bool p_relative, EaseType p_easeType)
{
if (p_target == null)
{
if (Model.killOnNullEncounter)
{
Stop_Internal();
}
return;
}
if (p_relative)
{
p_target.position =
p_startPosition + new Vector3(DashTween.EaseValue(0, p_finalPosition.x, p_delta, p_easeType),
DashTween.EaseValue(0, p_finalPosition.y, p_delta, p_easeType),
DashTween.EaseValue(0, p_finalPosition.z, p_delta, p_easeType));
}
else
{
p_target.position = new Vector3(DashTween.EaseValue(p_startPosition.x, p_finalPosition.x, p_delta, p_easeType),
DashTween.EaseValue(p_startPosition.y, p_finalPosition.y, p_delta, p_easeType),
DashTween.EaseValue(p_startPosition.z, p_finalPosition.z, p_delta, p_easeType));
}
}
protected override void ExecuteOnTarget(Transform p_target, NodeFlowData p_flowData)
{
if (_activeTweens == null)
{
_activeTweens = new List <DashTween>();
}
if (p_target == null)
{
ExecuteEnd(p_flowData);
return;
}
DashTween tween = Model.preset.Execute(p_target, ParameterResolver, p_flowData);
if (tween == null)
{
ExecuteEnd(p_flowData);
}
else
{
_activeTweens.Add(tween);
tween.OnComplete(() => ExecuteEnd(p_flowData, tween)).Start();
}
}
protected void UpdateScaleTween(Transform p_target, float p_delta, NodeFlowData p_flowData, Vector3 p_startScale, Vector3 p_toScale, bool p_relative, EaseType p_easeType)
{
if (p_target == null)
{
if (Model.killOnNullEncounter)
{
Stop_Internal();
}
return;
}
if (p_relative)
{
p_target.localScale = p_startScale + new Vector3(DashTween.EaseValue(0, p_toScale.x, p_delta, p_easeType),
DashTween.EaseValue(0, p_toScale.y, p_delta, p_easeType),
DashTween.EaseValue(0, p_toScale.z, p_delta, p_easeType));
}
else
{
p_toScale -= p_startScale;
p_target.localScale = p_startScale + new Vector3(DashTween.EaseValue(0, p_toScale.x, p_delta, p_easeType),
DashTween.EaseValue(0, p_toScale.y, p_delta, p_easeType),
DashTween.EaseValue(0, p_toScale.z, p_delta, p_easeType));
}
}
protected void ExecuteEnd(NodeFlowData p_flowData, DashTween p_tween = null)
{
if (p_tween != null)
{
_activeTweens.Remove(p_tween);
}
OnExecuteEnd();
OnExecuteOutput(0, p_flowData);
}
protected override void ExecuteOnTarget(Transform p_target, NodeFlowData p_flowData)
{
if (_activeTweens == null)
{
_activeTweens = new List <DashTween>();
}
if (p_target == null)
{
ExecuteEnd(p_flowData);
return;
}
for (int i = 0; i < p_target.childCount; i++)
{
NodeFlowData childData = p_flowData.Clone();
childData.SetAttribute("target", p_target.GetChild(Model.inReverse ? p_target.childCount - 1 - i : i));
if (GetParameterValue(Model.onChildDelay, p_flowData) == 0)
{
OnExecuteOutput(0, childData);
}
else
{
float time = GetParameterValue(Model.onChildDelay, p_flowData) * i;
DashTween tween = DashTween.To(Graph.Controller, 0, 1, time);
tween.OnComplete(() =>
{
_activeTweens.Remove(tween);
OnExecuteOutput(0, childData);
});
_activeTweens.Add(tween);
tween.Start();
}
}
if (Model.onFinishDelay == 0 && GetParameterValue(Model.onChildDelay, p_flowData) == 0)
{
ExecuteEnd(p_flowData);
}
else
{
float time = Model.onFinishDelay + GetParameterValue(Model.onChildDelay, p_flowData) * p_target.childCount;
DashTween tween = DashTween.To(Graph.Controller, 0, 1, time);
tween.OnComplete(() =>
{
_activeTweens.Remove(tween);
ExecuteEnd(p_flowData);
});
_activeTweens.Add(tween);
tween.Start();
}
}
protected override DashTween AnimateOnTarget(Transform p_target, NodeFlowData p_flowData)
{
Transform targetTransform = p_target.transform;
if (CheckException(targetTransform, "No RectTransform component found on target"))
{
return(null);
}
// TODO skip this if not using from rotation
Vector3 fromRotation = GetParameterValue(Model.fromRotation, p_flowData);
fromRotation.x = fromRotation.x > 180 ? fromRotation.x - 360 : fromRotation.x;
fromRotation.y = fromRotation.y > 180 ? fromRotation.y - 360 : fromRotation.y;
fromRotation.z = fromRotation.z > 180 ? fromRotation.z - 360 : fromRotation.z;
Quaternion startRotation = Model.useFrom
? Model.isFromRelative
? targetTransform.rotation * Quaternion.Euler(fromRotation)
: Quaternion.Euler(fromRotation)
: targetTransform.rotation;
if (Model.storeToAttribute)
{
string attribute = GetParameterValue(Model.storeAttributeName, p_flowData);
p_flowData.SetAttribute <Quaternion>(attribute, targetTransform.rotation);
}
Vector3 toRotation = GetParameterValue <Vector3>(Model.toRotation, p_flowData);
float time = GetParameterValue(Model.time, p_flowData);
float delay = GetParameterValue(Model.delay, p_flowData);
EaseType easing = GetParameterValue(Model.easeType, p_flowData);
if (time == 0)
{
UpdateTween(targetTransform, 1, p_flowData, startRotation, toRotation, easing);
return(null);
}
else
{
// Virtual tween to update from directly
// Tween tween = DOTween
// .To((f) => UpdateTween(targetTransform, f, p_flowData, startRotation, toRotation, easing), 0,
// 1, time)
// .SetDelay(delay)
// .SetEase(Ease.Linear);
return(DashTween.To(targetTransform, 0, 1, time)
.SetDelay(delay)
.OnUpdate(f => UpdateTween(targetTransform, f, p_flowData, startRotation, toRotation, easing)));
}
}
void OnUpdate()
{
if (!_previewStarted)
{
_previewStarted = true;
_previewGraph.Nodes[_previewNodeIndex].Execute(NodeFlowDataFactory.Create(Controller.transform));
}
if (_isPreviewing)
{
if (_previewGraph.CurrentExecutionCount == 0)
{
DashTween.DelayedCall(1f, StopPreview);
}
}
}
public void StopPreview()
{
DashTween.CleanAll();
DashTweenCore.Uninitialize();
DashCore.Instance.CleanPrefabPools();
DashCore.Instance.CleanSequencers();
EditorApplication.update -= OnUpdate;
if (!_isPreviewing)
{
return;
}
_isPreviewing = false;
if (_stage == null)
{
// Since we can do almost anything in preview we need to reload the scene before it
EditorSceneManager.OpenScene(EditorSceneManager.GetActiveScene().path);
DashController[] controllers = GameObject.FindObjectsOfType <DashController>();
DashController controller = controllers.ToList().Find(c => c.previewing);
DashEditorCore.EditController(controller, DashEditorCore.EditorConfig.editingGraphPath);
controller.previewing = false;
EditorUtility.SetDirty(controller);
EditorSceneManager.SaveOpenScenes();
Selection.activeGameObject = controller.gameObject;
}
else
{
_stage.GetType().GetMethod("ReloadStage", BindingFlags.Instance | BindingFlags.NonPublic).Invoke(_stage, new object[] {});
DashController[] controllers = _stage.prefabContentsRoot.GetComponentsInChildren <DashController>();
DashController controller = controllers.ToList().Find(c => c.previewing);
DashEditorCore.EditController(controller, DashEditorCore.EditorConfig.editingGraphPath);
controller.previewing = false;
if (_controllerSelected)
{
Selection.objects = new Object[] { controller.gameObject };
}
bool state = (bool)_stage.GetType().GetMethod("SavePrefab", BindingFlags.Instance | BindingFlags.NonPublic).Invoke(_stage, new object[] {});
}
}
override protected DashTween AnimateOnTarget(Transform p_target, NodeFlowData p_flowData)
{
float time = GetParameterValue(Model.time, p_flowData);
float delay = GetParameterValue(Model.delay, p_flowData);
EaseType easeType = GetParameterValue(Model.easeType, p_flowData);
DashTween tween;
if (Model.useDashAnimation)
{
if (Model.source == null)
{
SetError("Animation source cannot be null");
return(null);
}
CacheStarts(p_target);
// Change time if we are using custom one
time = Model.useAnimationTime ? Model.source.Duration : time;
// Virtual tween to update from sampler
tween = DashTween.To(p_target, 0, Model.source.Duration, time)
.OnUpdate(f => UpdateFromAnimation(p_target, f))
.SetDelay(delay)
.SetEase(easeType);
}
else
{
if (Model.clip == null)
{
SetError("Animation clip cannot be null");
return(null);
}
// Change time if we are using custom one
time = Model.useAnimationTime ? Model.clip.length : time;
// Virtual tween to update from sampler
tween = DashTween.To(p_target, 0, Model.clip.length, time)
.OnUpdate(f => UpdateFromClip(p_target, f))
.SetDelay(delay)
.SetEase(easeType);
}
return(tween);
}
protected override DashTween AnimateOnTarget(Transform p_target, NodeFlowData p_flowData)
{
RectTransform rectTransform = (RectTransform)p_target;
if (CheckException(rectTransform, "No RectTransform component found on target"))
{
return(null);
}
Transform towards = Model.toTarget.Resolve(Controller);
if (CheckException(towards, "Towards not defined in node " + _model.id))
{
return(null);
}
RectTransform rectTowards = towards.GetComponent <RectTransform>();
if (CheckException(rectTowards, "No RectTransform component found on towards"))
{
return(null);
}
Vector2 startPosition = rectTransform.anchoredPosition;
Quaternion startRotation = rectTransform.localRotation;
Vector3 startScale = rectTransform.localScale;
float time = GetParameterValue(Model.time, p_flowData);
float delay = GetParameterValue(Model.delay, p_flowData);
EaseType easeType = GetParameterValue(Model.easeType, p_flowData);
if (time == 0)
{
UpdateTween(rectTransform, 1, p_flowData, startPosition, startRotation, startScale, rectTowards, easeType);
return(null);
}
else
{
// Virtual tween to update from directly
return(DashTween.To(rectTransform, 0, 1, time)
.OnUpdate(f => UpdateTween(rectTransform, f, p_flowData, startPosition, startRotation, startScale,
rectTowards, easeType))
.SetDelay(delay));
}
}
protected void UpdateRotationTween(Transform p_target, float p_delta, NodeFlowData p_flowData, Quaternion p_startRotation, Vector3 p_toRotation, bool p_relative, EaseType p_easeType)
{
if (p_target == null)
{
if (Model.killOnNullEncounter)
{
Stop_Internal();
}
return;
}
Quaternion rotation = Quaternion.Euler(p_toRotation);
if (p_relative)
{
rotation = rotation * p_startRotation;
}
p_target.localRotation = Quaternion.Lerp(p_startRotation, rotation, DashTween.EaseValue(0, 1, p_delta, p_easeType));
}
protected override DashTween AnimateOnTarget(Transform p_target, NodeFlowData p_flowData)
{
Transform targetTransform = p_target.transform;
if (CheckException(targetTransform, "No RectTransform component found on target"))
{
return(null);
}
Vector3 fromScale = GetParameterValue(Model.fromScale, p_flowData);
Vector3 startScale = Model.useFrom
? Model.isFromRelative
? targetTransform.localScale + Model.fromScale.GetValue(ParameterResolver, p_flowData)
: fromScale
: targetTransform.localScale;
if (Model.storeToAttribute)
{
string attribute = GetParameterValue(Model.storeAttributeName, p_flowData);
p_flowData.SetAttribute <Vector3>(attribute, targetTransform.localScale);
}
Vector3 toScale = GetParameterValue(Model.toScale, p_flowData);
float time = GetParameterValue(Model.time, p_flowData);
float delay = GetParameterValue(Model.delay, p_flowData);
EaseType easeType = GetParameterValue(Model.easeType, p_flowData);
if (time == 0)
{
UpdateTween(targetTransform, 1, p_flowData, startScale, toScale, easeType);
return(null);
}
else
{
// Virtual tween to update from directly
return(DashTween.To(targetTransform, 0, 1, time)
.OnUpdate(f => UpdateTween(targetTransform, f, p_flowData, startScale, toScale, easeType))
.SetDelay(delay));
}
}
protected override DashTween AnimateOnTarget(Transform p_target, NodeFlowData p_flowData)
{
RectTransform rectTransform = p_target.GetComponent <RectTransform>();
if (CheckException(rectTransform, "Target doesn't contain RectTransform"))
{
return(null);
}
Vector2 fromSizeDelta = GetParameterValue(Model.fromSizeDelta, p_flowData);
Vector2 startSizeDelta = Model.useFrom
? Model.isFromRelative
? rectTransform.sizeDelta + fromSizeDelta
: fromSizeDelta
: rectTransform.sizeDelta;
if (Model.storeToAttribute)
{
string attribute = GetParameterValue(Model.storeAttributeName, p_flowData);
p_flowData.SetAttribute <Vector2>(attribute, rectTransform.sizeDelta);
}
Vector2 toSizeDelta = GetParameterValue(Model.toSizeDelta, p_flowData);
float time = GetParameterValue(Model.time, p_flowData);
float delay = GetParameterValue(Model.delay, p_flowData);
EaseType easeType = GetParameterValue(Model.easeType, p_flowData);
if (time == 0)
{
UpdateTween(rectTransform, 1, p_flowData, startSizeDelta, toSizeDelta, easeType);
return(null);
}
else
{
// Virtual tween to update from directly
return(DashTween.To(rectTransform, 0, 1, time).SetDelay(delay)
.OnUpdate(f => UpdateTween(rectTransform, f, p_flowData, startSizeDelta, toSizeDelta, easeType)));
}
}
protected void UpdateTween(CanvasGroup p_target, float p_delta, NodeFlowData p_flowData, float p_startAlpha, float p_toAlpha, EaseType p_easeType)
{
;
// Check if the target wasn't destroyed while the tween is running, correctly end user should also destroy all tweens explicitly
if (p_target == null)
{
if (Model.killOnNullEncounter)
{
Stop_Internal();
}
return;
}
if (Model.isToRelative)
{
p_target.alpha = p_startAlpha + DashTween.EaseValue(0, p_toAlpha, p_delta, p_easeType);
}
else
{
p_target.alpha = DashTween.EaseValue(p_startAlpha, p_toAlpha, p_delta, p_easeType);
}
}
protected override DashTween AnimateOnTarget(Transform p_target, NodeFlowData p_flowData)
{
RectTransform rectTransform = p_target.GetComponent <RectTransform>();
if (CheckException(rectTransform, "No RectTransform component found on target"))
{
return(null);
}
Vector2 fromPosition = GetParameterValue <Vector2>(Model.fromPosition, p_flowData);
Vector2 startPosition = Model.useFrom
? Model.isFromRelative
? rectTransform.anchoredPosition + fromPosition
: fromPosition
: rectTransform.anchoredPosition;
if (Model.storeToAttribute)
{
string attribute = GetParameterValue(Model.storeAttributeName, p_flowData);
p_flowData.SetAttribute <Vector2>(attribute, rectTransform.anchoredPosition);
}
Vector2 finalPosition = GetParameterValue <Vector2>(Model.toPosition, p_flowData);
EaseType easeType = GetParameterValue(Model.easeType, p_flowData);
float time = GetParameterValue(Model.time, p_flowData);
float delay = GetParameterValue(Model.delay, p_flowData);
if (time == 0)
{
UpdateTween(rectTransform, 1, p_flowData, startPosition, finalPosition, easeType);
return(null);
}
return(DashTween.To(rectTransform, 0, 1, time).SetDelay(delay)
.OnUpdate(f => UpdateTween(rectTransform, f, p_flowData, startPosition, finalPosition, easeType)));
}
protected void UpdateTween(RectTransform p_target, float p_delta, NodeFlowData p_flowData, Vector2 p_startSizeDelta, Vector2 p_toSizeDelta, EaseType p_easeType)
{
if (p_target == null)
{
if (Model.killOnNullEncounter)
{
Stop_Internal();
}
return;
}
if (Model.isToRelative)
{
p_target.sizeDelta =
p_startSizeDelta + new Vector2(DashTween.EaseValue(0, p_toSizeDelta.x, p_delta, p_easeType),
DashTween.EaseValue(0, p_toSizeDelta.y, p_delta, p_easeType));
}
else
{
p_target.sizeDelta = new Vector2(DashTween.EaseValue(p_startSizeDelta.x, p_toSizeDelta.x, p_delta, p_easeType),
DashTween.EaseValue(p_startSizeDelta.y, p_toSizeDelta.y, p_delta, p_easeType));
}
}
protected void UpdateTween(RectTransform p_target, float p_delta, NodeFlowData p_flowData, Vector2 p_startPosition, Vector2 p_finalPosition, EaseType p_easeType)
{
if (p_target == null)
{
if (Model.killOnNullEncounter)
{
Stop_Internal();
}
return;
}
if (Model.isToRelative)
{
p_target.anchoredPosition =
p_startPosition + new Vector2(DashTween.EaseValue(0, p_finalPosition.x, p_delta, p_easeType),
DashTween.EaseValue(0, p_finalPosition.y, p_delta, p_easeType));
}
else
{
p_target.anchoredPosition = new Vector2(DashTween.EaseValue(p_startPosition.x, p_finalPosition.x, p_delta, p_easeType),
DashTween.EaseValue(p_startPosition.y, p_finalPosition.y, p_delta, p_easeType));
}
}
override protected void OnExecuteStart(NodeFlowData p_flowData)
{
if (_activeTweens == null)
{
_activeTweens = new List <DashTween>();
}
List <Transform> transforms = new List <Transform>();
Transform transform;
if (!string.IsNullOrEmpty(Model.target))
{
if (!p_flowData.HasAttribute("target") && Model.isChild)
{
Debug.LogWarning("Cannot retarget to a child of null in node " + _model.id);
hasErrorsInExecution = true;
OnExecuteEnd();
return;
}
if (Model.isChild)
{
if (Model.findAll)
{
transforms = Controller.transform.DeepFindAll(Model.target);
}
else
{
transform = Controller.transform.DeepFind(Model.target);
if (transform != null)
{
transforms.Add(transform);
}
}
}
else
{
if (Model.findAll)
{
transforms = Controller.transform.root.DeepFindAll(Model.target);
}
else
{
transform = Controller.transform.root.DeepFind(Model.target);
if (transform != null)
{
transforms.Add(transform);
}
}
}
if (transforms.Count == 0)
{
Debug.LogWarning("Zero valid retargets found in node " + _model.id);
hasErrorsInExecution = true;
OnExecuteEnd();
return;
}
for (int i = 0; i < transforms.Count; i++)
{
transform = Model.inReverse ? transforms[transforms.Count - i - 1] : transforms[i];
NodeFlowData data = p_flowData.Clone();
data.SetAttribute("target", transform);
if (Model.delay.GetValue(ParameterResolver) == 0)
{
OnExecuteOutput(0, data);
}
else
{
float time = Model.delay.GetValue(ParameterResolver) * i;
DashTween tween = DashTween.To(Graph.Controller, 0, 1, time);
tween.OnComplete(() =>
{
_activeTweens.Remove(tween);
OnExecuteOutput(0, data);
});
tween.Start();
_activeTweens.Add(tween);
}
}
if (Model.delay.GetValue(ParameterResolver) == 0)
{
OnExecuteEnd();
}
else
{
float time = Model.delay.GetValue(ParameterResolver) * transforms.Count;
DashTween tween = DashTween.To(Graph.Controller, 0, 1, time);
tween.OnComplete(() =>
{
_activeTweens.Remove(tween);
OnExecuteEnd();
});
tween.Start();
_activeTweens.Add(tween);
}
}
else
{
Debug.LogWarning("Zero valid retargets found in node " + _model.id);
hasErrorsInExecution = true;
OnExecuteEnd();
}
}
protected override DashTween AnimateOnTarget(Transform p_target, NodeFlowData p_flowData)
{
bool useRectTransform = GetParameterValue(Model.useRectTransform, p_flowData);
Transform targetTransform;
if (Model.useToExpression)
{
var value = ExpressionEvaluator.EvaluateUntypedExpression(Model.targetToExpression,
ParameterResolver, p_flowData, false);
if (ExpressionEvaluator.hasErrorInEvaluation)
{
SetError(ExpressionEvaluator.errorMessage);
return(null);
}
targetTransform = value as Transform;
if (targetTransform == null && value.GetType() == typeof(GameObject))
{
targetTransform = (value as GameObject).transform;
}
else if (targetTransform == null && value is Component)
{
targetTransform = (value as Component).transform;
}
}
else
{
targetTransform = Model.targetTransform.Resolve(Controller);
}
if (CheckException(targetTransform, "Target transform null."))
{
return(null);
}
Vector2 startPosition = p_target.position;
Quaternion startRotation = p_target.localRotation;
Vector3 startScale = p_target.localScale;
if (useRectTransform)
{
RectTransform rectTransform = (RectTransform)p_target;
if (CheckException(rectTransform, "No RectTransform component found on target."))
{
return(null);
}
RectTransform targetRectTransform = (RectTransform)targetTransform;
if (CheckException(targetRectTransform, "No RectTransform component found on target transform."))
{
return(null);
}
startPosition = rectTransform.anchoredPosition;
}
float time = GetParameterValue(Model.time, p_flowData);
float delay = GetParameterValue(Model.delay, p_flowData);
EaseType easeType = GetParameterValue(Model.easeType, p_flowData);
if (time == 0)
{
if (useRectTransform)
{
UpdateRectTransformTween((RectTransform)p_target, 1, p_flowData, startPosition, startRotation,
startScale, (RectTransform)targetTransform, easeType);
}
else
{
UpdateTransformTween(p_target, 1, p_flowData, startPosition, startRotation, startScale,
targetTransform, easeType);
}
return(null);
}
else
{
if (useRectTransform)
{
return(DashTween.To((RectTransform)p_target, 0, 1, time)
.OnUpdate(f => UpdateRectTransformTween((RectTransform)p_target, f, p_flowData,
startPosition, startRotation, startScale, (RectTransform)targetTransform, easeType))
.SetDelay(delay));
}
else
{
return(DashTween.To((RectTransform)p_target, 0, 1, time)
.OnUpdate(f => UpdateTransformTween(p_target, f, p_flowData, startPosition, startRotation,
startScale, targetTransform, easeType))
.SetDelay(delay));
}
}
}
protected override DashTween AnimateOnTarget(Transform p_target, NodeFlowData p_flowData)
{
// Position
bool usePosition = GetParameterValue(Model.usePosition, p_flowData);
bool useFromPosition = GetParameterValue(Model.useFromPosition, p_flowData);
Vector3 fromPosition = GetParameterValue(Model.fromPosition, p_flowData);
bool isFromPositionRelative = GetParameterValue(Model.isFromPositionRelative, p_flowData);
bool storePositionToAttribute = GetParameterValue(Model.storePositionToAttribute, p_flowData);
Vector3 startPosition = useFromPosition
? isFromPositionRelative
? p_target.position + fromPosition
: fromPosition
: p_target.position;
if (storePositionToAttribute)
{
string attribute = GetParameterValue(Model.storePositionAttributeName, p_flowData);
p_flowData.SetAttribute(attribute, p_target.position);
}
Vector3 finalPosition = GetParameterValue(Model.toPosition, p_flowData);
bool isToPositionRelative = GetParameterValue(Model.isToPositionRelative, p_flowData);
EaseType easeType = GetParameterValue(Model.easeType, p_flowData);
// Rotation
bool useRotation = GetParameterValue(Model.useRotation, p_flowData);
bool useFromRotation = GetParameterValue(Model.useFromRotation, p_flowData);
Vector3 fromRotation = GetParameterValue(Model.fromRotation, p_flowData);
fromRotation.x = fromRotation.x > 180 ? fromRotation.x - 360 : fromRotation.x;
fromRotation.y = fromRotation.y > 180 ? fromRotation.y - 360 : fromRotation.y;
fromRotation.z = fromRotation.z > 180 ? fromRotation.z - 360 : fromRotation.z;
bool isFromRotationRelative = GetParameterValue(Model.isFromRotationRelative, p_flowData);
Quaternion startRotation = useFromPosition
? isFromPositionRelative
? p_target.rotation * Quaternion.Euler(fromRotation)
: Quaternion.Euler(fromRotation)
: p_target.rotation;
bool storeRotationToAttribute = GetParameterValue(Model.storeRotationToAttribute, p_flowData);
if (storeRotationToAttribute)
{
string attribute = GetParameterValue(Model.storeRotationAttributeName, p_flowData);
p_flowData.SetAttribute <Quaternion>(attribute, p_target.rotation);
}
Vector3 toRotation = GetParameterValue <Vector3>(Model.toRotation, p_flowData);
// Scale
bool useScale = GetParameterValue(Model.useScale, p_flowData);
bool useFromScale = GetParameterValue(Model.useFromScale, p_flowData);
Vector3 fromScale = GetParameterValue(Model.fromScale, p_flowData);
bool isFromScaleRelative = GetParameterValue(Model.isFromScaleRelative, p_flowData);
Vector3 startScale = useFromScale
? isFromScaleRelative
? p_target.localScale + Model.fromScale.GetValue(ParameterResolver, p_flowData)
: fromScale
: p_target.localScale;
bool storeScaleToAttribute = GetParameterValue(Model.storeScaleToAttribute, p_flowData);
if (storeScaleToAttribute)
{
string attribute = GetParameterValue(Model.storeScaleAttributeName, p_flowData);
p_flowData.SetAttribute <Vector3>(attribute, p_target.localScale);
}
Vector3 toScale = GetParameterValue(Model.toScale, p_flowData);
bool isToScaleRelative = GetParameterValue(Model.isToScaleRelative, p_flowData);
// Animation
float time = GetParameterValue(Model.time, p_flowData);
float delay = GetParameterValue(Model.delay, p_flowData);
if (time == 0)
{
if (usePosition)
{
UpdatePositionTween(p_target, 1, p_flowData, startPosition, finalPosition, isToPositionRelative, easeType);
}
if (useRotation)
{
UpdateRotationTween(p_target, 1, p_flowData, startRotation, toRotation, isToPositionRelative, easeType);
}
if (useScale)
{
UpdateScaleTween(p_target, 1, p_flowData, startScale, toScale, isToScaleRelative, easeType);
}
return(null);
}
return(DashTween.To(p_target, 0, 1, time).SetDelay(delay)
.OnUpdate(f =>
{
if (usePosition)
{
UpdatePositionTween(p_target, f, p_flowData, startPosition, finalPosition, isToPositionRelative,
easeType);
}
if (useRotation)
{
UpdateRotationTween(p_target, f, p_flowData, startRotation, toRotation, isToPositionRelative,
easeType);
}
if (useScale)
{
UpdateScaleTween(p_target, f, p_flowData, startScale, toScale, isToScaleRelative, easeType);
}
}));
}
protected override void OnExecuteStart(NodeFlowData p_flowData)
{
if (_activeTweens == null)
{
_activeTweens = new List <DashTween>();
}
int firstIndex = GetParameterValue(Model.firstIndex, p_flowData);
int lastIndex = GetParameterValue(Model.lastIndex, p_flowData);
int length = lastIndex - firstIndex;
if (length == 0)
{
EndLoop(p_flowData);
}
for (int i = firstIndex; i != lastIndex; i += Math.Abs(length) / length)
{
NodeFlowData data = p_flowData.Clone();
if (Model.addIndexAttribute)
{
data.SetAttribute(Model.indexAttribute, i);
}
if (GetParameterValue(Model.OnIterationDelay, p_flowData) == 0)
{
OnExecuteOutput(0, data);
}
else
{
float time = GetParameterValue(Model.OnIterationDelay, p_flowData) * i;
DashTween tween = DashTween.To(Graph.Controller, 0, 1, time);
_activeTweens.Add(tween);
tween.OnComplete(() =>
{
_activeTweens.Remove(tween);
OnExecuteOutput(0, data);
});
tween.Start();
}
}
if (Model.OnFinishedDelay == 0 && GetParameterValue(Model.OnIterationDelay, p_flowData) == 0)
{
EndLoop(p_flowData);
}
else
{
float time = Model.OnFinishedDelay + GetParameterValue(Model.OnIterationDelay, p_flowData) * length;
DashTween tween = DashTween.To(Graph.Controller, 0, 1, time);
_activeTweens.Add(tween);
tween.OnComplete(() =>
{
_activeTweens.Remove(tween);
EndLoop(p_flowData);
});
tween.Start();
}
}
