2
0

tween.h 7.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279
  1. /*************************************************************************/
  2. /* tween.h */
  3. /*************************************************************************/
  4. /* This file is part of: */
  5. /* GODOT ENGINE */
  6. /* https://godotengine.org */
  7. /*************************************************************************/
  8. /* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur. */
  9. /* Copyright (c) 2014-2021 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. #ifndef TWEEN_H
  31. #define TWEEN_H
  32. #include "core/object/ref_counted.h"
  33. class Tween;
  34. class Node;
  35. class Tweener : public RefCounted {
  36. GDCLASS(Tweener, RefCounted);
  37. public:
  38. virtual void set_tween(Ref<Tween> p_tween);
  39. virtual void start() = 0;
  40. virtual bool step(float &r_delta) = 0;
  41. void clear_tween();
  42. protected:
  43. static void _bind_methods();
  44. Ref<Tween> tween;
  45. float elapsed_time = 0;
  46. bool finished = false;
  47. };
  48. class PropertyTweener;
  49. class IntervalTweener;
  50. class CallbackTweener;
  51. class MethodTweener;
  52. class Tween : public RefCounted {
  53. GDCLASS(Tween, RefCounted);
  54. public:
  55. enum TweenProcessMode {
  56. TWEEN_PROCESS_PHYSICS,
  57. TWEEN_PROCESS_IDLE,
  58. };
  59. enum TweenPauseMode {
  60. TWEEN_PAUSE_BOUND,
  61. TWEEN_PAUSE_STOP,
  62. TWEEN_PAUSE_PROCESS,
  63. };
  64. enum TransitionType {
  65. TRANS_LINEAR,
  66. TRANS_SINE,
  67. TRANS_QUINT,
  68. TRANS_QUART,
  69. TRANS_QUAD,
  70. TRANS_EXPO,
  71. TRANS_ELASTIC,
  72. TRANS_CUBIC,
  73. TRANS_CIRC,
  74. TRANS_BOUNCE,
  75. TRANS_BACK,
  76. TRANS_MAX
  77. };
  78. enum EaseType {
  79. EASE_IN,
  80. EASE_OUT,
  81. EASE_IN_OUT,
  82. EASE_OUT_IN,
  83. EASE_MAX
  84. };
  85. private:
  86. TweenProcessMode process_mode = TweenProcessMode::TWEEN_PROCESS_IDLE;
  87. TweenPauseMode pause_mode = TweenPauseMode::TWEEN_PAUSE_STOP;
  88. TransitionType default_transition = TransitionType::TRANS_LINEAR;
  89. EaseType default_ease = EaseType::EASE_IN_OUT;
  90. ObjectID bound_node;
  91. Vector<List<Ref<Tweener>>> tweeners;
  92. int current_step = -1;
  93. int loops = 1;
  94. int loops_done = 0;
  95. float speed_scale = 1;
  96. bool is_bound = false;
  97. bool started = false;
  98. bool running = true;
  99. bool dead = false;
  100. bool valid = false;
  101. bool default_parallel = false;
  102. bool parallel_enabled = false;
  103. typedef real_t (*interpolater)(real_t t, real_t b, real_t c, real_t d);
  104. static interpolater interpolaters[TRANS_MAX][EASE_MAX];
  105. void start_tweeners();
  106. protected:
  107. static void _bind_methods();
  108. public:
  109. Ref<PropertyTweener> tween_property(Object *p_target, NodePath p_property, Variant p_to, float p_duration);
  110. Ref<IntervalTweener> tween_interval(float p_time);
  111. Ref<CallbackTweener> tween_callback(Callable p_callback);
  112. Ref<MethodTweener> tween_method(Callable p_callback, Variant p_from, Variant p_to, float p_duration);
  113. void append(Ref<Tweener> p_tweener);
  114. bool custom_step(float p_delta);
  115. void stop();
  116. void pause();
  117. void play();
  118. void kill();
  119. bool is_running();
  120. void set_valid(bool p_valid);
  121. bool is_valid();
  122. void clear();
  123. Ref<Tween> bind_node(Node *p_node);
  124. Ref<Tween> set_process_mode(TweenProcessMode p_mode);
  125. TweenProcessMode get_process_mode();
  126. Ref<Tween> set_pause_mode(TweenPauseMode p_mode);
  127. TweenPauseMode get_pause_mode();
  128. Ref<Tween> set_parallel(bool p_parallel);
  129. Ref<Tween> set_loops(int p_loops);
  130. Ref<Tween> set_speed_scale(float p_speed);
  131. Ref<Tween> set_trans(TransitionType p_trans);
  132. TransitionType get_trans();
  133. Ref<Tween> set_ease(EaseType p_ease);
  134. EaseType get_ease();
  135. Ref<Tween> parallel();
  136. Ref<Tween> chain();
  137. real_t run_equation(TransitionType p_trans_type, EaseType p_ease_type, real_t t, real_t b, real_t c, real_t d);
  138. Variant interpolate_variant(Variant p_initial_val, Variant p_delta_val, float p_time, float p_duration, Tween::TransitionType p_trans, Tween::EaseType p_ease);
  139. Variant calculate_delta_value(Variant p_intial_val, Variant p_final_val);
  140. bool step(float p_delta);
  141. bool should_pause();
  142. Tween() {}
  143. };
  144. VARIANT_ENUM_CAST(Tween::TweenPauseMode);
  145. VARIANT_ENUM_CAST(Tween::TweenProcessMode);
  146. VARIANT_ENUM_CAST(Tween::TransitionType);
  147. VARIANT_ENUM_CAST(Tween::EaseType);
  148. class PropertyTweener : public Tweener {
  149. GDCLASS(PropertyTweener, Tweener);
  150. public:
  151. Ref<PropertyTweener> from(Variant p_value);
  152. Ref<PropertyTweener> from_current();
  153. Ref<PropertyTweener> as_relative();
  154. Ref<PropertyTweener> set_trans(Tween::TransitionType p_trans);
  155. Ref<PropertyTweener> set_ease(Tween::EaseType p_ease);
  156. Ref<PropertyTweener> set_delay(float p_delay);
  157. void set_tween(Ref<Tween> p_tween) override;
  158. void start() override;
  159. bool step(float &r_delta) override;
  160. PropertyTweener(Object *p_target, NodePath p_property, Variant p_to, float p_duration);
  161. PropertyTweener();
  162. protected:
  163. static void _bind_methods();
  164. private:
  165. ObjectID target;
  166. Vector<StringName> property;
  167. Variant initial_val;
  168. Variant base_final_val;
  169. Variant final_val;
  170. Variant delta_val;
  171. float duration = 0;
  172. Tween::TransitionType trans_type = Tween::TRANS_MAX; // This is set inside set_tween();
  173. Tween::EaseType ease_type = Tween::EASE_MAX;
  174. float delay = 0;
  175. bool do_continue = true;
  176. bool relative = false;
  177. };
  178. class IntervalTweener : public Tweener {
  179. GDCLASS(IntervalTweener, Tweener);
  180. public:
  181. void start() override;
  182. bool step(float &r_delta) override;
  183. IntervalTweener(float p_time);
  184. IntervalTweener();
  185. private:
  186. float duration = 0;
  187. };
  188. class CallbackTweener : public Tweener {
  189. GDCLASS(CallbackTweener, Tweener);
  190. public:
  191. Ref<CallbackTweener> set_delay(float p_delay);
  192. void start() override;
  193. bool step(float &r_delta) override;
  194. CallbackTweener(Callable p_callback);
  195. CallbackTweener();
  196. protected:
  197. static void _bind_methods();
  198. private:
  199. Callable callback;
  200. float delay = 0;
  201. };
  202. class MethodTweener : public Tweener {
  203. GDCLASS(MethodTweener, Tweener);
  204. public:
  205. Ref<MethodTweener> set_trans(Tween::TransitionType p_trans);
  206. Ref<MethodTweener> set_ease(Tween::EaseType p_ease);
  207. Ref<MethodTweener> set_delay(float p_delay);
  208. void set_tween(Ref<Tween> p_tween) override;
  209. void start() override;
  210. bool step(float &r_delta) override;
  211. MethodTweener(Callable p_callback, Variant p_from, Variant p_to, float p_duration);
  212. MethodTweener();
  213. protected:
  214. static void _bind_methods();
  215. private:
  216. float duration = 0;
  217. float delay = 0;
  218. Tween::TransitionType trans_type = Tween::TRANS_MAX;
  219. Tween::EaseType ease_type = Tween::EASE_MAX;
  220. Ref<Tween> tween;
  221. Variant initial_val;
  222. Variant delta_val;
  223. Callable callback;
  224. };
  225. #endif