You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1771 lines
60 KiB
1771 lines
60 KiB
using System; |
|
using System.Collections.Generic; |
|
using FairyGUI.Utils; |
|
using UnityEngine; |
|
|
|
namespace FairyGUI |
|
{ |
|
/// <summary> |
|
/// |
|
/// </summary> |
|
public delegate void PlayCompleteCallback(); |
|
|
|
/// <summary> |
|
/// |
|
/// </summary> |
|
public delegate void TransitionHook(); |
|
|
|
/// <summary> |
|
/// |
|
/// </summary> |
|
public class Transition : ITweenListener |
|
{ |
|
/// <summary> |
|
/// 动效的名称。在编辑器里设定。 |
|
/// </summary> |
|
public string name { get; private set; } |
|
|
|
/// <summary> |
|
/// 当你启动了自动合批，动效里有涉及到XY、大小、旋转等的改变，如果你观察到元件的显示深度在播放过程中有错误，可以开启这个选项。 |
|
/// </summary> |
|
public bool invalidateBatchingEveryFrame; |
|
|
|
GComponent _owner; |
|
TransitionItem[] _items; |
|
int _totalTimes; |
|
int _totalTasks; |
|
bool _playing; |
|
bool _paused; |
|
float _ownerBaseX; |
|
float _ownerBaseY; |
|
PlayCompleteCallback _onComplete; |
|
int _options; |
|
bool _reversed; |
|
float _totalDuration; |
|
bool _autoPlay; |
|
int _autoPlayTimes; |
|
float _autoPlayDelay; |
|
float _timeScale; |
|
bool _ignoreEngineTimeScale; |
|
float _startTime; |
|
float _endTime; |
|
GTweenCallback _delayedCallDelegate; |
|
GTweenCallback _checkAllDelegate; |
|
GTweenCallback1 _delayedCallDelegate2; |
|
|
|
const int OPTION_IGNORE_DISPLAY_CONTROLLER = 1; |
|
const int OPTION_AUTO_STOP_DISABLED = 2; |
|
const int OPTION_AUTO_STOP_AT_END = 4; |
|
|
|
public Transition(GComponent owner) |
|
{ |
|
_owner = owner; |
|
_timeScale = 1; |
|
_ignoreEngineTimeScale = true; |
|
|
|
_delayedCallDelegate = OnDelayedPlay; |
|
_delayedCallDelegate2 = OnDelayedPlayItem; |
|
_checkAllDelegate = CheckAllComplete; |
|
} |
|
|
|
/// <summary> |
|
/// |
|
/// </summary> |
|
public void Play() |
|
{ |
|
_Play(1, 0, 0, -1, null, false); |
|
} |
|
|
|
/// <summary> |
|
/// |
|
/// </summary> |
|
/// <param name="onComplete"></param> |
|
public void Play(PlayCompleteCallback onComplete) |
|
{ |
|
_Play(1, 0, 0, -1, onComplete, false); |
|
} |
|
|
|
/// <summary> |
|
/// |
|
/// </summary> |
|
/// <param name="times"></param> |
|
/// <param name="delay"></param> |
|
/// <param name="onComplete"></param> |
|
public void Play(int times, float delay, PlayCompleteCallback onComplete) |
|
{ |
|
_Play(times, delay, 0, -1, onComplete, false); |
|
} |
|
|
|
/// <summary> |
|
/// |
|
/// </summary> |
|
/// <param name="times"></param> |
|
/// <param name="delay"></param> |
|
/// <param name="startTime"></param> |
|
/// <param name="endTime"></param> |
|
/// <param name="onComplete"></param> |
|
public void Play(int times, float delay, float startTime, float endTime, PlayCompleteCallback onComplete) |
|
{ |
|
_Play(times, delay, startTime, endTime, onComplete, false); |
|
} |
|
|
|
/// <summary> |
|
/// |
|
/// </summary> |
|
public void PlayReverse() |
|
{ |
|
_Play(1, 0, 0, -1, null, true); |
|
} |
|
|
|
/// <summary> |
|
/// |
|
/// </summary> |
|
/// <param name="onComplete"></param> |
|
public void PlayReverse(PlayCompleteCallback onComplete) |
|
{ |
|
_Play(1, 0, 0, -1, onComplete, true); |
|
} |
|
|
|
/// <summary> |
|
/// |
|
/// </summary> |
|
/// <param name="times"></param> |
|
/// <param name="delay"></param> |
|
/// <param name="onComplete"></param> |
|
public void PlayReverse(int times, float delay, PlayCompleteCallback onComplete) |
|
{ |
|
_Play(times, delay, 0, -1, onComplete, true); |
|
} |
|
|
|
/// <summary> |
|
/// |
|
/// </summary> |
|
/// <param name="value"></param> |
|
public void ChangePlayTimes(int value) |
|
{ |
|
_totalTimes = value; |
|
} |
|
|
|
/// <summary> |
|
/// 设置动效是否自动播放。 |
|
/// </summary> |
|
/// <param name="autoPlay"></param> |
|
/// <param name="times"></param> |
|
/// <param name="delay"></param> |
|
public void SetAutoPlay(bool autoPlay, int times, float delay) |
|
{ |
|
if (_autoPlay != autoPlay) |
|
{ |
|
_autoPlay = autoPlay; |
|
_autoPlayTimes = times; |
|
_autoPlayDelay = delay; |
|
if (_autoPlay) |
|
{ |
|
if (_owner.onStage) |
|
Play(times, delay, null); |
|
} |
|
else |
|
{ |
|
if (!_owner.onStage) |
|
Stop(false, true); |
|
} |
|
} |
|
} |
|
|
|
void _Play(int times, float delay, float startTime, float endTime, PlayCompleteCallback onComplete, bool reverse) |
|
{ |
|
Stop(true, true); |
|
|
|
_totalTimes = times; |
|
_reversed = reverse; |
|
_startTime = startTime; |
|
_endTime = endTime; |
|
_playing = true; |
|
_paused = false; |
|
_onComplete = onComplete; |
|
|
|
int cnt = _items.Length; |
|
for (int i = 0; i < cnt; i++) |
|
{ |
|
TransitionItem item = _items[i]; |
|
if (item.target == null) |
|
{ |
|
if (item.targetId.Length > 0) |
|
item.target = _owner.GetChildById(item.targetId); |
|
else |
|
item.target = _owner; |
|
} |
|
else if (item.target != _owner && item.target.parent != _owner) //maybe removed |
|
item.target = null; |
|
|
|
if (item.target != null && item.type == TransitionActionType.Transition) |
|
{ |
|
TValue_Transition value = (TValue_Transition)item.value; |
|
Transition trans = ((GComponent)item.target).GetTransition(value.transName); |
|
if (trans == this) |
|
trans = null; |
|
if (trans != null) |
|
{ |
|
if (value.playTimes == 0) //stop |
|
{ |
|
int j; |
|
for (j = i - 1; j >= 0; j--) |
|
{ |
|
TransitionItem item2 = _items[j]; |
|
if (item2.type == TransitionActionType.Transition) |
|
{ |
|
TValue_Transition value2 = (TValue_Transition)item2.value; |
|
if (value2.trans == trans) |
|
{ |
|
value2.stopTime = item.time - item2.time; |
|
break; |
|
} |
|
} |
|
} |
|
if (j < 0) |
|
value.stopTime = 0; |
|
else |
|
trans = null; //no need to handle stop anymore |
|
} |
|
else |
|
value.stopTime = -1; |
|
} |
|
value.trans = trans; |
|
} |
|
} |
|
|
|
if (delay == 0) |
|
OnDelayedPlay(); |
|
else |
|
GTween.DelayedCall(delay).SetTarget(this).OnComplete(_delayedCallDelegate); |
|
} |
|
|
|
/// <summary> |
|
/// |
|
/// </summary> |
|
public void Stop() |
|
{ |
|
Stop(true, false); |
|
} |
|
|
|
/// <summary> |
|
/// |
|
/// </summary> |
|
/// <param name="setToComplete"></param> |
|
/// <param name="processCallback"></param> |
|
public void Stop(bool setToComplete, bool processCallback) |
|
{ |
|
if (!_playing) |
|
return; |
|
|
|
_playing = false; |
|
_totalTasks = 0; |
|
_totalTimes = 0; |
|
PlayCompleteCallback func = _onComplete; |
|
_onComplete = null; |
|
|
|
GTween.Kill(this);//delay start |
|
|
|
int cnt = _items.Length; |
|
if (_reversed) |
|
{ |
|
for (int i = cnt - 1; i >= 0; i--) |
|
{ |
|
TransitionItem item = _items[i]; |
|
if (item.target == null) |
|
continue; |
|
|
|
StopItem(item, setToComplete); |
|
} |
|
} |
|
else |
|
{ |
|
for (int i = 0; i < cnt; i++) |
|
{ |
|
TransitionItem item = _items[i]; |
|
if (item.target == null) |
|
continue; |
|
|
|
StopItem(item, setToComplete); |
|
} |
|
} |
|
|
|
if (processCallback && func != null) |
|
func(); |
|
|
|
} |
|
|
|
void StopItem(TransitionItem item, bool setToComplete) |
|
{ |
|
if (item.displayLockToken != 0) |
|
{ |
|
item.target.ReleaseDisplayLock(item.displayLockToken); |
|
item.displayLockToken = 0; |
|
} |
|
|
|
if (item.tweener != null) |
|
{ |
|
item.tweener.Kill(setToComplete); |
|
item.tweener = null; |
|
|
|
if (item.type == TransitionActionType.Shake && !setToComplete) //震动必须归位，否则下次就越震越远了。 |
|
{ |
|
item.target._gearLocked = true; |
|
item.target.SetXY(item.target.x - ((TValue_Shake)item.value).lastOffset.x, item.target.y - ((TValue_Shake)item.value).lastOffset.y); |
|
item.target._gearLocked = false; |
|
|
|
_owner.InvalidateBatchingState(true); |
|
} |
|
} |
|
|
|
if (item.type == TransitionActionType.Transition) |
|
{ |
|
TValue_Transition value = (TValue_Transition)item.value; |
|
if (value.trans != null) |
|
value.trans.Stop(setToComplete, false); |
|
} |
|
} |
|
|
|
/// <summary> |
|
/// |
|
/// </summary> |
|
/// <param name="paused"></param> |
|
public void SetPaused(bool paused) |
|
{ |
|
if (!_playing || _paused == paused) |
|
return; |
|
|
|
_paused = paused; |
|
GTweener tweener = GTween.GetTween(this); |
|
if (tweener != null) |
|
tweener.SetPaused(paused); |
|
|
|
int cnt = _items.Length; |
|
for (int i = 0; i < cnt; i++) |
|
{ |
|
TransitionItem item = _items[i]; |
|
if (item.target == null) |
|
continue; |
|
|
|
if (item.type == TransitionActionType.Transition) |
|
{ |
|
if (((TValue_Transition)item.value).trans != null) |
|
((TValue_Transition)item.value).trans.SetPaused(paused); |
|
} |
|
else if (item.type == TransitionActionType.Animation) |
|
{ |
|
if (paused) |
|
{ |
|
((TValue_Animation)item.value).flag = ((IAnimationGear)item.target).playing; |
|
((IAnimationGear)item.target).playing = false; |
|
} |
|
else |
|
((IAnimationGear)item.target).playing = ((TValue_Animation)item.value).flag; |
|
} |
|
|
|
if (item.tweener != null) |
|
item.tweener.SetPaused(paused); |
|
} |
|
} |
|
|
|
public void Dispose() |
|
{ |
|
if (_playing) |
|
GTween.Kill(this);//delay start |
|
|
|
int cnt = _items.Length; |
|
for (int i = 0; i < cnt; i++) |
|
{ |
|
TransitionItem item = _items[i]; |
|
if (item.tweener != null) |
|
{ |
|
item.tweener.Kill(); |
|
item.tweener = null; |
|
} |
|
|
|
item.target = null; |
|
item.hook = null; |
|
if (item.tweenConfig != null) |
|
item.tweenConfig.endHook = null; |
|
} |
|
|
|
_playing = false; |
|
_onComplete = null; |
|
} |
|
|
|
/// <summary> |
|
/// |
|
/// </summary> |
|
public bool playing |
|
{ |
|
get { return _playing; } |
|
} |
|
|
|
/// <summary> |
|
/// transition's total duration, maybe zero when the transition only has one frame |
|
/// </summary> |
|
public float totalDuration |
|
{ |
|
get { return _totalDuration; } |
|
} |
|
|
|
/// <summary> |
|
/// |
|
/// </summary> |
|
/// <param name="label"></param> |
|
/// <param name="aParams"></param> |
|
public void SetValue(string label, params object[] aParams) |
|
{ |
|
int cnt = _items.Length; |
|
object value; |
|
bool found = false; |
|
for (int i = 0; i < cnt; i++) |
|
{ |
|
TransitionItem item = _items[i]; |
|
if (item.label == label) |
|
{ |
|
if (item.tweenConfig != null) |
|
value = item.tweenConfig.startValue; |
|
else |
|
value = item.value; |
|
found = true; |
|
} |
|
else if (item.tweenConfig != null && item.tweenConfig.endLabel == label) |
|
{ |
|
value = item.tweenConfig.endValue; |
|
found = true; |
|
} |
|
else |
|
continue; |
|
|
|
switch (item.type) |
|
{ |
|
case TransitionActionType.XY: |
|
case TransitionActionType.Size: |
|
case TransitionActionType.Pivot: |
|
case TransitionActionType.Scale: |
|
case TransitionActionType.Skew: |
|
{ |
|
TValue tvalue = (TValue)value; |
|
tvalue.b1 = true; |
|
tvalue.b2 = true; |
|
tvalue.f1 = Convert.ToSingle(aParams[0]); |
|
tvalue.f2 = Convert.ToSingle(aParams[1]); |
|
} |
|
break; |
|
|
|
case TransitionActionType.Alpha: |
|
((TValue)value).f1 = Convert.ToSingle(aParams[0]); |
|
break; |
|
|
|
case TransitionActionType.Rotation: |
|
((TValue)value).f1 = Convert.ToSingle(aParams[0]); |
|
break; |
|
|
|
case TransitionActionType.Color: |
|
((TValue)value).color = (Color)aParams[0]; |
|
break; |
|
|
|
case TransitionActionType.Animation: |
|
{ |
|
TValue_Animation tvalue = (TValue_Animation)value; |
|
tvalue.frame = Convert.ToInt32(aParams[0]); |
|
if (aParams.Length > 1) |
|
tvalue.playing = Convert.ToBoolean(aParams[1]); |
|
if (aParams.Length > 2) |
|
tvalue.animationName = (string)aParams[2]; |
|
if (aParams.Length > 3) |
|
tvalue.skinName = (string)aParams[3]; |
|
} |
|
break; |
|
|
|
case TransitionActionType.Visible: |
|
((TValue_Visible)value).visible = Convert.ToBoolean(aParams[0]); |
|
break; |
|
|
|
case TransitionActionType.Sound: |
|
{ |
|
TValue_Sound tvalue = (TValue_Sound)value; |
|
tvalue.sound = (string)aParams[0]; |
|
if (aParams.Length > 1) |
|
tvalue.volume = Convert.ToSingle(aParams[1]); |
|
} |
|
break; |
|
|
|
case TransitionActionType.Transition: |
|
{ |
|
TValue_Transition tvalue = (TValue_Transition)value; |
|
tvalue.transName = (string)aParams[0]; |
|
if (aParams.Length > 1) |
|
tvalue.playTimes = Convert.ToInt32(aParams[1]); |
|
} |
|
break; |
|
|
|
case TransitionActionType.Shake: |
|
{ |
|
((TValue_Shake)value).amplitude = Convert.ToSingle(aParams[0]); |
|
if (aParams.Length > 1) |
|
((TValue_Shake)value).duration = Convert.ToSingle(aParams[1]); |
|
} |
|
break; |
|
|
|
case TransitionActionType.ColorFilter: |
|
{ |
|
TValue tvalue = (TValue)value; |
|
tvalue.f1 = Convert.ToSingle(aParams[0]); |
|
tvalue.f2 = Convert.ToSingle(aParams[1]); |
|
tvalue.f3 = Convert.ToSingle(aParams[2]); |
|
tvalue.f4 = Convert.ToSingle(aParams[3]); |
|
} |
|
break; |
|
|
|
case TransitionActionType.Text: |
|
case TransitionActionType.Icon: |
|
((TValue_Text)value).text = (string)aParams[0]; |
|
break; |
|
} |
|
} |
|
|
|
if (!found) |
|
throw new Exception("label not exists"); |
|
} |
|
|
|
/// <summary> |
|
/// |
|
/// </summary> |
|
/// <param name="label"></param> |
|
/// <param name="callback"></param> |
|
public void SetHook(string label, TransitionHook callback) |
|
{ |
|
int cnt = _items.Length; |
|
bool found = false; |
|
for (int i = 0; i < cnt; i++) |
|
{ |
|
TransitionItem item = _items[i]; |
|
if (item.label == label) |
|
{ |
|
item.hook = callback; |
|
found = true; |
|
break; |
|
} |
|
else if (item.tweenConfig != null && item.tweenConfig.endLabel == label) |
|
{ |
|
item.tweenConfig.endHook = callback; |
|
found = true; |
|
break; |
|
} |
|
} |
|
if (!found) |
|
throw new Exception("label not exists"); |
|
} |
|
|
|
/// <summary> |
|
/// |
|
/// </summary> |
|
public void ClearHooks() |
|
{ |
|
int cnt = _items.Length; |
|
for (int i = 0; i < cnt; i++) |
|
{ |
|
TransitionItem item = _items[i]; |
|
item.hook = null; |
|
if (item.tweenConfig != null) |
|
item.tweenConfig.endHook = null; |
|
} |
|
} |
|
|
|
/// <summary> |
|
/// |
|
/// </summary> |
|
/// <param name="label"></param> |
|
/// <param name="newTarget"></param> |
|
public void SetTarget(string label, GObject newTarget) |
|
{ |
|
int cnt = _items.Length; |
|
bool found = false; |
|
for (int i = 0; i < cnt; i++) |
|
{ |
|
TransitionItem item = _items[i]; |
|
if (item.label == label) |
|
{ |
|
item.targetId = (newTarget == _owner || newTarget == null) ? string.Empty : newTarget.id; |
|
if (_playing) |
|
{ |
|
if (item.targetId.Length > 0) |
|
item.target = _owner.GetChildById(item.targetId); |
|
else |
|
item.target = _owner; |
|
} |
|
else |
|
item.target = null; |
|
found = true; |
|
} |
|
} |
|
if (!found) |
|
throw new Exception("label not exists"); |
|
} |
|
|
|
/// <summary> |
|
/// |
|
/// </summary> |
|
/// <param name="label"></param> |
|
/// <param name="value"></param> |
|
public void SetDuration(string label, float value) |
|
{ |
|
int cnt = _items.Length; |
|
bool found = false; |
|
for (int i = 0; i < cnt; i++) |
|
{ |
|
TransitionItem item = _items[i]; |
|
if (item.tweenConfig != null && item.label == label) |
|
{ |
|
item.tweenConfig.duration = value; |
|
found = true; |
|
} |
|
} |
|
|
|
if (!found) |
|
throw new Exception("label not exists or not a tween label"); |
|
} |
|
|
|
/// <summary> |
|
/// |
|
/// </summary> |
|
/// <param name="label"></param> |
|
/// <returns></returns> |
|
public float GetLabelTime(string label) |
|
{ |
|
int cnt = _items.Length; |
|
for (int i = 0; i < cnt; i++) |
|
{ |
|
TransitionItem item = _items[i]; |
|
if (item.label == label) |
|
return item.time; |
|
else if (item.tweenConfig != null && item.tweenConfig.endLabel == label) |
|
return item.time + item.tweenConfig.duration; |
|
} |
|
|
|
return float.NaN; |
|
} |
|
|
|
/// <summary> |
|
/// |
|
/// </summary> |
|
public float timeScale |
|
{ |
|
get { return _timeScale; } |
|
set |
|
{ |
|
if (_timeScale != value) |
|
{ |
|
_timeScale = value; |
|
|
|
int cnt = _items.Length; |
|
for (int i = 0; i < cnt; i++) |
|
{ |
|
TransitionItem item = _items[i]; |
|
if (item.tweener != null) |
|
item.tweener.SetTimeScale(value); |
|
else if (item.type == TransitionActionType.Transition) |
|
{ |
|
if (((TValue_Transition)item.value).trans != null) |
|
((TValue_Transition)item.value).trans.timeScale = value; |
|
} |
|
else if (item.type == TransitionActionType.Animation) |
|
{ |
|
if (item.target != null) |
|
((IAnimationGear)item.target).timeScale = value; |
|
} |
|
} |
|
} |
|
} |
|
} |
|
|
|
/// <summary> |
|
/// |
|
/// </summary> |
|
public bool ignoreEngineTimeScale |
|
{ |
|
get { return _ignoreEngineTimeScale; } |
|
set |
|
{ |
|
if (_ignoreEngineTimeScale != value) |
|
{ |
|
_ignoreEngineTimeScale = value; |
|
|
|
int cnt = _items.Length; |
|
for (int i = 0; i < cnt; i++) |
|
{ |
|
TransitionItem item = _items[i]; |
|
if (item.tweener != null) |
|
item.tweener.SetIgnoreEngineTimeScale(value); |
|
else if (item.type == TransitionActionType.Transition) |
|
{ |
|
if (((TValue_Transition)item.value).trans != null) |
|
((TValue_Transition)item.value).trans.ignoreEngineTimeScale = value; |
|
} |
|
else if (item.type == TransitionActionType.Animation) |
|
{ |
|
if (item.target != null) |
|
((IAnimationGear)item.target).ignoreEngineTimeScale = value; |
|
} |
|
} |
|
} |
|
} |
|
} |
|
|
|
internal void UpdateFromRelations(string targetId, float dx, float dy) |
|
{ |
|
int cnt = _items.Length; |
|
if (cnt == 0) |
|
return; |
|
|
|
for (int i = 0; i < cnt; i++) |
|
{ |
|
TransitionItem item = _items[i]; |
|
if (item.type == TransitionActionType.XY && item.targetId == targetId) |
|
{ |
|
if (item.tweenConfig != null) |
|
{ |
|
if (!item.tweenConfig.startValue.b3) |
|
{ |
|
item.tweenConfig.startValue.f1 += dx; |
|
item.tweenConfig.startValue.f2 += dy; |
|
} |
|
if (!item.tweenConfig.endValue.b3) |
|
{ |
|
item.tweenConfig.endValue.f1 += dx; |
|
item.tweenConfig.endValue.f2 += dy; |
|
} |
|
} |
|
else |
|
{ |
|
if (!((TValue)item.value).b3) |
|
{ |
|
((TValue)item.value).f1 += dx; |
|
((TValue)item.value).f2 += dy; |
|
} |
|
} |
|
} |
|
} |
|
} |
|
|
|
internal void OnOwnerAddedToStage() |
|
{ |
|
if (_autoPlay && !_playing) |
|
Play(_autoPlayTimes, _autoPlayDelay, null); |
|
} |
|
|
|
internal void OnOwnerRemovedFromStage() |
|
{ |
|
if ((_options & OPTION_AUTO_STOP_DISABLED) == 0) |
|
Stop((_options & OPTION_AUTO_STOP_AT_END) != 0 ? true : false, false); |
|
} |
|
|
|
void OnDelayedPlay() |
|
{ |
|
InternalPlay(); |
|
|
|
_playing = _totalTasks > 0; |
|
if (_playing) |
|
{ |
|
if ((_options & OPTION_IGNORE_DISPLAY_CONTROLLER) != 0) |
|
{ |
|
int cnt = _items.Length; |
|
for (int i = 0; i < cnt; i++) |
|
{ |
|
TransitionItem item = _items[i]; |
|
if (item.target != null && item.target != _owner) |
|
item.displayLockToken = item.target.AddDisplayLock(); |
|
} |
|
} |
|
} |
|
else if (_onComplete != null) |
|
{ |
|
PlayCompleteCallback func = _onComplete; |
|
_onComplete = null; |
|
func(); |
|
} |
|
} |
|
|
|
void InternalPlay() |
|
{ |
|
_ownerBaseX = _owner.x; |
|
_ownerBaseY = _owner.y; |
|
|
|
_totalTasks = 1; //prevent to complete inside the loop |
|
|
|
bool needSkipAnimations = false; |
|
int cnt = _items.Length; |
|
if (!_reversed) |
|
{ |
|
for (int i = 0; i < cnt; i++) |
|
{ |
|
TransitionItem item = _items[i]; |
|
if (item.target == null) |
|
continue; |
|
|
|
if (item.type == TransitionActionType.Animation && _startTime != 0 && item.time <= _startTime) |
|
{ |
|
needSkipAnimations = true; |
|
((TValue_Animation)item.value).flag = false; |
|
} |
|
else |
|
PlayItem(item); |
|
} |
|
} |
|
else |
|
{ |
|
for (int i = cnt - 1; i >= 0; i--) |
|
{ |
|
TransitionItem item = _items[i]; |
|
if (item.target == null) |
|
continue; |
|
|
|
PlayItem(item); |
|
} |
|
} |
|
|
|
if (needSkipAnimations) |
|
SkipAnimations(); |
|
|
|
_totalTasks--; |
|
} |
|
|
|
void PlayItem(TransitionItem item) |
|
{ |
|
float time; |
|
if (item.tweenConfig != null) |
|
{ |
|
if (_reversed) |
|
time = (_totalDuration - item.time - item.tweenConfig.duration); |
|
else |
|
time = item.time; |
|
|
|
if (_endTime == -1 || time <= _endTime) |
|
{ |
|
TValue startValue; |
|
TValue endValue; |
|
|
|
if (_reversed) |
|
{ |
|
startValue = item.tweenConfig.endValue; |
|
endValue = item.tweenConfig.startValue; |
|
} |
|
else |
|
{ |
|
startValue = item.tweenConfig.startValue; |
|
endValue = item.tweenConfig.endValue; |
|
} |
|
|
|
((TValue)item.value).b1 = startValue.b1 || endValue.b1; |
|
((TValue)item.value).b2 = startValue.b2 || endValue.b2; |
|
|
|
switch (item.type) |
|
{ |
|
case TransitionActionType.XY: |
|
case TransitionActionType.Size: |
|
case TransitionActionType.Scale: |
|
case TransitionActionType.Skew: |
|
item.tweener = GTween.To(startValue.vec2, endValue.vec2, item.tweenConfig.duration); |
|
break; |
|
|
|
case TransitionActionType.Alpha: |
|
case TransitionActionType.Rotation: |
|
item.tweener = GTween.To(startValue.f1, endValue.f1, item.tweenConfig.duration); |
|
break; |
|
|
|
case TransitionActionType.Color: |
|
item.tweener = GTween.To(startValue.color, endValue.color, item.tweenConfig.duration); |
|
break; |
|
|
|
case TransitionActionType.ColorFilter: |
|
item.tweener = GTween.To(startValue.vec4, endValue.vec4, item.tweenConfig.duration); |
|
break; |
|
} |
|
|
|
item.tweener.SetDelay(time) |
|
.SetEase(item.tweenConfig.easeType, item.tweenConfig.customEase) |
|
.SetRepeat(item.tweenConfig.repeat, item.tweenConfig.yoyo) |
|
.SetTimeScale(_timeScale) |
|
.SetIgnoreEngineTimeScale(_ignoreEngineTimeScale) |
|
.SetTarget(item) |
|
.SetListener(this); |
|
|
|
if (_endTime >= 0) |
|
item.tweener.SetBreakpoint(_endTime - time); |
|
|
|
_totalTasks++; |
|
} |
|
} |
|
else if (item.type == TransitionActionType.Shake) |
|
{ |
|
TValue_Shake value = (TValue_Shake)item.value; |
|
|
|
if (_reversed) |
|
time = (_totalDuration - item.time - value.duration); |
|
else |
|
time = item.time; |
|
|
|
if (_endTime == -1 || time <= _endTime) |
|
{ |
|
value.lastOffset.Set(0, 0); |
|
value.offset.Set(0, 0); |
|
item.tweener = GTween.Shake(Vector3.zero, value.amplitude, value.duration) |
|
.SetDelay(time) |
|
.SetTimeScale(_timeScale) |
|
.SetIgnoreEngineTimeScale(_ignoreEngineTimeScale) |
|
.SetTarget(item) |
|
.SetListener(this); |
|
|
|
if (_endTime >= 0) |
|
item.tweener.SetBreakpoint(_endTime - item.time); |
|
|
|
_totalTasks++; |
|
} |
|
} |
|
else |
|
{ |
|
if (_reversed) |
|
time = (_totalDuration - item.time); |
|
else |
|
time = item.time; |
|
|
|
if (time <= _startTime) |
|
{ |
|
ApplyValue(item); |
|
CallHook(item, false); |
|
} |
|
else if (_endTime == -1 || time <= _endTime) |
|
{ |
|
_totalTasks++; |
|
item.tweener = GTween.DelayedCall(time) |
|
.SetTimeScale(_timeScale) |
|
.SetIgnoreEngineTimeScale(_ignoreEngineTimeScale) |
|
.SetTarget(item) |
|
.OnComplete(_delayedCallDelegate2); |
|
} |
|
} |
|
|
|
if (item.tweener != null) |
|
item.tweener.Seek(_startTime); |
|
} |
|
|
|
void SkipAnimations() |
|
{ |
|
int frame; |
|
float playStartTime; |
|
float playTotalTime; |
|
TValue_Animation value; |
|
IAnimationGear target; |
|
TransitionItem item; |
|
|
|
int cnt = _items.Length; |
|
for (int i = 0; i < cnt; i++) |
|
{ |
|
item = _items[i]; |
|
if (item.type != TransitionActionType.Animation || item.time > _startTime) |
|
continue; |
|
|
|
value = (TValue_Animation)item.value; |
|
if (value.flag) |
|
continue; |
|
|
|
target = (IAnimationGear)item.target; |
|
frame = target.frame; |
|
playStartTime = target.playing ? 0 : -1; |
|
playTotalTime = 0; |
|
|
|
for (int j = i; j < cnt; j++) |
|
{ |
|
item = _items[j]; |
|
if (item.type != TransitionActionType.Animation || item.target != target || item.time > _startTime) |
|
continue; |
|
|
|
value = (TValue_Animation)item.value; |
|
value.flag = true; |
|
|
|
if (value.frame != -1) |
|
{ |
|
frame = value.frame; |
|
if (value.playing) |
|
playStartTime = item.time; |
|
else |
|
playStartTime = -1; |
|
playTotalTime = 0; |
|
} |
|
else |
|
{ |
|
if (value.playing) |
|
{ |
|
if (playStartTime < 0) |
|
playStartTime = item.time; |
|
} |
|
else |
|
{ |
|
if (playStartTime >= 0) |
|
playTotalTime += (item.time - playStartTime); |
|
playStartTime = -1; |
|
} |
|
} |
|
|
|
CallHook(item, false); |
|
} |
|
|
|
if (playStartTime >= 0) |
|
playTotalTime += (_startTime - playStartTime); |
|
|
|
target.playing = playStartTime >= 0; |
|
target.frame = frame; |
|
if (playTotalTime > 0) |
|
target.Advance(playTotalTime); |
|
} |
|
} |
|
|
|
void OnDelayedPlayItem(GTweener tweener) |
|
{ |
|
TransitionItem item = (TransitionItem)tweener.target; |
|
item.tweener = null; |
|
_totalTasks--; |
|
|
|
ApplyValue(item); |
|
CallHook(item, false); |
|
|
|
CheckAllComplete(); |
|
} |
|
|
|
public void OnTweenStart(GTweener tweener) |
|
{ |
|
TransitionItem item = (TransitionItem)tweener.target; |
|
|
|
if (item.type == TransitionActionType.XY || item.type == TransitionActionType.Size) //位置和大小要到start才最终确认起始值 |
|
{ |
|
TValue startValue; |
|
TValue endValue; |
|
|
|
if (_reversed) |
|
{ |
|
startValue = item.tweenConfig.endValue; |
|
endValue = item.tweenConfig.startValue; |
|
} |
|
else |
|
{ |
|
startValue = item.tweenConfig.startValue; |
|
endValue = item.tweenConfig.endValue; |
|
} |
|
|
|
if (item.type == TransitionActionType.XY) |
|
{ |
|
if (item.target != _owner) |
|
{ |
|
if (!startValue.b1) |
|
tweener.startValue.x = item.target.x; |
|
else if (startValue.b3) //percent |
|
tweener.startValue.x = startValue.f1 * _owner.width; |
|
|
|
if (!startValue.b2) |
|
tweener.startValue.y = item.target.y; |
|
else if (startValue.b3) //percent |
|
tweener.startValue.y = startValue.f2 * _owner.height; |
|
|
|
if (!endValue.b1) |
|
tweener.endValue.x = tweener.startValue.x; |
|
else if (endValue.b3) |
|
tweener.endValue.x = endValue.f1 * _owner.width; |
|
|
|
if (!endValue.b2) |
|
tweener.endValue.y = tweener.startValue.y; |
|
else if (endValue.b3) |
|
tweener.endValue.y = endValue.f2 * _owner.height; |
|
} |
|
else |
|
{ |
|
if (!startValue.b1) |
|
tweener.startValue.x = item.target.x - _ownerBaseX; |
|
if (!startValue.b2) |
|
tweener.startValue.y = item.target.y - _ownerBaseY; |
|
|
|
if (!endValue.b1) |
|
tweener.endValue.x = tweener.startValue.x; |
|
if (!endValue.b2) |
|
tweener.endValue.y = tweener.startValue.y; |
|
} |
|
} |
|
else |
|
{ |
|
if (!startValue.b1) |
|
tweener.startValue.x = item.target.width; |
|
if (!startValue.b2) |
|
tweener.startValue.y = item.target.height; |
|
|
|
if (!endValue.b1) |
|
tweener.endValue.x = tweener.startValue.x; |
|
if (!endValue.b2) |
|
tweener.endValue.y = tweener.startValue.y; |
|
} |
|
|
|
if (item.tweenConfig.path != null) |
|
{ |
|
((TValue)item.value).b1 = ((TValue)item.value).b2 = true; |
|
tweener.SetPath(item.tweenConfig.path); |
|
} |
|
} |
|
|
|
CallHook(item, false); |
|
} |
|
|
|
public void OnTweenUpdate(GTweener tweener) |
|
{ |
|
TransitionItem item = (TransitionItem)tweener.target; |
|
switch (item.type) |
|
{ |
|
case TransitionActionType.XY: |
|
case TransitionActionType.Size: |
|
case TransitionActionType.Scale: |
|
case TransitionActionType.Skew: |
|
((TValue)item.value).vec2 = tweener.value.vec2; |
|
if (item.tweenConfig.path != null) |
|
{ |
|
((TValue)item.value).f1 += tweener.startValue.x; |
|
((TValue)item.value).f2 += tweener.startValue.y; |
|
} |
|
break; |
|
|
|
case TransitionActionType.Alpha: |
|
case TransitionActionType.Rotation: |
|
((TValue)item.value).f1 = tweener.value.x; |
|
break; |
|
|
|
case TransitionActionType.Color: |
|
((TValue)item.value).color = tweener.value.color; |
|
break; |
|
|
|
case TransitionActionType.ColorFilter: |
|
((TValue)item.value).vec4 = tweener.value.vec4; |
|
break; |
|
|
|
case TransitionActionType.Shake: |
|
((TValue_Shake)item.value).offset = tweener.deltaValue.vec2; |
|
break; |
|
} |
|
ApplyValue(item); |
|
} |
|
|
|
public void OnTweenComplete(GTweener tweener) |
|
{ |
|
TransitionItem item = (TransitionItem)tweener.target; |
|
item.tweener = null; |
|
_totalTasks--; |
|
|
|
if (tweener.allCompleted) //当整体播放结束时间在这个tween的中间时不应该调用结尾钩子 |
|
CallHook(item, true); |
|
|
|
CheckAllComplete(); |
|
} |
|
|
|
void OnPlayTransCompleted(TransitionItem item) |
|
{ |
|
_totalTasks--; |
|
|
|
CheckAllComplete(); |
|
} |
|
|
|
void CallHook(TransitionItem item, bool tweenEnd) |
|
{ |
|
if (tweenEnd) |
|
{ |
|
if (item.tweenConfig != null && item.tweenConfig.endHook != null) |
|
item.tweenConfig.endHook(); |
|
} |
|
else |
|
{ |
|
if (item.time >= _startTime && item.hook != null) |
|
item.hook(); |
|
} |
|
} |
|
|
|
void CheckAllComplete() |
|
{ |
|
if (_playing && _totalTasks == 0) |
|
{ |
|
if (_totalTimes < 0) |
|
{ |
|
InternalPlay(); |
|
if (_totalTasks == 0) |
|
GTween.DelayedCall(0).SetTarget(this).OnComplete(_checkAllDelegate); |
|
} |
|
else |
|
{ |
|
_totalTimes--; |
|
if (_totalTimes > 0) |
|
{ |
|
InternalPlay(); |
|
if (_totalTasks == 0) |
|
GTween.DelayedCall(0).SetTarget(this).OnComplete(_checkAllDelegate); |
|
} |
|
else |
|
{ |
|
_playing = false; |
|
|
|
int cnt = _items.Length; |
|
for (int i = 0; i < cnt; i++) |
|
{ |
|
TransitionItem item = _items[i]; |
|
if (item.target != null && item.displayLockToken != 0) |
|
{ |
|
item.target.ReleaseDisplayLock(item.displayLockToken); |
|
item.displayLockToken = 0; |
|
} |
|
} |
|
|
|
if (_onComplete != null) |
|
{ |
|
PlayCompleteCallback func = _onComplete; |
|
_onComplete = null; |
|
func(); |
|
} |
|
} |
|
} |
|
} |
|
} |
|
|
|
void ApplyValue(TransitionItem item) |
|
{ |
|
item.target._gearLocked = true; |
|
|
|
switch (item.type) |
|
{ |
|
case TransitionActionType.XY: |
|
{ |
|
TValue value = (TValue)item.value; |
|
if (item.target == _owner) |
|
{ |
|
if (value.b1 && value.b2) |
|
item.target.SetXY(value.f1 + _ownerBaseX, value.f2 + _ownerBaseY); |
|
else if (value.b1) |
|
item.target.x = value.f1 + _ownerBaseX; |
|
else |
|
item.target.y = value.f2 + _ownerBaseY; |
|
} |
|
else |
|
{ |
|
if (value.b3) //position in percent |
|
{ |
|
if (value.b1 && value.b2) |
|
item.target.SetXY(value.f1 * _owner.width, value.f2 * _owner.height); |
|
else if (value.b1) |
|
item.target.x = value.f1 * _owner.width; |
|
else if (value.b2) |
|
item.target.y = value.f2 * _owner.height; |
|
} |
|
else |
|
{ |
|
if (value.b1 && value.b2) |
|
item.target.SetXY(value.f1, value.f2); |
|
else if (value.b1) |
|
item.target.x = value.f1; |
|
else if (value.b2) |
|
item.target.y = value.f2; |
|
} |
|
} |
|
if (invalidateBatchingEveryFrame) |
|
_owner.InvalidateBatchingState(true); |
|
} |
|
break; |
|
|
|
case TransitionActionType.Size: |
|
{ |
|
TValue value = (TValue)item.value; |
|
if (!value.b1) |
|
value.f1 = item.target.width; |
|
if (!value.b2) |
|
value.f2 = item.target.height; |
|
item.target.SetSize(value.f1, value.f2); |
|
if (invalidateBatchingEveryFrame) |
|
_owner.InvalidateBatchingState(true); |
|
} |
|
break; |
|
|
|
case TransitionActionType.Pivot: |
|
item.target.SetPivot(((TValue)item.value).f1, ((TValue)item.value).f2, item.target.pivotAsAnchor); |
|
if (invalidateBatchingEveryFrame) |
|
_owner.InvalidateBatchingState(true); |
|
break; |
|
|
|
case TransitionActionType.Alpha: |
|
item.target.alpha = ((TValue)item.value).f1; |
|
break; |
|
|
|
case TransitionActionType.Rotation: |
|
item.target.rotation = ((TValue)item.value).f1; |
|
if (invalidateBatchingEveryFrame) |
|
_owner.InvalidateBatchingState(true); |
|
break; |
|
|
|
case TransitionActionType.Scale: |
|
item.target.SetScale(((TValue)item.value).f1, ((TValue)item.value).f2); |
|
if (invalidateBatchingEveryFrame) |
|
_owner.InvalidateBatchingState(true); |
|
break; |
|
|
|
case TransitionActionType.Skew: |
|
item.target.skew = ((TValue)item.value).vec2; |
|
if (invalidateBatchingEveryFrame) |
|
_owner.InvalidateBatchingState(true); |
|
break; |
|
|
|
case TransitionActionType.Color: |
|
((IColorGear)item.target).color = ((TValue)item.value).color; |
|
break; |
|
|
|
case TransitionActionType.Animation: |
|
{ |
|
TValue_Animation value = (TValue_Animation)item.value; |
|
if (value.frame >= 0) |
|
((IAnimationGear)item.target).frame = value.frame; |
|
((IAnimationGear)item.target).playing = value.playing; |
|
((IAnimationGear)item.target).timeScale = _timeScale; |
|
((IAnimationGear)item.target).ignoreEngineTimeScale = _ignoreEngineTimeScale; |
|
if (value.animationName != null) |
|
((GLoader3D)item.target).animationName = value.animationName; |
|
if (value.skinName != null) |
|
((GLoader3D)item.target).skinName = value.skinName; |
|
} |
|
break; |
|
|
|
case TransitionActionType.Visible: |
|
item.target.visible = ((TValue_Visible)item.value).visible; |
|
break; |
|
|
|
case TransitionActionType.Shake: |
|
{ |
|
TValue_Shake value = (TValue_Shake)item.value; |
|
item.target.SetXY(item.target.x - value.lastOffset.x + value.offset.x, item.target.y - value.lastOffset.y + value.offset.y); |
|
value.lastOffset = value.offset; |
|
|
|
if (invalidateBatchingEveryFrame) |
|
_owner.InvalidateBatchingState(true); |
|
} |
|
break; |
|
|
|
case TransitionActionType.Transition: |
|
if (_playing) |
|
{ |
|
TValue_Transition value = (TValue_Transition)item.value; |
|
if (value.trans != null) |
|
{ |
|
_totalTasks++; |
|
|
|
float startTime = _startTime > item.time ? (_startTime - item.time) : 0; |
|
float endTime = _endTime >= 0 ? (_endTime - item.time) : -1; |
|
if (value.stopTime >= 0 && (endTime < 0 || endTime > value.stopTime)) |
|
endTime = value.stopTime; |
|
value.trans.timeScale = _timeScale; |
|
value.trans.ignoreEngineTimeScale = _ignoreEngineTimeScale; |
|
value.trans._Play(value.playTimes, 0, startTime, endTime, value.playCompleteDelegate, _reversed); |
|
} |
|
} |
|
break; |
|
|
|
case TransitionActionType.Sound: |
|
if (_playing && item.time >= _startTime) |
|
{ |
|
TValue_Sound value = (TValue_Sound)item.value; |
|
if (value.audioClip == null) |
|
{ |
|
if (UIConfig.soundLoader == null || value.sound.StartsWith(UIPackage.URL_PREFIX)) |
|
value.audioClip = UIPackage.GetItemAssetByURL(value.sound) as NAudioClip; |
|
else |
|
value.audioClip = UIConfig.soundLoader(value.sound); |
|
} |
|
|
|
if (value.audioClip != null && value.audioClip.nativeClip != null) |
|
Stage.inst.PlayOneShotSound(value.audioClip.nativeClip, value.volume); |
|
} |
|
break; |
|
|
|
case TransitionActionType.ColorFilter: |
|
{ |
|
TValue value = (TValue)item.value; |
|
ColorFilter cf = item.target.filter as ColorFilter; |
|
if (cf == null) |
|
{ |
|
cf = new ColorFilter(); |
|
item.target.filter = cf; |
|
} |
|
else |
|
cf.Reset(); |
|
|
|
cf.AdjustBrightness(value.f1); |
|
cf.AdjustContrast(value.f2); |
|
cf.AdjustSaturation(value.f3); |
|
cf.AdjustHue(value.f4); |
|
} |
|
break; |
|
|
|
case TransitionActionType.Text: |
|
item.target.text = ((TValue_Text)item.value).text; |
|
break; |
|
|
|
case TransitionActionType.Icon: |
|
item.target.icon = ((TValue_Text)item.value).text; |
|
break; |
|
} |
|
|
|
item.target._gearLocked = false; |
|
} |
|
|
|
public void Setup(ByteBuffer buffer) |
|
{ |
|
this.name = buffer.ReadS(); |
|
_options = buffer.ReadInt(); |
|
_autoPlay = buffer.ReadBool(); |
|
_autoPlayTimes = buffer.ReadInt(); |
|
_autoPlayDelay = buffer.ReadFloat(); |
|
|
|
int cnt = buffer.ReadShort(); |
|
_items = new TransitionItem[cnt]; |
|
for (int i = 0; i < cnt; i++) |
|
{ |
|
int dataLen = buffer.ReadShort(); |
|
int curPos = buffer.position; |
|
|
|
buffer.Seek(curPos, 0); |
|
|
|
TransitionItem item = new TransitionItem((TransitionActionType)buffer.ReadByte()); |
|
_items[i] = item; |
|
|
|
item.time = buffer.ReadFloat(); |
|
int targetId = buffer.ReadShort(); |
|
if (targetId < 0) |
|
item.targetId = string.Empty; |
|
else |
|
item.targetId = _owner.GetChildAt(targetId).id; |
|
item.label = buffer.ReadS(); |
|
|
|
if (buffer.ReadBool()) |
|
{ |
|
buffer.Seek(curPos, 1); |
|
|
|
item.tweenConfig = new TweenConfig(); |
|
item.tweenConfig.duration = buffer.ReadFloat(); |
|
if (item.time + item.tweenConfig.duration > _totalDuration) |
|
_totalDuration = item.time + item.tweenConfig.duration; |
|
item.tweenConfig.easeType = (EaseType)buffer.ReadByte(); |
|
item.tweenConfig.repeat = buffer.ReadInt(); |
|
item.tweenConfig.yoyo = buffer.ReadBool(); |
|
item.tweenConfig.endLabel = buffer.ReadS(); |
|
|
|
buffer.Seek(curPos, 2); |
|
|
|
DecodeValue(item, buffer, item.tweenConfig.startValue); |
|
|
|
buffer.Seek(curPos, 3); |
|
|
|
DecodeValue(item, buffer, item.tweenConfig.endValue); |
|
|
|
if (buffer.version >= 2) |
|
{ |
|
var pts = buffer.ReadPath(); |
|
if (pts.Count > 0) |
|
{ |
|
item.tweenConfig.path = new GPath(); |
|
item.tweenConfig.path.Create(pts); |
|
} |
|
} |
|
|
|
if (buffer.version >= 4 && item.tweenConfig.easeType == EaseType.Custom) |
|
{ |
|
var pts = buffer.ReadPath(); |
|
if (pts.Count > 0) |
|
{ |
|
item.tweenConfig.customEase = new CustomEase(); |
|
item.tweenConfig.customEase.Create(pts); |
|
} |
|
} |
|
} |
|
else |
|
{ |
|
if (item.time > _totalDuration) |
|
_totalDuration = item.time; |
|
|
|
buffer.Seek(curPos, 2); |
|
|
|
DecodeValue(item, buffer, item.value); |
|
} |
|
|
|
buffer.position = curPos + dataLen; |
|
} |
|
} |
|
|
|
void DecodeValue(TransitionItem item, ByteBuffer buffer, object value) |
|
{ |
|
switch (item.type) |
|
{ |
|
case TransitionActionType.XY: |
|
case TransitionActionType.Size: |
|
case TransitionActionType.Pivot: |
|
case TransitionActionType.Skew: |
|
{ |
|
TValue tvalue = (TValue)value; |
|
tvalue.b1 = buffer.ReadBool(); |
|
tvalue.b2 = buffer.ReadBool(); |
|
tvalue.f1 = buffer.ReadFloat(); |
|
tvalue.f2 = buffer.ReadFloat(); |
|
|
|
if (buffer.version >= 2 && item.type == TransitionActionType.XY) |
|
tvalue.b3 = buffer.ReadBool(); //percent |
|
} |
|
break; |
|
|
|
case TransitionActionType.Alpha: |
|
case TransitionActionType.Rotation: |
|
((TValue)value).f1 = buffer.ReadFloat(); |
|
break; |
|
|
|
case TransitionActionType.Scale: |
|
((TValue)value).f1 = buffer.ReadFloat(); |
|
((TValue)value).f2 = buffer.ReadFloat(); |
|
break; |
|
|
|
case TransitionActionType.Color: |
|
((TValue)value).color = buffer.ReadColor(); |
|
break; |
|
|
|
case TransitionActionType.Animation: |
|
((TValue_Animation)value).playing = buffer.ReadBool(); |
|
((TValue_Animation)value).frame = buffer.ReadInt(); |
|
if (buffer.version >= 6) |
|
{ |
|
((TValue_Animation)value).animationName = buffer.ReadS(); |
|
((TValue_Animation)value).skinName = buffer.ReadS(); |
|
} |
|
break; |
|
|
|
case TransitionActionType.Visible: |
|
((TValue_Visible)value).visible = buffer.ReadBool(); |
|
break; |
|
|
|
case TransitionActionType.Sound: |
|
((TValue_Sound)value).sound = buffer.ReadS(); |
|
((TValue_Sound)value).volume = buffer.ReadFloat(); |
|
break; |
|
|
|
case TransitionActionType.Transition: |
|
((TValue_Transition)value).transName = buffer.ReadS(); |
|
((TValue_Transition)value).playTimes = buffer.ReadInt(); |
|
((TValue_Transition)value).playCompleteDelegate = () => { OnPlayTransCompleted(item); }; |
|
break; |
|
|
|
case TransitionActionType.Shake: |
|
((TValue_Shake)value).amplitude = buffer.ReadFloat(); |
|
((TValue_Shake)value).duration = buffer.ReadFloat(); |
|
break; |
|
|
|
case TransitionActionType.ColorFilter: |
|
{ |
|
TValue tvalue = (TValue)value; |
|
tvalue.f1 = buffer.ReadFloat(); |
|
tvalue.f2 = buffer.ReadFloat(); |
|
tvalue.f3 = buffer.ReadFloat(); |
|
tvalue.f4 = buffer.ReadFloat(); |
|
} |
|
break; |
|
|
|
case TransitionActionType.Text: |
|
case TransitionActionType.Icon: |
|
((TValue_Text)value).text = buffer.ReadS(); |
|
break; |
|
} |
|
} |
|
} |
|
|
|
class TransitionItem |
|
{ |
|
public float time; |
|
public string targetId; |
|
public TransitionActionType type; |
|
public TweenConfig tweenConfig; |
|
public string label; |
|
public object value; |
|
public TransitionHook hook; |
|
|
|
//running properties |
|
public GTweener tweener; |
|
public GObject target; |
|
public uint displayLockToken; |
|
|
|
public TransitionItem(TransitionActionType type) |
|
{ |
|
this.type = type; |
|
|
|
switch (type) |
|
{ |
|
case TransitionActionType.XY: |
|
case TransitionActionType.Size: |
|
case TransitionActionType.Scale: |
|
case TransitionActionType.Pivot: |
|
case TransitionActionType.Skew: |
|
case TransitionActionType.Alpha: |
|
case TransitionActionType.Rotation: |
|
case TransitionActionType.Color: |
|
case TransitionActionType.ColorFilter: |
|
value = new TValue(); |
|
break; |
|
|
|
case TransitionActionType.Animation: |
|
value = new TValue_Animation(); |
|
break; |
|
|
|
case TransitionActionType.Shake: |
|
value = new TValue_Shake(); |
|
break; |
|
|
|
case TransitionActionType.Sound: |
|
value = new TValue_Sound(); |
|
break; |
|
|
|
case TransitionActionType.Transition: |
|
value = new TValue_Transition(); |
|
break; |
|
|
|
case TransitionActionType.Visible: |
|
value = new TValue_Visible(); |
|
break; |
|
|
|
case TransitionActionType.Text: |
|
case TransitionActionType.Icon: |
|
value = new TValue_Text(); |
|
break; |
|
} |
|
} |
|
} |
|
|
|
class TweenConfig |
|
{ |
|
public float duration; |
|
public EaseType easeType; |
|
public CustomEase customEase; |
|
public int repeat; |
|
public bool yoyo; |
|
|
|
public TValue startValue; |
|
public TValue endValue; |
|
|
|
public string endLabel; |
|
public TransitionHook endHook; |
|
|
|
public GPath path; |
|
|
|
public TweenConfig() |
|
{ |
|
easeType = EaseType.QuadOut; |
|
startValue = new TValue(); |
|
endValue = new TValue(); |
|
} |
|
} |
|
|
|
class TValue_Visible |
|
{ |
|
public bool visible; |
|
} |
|
|
|
class TValue_Animation |
|
{ |
|
public int frame; |
|
public bool playing; |
|
public bool flag; |
|
public string animationName; |
|
public string skinName; |
|
} |
|
|
|
class TValue_Sound |
|
{ |
|
public string sound; |
|
public float volume; |
|
public NAudioClip audioClip; |
|
} |
|
|
|
class TValue_Transition |
|
{ |
|
public string transName; |
|
public int playTimes; |
|
public Transition trans; |
|
public PlayCompleteCallback playCompleteDelegate; |
|
public float stopTime; |
|
} |
|
|
|
class TValue_Shake |
|
{ |
|
public float amplitude; |
|
public float duration; |
|
public Vector2 lastOffset; |
|
public Vector2 offset; |
|
} |
|
|
|
class TValue_Text |
|
{ |
|
public string text; |
|
} |
|
|
|
class TValue |
|
{ |
|
public float f1; |
|
public float f2; |
|
public float f3; |
|
public float f4; |
|
public bool b1; |
|
public bool b2; |
|
public bool b3; |
|
|
|
public TValue() |
|
{ |
|
b1 = true; |
|
b2 = true; |
|
} |
|
|
|
public void Copy(TValue source) |
|
{ |
|
this.f1 = source.f1; |
|
this.f2 = source.f2; |
|
this.f3 = source.f3; |
|
this.f4 = source.f4; |
|
this.b1 = source.b1; |
|
this.b2 = source.b2; |
|
} |
|
|
|
public Vector2 vec2 |
|
{ |
|
get { return new Vector2(f1, f2); } |
|
set |
|
{ |
|
f1 = value.x; |
|
f2 = value.y; |
|
} |
|
} |
|
|
|
public Vector4 vec4 |
|
{ |
|
get { return new Vector4(f1, f2, f3, f4); } |
|
set |
|
{ |
|
f1 = value.x; |
|
f2 = value.y; |
|
f3 = value.z; |
|
f4 = value.w; |
|
} |
|
} |
|
|
|
public Color color |
|
{ |
|
get { return new Color(f1, f2, f3, f4); } |
|
set |
|
{ |
|
f1 = value.r; |
|
f2 = value.g; |
|
f3 = value.b; |
|
f4 = value.a; |
|
} |
|
} |
|
} |
|
}
|
|
|