tween.cpp 27 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964
  1. /*************************************************************************/
  2. /* tween.cpp */
  3. /*************************************************************************/
  4. /* This file is part of: */
  5. /* GODOT ENGINE */
  6. /* https://godotengine.org */
  7. /*************************************************************************/
  8. /* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur. */
  9. /* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md). */
  10. /* */
  11. /* Permission is hereby granted, free of charge, to any person obtaining */
  12. /* a copy of this software and associated documentation files (the */
  13. /* "Software"), to deal in the Software without restriction, including */
  14. /* without limitation the rights to use, copy, modify, merge, publish, */
  15. /* distribute, sublicense, and/or sell copies of the Software, and to */
  16. /* permit persons to whom the Software is furnished to do so, subject to */
  17. /* the following conditions: */
  18. /* */
  19. /* The above copyright notice and this permission notice shall be */
  20. /* included in all copies or substantial portions of the Software. */
  21. /* */
  22. /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
  23. /* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
  24. /* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
  25. /* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
  26. /* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
  27. /* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
  28. /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
  29. /*************************************************************************/
  30. #include "tween.h"
  31. #include "scene/animation/easing_equations.h"
  32. #include "scene/main/node.h"
  33. Tween::interpolater Tween::interpolaters[Tween::TRANS_MAX][Tween::EASE_MAX] = {
  34. { &linear::in, &linear::in, &linear::in, &linear::in }, // Linear is the same for each easing.
  35. { &sine::in, &sine::out, &sine::in_out, &sine::out_in },
  36. { &quint::in, &quint::out, &quint::in_out, &quint::out_in },
  37. { &quart::in, &quart::out, &quart::in_out, &quart::out_in },
  38. { &quad::in, &quad::out, &quad::in_out, &quad::out_in },
  39. { &expo::in, &expo::out, &expo::in_out, &expo::out_in },
  40. { &elastic::in, &elastic::out, &elastic::in_out, &elastic::out_in },
  41. { &cubic::in, &cubic::out, &cubic::in_out, &cubic::out_in },
  42. { &circ::in, &circ::out, &circ::in_out, &circ::out_in },
  43. { &bounce::in, &bounce::out, &bounce::in_out, &bounce::out_in },
  44. { &back::in, &back::out, &back::in_out, &back::out_in },
  45. };
  46. void Tweener::set_tween(Ref<Tween> p_tween) {
  47. tween = p_tween;
  48. }
  49. void Tweener::clear_tween() {
  50. tween.unref();
  51. }
  52. void Tweener::_bind_methods() {
  53. ADD_SIGNAL(MethodInfo("finished"));
  54. }
  55. void Tween::start_tweeners() {
  56. if (tweeners.is_empty()) {
  57. dead = true;
  58. ERR_FAIL_MSG("Tween without commands, aborting.");
  59. }
  60. for (Ref<Tweener> &tweener : tweeners.write[current_step]) {
  61. tweener->start();
  62. }
  63. }
  64. Ref<PropertyTweener> Tween::tween_property(Object *p_target, NodePath p_property, Variant p_to, float p_duration) {
  65. ERR_FAIL_NULL_V(p_target, nullptr);
  66. ERR_FAIL_COND_V_MSG(!valid, nullptr, "Tween invalid. Either finished or created outside scene tree.");
  67. ERR_FAIL_COND_V_MSG(started, nullptr, "Can't append to a Tween that has started. Use stop() first.");
  68. #ifdef DEBUG_ENABLED
  69. Variant::Type property_type = p_target->get_indexed(p_property.get_as_property_path().get_subnames()).get_type();
  70. ERR_FAIL_COND_V_MSG(property_type != p_to.get_type(), Ref<PropertyTweener>(), "Type mismatch between property and final value: " + Variant::get_type_name(property_type) + " and " + Variant::get_type_name(p_to.get_type()));
  71. #endif
  72. Ref<PropertyTweener> tweener = memnew(PropertyTweener(p_target, p_property, p_to, p_duration));
  73. append(tweener);
  74. return tweener;
  75. }
  76. Ref<IntervalTweener> Tween::tween_interval(float p_time) {
  77. ERR_FAIL_COND_V_MSG(!valid, nullptr, "Tween invalid. Either finished or created outside scene tree.");
  78. ERR_FAIL_COND_V_MSG(started, nullptr, "Can't append to a Tween that has started. Use stop() first.");
  79. Ref<IntervalTweener> tweener = memnew(IntervalTweener(p_time));
  80. append(tweener);
  81. return tweener;
  82. }
  83. Ref<CallbackTweener> Tween::tween_callback(Callable p_callback) {
  84. ERR_FAIL_COND_V_MSG(!valid, nullptr, "Tween invalid. Either finished or created outside scene tree.");
  85. ERR_FAIL_COND_V_MSG(started, nullptr, "Can't append to a Tween that has started. Use stop() first.");
  86. Ref<CallbackTweener> tweener = memnew(CallbackTweener(p_callback));
  87. append(tweener);
  88. return tweener;
  89. }
  90. Ref<MethodTweener> Tween::tween_method(Callable p_callback, Variant p_from, Variant p_to, float p_duration) {
  91. ERR_FAIL_COND_V_MSG(!valid, nullptr, "Tween invalid. Either finished or created outside scene tree.");
  92. ERR_FAIL_COND_V_MSG(started, nullptr, "Can't append to a Tween that has started. Use stop() first.");
  93. Ref<MethodTweener> tweener = memnew(MethodTweener(p_callback, p_from, p_to, p_duration));
  94. append(tweener);
  95. return tweener;
  96. }
  97. void Tween::append(Ref<Tweener> p_tweener) {
  98. p_tweener->set_tween(this);
  99. if (parallel_enabled) {
  100. current_step = MAX(current_step, 0);
  101. } else {
  102. current_step++;
  103. }
  104. parallel_enabled = default_parallel;
  105. tweeners.resize(current_step + 1);
  106. tweeners.write[current_step].push_back(p_tweener);
  107. }
  108. void Tween::stop() {
  109. started = false;
  110. running = false;
  111. dead = false;
  112. total_time = 0;
  113. }
  114. void Tween::pause() {
  115. running = false;
  116. }
  117. void Tween::play() {
  118. ERR_FAIL_COND_MSG(!valid, "Tween invalid. Either finished or created outside scene tree.");
  119. ERR_FAIL_COND_MSG(dead, "Can't play finished Tween, use stop() first to reset its state.");
  120. running = true;
  121. }
  122. void Tween::kill() {
  123. running = false; // For the sake of is_running().
  124. dead = true;
  125. }
  126. bool Tween::is_running() {
  127. return running;
  128. }
  129. bool Tween::is_valid() {
  130. return valid;
  131. }
  132. void Tween::clear() {
  133. valid = false;
  134. for (List<Ref<Tweener>> &step : tweeners) {
  135. for (Ref<Tweener> &tweener : step) {
  136. tweener->clear_tween();
  137. }
  138. }
  139. tweeners.clear();
  140. }
  141. Ref<Tween> Tween::bind_node(Node *p_node) {
  142. ERR_FAIL_NULL_V(p_node, this);
  143. bound_node = p_node->get_instance_id();
  144. is_bound = true;
  145. return this;
  146. }
  147. Ref<Tween> Tween::set_process_mode(TweenProcessMode p_mode) {
  148. process_mode = p_mode;
  149. return this;
  150. }
  151. Tween::TweenProcessMode Tween::get_process_mode() {
  152. return process_mode;
  153. }
  154. Ref<Tween> Tween::set_pause_mode(TweenPauseMode p_mode) {
  155. pause_mode = p_mode;
  156. return this;
  157. }
  158. Tween::TweenPauseMode Tween::get_pause_mode() {
  159. return pause_mode;
  160. }
  161. Ref<Tween> Tween::set_parallel(bool p_parallel) {
  162. default_parallel = p_parallel;
  163. parallel_enabled = p_parallel;
  164. return this;
  165. }
  166. Ref<Tween> Tween::set_loops(int p_loops) {
  167. loops = p_loops;
  168. return this;
  169. }
  170. Ref<Tween> Tween::set_speed_scale(float p_speed) {
  171. speed_scale = p_speed;
  172. return this;
  173. }
  174. Ref<Tween> Tween::set_trans(TransitionType p_trans) {
  175. default_transition = p_trans;
  176. return this;
  177. }
  178. Tween::TransitionType Tween::get_trans() {
  179. return default_transition;
  180. }
  181. Ref<Tween> Tween::set_ease(EaseType p_ease) {
  182. default_ease = p_ease;
  183. return this;
  184. }
  185. Tween::EaseType Tween::get_ease() {
  186. return default_ease;
  187. }
  188. Ref<Tween> Tween::parallel() {
  189. parallel_enabled = true;
  190. return this;
  191. }
  192. Ref<Tween> Tween::chain() {
  193. parallel_enabled = false;
  194. return this;
  195. }
  196. bool Tween::custom_step(float p_delta) {
  197. bool r = running;
  198. running = true;
  199. bool ret = step(p_delta);
  200. running = running && r; // Running might turn false when Tween finished.
  201. return ret;
  202. }
  203. bool Tween::step(float p_delta) {
  204. if (dead) {
  205. return false;
  206. }
  207. if (!running) {
  208. return true;
  209. }
  210. if (is_bound) {
  211. Node *bound_node = get_bound_node();
  212. if (bound_node) {
  213. if (!bound_node->is_inside_tree()) {
  214. return true;
  215. }
  216. } else {
  217. return false;
  218. }
  219. }
  220. if (!started) {
  221. ERR_FAIL_COND_V_MSG(tweeners.is_empty(), false, "Tween started, but has no Tweeners.");
  222. current_step = 0;
  223. loops_done = 0;
  224. total_time = 0;
  225. start_tweeners();
  226. started = true;
  227. }
  228. float rem_delta = p_delta * speed_scale;
  229. bool step_active = false;
  230. total_time += rem_delta;
  231. while (rem_delta > 0 && running) {
  232. float step_delta = rem_delta;
  233. step_active = false;
  234. #ifdef DEBUG_ENABLED
  235. float prev_delta = rem_delta;
  236. #endif
  237. for (Ref<Tweener> &tweener : tweeners.write[current_step]) {
  238. // Modified inside Tweener.step().
  239. float temp_delta = rem_delta;
  240. // Turns to true if any Tweener returns true (i.e. is still not finished).
  241. step_active = tweener->step(temp_delta) || step_active;
  242. step_delta = MIN(temp_delta, step_delta);
  243. }
  244. rem_delta = step_delta;
  245. if (!step_active) {
  246. emit_signal(SNAME("step_finished"), current_step);
  247. current_step++;
  248. if (current_step == tweeners.size()) {
  249. loops_done++;
  250. if (loops_done == loops) {
  251. running = false;
  252. dead = true;
  253. emit_signal(SNAME("finished"));
  254. } else {
  255. emit_signal(SNAME("loop_finished"), loops_done);
  256. current_step = 0;
  257. start_tweeners();
  258. }
  259. } else {
  260. start_tweeners();
  261. }
  262. }
  263. #ifdef DEBUG_ENABLED
  264. if (Math::is_equal_approx(rem_delta, prev_delta) && running && loops <= 0) {
  265. ERR_FAIL_V_MSG(false, "Infinite loop detected. Check set_loops() description for more info.");
  266. }
  267. #endif
  268. }
  269. return true;
  270. }
  271. bool Tween::can_process(bool p_tree_paused) const {
  272. if (is_bound && pause_mode == TWEEN_PAUSE_BOUND) {
  273. Node *bound_node = get_bound_node();
  274. if (bound_node) {
  275. return bound_node->can_process();
  276. }
  277. }
  278. return !p_tree_paused || pause_mode == TWEEN_PAUSE_PROCESS;
  279. }
  280. Node *Tween::get_bound_node() const {
  281. if (is_bound) {
  282. return Object::cast_to<Node>(ObjectDB::get_instance(bound_node));
  283. } else {
  284. return nullptr;
  285. }
  286. }
  287. float Tween::get_total_time() const {
  288. return total_time;
  289. }
  290. real_t Tween::run_equation(TransitionType p_trans_type, EaseType p_ease_type, real_t p_time, real_t p_initial, real_t p_delta, real_t p_duration) {
  291. if (p_duration == 0) {
  292. // Special case to avoid dividing by 0 in equations.
  293. return p_initial + p_delta;
  294. }
  295. interpolater func = interpolaters[p_trans_type][p_ease_type];
  296. return func(p_time, p_initial, p_delta, p_duration);
  297. }
  298. Variant Tween::interpolate_variant(Variant p_initial_val, Variant p_delta_val, float p_time, float p_duration, TransitionType p_trans, EaseType p_ease) {
  299. ERR_FAIL_INDEX_V(p_trans, TransitionType::TRANS_MAX, Variant());
  300. ERR_FAIL_INDEX_V(p_ease, EaseType::EASE_MAX, Variant());
  301. // Helper macro to run equation on sub-elements of the value (e.g. x and y of Vector2).
  302. #define APPLY_EQUATION(element) \
  303. r.element = run_equation(p_trans, p_ease, p_time, i.element, d.element, p_duration);
  304. switch (p_initial_val.get_type()) {
  305. case Variant::BOOL: {
  306. return (run_equation(p_trans, p_ease, p_time, p_initial_val, p_delta_val, p_duration)) >= 0.5;
  307. }
  308. case Variant::INT: {
  309. return (int)run_equation(p_trans, p_ease, p_time, (int)p_initial_val, (int)p_delta_val, p_duration);
  310. }
  311. case Variant::FLOAT: {
  312. return run_equation(p_trans, p_ease, p_time, (real_t)p_initial_val, (real_t)p_delta_val, p_duration);
  313. }
  314. case Variant::VECTOR2: {
  315. Vector2 i = p_initial_val;
  316. Vector2 d = p_delta_val;
  317. Vector2 r;
  318. APPLY_EQUATION(x);
  319. APPLY_EQUATION(y);
  320. return r;
  321. }
  322. case Variant::VECTOR2I: {
  323. Vector2i i = p_initial_val;
  324. Vector2i d = p_delta_val;
  325. Vector2i r;
  326. APPLY_EQUATION(x);
  327. APPLY_EQUATION(y);
  328. return r;
  329. }
  330. case Variant::RECT2: {
  331. Rect2 i = p_initial_val;
  332. Rect2 d = p_delta_val;
  333. Rect2 r;
  334. APPLY_EQUATION(position.x);
  335. APPLY_EQUATION(position.y);
  336. APPLY_EQUATION(size.x);
  337. APPLY_EQUATION(size.y);
  338. return r;
  339. }
  340. case Variant::RECT2I: {
  341. Rect2i i = p_initial_val;
  342. Rect2i d = p_delta_val;
  343. Rect2i r;
  344. APPLY_EQUATION(position.x);
  345. APPLY_EQUATION(position.y);
  346. APPLY_EQUATION(size.x);
  347. APPLY_EQUATION(size.y);
  348. return r;
  349. }
  350. case Variant::VECTOR3: {
  351. Vector3 i = p_initial_val;
  352. Vector3 d = p_delta_val;
  353. Vector3 r;
  354. APPLY_EQUATION(x);
  355. APPLY_EQUATION(y);
  356. APPLY_EQUATION(z);
  357. return r;
  358. }
  359. case Variant::VECTOR3I: {
  360. Vector3i i = p_initial_val;
  361. Vector3i d = p_delta_val;
  362. Vector3i r;
  363. APPLY_EQUATION(x);
  364. APPLY_EQUATION(y);
  365. APPLY_EQUATION(z);
  366. return r;
  367. }
  368. case Variant::TRANSFORM2D: {
  369. Transform2D i = p_initial_val;
  370. Transform2D d = p_delta_val;
  371. Transform2D r;
  372. APPLY_EQUATION(columns[0][0]);
  373. APPLY_EQUATION(columns[0][1]);
  374. APPLY_EQUATION(columns[1][0]);
  375. APPLY_EQUATION(columns[1][1]);
  376. APPLY_EQUATION(columns[2][0]);
  377. APPLY_EQUATION(columns[2][1]);
  378. return r;
  379. }
  380. case Variant::QUATERNION: {
  381. Quaternion i = p_initial_val;
  382. Quaternion d = p_delta_val;
  383. Quaternion r;
  384. APPLY_EQUATION(x);
  385. APPLY_EQUATION(y);
  386. APPLY_EQUATION(z);
  387. APPLY_EQUATION(w);
  388. return r;
  389. }
  390. case Variant::AABB: {
  391. AABB i = p_initial_val;
  392. AABB d = p_delta_val;
  393. AABB r;
  394. APPLY_EQUATION(position.x);
  395. APPLY_EQUATION(position.y);
  396. APPLY_EQUATION(position.z);
  397. APPLY_EQUATION(size.x);
  398. APPLY_EQUATION(size.y);
  399. APPLY_EQUATION(size.z);
  400. return r;
  401. }
  402. case Variant::BASIS: {
  403. Basis i = p_initial_val;
  404. Basis d = p_delta_val;
  405. Basis r;
  406. APPLY_EQUATION(elements[0][0]);
  407. APPLY_EQUATION(elements[0][1]);
  408. APPLY_EQUATION(elements[0][2]);
  409. APPLY_EQUATION(elements[1][0]);
  410. APPLY_EQUATION(elements[1][1]);
  411. APPLY_EQUATION(elements[1][2]);
  412. APPLY_EQUATION(elements[2][0]);
  413. APPLY_EQUATION(elements[2][1]);
  414. APPLY_EQUATION(elements[2][2]);
  415. return r;
  416. }
  417. case Variant::TRANSFORM3D: {
  418. Transform3D i = p_initial_val;
  419. Transform3D d = p_delta_val;
  420. Transform3D r;
  421. APPLY_EQUATION(basis.elements[0][0]);
  422. APPLY_EQUATION(basis.elements[0][1]);
  423. APPLY_EQUATION(basis.elements[0][2]);
  424. APPLY_EQUATION(basis.elements[1][0]);
  425. APPLY_EQUATION(basis.elements[1][1]);
  426. APPLY_EQUATION(basis.elements[1][2]);
  427. APPLY_EQUATION(basis.elements[2][0]);
  428. APPLY_EQUATION(basis.elements[2][1]);
  429. APPLY_EQUATION(basis.elements[2][2]);
  430. APPLY_EQUATION(origin.x);
  431. APPLY_EQUATION(origin.y);
  432. APPLY_EQUATION(origin.z);
  433. return r;
  434. }
  435. case Variant::COLOR: {
  436. Color i = p_initial_val;
  437. Color d = p_delta_val;
  438. Color r;
  439. APPLY_EQUATION(r);
  440. APPLY_EQUATION(g);
  441. APPLY_EQUATION(b);
  442. APPLY_EQUATION(a);
  443. return r;
  444. }
  445. default: {
  446. return p_initial_val;
  447. }
  448. };
  449. #undef APPLY_EQUATION
  450. }
  451. Variant Tween::calculate_delta_value(Variant p_intial_val, Variant p_final_val) {
  452. ERR_FAIL_COND_V_MSG(p_intial_val.get_type() != p_final_val.get_type(), p_intial_val, "Type mismatch between initial and final value: " + Variant::get_type_name(p_intial_val.get_type()) + " and " + Variant::get_type_name(p_final_val.get_type()));
  453. switch (p_intial_val.get_type()) {
  454. case Variant::BOOL: {
  455. return (int)p_final_val - (int)p_intial_val;
  456. }
  457. case Variant::RECT2: {
  458. Rect2 i = p_intial_val;
  459. Rect2 f = p_final_val;
  460. return Rect2(f.position - i.position, f.size - i.size);
  461. }
  462. case Variant::RECT2I: {
  463. Rect2i i = p_intial_val;
  464. Rect2i f = p_final_val;
  465. return Rect2i(f.position - i.position, f.size - i.size);
  466. }
  467. case Variant::TRANSFORM2D: {
  468. Transform2D i = p_intial_val;
  469. Transform2D f = p_final_val;
  470. return Transform2D(f.columns[0][0] - i.columns[0][0],
  471. f.columns[0][1] - i.columns[0][1],
  472. f.columns[1][0] - i.columns[1][0],
  473. f.columns[1][1] - i.columns[1][1],
  474. f.columns[2][0] - i.columns[2][0],
  475. f.columns[2][1] - i.columns[2][1]);
  476. }
  477. case Variant::AABB: {
  478. AABB i = p_intial_val;
  479. AABB f = p_final_val;
  480. return AABB(f.position - i.position, f.size - i.size);
  481. }
  482. case Variant::BASIS: {
  483. Basis i = p_intial_val;
  484. Basis f = p_final_val;
  485. return Basis(f.elements[0][0] - i.elements[0][0],
  486. f.elements[0][1] - i.elements[0][1],
  487. f.elements[0][2] - i.elements[0][2],
  488. f.elements[1][0] - i.elements[1][0],
  489. f.elements[1][1] - i.elements[1][1],
  490. f.elements[1][2] - i.elements[1][2],
  491. f.elements[2][0] - i.elements[2][0],
  492. f.elements[2][1] - i.elements[2][1],
  493. f.elements[2][2] - i.elements[2][2]);
  494. }
  495. case Variant::TRANSFORM3D: {
  496. Transform3D i = p_intial_val;
  497. Transform3D f = p_final_val;
  498. return Transform3D(f.basis.elements[0][0] - i.basis.elements[0][0],
  499. f.basis.elements[0][1] - i.basis.elements[0][1],
  500. f.basis.elements[0][2] - i.basis.elements[0][2],
  501. f.basis.elements[1][0] - i.basis.elements[1][0],
  502. f.basis.elements[1][1] - i.basis.elements[1][1],
  503. f.basis.elements[1][2] - i.basis.elements[1][2],
  504. f.basis.elements[2][0] - i.basis.elements[2][0],
  505. f.basis.elements[2][1] - i.basis.elements[2][1],
  506. f.basis.elements[2][2] - i.basis.elements[2][2],
  507. f.origin.x - i.origin.x,
  508. f.origin.y - i.origin.y,
  509. f.origin.z - i.origin.z);
  510. }
  511. default: {
  512. return Variant::evaluate(Variant::OP_SUBTRACT, p_final_val, p_intial_val);
  513. }
  514. };
  515. }
  516. void Tween::_bind_methods() {
  517. ClassDB::bind_method(D_METHOD("tween_property", "object", "property", "final_val", "duration"), &Tween::tween_property);
  518. ClassDB::bind_method(D_METHOD("tween_interval", "time"), &Tween::tween_interval);
  519. ClassDB::bind_method(D_METHOD("tween_callback", "callback"), &Tween::tween_callback);
  520. ClassDB::bind_method(D_METHOD("tween_method", "method", "from", "to", "duration"), &Tween::tween_method);
  521. ClassDB::bind_method(D_METHOD("custom_step", "delta"), &Tween::custom_step);
  522. ClassDB::bind_method(D_METHOD("stop"), &Tween::stop);
  523. ClassDB::bind_method(D_METHOD("pause"), &Tween::pause);
  524. ClassDB::bind_method(D_METHOD("play"), &Tween::play);
  525. ClassDB::bind_method(D_METHOD("kill"), &Tween::kill);
  526. ClassDB::bind_method(D_METHOD("get_total_elapsed_time"), &Tween::get_total_time);
  527. ClassDB::bind_method(D_METHOD("is_running"), &Tween::is_running);
  528. ClassDB::bind_method(D_METHOD("is_valid"), &Tween::is_valid);
  529. ClassDB::bind_method(D_METHOD("bind_node", "node"), &Tween::bind_node);
  530. ClassDB::bind_method(D_METHOD("set_process_mode", "mode"), &Tween::set_process_mode);
  531. ClassDB::bind_method(D_METHOD("set_pause_mode", "mode"), &Tween::set_pause_mode);
  532. ClassDB::bind_method(D_METHOD("set_parallel", "parallel"), &Tween::set_parallel, DEFVAL(true));
  533. ClassDB::bind_method(D_METHOD("set_loops", "loops"), &Tween::set_loops, DEFVAL(0));
  534. ClassDB::bind_method(D_METHOD("set_speed_scale", "speed"), &Tween::set_speed_scale);
  535. ClassDB::bind_method(D_METHOD("set_trans", "trans"), &Tween::set_trans);
  536. ClassDB::bind_method(D_METHOD("set_ease", "ease"), &Tween::set_ease);
  537. ClassDB::bind_method(D_METHOD("parallel"), &Tween::parallel);
  538. ClassDB::bind_method(D_METHOD("chain"), &Tween::chain);
  539. ClassDB::bind_static_method("Tween", D_METHOD("interpolate_value", "initial_value", "delta_value", "elapsed_time", "duration", "trans_type", "ease_type"), &Tween::interpolate_variant);
  540. ADD_SIGNAL(MethodInfo("step_finished", PropertyInfo(Variant::INT, "idx")));
  541. ADD_SIGNAL(MethodInfo("loop_finished", PropertyInfo(Variant::INT, "loop_count")));
  542. ADD_SIGNAL(MethodInfo("finished"));
  543. BIND_ENUM_CONSTANT(TWEEN_PROCESS_PHYSICS);
  544. BIND_ENUM_CONSTANT(TWEEN_PROCESS_IDLE);
  545. BIND_ENUM_CONSTANT(TWEEN_PAUSE_BOUND);
  546. BIND_ENUM_CONSTANT(TWEEN_PAUSE_STOP);
  547. BIND_ENUM_CONSTANT(TWEEN_PAUSE_PROCESS);
  548. BIND_ENUM_CONSTANT(TRANS_LINEAR);
  549. BIND_ENUM_CONSTANT(TRANS_SINE);
  550. BIND_ENUM_CONSTANT(TRANS_QUINT);
  551. BIND_ENUM_CONSTANT(TRANS_QUART);
  552. BIND_ENUM_CONSTANT(TRANS_QUAD);
  553. BIND_ENUM_CONSTANT(TRANS_EXPO);
  554. BIND_ENUM_CONSTANT(TRANS_ELASTIC);
  555. BIND_ENUM_CONSTANT(TRANS_CUBIC);
  556. BIND_ENUM_CONSTANT(TRANS_CIRC);
  557. BIND_ENUM_CONSTANT(TRANS_BOUNCE);
  558. BIND_ENUM_CONSTANT(TRANS_BACK);
  559. BIND_ENUM_CONSTANT(EASE_IN);
  560. BIND_ENUM_CONSTANT(EASE_OUT);
  561. BIND_ENUM_CONSTANT(EASE_IN_OUT);
  562. BIND_ENUM_CONSTANT(EASE_OUT_IN);
  563. }
  564. Tween::Tween() {
  565. ERR_FAIL_MSG("Tween can't be created directly. Use create_tween() method.");
  566. }
  567. Tween::Tween(bool p_valid) {
  568. valid = p_valid;
  569. }
  570. Ref<PropertyTweener> PropertyTweener::from(Variant p_value) {
  571. initial_val = p_value;
  572. do_continue = false;
  573. return this;
  574. }
  575. Ref<PropertyTweener> PropertyTweener::from_current() {
  576. do_continue = false;
  577. return this;
  578. }
  579. Ref<PropertyTweener> PropertyTweener::as_relative() {
  580. relative = true;
  581. return this;
  582. }
  583. Ref<PropertyTweener> PropertyTweener::set_trans(Tween::TransitionType p_trans) {
  584. trans_type = p_trans;
  585. return this;
  586. }
  587. Ref<PropertyTweener> PropertyTweener::set_ease(Tween::EaseType p_ease) {
  588. ease_type = p_ease;
  589. return this;
  590. }
  591. Ref<PropertyTweener> PropertyTweener::set_delay(float p_delay) {
  592. delay = p_delay;
  593. return this;
  594. }
  595. void PropertyTweener::start() {
  596. elapsed_time = 0;
  597. finished = false;
  598. Object *target_instance = ObjectDB::get_instance(target);
  599. if (!target_instance) {
  600. WARN_PRINT("Target object freed before starting, aborting Tweener.");
  601. return;
  602. }
  603. if (do_continue) {
  604. initial_val = target_instance->get_indexed(property);
  605. }
  606. if (relative) {
  607. final_val = Variant::evaluate(Variant::Operator::OP_ADD, initial_val, base_final_val);
  608. }
  609. delta_val = tween->calculate_delta_value(initial_val, final_val);
  610. }
  611. bool PropertyTweener::step(float &r_delta) {
  612. if (finished) {
  613. // This is needed in case there's a parallel Tweener with longer duration.
  614. return false;
  615. }
  616. Object *target_instance = ObjectDB::get_instance(target);
  617. if (!target_instance) {
  618. return false;
  619. }
  620. elapsed_time += r_delta;
  621. if (elapsed_time < delay) {
  622. r_delta = 0;
  623. return true;
  624. }
  625. float time = MIN(elapsed_time - delay, duration);
  626. if (time < duration) {
  627. target_instance->set_indexed(property, tween->interpolate_variant(initial_val, delta_val, time, duration, trans_type, ease_type));
  628. r_delta = 0;
  629. return true;
  630. } else {
  631. target_instance->set_indexed(property, final_val);
  632. finished = true;
  633. r_delta = elapsed_time - delay - duration;
  634. emit_signal(SNAME("finished"));
  635. return false;
  636. }
  637. }
  638. void PropertyTweener::set_tween(Ref<Tween> p_tween) {
  639. tween = p_tween;
  640. if (trans_type == Tween::TRANS_MAX) {
  641. trans_type = tween->get_trans();
  642. }
  643. if (ease_type == Tween::EASE_MAX) {
  644. ease_type = tween->get_ease();
  645. }
  646. }
  647. void PropertyTweener::_bind_methods() {
  648. ClassDB::bind_method(D_METHOD("from", "value"), &PropertyTweener::from);
  649. ClassDB::bind_method(D_METHOD("from_current"), &PropertyTweener::from_current);
  650. ClassDB::bind_method(D_METHOD("as_relative"), &PropertyTweener::as_relative);
  651. ClassDB::bind_method(D_METHOD("set_trans", "trans"), &PropertyTweener::set_trans);
  652. ClassDB::bind_method(D_METHOD("set_ease", "ease"), &PropertyTweener::set_ease);
  653. ClassDB::bind_method(D_METHOD("set_delay", "delay"), &PropertyTweener::set_delay);
  654. }
  655. PropertyTweener::PropertyTweener(Object *p_target, NodePath p_property, Variant p_to, float p_duration) {
  656. target = p_target->get_instance_id();
  657. property = p_property.get_as_property_path().get_subnames();
  658. initial_val = p_target->get_indexed(property);
  659. base_final_val = p_to;
  660. final_val = base_final_val;
  661. duration = p_duration;
  662. }
  663. PropertyTweener::PropertyTweener() {
  664. ERR_FAIL_MSG("Can't create empty PropertyTweener. Use get_tree().tween_property() or tween_property() instead.");
  665. }
  666. void IntervalTweener::start() {
  667. elapsed_time = 0;
  668. finished = false;
  669. }
  670. bool IntervalTweener::step(float &r_delta) {
  671. if (finished) {
  672. return false;
  673. }
  674. elapsed_time += r_delta;
  675. if (elapsed_time < duration) {
  676. r_delta = 0;
  677. return true;
  678. } else {
  679. finished = true;
  680. r_delta = elapsed_time - duration;
  681. emit_signal(SNAME("finished"));
  682. return false;
  683. }
  684. }
  685. IntervalTweener::IntervalTweener(float p_time) {
  686. duration = p_time;
  687. }
  688. IntervalTweener::IntervalTweener() {
  689. ERR_FAIL_MSG("Can't create empty IntervalTweener. Use get_tree().tween_interval() instead.");
  690. }
  691. Ref<CallbackTweener> CallbackTweener::set_delay(float p_delay) {
  692. delay = p_delay;
  693. return this;
  694. }
  695. void CallbackTweener::start() {
  696. elapsed_time = 0;
  697. finished = false;
  698. }
  699. bool CallbackTweener::step(float &r_delta) {
  700. if (finished) {
  701. return false;
  702. }
  703. elapsed_time += r_delta;
  704. if (elapsed_time >= delay) {
  705. Variant result;
  706. Callable::CallError ce;
  707. callback.call(nullptr, 0, result, ce);
  708. if (ce.error != Callable::CallError::CALL_OK) {
  709. ERR_FAIL_V_MSG(false, "Error calling method from CallbackTweener: " + Variant::get_call_error_text(callback.get_object(), callback.get_method(), nullptr, 0, ce));
  710. }
  711. finished = true;
  712. r_delta = elapsed_time - delay;
  713. emit_signal(SNAME("finished"));
  714. return false;
  715. }
  716. r_delta = 0;
  717. return true;
  718. }
  719. void CallbackTweener::_bind_methods() {
  720. ClassDB::bind_method(D_METHOD("set_delay", "delay"), &CallbackTweener::set_delay);
  721. }
  722. CallbackTweener::CallbackTweener(Callable p_callback) {
  723. callback = p_callback;
  724. }
  725. CallbackTweener::CallbackTweener() {
  726. ERR_FAIL_MSG("Can't create empty CallbackTweener. Use get_tree().tween_callback() instead.");
  727. }
  728. Ref<MethodTweener> MethodTweener::set_delay(float p_delay) {
  729. delay = p_delay;
  730. return this;
  731. }
  732. Ref<MethodTweener> MethodTweener::set_trans(Tween::TransitionType p_trans) {
  733. trans_type = p_trans;
  734. return this;
  735. }
  736. Ref<MethodTweener> MethodTweener::set_ease(Tween::EaseType p_ease) {
  737. ease_type = p_ease;
  738. return this;
  739. }
  740. void MethodTweener::start() {
  741. elapsed_time = 0;
  742. finished = false;
  743. }
  744. bool MethodTweener::step(float &r_delta) {
  745. if (finished) {
  746. return false;
  747. }
  748. elapsed_time += r_delta;
  749. if (elapsed_time < delay) {
  750. r_delta = 0;
  751. return true;
  752. }
  753. Variant current_val;
  754. float time = MIN(elapsed_time - delay, duration);
  755. if (time < duration) {
  756. current_val = tween->interpolate_variant(initial_val, delta_val, time, duration, trans_type, ease_type);
  757. } else {
  758. current_val = final_val;
  759. }
  760. const Variant **argptr = (const Variant **)alloca(sizeof(Variant *));
  761. argptr[0] = &current_val;
  762. Variant result;
  763. Callable::CallError ce;
  764. callback.call(argptr, 1, result, ce);
  765. if (ce.error != Callable::CallError::CALL_OK) {
  766. ERR_FAIL_V_MSG(false, "Error calling method from MethodTweener: " + Variant::get_call_error_text(callback.get_object(), callback.get_method(), argptr, 1, ce));
  767. }
  768. if (time < duration) {
  769. r_delta = 0;
  770. return true;
  771. } else {
  772. finished = true;
  773. r_delta = elapsed_time - delay - duration;
  774. emit_signal(SNAME("finished"));
  775. return false;
  776. }
  777. }
  778. void MethodTweener::set_tween(Ref<Tween> p_tween) {
  779. tween = p_tween;
  780. if (trans_type == Tween::TRANS_MAX) {
  781. trans_type = tween->get_trans();
  782. }
  783. if (ease_type == Tween::EASE_MAX) {
  784. ease_type = tween->get_ease();
  785. }
  786. }
  787. void MethodTweener::_bind_methods() {
  788. ClassDB::bind_method(D_METHOD("set_delay", "delay"), &MethodTweener::set_delay);
  789. ClassDB::bind_method(D_METHOD("set_trans", "trans"), &MethodTweener::set_trans);
  790. ClassDB::bind_method(D_METHOD("set_ease", "ease"), &MethodTweener::set_ease);
  791. }
  792. MethodTweener::MethodTweener(Callable p_callback, Variant p_from, Variant p_to, float p_duration) {
  793. callback = p_callback;
  794. initial_val = p_from;
  795. delta_val = tween->calculate_delta_value(p_from, p_to);
  796. final_val = p_to;
  797. duration = p_duration;
  798. }
  799. MethodTweener::MethodTweener() {
  800. ERR_FAIL_MSG("Can't create empty MethodTweener. Use get_tree().tween_method() instead.");
  801. }