TimelineState.cs 34 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922
  1. using System;
  2. using System.Collections.Generic;
  3. namespace DragonBones
  4. {
  5. /**
  6. * @private
  7. */
  8. public class AnimationTimelineState : TimelineState<AnimationFrameData, AnimationData>
  9. {
  10. public AnimationTimelineState()
  11. {
  12. }
  13. protected void _onCrossFrame(AnimationFrameData frame)
  14. {
  15. if (_animationState.actionEnabled)
  16. {
  17. var actions = frame.actions;
  18. for (int i = 0, l = actions.Count; i < l; ++i)
  19. {
  20. _armature._bufferAction(actions[i]);
  21. }
  22. }
  23. var eventDispatcher = _armature.eventDispatcher;
  24. foreach (var eventData in frame.events)
  25. {
  26. string eventType = null;
  27. switch (eventData.type)
  28. {
  29. case EventType.Frame:
  30. eventType = EventObject.FRAME_EVENT;
  31. break;
  32. case EventType.Sound:
  33. eventType = EventObject.SOUND_EVENT;
  34. break;
  35. }
  36. if (eventDispatcher.HasEventListener(eventType) || eventData.type == EventType.Sound)
  37. {
  38. var eventObject = BaseObject.BorrowObject<EventObject>();
  39. eventObject.name = eventData.name;
  40. eventObject.frame = frame;
  41. eventObject.data = eventData.data;
  42. eventObject.animationState = _animationState;
  43. if (eventData.bone != null)
  44. {
  45. eventObject.bone = _armature.GetBone(eventData.bone.name);
  46. }
  47. if (eventData.slot != null)
  48. {
  49. eventObject.slot = _armature.GetSlot(eventData.slot.name);
  50. }
  51. _armature._bufferEvent(eventObject, eventType);
  52. }
  53. }
  54. }
  55. override public void Update(float passedTime)
  56. {
  57. var prevState = _playState;
  58. var prevTime = _currentTime;
  59. var prevPlayTimes = _currentPlayTimes;
  60. if (_playState <= 0 && _setCurrentTime(passedTime))
  61. {
  62. var eventDispatcher = _armature.eventDispatcher;
  63. if (prevState < 0 && _playState != prevState)
  64. {
  65. if (_animationState.displayControl)
  66. {
  67. _armature._sortZOrder(null);
  68. }
  69. if (eventDispatcher.HasEventListener(EventObject.START))
  70. {
  71. var eventObject = BaseObject.BorrowObject<EventObject>();
  72. eventObject.animationState = _animationState;
  73. _armature._bufferEvent(eventObject, EventObject.START);
  74. }
  75. }
  76. if (prevTime < 0.0f)
  77. {
  78. return;
  79. }
  80. bool isReverse = false;
  81. EventObject loopCompleteEvent = null;
  82. EventObject completeEvent = null;
  83. if (_currentPlayTimes != prevPlayTimes)
  84. {
  85. if (eventDispatcher.HasEventListener(EventObject.LOOP_COMPLETE))
  86. {
  87. loopCompleteEvent = BaseObject.BorrowObject<EventObject>();
  88. loopCompleteEvent.animationState = _animationState;
  89. }
  90. if (_playState > 0)
  91. {
  92. if (eventDispatcher.HasEventListener(EventObject.COMPLETE))
  93. {
  94. completeEvent = BaseObject.BorrowObject<EventObject>();
  95. completeEvent.animationState = _animationState;
  96. }
  97. isReverse = prevTime > this._currentTime;
  98. }
  99. else
  100. {
  101. isReverse = prevTime < this._currentTime;
  102. }
  103. }
  104. else
  105. {
  106. isReverse = prevTime > this._currentTime;
  107. }
  108. if (_keyFrameCount > 1)
  109. {
  110. var currentFrameIndex = (int)(_currentTime * _frameRate); // uint
  111. var currentFrame = _timelineData.frames[currentFrameIndex];
  112. if (_currentFrame != currentFrame)
  113. {
  114. var crossedFrame = _currentFrame;
  115. _currentFrame = currentFrame;
  116. if (isReverse)
  117. {
  118. if (crossedFrame == null)
  119. {
  120. var prevFrameIndex = (int)(prevTime * _frameRate);
  121. crossedFrame = _timelineData.frames[prevFrameIndex];
  122. if (_currentPlayTimes == prevPlayTimes) // Start.
  123. {
  124. if (crossedFrame == currentFrame) // Uncrossed.
  125. {
  126. crossedFrame = null;
  127. }
  128. }
  129. }
  130. while (crossedFrame != null)
  131. {
  132. if (
  133. _position <= crossedFrame.position &&
  134. crossedFrame.position <= _position + _duration
  135. ) // Support interval play.
  136. {
  137. _onCrossFrame(crossedFrame);
  138. }
  139. if (loopCompleteEvent != null && crossedFrame == _timelineData.frames[0]) // Add loop complete event after first frame.
  140. {
  141. _armature._bufferEvent(loopCompleteEvent, EventObject.LOOP_COMPLETE);
  142. loopCompleteEvent = null;
  143. }
  144. crossedFrame = crossedFrame.prev;
  145. if (crossedFrame == currentFrame)
  146. {
  147. break;
  148. }
  149. }
  150. }
  151. else
  152. {
  153. if (crossedFrame == null)
  154. {
  155. var prevFrameIndex = (int)(prevTime * _frameRate);
  156. crossedFrame = _timelineData.frames[prevFrameIndex];
  157. if (_currentPlayTimes == prevPlayTimes) // Start.
  158. {
  159. if (prevTime <= crossedFrame.position) // Crossed.
  160. {
  161. crossedFrame = crossedFrame.prev;
  162. }
  163. else if (crossedFrame == currentFrame) // Uncrossed.
  164. {
  165. crossedFrame = null;
  166. }
  167. }
  168. }
  169. while (crossedFrame != null)
  170. {
  171. crossedFrame = crossedFrame.next;
  172. if (loopCompleteEvent != null && crossedFrame == _timelineData.frames[0]) // Add loop complete event before first frame.
  173. {
  174. _armature._bufferEvent(loopCompleteEvent, EventObject.LOOP_COMPLETE);
  175. loopCompleteEvent = null;
  176. }
  177. if (
  178. _position <= crossedFrame.position &&
  179. crossedFrame.position <= _position + _duration
  180. ) // Support interval play.
  181. {
  182. _onCrossFrame(crossedFrame);
  183. }
  184. if (crossedFrame == currentFrame)
  185. {
  186. break;
  187. }
  188. }
  189. }
  190. }
  191. else if (_keyFrameCount > 0 && _currentFrame == null)
  192. {
  193. _currentFrame = _timelineData.frames[0];
  194. if (_currentPlayTimes == prevPlayTimes) // Start.
  195. {
  196. if (prevTime <= _currentFrame.position)
  197. {
  198. _onCrossFrame(_currentFrame);
  199. }
  200. }
  201. else if (_position <= _currentFrame.position) // Loop complete.
  202. {
  203. if (!isReverse && loopCompleteEvent != null) // Add loop complete event before first frame.
  204. {
  205. _armature._bufferEvent(loopCompleteEvent, EventObject.LOOP_COMPLETE);
  206. loopCompleteEvent = null;
  207. }
  208. _onCrossFrame(_currentFrame);
  209. }
  210. }
  211. }
  212. if (loopCompleteEvent != null)
  213. {
  214. _armature._bufferEvent(loopCompleteEvent, EventObject.LOOP_COMPLETE);
  215. loopCompleteEvent = null;
  216. }
  217. if (completeEvent != null)
  218. {
  219. _armature._bufferEvent(completeEvent, EventObject.COMPLETE);
  220. completeEvent = null;
  221. }
  222. }
  223. }
  224. public void setCurrentTime(float value)
  225. {
  226. _setCurrentTime(value);
  227. _currentFrame = null;
  228. }
  229. }
  230. /**
  231. * @private
  232. */
  233. public class ZOrderTimelineState : TimelineState<ZOrderFrameData, ZOrderTimelineData>
  234. {
  235. public ZOrderTimelineState()
  236. {
  237. }
  238. override protected void _onArriveAtFrame()
  239. {
  240. base._onArriveAtFrame();
  241. _armature._sortZOrder(_currentFrame.zOrder);
  242. }
  243. }
  244. /**
  245. * @private
  246. */
  247. public class BoneTimelineState : TweenTimelineState<BoneFrameData, BoneTimelineData>
  248. {
  249. public Bone bone;
  250. private bool _transformDirty;
  251. private TweenType _tweenTransform;
  252. private TweenType _tweenRotate;
  253. private TweenType _tweenScale;
  254. private readonly Transform _transform = new Transform();
  255. private readonly Transform _durationTransform = new Transform();
  256. private Transform _boneTransform;
  257. private Transform _originalTransform;
  258. public BoneTimelineState()
  259. {
  260. }
  261. override protected void _onClear()
  262. {
  263. base._onClear();
  264. bone = null;
  265. _transformDirty = false;
  266. _tweenTransform = TweenType.None;
  267. _tweenRotate = TweenType.None;
  268. _tweenScale = TweenType.None;
  269. _transform.Identity();
  270. _durationTransform.Identity();
  271. _boneTransform = null;
  272. _originalTransform = null;
  273. }
  274. override protected void _onArriveAtFrame()
  275. {
  276. base._onArriveAtFrame();
  277. _tweenTransform = TweenType.Once;
  278. _tweenRotate = TweenType.Once;
  279. _tweenScale = TweenType.Once;
  280. if (_keyFrameCount > 1 && (_tweenEasing != DragonBones.NO_TWEEN || _curve != null))
  281. {
  282. var currentTransform = _currentFrame.transform;
  283. var nextFrame = _currentFrame.next;
  284. var nextTransform = nextFrame.transform;
  285. // Transform.
  286. _durationTransform.x = nextTransform.x - currentTransform.x;
  287. _durationTransform.y = nextTransform.y - currentTransform.y;
  288. if (_durationTransform.x != 0.0f || _durationTransform.y != 0.0f)
  289. {
  290. _tweenTransform = TweenType.Always;
  291. }
  292. // Rotate.
  293. var tweenRotate = _currentFrame.tweenRotate;
  294. if (tweenRotate != DragonBones.NO_TWEEN)
  295. {
  296. if (tweenRotate != 0.0f)
  297. {
  298. if (tweenRotate > 0.0f ? nextTransform.skewY >= currentTransform.skewY : nextTransform.skewY <= currentTransform.skewY)
  299. {
  300. tweenRotate = tweenRotate > 0.0f ? tweenRotate - 1.0f : tweenRotate + 1.0f;
  301. }
  302. _durationTransform.skewX = nextTransform.skewX - currentTransform.skewX + DragonBones.PI_D * tweenRotate;
  303. _durationTransform.skewY = nextTransform.skewY - currentTransform.skewY + DragonBones.PI_D * tweenRotate;
  304. }
  305. else
  306. {
  307. _durationTransform.skewX = Transform.NormalizeRadian(nextTransform.skewX - currentTransform.skewX);
  308. _durationTransform.skewY = Transform.NormalizeRadian(nextTransform.skewY - currentTransform.skewY);
  309. }
  310. if (_durationTransform.skewX != 0.0f || _durationTransform.skewY != 0.0f)
  311. {
  312. _tweenRotate = TweenType.Always;
  313. }
  314. }
  315. else
  316. {
  317. _durationTransform.skewX = 0.0f;
  318. _durationTransform.skewY = 0.0f;
  319. }
  320. // Scale.
  321. if (_currentFrame.tweenScale)
  322. {
  323. _durationTransform.scaleX = nextTransform.scaleX - currentTransform.scaleX;
  324. _durationTransform.scaleY = nextTransform.scaleY - currentTransform.scaleY;
  325. if (_durationTransform.scaleX != 0.0f || _durationTransform.scaleY != 0.0f)
  326. {
  327. _tweenScale = TweenType.Always;
  328. }
  329. }
  330. else
  331. {
  332. _durationTransform.scaleX = 0.0f;
  333. _durationTransform.scaleY = 0.0f;
  334. }
  335. }
  336. else
  337. {
  338. _durationTransform.x = 0.0f;
  339. _durationTransform.y = 0.0f;
  340. _durationTransform.skewX = 0.0f;
  341. _durationTransform.skewY = 0.0f;
  342. _durationTransform.scaleX = 0.0f;
  343. _durationTransform.scaleY = 0.0f;
  344. }
  345. }
  346. override protected void _onUpdateFrame()
  347. {
  348. base._onUpdateFrame();
  349. var tweenProgress = 0.0f;
  350. var currentTransform = _currentFrame.transform;
  351. if (_tweenTransform != TweenType.None)
  352. {
  353. if (_tweenTransform == TweenType.Once)
  354. {
  355. _tweenTransform = TweenType.None;
  356. tweenProgress = 0.0f;
  357. }
  358. else
  359. {
  360. tweenProgress = _tweenProgress;
  361. }
  362. if (_animationState.additiveBlending) // Additive blending.
  363. {
  364. _transform.x = currentTransform.x + _durationTransform.x * tweenProgress;
  365. _transform.y = currentTransform.y + _durationTransform.y * tweenProgress;
  366. }
  367. else // Normal blending.
  368. {
  369. _transform.x = _originalTransform.x + currentTransform.x + _durationTransform.x * tweenProgress;
  370. _transform.y = _originalTransform.y + currentTransform.y + _durationTransform.y * tweenProgress;
  371. }
  372. _transformDirty = true;
  373. }
  374. if (_tweenRotate != TweenType.None)
  375. {
  376. if (_tweenRotate == TweenType.Once)
  377. {
  378. _tweenRotate = TweenType.None;
  379. tweenProgress = 0.0f;
  380. }
  381. else
  382. {
  383. tweenProgress = _tweenProgress;
  384. }
  385. if (_animationState.additiveBlending) // Additive blending.
  386. {
  387. _transform.skewX = currentTransform.skewX + _durationTransform.skewX * tweenProgress;
  388. _transform.skewY = currentTransform.skewY + _durationTransform.skewY * tweenProgress;
  389. }
  390. else // Normal blending.
  391. {
  392. _transform.skewX = _originalTransform.skewX + currentTransform.skewX + _durationTransform.skewX * tweenProgress;
  393. _transform.skewY = _originalTransform.skewY + currentTransform.skewY + _durationTransform.skewY * tweenProgress;
  394. }
  395. _transformDirty = true;
  396. }
  397. if (_tweenScale != TweenType.None)
  398. {
  399. if (_tweenScale == TweenType.Once)
  400. {
  401. _tweenScale = TweenType.None;
  402. tweenProgress = 0.0f;
  403. }
  404. else
  405. {
  406. tweenProgress = _tweenProgress;
  407. }
  408. if (_animationState.additiveBlending) // Additive blending.
  409. {
  410. _transform.scaleX = currentTransform.scaleX + _durationTransform.scaleX * tweenProgress;
  411. _transform.scaleY = currentTransform.scaleY + _durationTransform.scaleY * tweenProgress;
  412. }
  413. else // Normal blending.
  414. {
  415. _transform.scaleX = _originalTransform.scaleX * (currentTransform.scaleX + _durationTransform.scaleX * tweenProgress);
  416. _transform.scaleY = _originalTransform.scaleY * (currentTransform.scaleY + _durationTransform.scaleY * tweenProgress);
  417. }
  418. _transformDirty = true;
  419. }
  420. }
  421. override public void _init(Armature armature, AnimationState animationState, BoneTimelineData timelineData)
  422. {
  423. base._init(armature, animationState, timelineData);
  424. _originalTransform = _timelineData.originTransform;
  425. _boneTransform = bone._animationPose;
  426. }
  427. override public void FadeOut()
  428. {
  429. _transform.skewX = Transform.NormalizeRadian(_transform.skewX);
  430. _transform.skewY = Transform.NormalizeRadian(_transform.skewY);
  431. }
  432. override public void Update(float passedTime)
  433. {
  434. // Blend animation state.
  435. var animationLayer = _animationState._layer;
  436. var weight = _animationState._weightResult;
  437. if (bone._updateState <= 0)
  438. {
  439. base.Update(passedTime);
  440. bone._blendLayer = animationLayer;
  441. bone._blendLeftWeight = 1.0f;
  442. bone._blendTotalWeight = weight;
  443. _boneTransform.x = _transform.x * weight;
  444. _boneTransform.y = _transform.y * weight;
  445. _boneTransform.skewX = _transform.skewX * weight;
  446. _boneTransform.skewY = _transform.skewY * weight;
  447. _boneTransform.scaleX = (_transform.scaleX - 1) * weight + 1.0f;
  448. _boneTransform.scaleY = (_transform.scaleY - 1) * weight + 1.0f;
  449. bone._updateState = 1;
  450. }
  451. else if (bone._blendLeftWeight > 0.0f)
  452. {
  453. if (bone._blendLayer != animationLayer)
  454. {
  455. if (bone._blendTotalWeight >= bone._blendLeftWeight)
  456. {
  457. bone._blendLeftWeight = 0.0f;
  458. }
  459. else
  460. {
  461. bone._blendLayer = animationLayer;
  462. bone._blendLeftWeight -= bone._blendTotalWeight;
  463. bone._blendTotalWeight = 0.0f;
  464. }
  465. }
  466. weight *= bone._blendLeftWeight;
  467. if (weight > 0.0f)
  468. {
  469. base.Update(passedTime);
  470. bone._blendTotalWeight += weight;
  471. _boneTransform.x += _transform.x * weight;
  472. _boneTransform.y += _transform.y * weight;
  473. _boneTransform.skewX += _transform.skewX * weight;
  474. _boneTransform.skewY += _transform.skewY * weight;
  475. _boneTransform.scaleX += (_transform.scaleX - 1.0f) * weight;
  476. _boneTransform.scaleY += (_transform.scaleY - 1.0f) * weight;
  477. bone._updateState++;
  478. }
  479. }
  480. if (bone._updateState > 0)
  481. {
  482. if (_transformDirty || _animationState._fadeState != 0 || _animationState._subFadeState != 0)
  483. {
  484. _transformDirty = false;
  485. bone.InvalidUpdate();
  486. }
  487. }
  488. }
  489. }
  490. /**
  491. * @private
  492. */
  493. public class SlotTimelineState : TweenTimelineState<SlotFrameData, SlotTimelineData>
  494. {
  495. public Slot slot;
  496. private bool _colorDirty;
  497. private TweenType _tweenColor;
  498. private readonly ColorTransform _color = new ColorTransform();
  499. private readonly ColorTransform _durationColor = new ColorTransform();
  500. private ColorTransform _slotColor;
  501. public SlotTimelineState()
  502. {
  503. }
  504. override protected void _onClear()
  505. {
  506. base._onClear();
  507. slot = null;
  508. _colorDirty = false;
  509. _tweenColor = TweenType.None;
  510. _color.Identity();
  511. _durationColor.Identity();
  512. _slotColor = null;
  513. }
  514. override protected void _onArriveAtFrame()
  515. {
  516. base._onArriveAtFrame();
  517. if (_animationState._isDisabled(slot))
  518. {
  519. _tweenEasing = DragonBones.NO_TWEEN;
  520. _curve = null;
  521. _tweenColor = TweenType.None;
  522. return;
  523. }
  524. var displayIndex = _currentFrame.displayIndex;
  525. if (_playState >= 0 && slot.displayIndex != displayIndex)
  526. {
  527. slot._setDisplayIndex(displayIndex);
  528. }
  529. if (displayIndex >= 0)
  530. {
  531. _tweenColor = TweenType.None;
  532. var currentColor = _currentFrame.color;
  533. if (_tweenEasing != DragonBones.NO_TWEEN || _curve != null)
  534. {
  535. var nextFrame = _currentFrame.next;
  536. var nextColor = nextFrame.color;
  537. if (currentColor != nextColor)
  538. {
  539. _durationColor.alphaMultiplier = nextColor.alphaMultiplier - currentColor.alphaMultiplier;
  540. _durationColor.redMultiplier = nextColor.redMultiplier - currentColor.redMultiplier;
  541. _durationColor.greenMultiplier = nextColor.greenMultiplier - currentColor.greenMultiplier;
  542. _durationColor.blueMultiplier = nextColor.blueMultiplier - currentColor.blueMultiplier;
  543. _durationColor.alphaOffset = nextColor.alphaOffset - currentColor.alphaOffset;
  544. _durationColor.redOffset = nextColor.redOffset - currentColor.redOffset;
  545. _durationColor.greenOffset = nextColor.greenOffset - currentColor.greenOffset;
  546. _durationColor.blueOffset = nextColor.blueOffset - currentColor.blueOffset;
  547. if (
  548. _durationColor.alphaMultiplier != 0.0f ||
  549. _durationColor.redMultiplier != 0.0f ||
  550. _durationColor.greenMultiplier != 0.0f ||
  551. _durationColor.blueMultiplier != 0.0f ||
  552. _durationColor.alphaOffset != 0 ||
  553. _durationColor.redOffset != 0 ||
  554. _durationColor.greenOffset != 0 ||
  555. _durationColor.blueOffset != 0
  556. )
  557. {
  558. _tweenColor = TweenType.Always;
  559. }
  560. }
  561. }
  562. if (_tweenColor == TweenType.None)
  563. {
  564. if (
  565. _slotColor.alphaMultiplier != currentColor.alphaMultiplier ||
  566. _slotColor.redMultiplier != currentColor.redMultiplier ||
  567. _slotColor.greenMultiplier != currentColor.greenMultiplier ||
  568. _slotColor.blueMultiplier != currentColor.blueMultiplier ||
  569. _slotColor.alphaOffset != currentColor.alphaOffset ||
  570. _slotColor.redOffset != currentColor.redOffset ||
  571. _slotColor.greenOffset != currentColor.greenOffset ||
  572. _slotColor.blueOffset != currentColor.blueOffset
  573. )
  574. {
  575. _tweenColor = TweenType.Once;
  576. }
  577. }
  578. }
  579. else
  580. {
  581. _tweenEasing = DragonBones.NO_TWEEN;
  582. _curve = null;
  583. _tweenColor = TweenType.None;
  584. }
  585. }
  586. override protected void _onUpdateFrame()
  587. {
  588. base._onUpdateFrame();
  589. var tweenProgress = 0.0f;
  590. if (_tweenColor != TweenType.None)
  591. {
  592. if (_tweenColor == TweenType.Once)
  593. {
  594. _tweenColor = TweenType.None;
  595. tweenProgress = 0.0f;
  596. }
  597. else
  598. {
  599. tweenProgress = _tweenProgress;
  600. }
  601. var currentColor = _currentFrame.color;
  602. _color.alphaMultiplier = currentColor.alphaMultiplier + _durationColor.alphaMultiplier * tweenProgress;
  603. _color.redMultiplier = currentColor.redMultiplier + _durationColor.redMultiplier * tweenProgress;
  604. _color.greenMultiplier = currentColor.greenMultiplier + _durationColor.greenMultiplier * tweenProgress;
  605. _color.blueMultiplier = currentColor.blueMultiplier + _durationColor.blueMultiplier * tweenProgress;
  606. _color.alphaOffset = currentColor.alphaOffset + (int)(_durationColor.alphaOffset * tweenProgress);
  607. _color.redOffset = currentColor.redOffset + (int)(_durationColor.redOffset * tweenProgress);
  608. _color.greenOffset = currentColor.greenOffset + (int)(_durationColor.greenOffset * tweenProgress);
  609. _color.blueOffset = currentColor.blueOffset + (int)(_durationColor.blueOffset * tweenProgress);
  610. _colorDirty = true;
  611. }
  612. }
  613. override public void _init(Armature armature, AnimationState animationState, SlotTimelineData timelineData)
  614. {
  615. base._init(armature, animationState, timelineData);
  616. _slotColor = slot._colorTransform;
  617. }
  618. override public void FadeOut()
  619. {
  620. _tweenColor = TweenType.None;
  621. }
  622. override public void Update(float passedTime)
  623. {
  624. base.Update(passedTime);
  625. // Fade animation.
  626. if (_tweenColor != TweenType.None || _colorDirty)
  627. {
  628. if (_animationState._fadeState != 0 || _animationState._subFadeState != 0)
  629. {
  630. var fadeProgress = (float)Math.Pow(_animationState._fadeProgress, 4.0f);
  631. _slotColor.alphaMultiplier += (_color.alphaMultiplier - _slotColor.alphaMultiplier) * fadeProgress;
  632. _slotColor.redMultiplier += (_color.redMultiplier - _slotColor.redMultiplier) * fadeProgress;
  633. _slotColor.greenMultiplier += (_color.greenMultiplier - _slotColor.greenMultiplier) * fadeProgress;
  634. _slotColor.blueMultiplier += (_color.blueMultiplier - _slotColor.blueMultiplier) * fadeProgress;
  635. _slotColor.alphaOffset += (int)((_color.alphaOffset - _slotColor.alphaOffset) * fadeProgress);
  636. _slotColor.redOffset += (int)((_color.redOffset - _slotColor.redOffset) * fadeProgress);
  637. _slotColor.greenOffset += (int)((_color.greenOffset - _slotColor.greenOffset) * fadeProgress);
  638. _slotColor.blueOffset += (int)((_color.blueOffset - _slotColor.blueOffset) * fadeProgress);
  639. slot._colorDirty = true;
  640. }
  641. else if (_colorDirty)
  642. {
  643. _colorDirty = false;
  644. _slotColor.alphaMultiplier = _color.alphaMultiplier;
  645. _slotColor.redMultiplier = _color.redMultiplier;
  646. _slotColor.greenMultiplier = _color.greenMultiplier;
  647. _slotColor.blueMultiplier = _color.blueMultiplier;
  648. _slotColor.alphaOffset = _color.alphaOffset;
  649. _slotColor.redOffset = _color.redOffset;
  650. _slotColor.greenOffset = _color.greenOffset;
  651. _slotColor.blueOffset = _color.blueOffset;
  652. slot._colorDirty = true;
  653. }
  654. }
  655. }
  656. }
  657. /**
  658. * @private
  659. */
  660. public class FFDTimelineState : TweenTimelineState<ExtensionFrameData, FFDTimelineData>
  661. {
  662. public Slot slot;
  663. private bool _ffdDirty;
  664. private TweenType _tweenFFD;
  665. private readonly List<float> _ffdVertices = new List<float>();
  666. private readonly List<float> _durationFFDVertices = new List<float>();
  667. private List<float> _slotFFDVertices;
  668. public FFDTimelineState()
  669. {
  670. }
  671. override protected void _onClear()
  672. {
  673. base._onClear();
  674. slot = null;
  675. _ffdDirty = false;
  676. _tweenFFD = TweenType.None;
  677. _ffdVertices.Clear();
  678. _durationFFDVertices.Clear();
  679. _slotFFDVertices = null;
  680. }
  681. override protected void _onArriveAtFrame()
  682. {
  683. if (slot.displayIndex >= 0 && _animationState._isDisabled(slot))
  684. {
  685. _tweenEasing = DragonBones.NO_TWEEN;
  686. _curve = null;
  687. _tweenFFD = TweenType.None;
  688. return;
  689. }
  690. base._onArriveAtFrame();
  691. _tweenFFD = TweenType.None;
  692. if (_tweenEasing != DragonBones.NO_TWEEN || _curve != null)
  693. {
  694. var currentFFDVertices = _currentFrame.tweens;
  695. var nextFFDVertices = _currentFrame.next.tweens;
  696. for (int i = 0, l = currentFFDVertices.Count; i < l; ++i)
  697. {
  698. var duration = nextFFDVertices[i] - currentFFDVertices[i];
  699. _durationFFDVertices[i] = duration;
  700. if (duration != 0.0f)
  701. {
  702. _tweenFFD = TweenType.Always;
  703. }
  704. }
  705. }
  706. if (_tweenFFD == TweenType.None)
  707. {
  708. _tweenFFD = TweenType.Once;
  709. for (int i = 0, l = _durationFFDVertices.Count; i < l; ++i)
  710. {
  711. _durationFFDVertices[i] = 0.0f;
  712. }
  713. }
  714. }
  715. override protected void _onUpdateFrame()
  716. {
  717. base._onUpdateFrame();
  718. var tweenProgress = 0.0f;
  719. if (_tweenFFD != TweenType.None)
  720. {
  721. if (_tweenFFD == TweenType.Once)
  722. {
  723. _tweenFFD = TweenType.None;
  724. tweenProgress = 0.0f;
  725. }
  726. else
  727. {
  728. tweenProgress = _tweenProgress;
  729. }
  730. var currentFFDVertices = _currentFrame.tweens;
  731. for (int i = 0, l = currentFFDVertices.Count; i < l; ++i)
  732. {
  733. _ffdVertices[i] = currentFFDVertices[i] + _durationFFDVertices[i] * tweenProgress;
  734. }
  735. _ffdDirty = true;
  736. }
  737. }
  738. override public void _init(Armature armature, AnimationState animationState, FFDTimelineData timelineData)
  739. {
  740. base._init(armature, animationState, timelineData);
  741. _slotFFDVertices = slot._ffdVertices;
  742. DragonBones.ResizeList(_ffdVertices, _timelineData.frames[0].tweens.Count, 0.0f);
  743. DragonBones.ResizeList(_durationFFDVertices, _ffdVertices.Count, 0.0f);
  744. for (int i = 0, l = _ffdVertices.Count; i < l; ++i)
  745. {
  746. _ffdVertices[i] = 0.0f;
  747. }
  748. for (int i = 0, l = _durationFFDVertices.Count; i < l; ++i)
  749. {
  750. _durationFFDVertices[i] = 0.0f;
  751. }
  752. }
  753. override public void FadeOut()
  754. {
  755. _tweenFFD = TweenType.None;
  756. }
  757. override public void Update(float passedTime)
  758. {
  759. if (slot.parent._blendLayer < _animationState._layer)
  760. {
  761. return;
  762. }
  763. base.Update(passedTime);
  764. if (slot._meshData != _timelineData.display.mesh)
  765. {
  766. return;
  767. }
  768. // Fade animation.
  769. if (_tweenFFD != TweenType.None || _ffdDirty)
  770. {
  771. if (_animationState._fadeState != 0 || _animationState._subFadeState != 0)
  772. {
  773. var fadeProgress = (float)Math.Pow(_animationState._fadeProgress, 4.0f);
  774. for (int i = 0, l = _ffdVertices.Count; i < l; ++i)
  775. {
  776. _slotFFDVertices[i] += (_ffdVertices[i] - _slotFFDVertices[i]) * fadeProgress;
  777. }
  778. slot._meshDirty = true;
  779. }
  780. else if (_ffdDirty)
  781. {
  782. _ffdDirty = false;
  783. for (int i = 0, l = _ffdVertices.Count; i < l; ++i)
  784. {
  785. _slotFFDVertices[i] = _ffdVertices[i];
  786. }
  787. slot._meshDirty = true;
  788. }
  789. }
  790. }
  791. }
  792. }