public float GetFinalTime(SE_Animation anim, int index)
{
float start, eDuration;
GetElementTimes(anim, index, out start, out eDuration);
return(start + eDuration);
}
public override void Apply_Characters(TextAnimation se, SE_Animation anim, int sequenceIndex)
{
if (anim.mTime < mDelay && !_InitAllElements)
{
return;
}
// Iterate through all the valid range
for (int iElement = mElementRangeStart; iElement < mElementRangeEnd; ++iElement)
{
float progress = GetProgress(anim.mTime, anim, iElement);
if (!_InitAllElements && progress < 0)
{
continue;
}
progress = progress < 0 ? 0 : progress;
progress = _EasingCurve.Evaluate(progress);
var currentColor = TextAnimation.mOriginalVertices.Buffer[iElement * 4].color;
// Find Color for this Character
var newColor = _Gradient.Evaluate(progress);//Color32.Lerp(cFrom, cTo, progress);
//--[ Blend ]----------------------------
switch (_ColorBlend)
{
case eColorBlendMode.Replace: break;
case eColorBlendMode.Multiply: newColor = newColor * currentColor; break;
case eColorBlendMode.Additive: newColor = newColor + currentColor; break;
case eColorBlendMode.AlphaBlend: newColor = Color.Lerp(currentColor, newColor, newColor.a); break;
}
if (_ApplyR)
{
currentColor.r = (byte)(newColor.r * 255);
}
if (_ApplyG)
{
currentColor.g = (byte)(newColor.g * 255);
}
if (_ApplyB)
{
currentColor.b = (byte)(newColor.b * 255);
}
if (_ApplyA)
{
currentColor.a = (byte)(newColor.a * 255);
}
// Apply to all Vertices
for (int v = iElement * 4; v < iElement * 4 + 4; ++v)
{
TextAnimation.mOriginalVertices.Buffer[v].color = currentColor;
}
}
}
public override void OnStop(TextAnimation se, SE_Animation anim, int sequenceIndex)
{
if (!Application.isPlaying || !_OnFinish_SetAlphaToFinalValue)
{
return;
}
var currentAlpha = se.mWidgetColor.a;
float t = anim._Backwards ? 0 : 1;
var progress = _EasingCurve.Evaluate(t);
//--[ From ]----------------------------
float aFrom = _From * 255;
if (_AnimBlend_From == eFloatAnimBlendMode.Offset)
{
aFrom = aFrom + currentAlpha;
}
if (_AnimBlend_From == eFloatAnimBlendMode.Blend)
{
aFrom = _From * currentAlpha;
}
if (HasRandom(_FromRandom))
{
aFrom += 255 * _FromRandom * DRandom.GetUnit(0);
}
//--[ To ]----------------------------
float aTo = 255 * _To;
if (_AnimBlend_To == eFloatAnimBlendMode.Offset)
{
aTo = (currentAlpha + _To);
}
if (_AnimBlend_To == eFloatAnimBlendMode.Blend)
{
aTo = (currentAlpha * _To);
}
if (HasRandom(_ToRandom))
{
aTo += 255 * _ToRandom * DRandom.GetUnit(0 * 2 + 90);
}
// Find Alpha for this Character
float falpha = (aFrom + (aTo - aFrom) * progress);
byte alpha = (byte)(falpha < 0 ? 0 : falpha > 255 ? 255 : falpha);
var color = se.mWidgetColor;
color.a = alpha;
se.SetWidgetColor(color);
}
public virtual int GetRandomSeed(SE_Animation anim, int sequenceIndex)
{
float t = anim.mTime - mDelay;
if (t < 0.0001f)
{
t = 0.0001f;
}
return(anim.mRandomSeed + (anim.GetCurrentLoop() * anim._Sequences.Length + Mathf.CeilToInt(t / mTotalLoopDuration)) * 20 * sequenceIndex);
}
public SE_Animation CreateAnimation()
{
if (_Preset != null)
{
mAnimation = _Preset.CreateAnimation();
}
else
{
mAnimation = SE_Animation.LoadFromSerializedData(_LocalSerializedData) ?? new SE_Animation();
}
return(mAnimation);
}
public override void OnInspectorGUI()
{
#if UNITY_5_6_OR_NEWER
serializedObject.UpdateIfRequiredOrScript();
#else
serializedObject.UpdateIfDirtyOrScript();
#endif
EditorGUIUtility.labelWidth = 50;
GUI.backgroundColor = Color.Lerp(Color.black, Color.gray, 1);
GUILayout.BeginVertical(I2_InspectorTools.GUIStyle_Background, GUILayout.Height(1));
GUI.backgroundColor = Color.white;
//--[ HEADER ]----------------------
if (GUILayout.Button("SE Animation", I2_InspectorTools.GUIStyle_Header))
{
//Application.OpenURL(SE_InspectorTools.HelpURL_Documentation);
}
GUILayout.Space(5);
//--[ INSPECTOR ]---------------------
EditorGUI.BeginChangeCheck();
mInspector.OnGUI_Animation();
if (EditorGUI.EndChangeCheck() || mDirty)
{
mDirty = false;
var data = SE_Animation.SaveSerializedData(mInspector.mAnimation);
if (mProp_SerializedData.stringValue != data)
{
mProp_SerializedData.stringValue = data;
//Debug.Log(data);
}
}
//--[ FOOTER ]-------------------------
GUILayout.Space(10);
GUILayout.FlexibleSpace();
GUITools.OnGUI_Footer("I2 TextAnimation", I2_InspectorTools.GetVersion(), I2_InspectorTools.HelpURL_forum, I2_InspectorTools.HelpURL_Documentation, I2_InspectorTools.HelpURL_AssetStore);
EditorGUIUtility.labelWidth = 0;
GUILayout.EndVertical();
serializedObject.ApplyModifiedProperties();
}
public static string SaveSerializedData(SE_Animation anim)
{
try
{
var writer = new System.IO.StringWriter(System.Globalization.CultureInfo.InvariantCulture);
var serializer = new System.Xml.Serialization.XmlSerializer(typeof(SE_Animation), mAnimSequenceTypes);
serializer.Serialize(writer, anim);
//Debug.Log(writer.ToString());
return(writer.ToString());
}
catch (Exception) { }
return(null);
}
public SE_Animation_Inspector(SE_Animation anim, TextAnimation se)
{
mTextAnimation = se;
mAnimation = anim;
if (mTextAnimation != null && !Application.isPlaying)
{
mTextAnimation.StopAllAnimations(false);
}
mAnimation.InitTimes(mTextAnimation, true);
if (!Application.isPlaying)
{
mAnimation.Play(mTextAnimation);
}
AnimationControls_StopPlaying(true);
}
public override void OnStop(TextAnimation se, SE_Animation anim, int sequenceIndex)
{
if (!Application.isPlaying || !_OnFinish_SetColorToFinalValue)
{
return;
}
float t = anim._Backwards ? 0 : 1;
var progress = _EasingCurve.Evaluate(t);
var currentColor = se.mWidgetColor;
// Find Color for this Character
var newColor = _Gradient.Evaluate(progress);
//--[ Blend ]----------------------------
switch (_ColorBlend)
{
case eColorBlendMode.Replace: break;
case eColorBlendMode.Multiply: newColor = newColor * currentColor; break;
case eColorBlendMode.Additive: newColor = newColor + currentColor; break;
case eColorBlendMode.AlphaBlend: newColor = Color.Lerp(currentColor, newColor, newColor.a); break;
}
if (_ApplyR)
{
currentColor.r = (byte)(newColor.r * 255);
}
if (_ApplyG)
{
currentColor.g = (byte)(newColor.g * 255);
}
if (_ApplyB)
{
currentColor.b = (byte)(newColor.b * 255);
}
if (_ApplyA)
{
currentColor.a = (byte)(newColor.a * 255);
}
se.SetWidgetColor(currentColor);
}
public void GetElementTimes(SE_Animation anim, int index, out float startTime, out float elementDuration)
{
startTime = index * mElementDelay;
elementDuration = mElementDuration;
float loopTime = mTotalTime - mDelay;
int randomSeedBase = anim.mRandomSeed + 10 * anim.GetCurrentLoop() - DRandom.mCurrentSeed;
if (_DurationRandom_Slower > 0 || _DurationRandom_Faster > 0)
{
float durRangeSlower = _DurationRandom_Slower * loopTime;
float durRangeFaster = _DurationRandom_Faster * elementDuration;
float minDuration = elementDuration - durRangeFaster; if (minDuration < 0.001f)
{
minDuration = 0.001f;
}
float maxDuration = elementDuration + durRangeSlower; if (maxDuration > loopTime - startTime)
{
maxDuration = loopTime - startTime;
}
elementDuration = DRandom.Get(index + randomSeedBase, minDuration, maxDuration);
}
if (_RandomStart > 0)
{
float randRange = _RandomStart * loopTime;
float minStart = startTime - randRange; if (minStart < 0)
{
minStart = 0;
}
float maxStart = startTime + randRange; if (maxStart > loopTime - elementDuration)
{
maxStart = loopTime - elementDuration;
}
startTime = DRandom.Get(index + randomSeedBase, minStart, maxStart);
}
if (_Backwards)
{
startTime = mTotalTime - (startTime + mDelay) - elementDuration;
}
}
public void OnGUI_AnimationSlot()
{
var prop_Slot = mSerialized_AnimationSlots.GetArrayElementAtIndex(mAnimationsReorderableList.index);
var prop_SlotPreset = prop_Slot.FindPropertyRelative("_Preset");
var prop_SlotLocalData = prop_Slot.FindPropertyRelative("_LocalSerializedData");
if (mEditor_SelectedAnim == null || iCurrentAnimationSlot != mAnimationsReorderableList.index)
{
iCurrentAnimationSlot = mAnimationsReorderableList.index;
if (prop_SlotPreset.objectReferenceValue != null)
{
mSerializedObject_SelectedAnim = new SerializedObject(prop_SlotPreset.objectReferenceValue);
}
else
{
mSerializedObject_SelectedAnim = null;
}
DestroyAnimationInspector();
mEditor_SelectedAnim = new SE_Animation_Inspector(mTarget._AnimationSlots[iCurrentAnimationSlot]._Animation /*CreateAnimation()*/, mTarget);
}
if (prop_SlotPreset.objectReferenceValue != null && mSerializedObject_SelectedAnim != null)
{
#if UNITY_5_6_OR_NEWER
mSerializedObject_SelectedAnim.UpdateIfRequiredOrScript();
#else
mSerializedObject_SelectedAnim.UpdateIfDirtyOrScript();
#endif
}
GUILayout.Space(10);
//GUITools.DrawHeader("Animation", true);
var boxArea = new GUIStyle("Box");
boxArea.overflow = new RectOffset(2, 2, 0, 0);
bool deselectAnimation = false;
GUILayout.BeginHorizontal(boxArea);
GUILayout.Toggle(true, "Animation", EditorStyles.foldout);
GUILayout.FlexibleSpace();
deselectAnimation = GUILayout.Button("X", EditorStyles.miniButton);
GUILayout.EndHorizontal();
GUILayout.Space(-4);
GUI.backgroundColor = GUITools.DarkGray;
GUILayout.BeginVertical(/*EditorStyles.textArea, */ GUILayout.Height(1));
GUI.backgroundColor = Color.white;
EditorGUI.BeginChangeCheck();
mEditor_SelectedAnim.OnGUI_Animation();
if (EditorGUI.EndChangeCheck() || SE_AnimationPreset_Inspector.mDirty)
{
SE_AnimationPreset_Inspector.mDirty = false;
var data = SE_Animation.SaveSerializedData(mEditor_SelectedAnim.mAnimation);
if (prop_SlotLocalData.stringValue != data)
{
prop_SlotLocalData.stringValue = data;
//Debug.Log(data);
}
if (prop_SlotPreset.objectReferenceValue != null)
{
var prop_PresetData = mSerializedObject_SelectedAnim.FindProperty("mSerializedData");
if (prop_PresetData.stringValue != data)
{
prop_PresetData.stringValue = data;
mSerializedObject_SelectedAnim.ApplyModifiedProperties();
//mTarget._AnimationSlots[iCurrentAnimationSlot].CreateAnimation();
}
}
}
if (mEditor_SelectedAnim.mAnimation.IsPlaying)
{
mMakeMaterialDirty = mMakeVerticesDirty = true;
}
GUITools.CloseHeader();
if (deselectAnimation)
{
DeselectAnimation();
}
}
public override void UpdateSequence(float dt, TextAnimation se, SE_Animation anim, int sequenceIndex, ref bool makeMaterialDirty, ref bool makeVerticesDirty)
{
base.UpdateSequence(dt, se, anim, sequenceIndex, ref makeMaterialDirty, ref makeVerticesDirty);
makeVerticesDirty = true;
}
public float GetProgress(float time, SE_Animation anim, int characterID)
{
//--[ Verify that the animation is playing ]--------------------------------
if (time < mDelay)
{
return(-1);
}
if (time > mTotalTime)
{
time = mTotalTime;
}
//--[ Only accept elements in the Characters Range ]--------------------------------
int elementId = characterID;
int nElements = TextAnimation.mCharacters.Size;
if (mElementRangeEnd <= mElementRangeStart || elementId < mElementRangeStart || elementId >= mElementRangeEnd)
{
return(-1);
}
//--[ only accept those elements in the Custom array ]--------------------------------
if (_TargetRangeType == eTargetRange.Custom && _TargetRangeCustom != null)
{
bool found = false;
for (int i = 0, imax = _TargetRangeCustom.Length; i < imax; ++i)
{
if (_TargetRangeCustom[i] == characterID)
{
found = true;
break;
}
}
if (!found)
{
return(-1);
}
}
if (time >= mTotalTime)
{
return(1);
}
time -= mDelay;
nElements = mElementRangeEnd - mElementRangeStart;
elementId -= mElementRangeStart;
//--[ Apply Playback ]--------------------------------
switch (_Playback)
{
case SE_Animation.ePlayback.Loop:
time = Mathf.Repeat(time, mLoopDuration);
mElementDelay -= 0.5f * mElementDelay / (float)nElements;
break;
case SE_Animation.ePlayback.PingPong:
{
time = Mathf.Repeat(time, 2 * mLoopDuration);
mElementDelay -= 0.5f * mElementDelay / (float)nElements;
if (time > mLoopDuration)
{
time = mLoopDuration - (time - mLoopDuration);
time -= 0.25f * mElementDelay;
}
break;
}
default: //case ePlayback.Single:
break;
}
//--[ Find element progress and apply Easing ]--------------------------------
float startTime, elementDuration;
GetElementTimes(anim, elementId, out startTime, out elementDuration);
float t = (time - startTime) / elementDuration;
t = t > 1 ? 1 : t;
return(t);
}
public virtual void Apply_Characters(TextAnimation se, SE_Animation anim, int sequenceIndex)
{
}
public virtual void UpdateSequence(float dt, TextAnimation se, SE_Animation anim, int sequenceIndex, ref bool makeMaterialDirty, ref bool makeVerticesDirty)
{
}
// Copy from SE_AnimSequence_Position, except where noted
public override void Apply_Characters(TextAnimation se, SE_Animation anim, int sequenceIndex)
{
if (anim.mTime < mDelay && !_InitAllElements)
{
return;
}
bool applyRandomFrom = HasRandom(_FromRandom);
bool applyRandomTo = HasRandom(_ToRandom);
DRandom.mCurrentSeed = GetRandomSeed(anim, sequenceIndex);
Vector3 from = _From; // * se.mCharacterSize; // REMOVED *se.mCharacterSize
Vector3 to = _To; // * se.mCharacterSize; // REMOVED *se.mCharacterSize
Vector3 newValue = MathUtils.v3zero;
// Iterate through all the valid range
for (int iElement = mElementRangeStart; iElement < mElementRangeEnd; ++iElement)
{
float progress = GetProgress(anim.mTime, anim, iElement);
if (!_InitAllElements && progress < 0)
{
continue;
}
progress = progress < 0 ? 0 : progress;
float tx = _EasingCurve.Evaluate(progress);
float ty = _UseAxisEasingCurves ? _EasingCurveY.Evaluate(progress) : tx;
float tz = _UseAxisEasingCurves ? _EasingCurveZ.Evaluate(progress) : tx;
var currentValue = MathUtils.v3one; // MODIFIED
var vFrom = (_AnimBlend_From == ePositionAnimBlendMode.Replace) ? from : (currentValue + from);
var vTo = (_AnimBlend_To == ePositionAnimBlendMode.Replace) ? to : (currentValue + to);
if (applyRandomFrom)
{
vFrom += GetRandom(_FromRandom /* se.mCharacterSize*/, iElement); // REMOVED *se.mCharacterSize
}
if (applyRandomTo)
{
vTo += GetRandom(_ToRandom /* se.mCharacterSize*/, iElement * 2 + 90); // REMOVED *se.mCharacterSize
}
if (_ApplyX)
{
newValue.x = vFrom.x + (vTo.x - vFrom.x) * tx;
}
else
{
newValue.x = 0;
}
if (_ApplyY)
{
newValue.y = vFrom.y + (vTo.y - vFrom.y) * ty;
}
else
{
newValue.y = 0;
}
if (_ApplyZ)
{
newValue.z = vFrom.z + (vTo.z - vFrom.z) * tz;
}
else
{
newValue.z = 0;
}
// NEW CODE (in Scale)-----------------------------------------------------------------------------------------------------------------------------------------
Vector3 vPivot = MathUtils.v3half;
if (_PivotType == ePivotType.Relative_Letter || _PivotType == ePivotType.Relative_Word || _PivotType == ePivotType.Relative_Line)
{
vPivot.x = MathUtils.LerpUnclamped(TextAnimation.mCharacters.Buffer[iElement].Min.x, TextAnimation.mCharacters.Buffer[iElement].Max.x, _Pivot.x);
vPivot.y = MathUtils.LerpUnclamped(TextAnimation.mCharacters.Buffer[iElement].Min.y, TextAnimation.mCharacters.Buffer[iElement].Max.y, _Pivot.y);
}
else
if (_PivotType == ePivotType.Relative_All)
{
vPivot.x = MathUtils.LerpUnclamped(se.mAllCharactersMin.x, se.mAllCharactersMax.x, _Pivot.x);
vPivot.y = MathUtils.LerpUnclamped(se.mAllCharactersMin.y, se.mAllCharactersMax.y, _Pivot.y);
}
else
if (_PivotType == ePivotType.Relative_Rect)
{
vPivot.x = MathUtils.LerpUnclamped(se.mWidgetRectMin.x, se.mWidgetRectMax.x, _Pivot.x);
vPivot.y = MathUtils.LerpUnclamped(se.mWidgetRectMin.y, se.mWidgetRectMax.y, _Pivot.y);
}
else
{
vPivot = _Pivot * se.mCharacterSize;
}
// END NEW CODE
Quaternion qRot = Quaternion.Euler(newValue); // NEW CODE (for rotation)--------------------------------------------------------------------------
// Apply to all Vertices
for (int v = iElement * 4; v < iElement * 4 + 4; ++v)
{
TextAnimation.mOriginalVertices.Buffer[v].position = qRot * (TextAnimation.mOriginalVertices.Buffer[v].position - vPivot) + vPivot;
}
}
}
public virtual void OnStop(TextAnimation se, SE_Animation anim, int sequenceIndex)
{
}
public virtual void InitTimes(TextAnimation se, SE_Animation anim, int sequenceIndex, int nElements)
{
switch (_StartType)
{
case eStartType.AfterPrevious:
{
if (sequenceIndex > 0)
{
mDelay = anim._Sequences[sequenceIndex - 1].mTotalTime;
}
break;
}
case eStartType.AllPrevious:
{
mDelay = 0;
for (int i = 0; i < sequenceIndex; ++i)
{
mDelay = Mathf.Max(mDelay, anim._Sequences[sequenceIndex].mTotalTime);
}
break;
}
case eStartType.WithPrevious:
{
if (sequenceIndex > 0)
{
mDelay = anim._Sequences[sequenceIndex - 1].mDelay;
}
break;
}
case eStartType.AllUsedElements:
{
mDelay = 0;
for (int i = 0; i < sequenceIndex; ++i)
{
if (anim._Sequences[sequenceIndex].IsUsingCommonElements(this))
{
mDelay = Mathf.Max(mDelay, anim._Sequences[sequenceIndex].mTotalTime);
}
}
break;
}
default:
//case eStartType.OnAnimStart:
{
mDelay = 0;
break;
}
}
mDelay += _StartDelay;
//--[ Get Animation Range ]--------------------------------
mElementRangeStart = 0;
mElementRangeEnd = nElements;
switch (_TargetRangeType)
{
case eTargetRange.All:
mElementRangeStart = 0;
mElementRangeEnd = nElements;
break;
case eTargetRange.First:
mElementRangeStart = 0;
mElementRangeEnd = _TargetRangeAmount;
break;
case eTargetRange.Last:
mElementRangeStart = nElements - _TargetRangeAmount;
mElementRangeEnd = nElements;
break;
case eTargetRange.Range:
mElementRangeStart = _TargetRangeStart;
mElementRangeEnd = _TargetRangeStart + _TargetRangeAmount;
break;
}
nElements = mElementRangeEnd - mElementRangeStart;
//--[ Find Times ]--------------------------------
if (_DurationType == eDurationType.PerElement)
{
mElementDuration = _Duration;
mLoopDuration = mElementDuration + (mElementDuration * _Separation * (nElements - 1));
}
else
{
mLoopDuration = _Duration;
mElementDuration = mLoopDuration / (_Separation * nElements - _Separation + 1);
}
mElementDelay = mElementDuration * _Separation;
mTotalLoopDuration = _Playback == SE_Animation.ePlayback.PingPong ? 2 * mLoopDuration : mLoopDuration;
if (_Playback == SE_Animation.ePlayback.Loop || _Playback == SE_Animation.ePlayback.PingPong)
{
if (_PlaybackTimes > 0)
{
mTotalTime = mDelay + mLoopDuration * _PlaybackTimes;
}
else
{
mTotalTime = float.MaxValue;
}
}
else
{
mTotalTime = mDelay + mLoopDuration;
}
}
public override void Apply_Characters(TextAnimation se, SE_Animation anim, int sequenceIndex)
{
if (anim.mTime < mDelay && !_InitAllElements)
{
return;
}
bool applyRandomFrom = HasRandom(_FromRandom);
bool applyRandomTo = HasRandom(_ToRandom);
DRandom.mCurrentSeed = GetRandomSeed(anim, sequenceIndex);
Vector3 from = _From * se.mCharacterSize;
Vector3 to = _To * se.mCharacterSize;
Vector3 newValue = MathUtils.v3zero;
if (_AnimBlend_From == ePositionAnimBlendMode.Replace)
{
from.x = MathUtils.LerpUnclamped(se.mAllCharactersMin.x, se.mAllCharactersMax.x, _From.x);
from.y = MathUtils.LerpUnclamped(se.mAllCharactersMin.y, se.mAllCharactersMax.y, _From.y);
}
if (_AnimBlend_To == ePositionAnimBlendMode.Replace)
{
to.x = MathUtils.LerpUnclamped(se.mAllCharactersMin.x, se.mAllCharactersMax.x, _To.x);
to.y = MathUtils.LerpUnclamped(se.mAllCharactersMin.y, se.mAllCharactersMax.y, _To.y);
}
// Iterate through all the valid range
for (int iElement = mElementRangeStart; iElement < mElementRangeEnd; ++iElement)
{
float progress = GetProgress(anim.mTime, anim, iElement);
if (!_InitAllElements && progress < 0)
{
continue;
}
progress = progress < 0 ? 0 : progress;
float tx = _EasingCurve.Evaluate(progress);
float ty = _UseAxisEasingCurves ? _EasingCurveY.Evaluate(progress) : tx;
float tz = _UseAxisEasingCurves ? _EasingCurveZ.Evaluate(progress) : tx;
var currentValue = TextAnimation.mOriginalVertices.Buffer[iElement * 4].position;
var vFrom = (_AnimBlend_From == ePositionAnimBlendMode.Offset) ? (currentValue + from) : from;
var vTo = (_AnimBlend_To == ePositionAnimBlendMode.Offset) ? (currentValue + to) : to;
if (applyRandomFrom)
{
vFrom += GetRandom(_FromRandom * se.mCharacterSize, iElement);
}
if (applyRandomTo)
{
vTo += GetRandom(_ToRandom * se.mCharacterSize, iElement * 2 + 90);
}
if (_ApplyX)
{
newValue.x = vFrom.x + (vTo.x - vFrom.x) * tx;
}
if (_ApplyY)
{
newValue.y = vFrom.y + (vTo.y - vFrom.y) * ty;
}
if (_ApplyZ)
{
newValue.z = vFrom.z + (vTo.z - vFrom.z) * tz;
}
// Apply to all Vertices
for (int v = iElement * 4; v < iElement * 4 + 4; ++v)
{
// Apply Lerp(vFrom, vTo, t) + offset_from_currentValue (the offset is applied to avoid changing the character's size)
if (_ApplyX)
{
TextAnimation.mOriginalVertices.Buffer[v].position.x = newValue.x + (TextAnimation.mOriginalVertices.Buffer[v].position.x - currentValue.x);
}
if (_ApplyY)
{
TextAnimation.mOriginalVertices.Buffer[v].position.y = newValue.y + (TextAnimation.mOriginalVertices.Buffer[v].position.y - currentValue.y);
}
if (_ApplyZ)
{
TextAnimation.mOriginalVertices.Buffer[v].position.z = newValue.z + (TextAnimation.mOriginalVertices.Buffer[v].position.z - currentValue.z);
}
}
}
}
public SE_Animation CreateAnimation()
{
return(SE_Animation.LoadFromSerializedData(mSerializedData) ?? new SE_Animation());
}
public override void Apply_Characters(TextAnimation se, SE_Animation anim, int sequenceIndex)
{
if (anim.mTime < mDelay && !_InitAllElements)
{
return;
}
bool applyRandomFrom = HasRandom(_FromRandom);
bool applyRandomTo = HasRandom(_ToRandom);
DRandom.mCurrentSeed = GetRandomSeed(anim, sequenceIndex);
// Iterate through all the valid range
for (int iElement = mElementRangeStart; iElement < mElementRangeEnd; ++iElement)
{
float progress = GetProgress(anim.mTime, anim, iElement);
if (!_InitAllElements && progress < 0)
{
continue;
}
progress = progress < 0 ? 0 : progress;
progress = _EasingCurve.Evaluate(progress);
var currentAlpha = TextAnimation.mOriginalVertices.Buffer[iElement * 4].color.a;
//--[ From ]----------------------------
float aFrom = _From * 255;
if (_AnimBlend_From == eFloatAnimBlendMode.Offset)
{
aFrom = aFrom + currentAlpha;
}
if (_AnimBlend_From == eFloatAnimBlendMode.Blend)
{
aFrom = _From * currentAlpha;
}
if (applyRandomFrom)
{
aFrom += 255 * _FromRandom * DRandom.GetUnit(iElement);
}
//--[ To ]----------------------------
float aTo = 255 * _To;
if (_AnimBlend_To == eFloatAnimBlendMode.Offset)
{
aTo = (currentAlpha + _To);
}
if (_AnimBlend_To == eFloatAnimBlendMode.Blend)
{
aTo = (currentAlpha * _To);
}
if (applyRandomTo)
{
aTo += 255 * _ToRandom * DRandom.GetUnit(iElement * 2 + 90);
}
// Find Alpha for this Character
float falpha = (aFrom + (aTo - aFrom) * progress);
byte alpha = (byte)(falpha < 0?0 : falpha > 255?255: falpha);
// Apply to all Vertices
for (int v = iElement * 4; v < iElement * 4 + 4; ++v)
{
TextAnimation.mOriginalVertices.Buffer[v].color.a = alpha;
}
}
}
public override void Apply_Characters(TextAnimation se, SE_Animation anim, int sequenceIndex)
{
base.Apply_Characters(se, anim, sequenceIndex);
}