/*************************************************************************/ /* tween.cpp */ /*************************************************************************/ /* This file is part of: */ /* GODOT ENGINE */ /* https://godotengine.org */ /*************************************************************************/ /* Copyright (c) 2007-2018 Juan Linietsky, Ariel Manzur. */ /* Copyright (c) 2014-2018 Godot Engine contributors (cf. AUTHORS.md) */ /* */ /* Permission is hereby granted, free of charge, to any person obtaining */ /* a copy of this software and associated documentation files (the */ /* "Software"), to deal in the Software without restriction, including */ /* without limitation the rights to use, copy, modify, merge, publish, */ /* distribute, sublicense, and/or sell copies of the Software, and to */ /* permit persons to whom the Software is furnished to do so, subject to */ /* the following conditions: */ /* */ /* The above copyright notice and this permission notice shall be */ /* included in all copies or substantial portions of the Software. */ /* */ /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ /* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ /* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ /* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ /* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ /* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ /*************************************************************************/ #include "tween.h" #include "core/method_bind_ext.gen.inc" void Tween::_add_pending_command(StringName p_key, const Variant &p_arg1, const Variant &p_arg2, const Variant &p_arg3, const Variant &p_arg4, const Variant &p_arg5, const Variant &p_arg6, const Variant &p_arg7, const Variant &p_arg8, const Variant &p_arg9, const Variant &p_arg10) { pending_commands.push_back(PendingCommand()); PendingCommand &cmd = pending_commands.back()->get(); cmd.key = p_key; int &count = cmd.args; if (p_arg10.get_type() != Variant::NIL) count = 10; else if (p_arg9.get_type() != Variant::NIL) count = 9; else if (p_arg8.get_type() != Variant::NIL) count = 8; else if (p_arg7.get_type() != Variant::NIL) count = 7; else if (p_arg6.get_type() != Variant::NIL) count = 6; else if (p_arg5.get_type() != Variant::NIL) count = 5; else if (p_arg4.get_type() != Variant::NIL) count = 4; else if (p_arg3.get_type() != Variant::NIL) count = 3; else if (p_arg2.get_type() != Variant::NIL) count = 2; else if (p_arg1.get_type() != Variant::NIL) count = 1; if (count > 0) cmd.arg[0] = p_arg1; if (count > 1) cmd.arg[1] = p_arg2; if (count > 2) cmd.arg[2] = p_arg3; if (count > 3) cmd.arg[3] = p_arg4; if (count > 4) cmd.arg[4] = p_arg5; if (count > 5) cmd.arg[5] = p_arg6; if (count > 6) cmd.arg[6] = p_arg7; if (count > 7) cmd.arg[7] = p_arg8; if (count > 8) cmd.arg[8] = p_arg9; if (count > 9) cmd.arg[9] = p_arg10; } void Tween::_process_pending_commands() { for (List::Element *E = pending_commands.front(); E; E = E->next()) { PendingCommand &cmd = E->get(); Variant::CallError err; Variant *arg[10] = { &cmd.arg[0], &cmd.arg[1], &cmd.arg[2], &cmd.arg[3], &cmd.arg[4], &cmd.arg[5], &cmd.arg[6], &cmd.arg[7], &cmd.arg[8], &cmd.arg[9], }; this->call(cmd.key, (const Variant **)arg, cmd.args, err); } pending_commands.clear(); } bool Tween::_set(const StringName &p_name, const Variant &p_value) { String name = p_name; if (name == "playback/speed" || name == "speed") { //bw compatibility set_speed_scale(p_value); } else if (name == "playback/active") { set_active(p_value); } else if (name == "playback/repeat") { set_repeat(p_value); } return true; } bool Tween::_get(const StringName &p_name, Variant &r_ret) const { String name = p_name; if (name == "playback/speed") { //bw compatibility r_ret = speed_scale; } else if (name == "playback/active") { r_ret = is_active(); } else if (name == "playback/repeat") { r_ret = is_repeat(); } return true; } void Tween::_get_property_list(List *p_list) const { p_list->push_back(PropertyInfo(Variant::BOOL, "playback/active", PROPERTY_HINT_NONE, "")); p_list->push_back(PropertyInfo(Variant::BOOL, "playback/repeat", PROPERTY_HINT_NONE, "")); p_list->push_back(PropertyInfo(Variant::REAL, "playback/speed", PROPERTY_HINT_RANGE, "-64,64,0.01")); } void Tween::_notification(int p_what) { switch (p_what) { case NOTIFICATION_ENTER_TREE: { if (!is_active()) { //make sure that a previous process state was not saved //only process if "processing" is set set_physics_process_internal(false); set_process_internal(false); } } break; case NOTIFICATION_READY: { } break; case NOTIFICATION_INTERNAL_PROCESS: { if (tween_process_mode == TWEEN_PROCESS_PHYSICS) break; if (is_active()) _tween_process(get_process_delta_time()); } break; case NOTIFICATION_INTERNAL_PHYSICS_PROCESS: { if (tween_process_mode == TWEEN_PROCESS_IDLE) break; if (is_active()) _tween_process(get_physics_process_delta_time()); } break; case NOTIFICATION_EXIT_TREE: { stop_all(); } break; } } void Tween::_bind_methods() { ClassDB::bind_method(D_METHOD("is_active"), &Tween::is_active); ClassDB::bind_method(D_METHOD("set_active", "active"), &Tween::set_active); ClassDB::bind_method(D_METHOD("is_repeat"), &Tween::is_repeat); ClassDB::bind_method(D_METHOD("set_repeat", "repeat"), &Tween::set_repeat); ClassDB::bind_method(D_METHOD("set_speed_scale", "speed"), &Tween::set_speed_scale); ClassDB::bind_method(D_METHOD("get_speed_scale"), &Tween::get_speed_scale); ClassDB::bind_method(D_METHOD("set_tween_process_mode", "mode"), &Tween::set_tween_process_mode); ClassDB::bind_method(D_METHOD("get_tween_process_mode"), &Tween::get_tween_process_mode); ClassDB::bind_method(D_METHOD("start"), &Tween::start); ClassDB::bind_method(D_METHOD("reset", "object", "key"), &Tween::reset, DEFVAL("")); ClassDB::bind_method(D_METHOD("reset_all"), &Tween::reset_all); ClassDB::bind_method(D_METHOD("stop", "object", "key"), &Tween::stop, DEFVAL("")); ClassDB::bind_method(D_METHOD("stop_all"), &Tween::stop_all); ClassDB::bind_method(D_METHOD("resume", "object", "key"), &Tween::resume, DEFVAL("")); ClassDB::bind_method(D_METHOD("resume_all"), &Tween::resume_all); ClassDB::bind_method(D_METHOD("remove", "object", "key"), &Tween::remove, DEFVAL("")); ClassDB::bind_method(D_METHOD("_remove_by_uid", "uid"), &Tween::_remove_by_uid); ClassDB::bind_method(D_METHOD("remove_all"), &Tween::remove_all); ClassDB::bind_method(D_METHOD("seek", "time"), &Tween::seek); ClassDB::bind_method(D_METHOD("tell"), &Tween::tell); ClassDB::bind_method(D_METHOD("get_runtime"), &Tween::get_runtime); ClassDB::bind_method(D_METHOD("interpolate_property", "object", "property", "initial_val", "final_val", "duration", "trans_type", "ease_type", "delay"), &Tween::interpolate_property, DEFVAL(0)); ClassDB::bind_method(D_METHOD("interpolate_method", "object", "method", "initial_val", "final_val", "duration", "trans_type", "ease_type", "delay"), &Tween::interpolate_method, DEFVAL(0)); ClassDB::bind_method(D_METHOD("interpolate_callback", "object", "duration", "callback", "arg1", "arg2", "arg3", "arg4", "arg5"), &Tween::interpolate_callback, DEFVAL(Variant()), DEFVAL(Variant()), DEFVAL(Variant()), DEFVAL(Variant()), DEFVAL(Variant())); ClassDB::bind_method(D_METHOD("interpolate_deferred_callback", "object", "duration", "callback", "arg1", "arg2", "arg3", "arg4", "arg5"), &Tween::interpolate_deferred_callback, DEFVAL(Variant()), DEFVAL(Variant()), DEFVAL(Variant()), DEFVAL(Variant()), DEFVAL(Variant())); ClassDB::bind_method(D_METHOD("follow_property", "object", "property", "initial_val", "target", "target_property", "duration", "trans_type", "ease_type", "delay"), &Tween::follow_property, DEFVAL(0)); ClassDB::bind_method(D_METHOD("follow_method", "object", "method", "initial_val", "target", "target_method", "duration", "trans_type", "ease_type", "delay"), &Tween::follow_method, DEFVAL(0)); ClassDB::bind_method(D_METHOD("targeting_property", "object", "property", "initial", "initial_val", "final_val", "duration", "trans_type", "ease_type", "delay"), &Tween::targeting_property, DEFVAL(0)); ClassDB::bind_method(D_METHOD("targeting_method", "object", "method", "initial", "initial_method", "final_val", "duration", "trans_type", "ease_type", "delay"), &Tween::targeting_method, DEFVAL(0)); ADD_SIGNAL(MethodInfo("tween_started", PropertyInfo(Variant::OBJECT, "object"), PropertyInfo(Variant::NODE_PATH, "key"))); ADD_SIGNAL(MethodInfo("tween_step", PropertyInfo(Variant::OBJECT, "object"), PropertyInfo(Variant::NODE_PATH, "key"), PropertyInfo(Variant::REAL, "elapsed"), PropertyInfo(Variant::OBJECT, "value"))); ADD_SIGNAL(MethodInfo("tween_completed", PropertyInfo(Variant::OBJECT, "object"), PropertyInfo(Variant::NODE_PATH, "key"))); ADD_PROPERTY(PropertyInfo(Variant::BOOL, "repeat"), "set_repeat", "is_repeat"); ADD_PROPERTY(PropertyInfo(Variant::INT, "playback_process_mode", PROPERTY_HINT_ENUM, "Physics,Idle"), "set_tween_process_mode", "get_tween_process_mode"); ADD_PROPERTY(PropertyInfo(Variant::REAL, "playback_speed", PROPERTY_HINT_RANGE, "-64,64,0.01"), "set_speed_scale", "get_speed_scale"); BIND_ENUM_CONSTANT(TWEEN_PROCESS_PHYSICS); BIND_ENUM_CONSTANT(TWEEN_PROCESS_IDLE); BIND_ENUM_CONSTANT(TRANS_LINEAR); BIND_ENUM_CONSTANT(TRANS_SINE); BIND_ENUM_CONSTANT(TRANS_QUINT); BIND_ENUM_CONSTANT(TRANS_QUART); BIND_ENUM_CONSTANT(TRANS_QUAD); BIND_ENUM_CONSTANT(TRANS_EXPO); BIND_ENUM_CONSTANT(TRANS_ELASTIC); BIND_ENUM_CONSTANT(TRANS_CUBIC); BIND_ENUM_CONSTANT(TRANS_CIRC); BIND_ENUM_CONSTANT(TRANS_BOUNCE); BIND_ENUM_CONSTANT(TRANS_BACK); BIND_ENUM_CONSTANT(EASE_IN); BIND_ENUM_CONSTANT(EASE_OUT); BIND_ENUM_CONSTANT(EASE_IN_OUT); BIND_ENUM_CONSTANT(EASE_OUT_IN); } Variant &Tween::_get_initial_val(InterpolateData &p_data) { switch (p_data.type) { case INTER_PROPERTY: case INTER_METHOD: case FOLLOW_PROPERTY: case FOLLOW_METHOD: return p_data.initial_val; case TARGETING_PROPERTY: case TARGETING_METHOD: { Object *object = ObjectDB::get_instance(p_data.target_id); ERR_FAIL_COND_V(object == NULL, p_data.initial_val); static Variant initial_val; if (p_data.type == TARGETING_PROPERTY) { bool valid = false; initial_val = object->get_indexed(p_data.target_key, &valid); ERR_FAIL_COND_V(!valid, p_data.initial_val); } else { Variant::CallError error; initial_val = object->call(p_data.target_key[0], NULL, 0, error); ERR_FAIL_COND_V(error.error != Variant::CallError::CALL_OK, p_data.initial_val); } return initial_val; } case INTER_CALLBACK: break; } return p_data.delta_val; } Variant &Tween::_get_delta_val(InterpolateData &p_data) { switch (p_data.type) { case INTER_PROPERTY: case INTER_METHOD: return p_data.delta_val; case FOLLOW_PROPERTY: case FOLLOW_METHOD: { Object *target = ObjectDB::get_instance(p_data.target_id); ERR_FAIL_COND_V(target == NULL, p_data.initial_val); Variant final_val; if (p_data.type == FOLLOW_PROPERTY) { bool valid = false; final_val = target->get_indexed(p_data.target_key, &valid); ERR_FAIL_COND_V(!valid, p_data.initial_val); } else { Variant::CallError error; final_val = target->call(p_data.target_key[0], NULL, 0, error); ERR_FAIL_COND_V(error.error != Variant::CallError::CALL_OK, p_data.initial_val); } // convert INT to REAL is better for interpolaters if (final_val.get_type() == Variant::INT) final_val = final_val.operator real_t(); _calc_delta_val(p_data.initial_val, final_val, p_data.delta_val); return p_data.delta_val; } case TARGETING_PROPERTY: case TARGETING_METHOD: { Variant initial_val = _get_initial_val(p_data); // convert INT to REAL is better for interpolaters if (initial_val.get_type() == Variant::INT) initial_val = initial_val.operator real_t(); //_calc_delta_val(p_data.initial_val, p_data.final_val, p_data.delta_val); _calc_delta_val(initial_val, p_data.final_val, p_data.delta_val); return p_data.delta_val; } case INTER_CALLBACK: break; } return p_data.initial_val; } Variant Tween::_run_equation(InterpolateData &p_data) { Variant &initial_val = _get_initial_val(p_data); Variant &delta_val = _get_delta_val(p_data); Variant result; #define APPLY_EQUATION(element) \ r.element = _run_equation(p_data.trans_type, p_data.ease_type, p_data.elapsed - p_data.delay, i.element, d.element, p_data.duration); switch (initial_val.get_type()) { case Variant::BOOL: result = (_run_equation(p_data.trans_type, p_data.ease_type, p_data.elapsed - p_data.delay, initial_val, delta_val, p_data.duration)) >= 0.5; break; case Variant::INT: result = (int)_run_equation(p_data.trans_type, p_data.ease_type, p_data.elapsed - p_data.delay, (int)initial_val, (int)delta_val, p_data.duration); break; case Variant::REAL: result = _run_equation(p_data.trans_type, p_data.ease_type, p_data.elapsed - p_data.delay, (real_t)initial_val, (real_t)delta_val, p_data.duration); break; case Variant::VECTOR2: { Vector2 i = initial_val; Vector2 d = delta_val; Vector2 r; APPLY_EQUATION(x); APPLY_EQUATION(y); result = r; } break; case Variant::VECTOR3: { Vector3 i = initial_val; Vector3 d = delta_val; Vector3 r; APPLY_EQUATION(x); APPLY_EQUATION(y); APPLY_EQUATION(z); result = r; } break; case Variant::BASIS: { Basis i = initial_val; Basis d = delta_val; Basis r; APPLY_EQUATION(elements[0][0]); APPLY_EQUATION(elements[0][1]); APPLY_EQUATION(elements[0][2]); APPLY_EQUATION(elements[1][0]); APPLY_EQUATION(elements[1][1]); APPLY_EQUATION(elements[1][2]); APPLY_EQUATION(elements[2][0]); APPLY_EQUATION(elements[2][1]); APPLY_EQUATION(elements[2][2]); result = r; } break; case Variant::TRANSFORM2D: { Transform2D i = initial_val; Transform2D d = delta_val; Transform2D r; APPLY_EQUATION(elements[0][0]); APPLY_EQUATION(elements[0][1]); APPLY_EQUATION(elements[1][0]); APPLY_EQUATION(elements[1][1]); APPLY_EQUATION(elements[2][0]); APPLY_EQUATION(elements[2][1]); result = r; } break; case Variant::QUAT: { Quat i = initial_val; Quat d = delta_val; Quat r; APPLY_EQUATION(x); APPLY_EQUATION(y); APPLY_EQUATION(z); APPLY_EQUATION(w); result = r; } break; case Variant::AABB: { AABB i = initial_val; AABB d = delta_val; AABB r; APPLY_EQUATION(position.x); APPLY_EQUATION(position.y); APPLY_EQUATION(position.z); APPLY_EQUATION(size.x); APPLY_EQUATION(size.y); APPLY_EQUATION(size.z); result = r; } break; case Variant::TRANSFORM: { Transform i = initial_val; Transform d = delta_val; Transform r; APPLY_EQUATION(basis.elements[0][0]); APPLY_EQUATION(basis.elements[0][1]); APPLY_EQUATION(basis.elements[0][2]); APPLY_EQUATION(basis.elements[1][0]); APPLY_EQUATION(basis.elements[1][1]); APPLY_EQUATION(basis.elements[1][2]); APPLY_EQUATION(basis.elements[2][0]); APPLY_EQUATION(basis.elements[2][1]); APPLY_EQUATION(basis.elements[2][2]); APPLY_EQUATION(origin.x); APPLY_EQUATION(origin.y); APPLY_EQUATION(origin.z); result = r; } break; case Variant::COLOR: { Color i = initial_val; Color d = delta_val; Color r; APPLY_EQUATION(r); APPLY_EQUATION(g); APPLY_EQUATION(b); APPLY_EQUATION(a); result = r; } break; default: { result = initial_val; } break; }; #undef APPLY_EQUATION return result; } bool Tween::_apply_tween_value(InterpolateData &p_data, Variant &value) { Object *object = ObjectDB::get_instance(p_data.id); ERR_FAIL_COND_V(object == NULL, false); switch (p_data.type) { case INTER_PROPERTY: case FOLLOW_PROPERTY: case TARGETING_PROPERTY: { bool valid = false; object->set_indexed(p_data.key, value, &valid); return valid; } case INTER_METHOD: case FOLLOW_METHOD: case TARGETING_METHOD: { Variant::CallError error; if (value.get_type() != Variant::NIL) { Variant *arg[1] = { &value }; object->call(p_data.key[0], (const Variant **)arg, 1, error); } else { object->call(p_data.key[0], NULL, 0, error); } if (error.error == Variant::CallError::CALL_OK) return true; return false; } case INTER_CALLBACK: break; }; return true; } void Tween::_tween_process(float p_delta) { _process_pending_commands(); if (speed_scale == 0) return; p_delta *= speed_scale; pending_update++; // if repeat and all interpolates was finished then reset all interpolates bool all_finished = true; if (repeat) { for (List::Element *E = interpolates.front(); E; E = E->next()) { InterpolateData &data = E->get(); if (!data.finish) { all_finished = false; break; } } if (all_finished) reset_all(); } all_finished = true; for (List::Element *E = interpolates.front(); E; E = E->next()) { InterpolateData &data = E->get(); all_finished = all_finished && data.finish; if (!data.active || data.finish) continue; Object *object = ObjectDB::get_instance(data.id); if (object == NULL) continue; bool prev_delaying = data.elapsed <= data.delay; data.elapsed += p_delta; if (data.elapsed < data.delay) continue; else if (prev_delaying) { _apply_tween_value(data, data.initial_val); emit_signal("tween_started", object, NodePath(Vector(), data.key, false)); } if (data.elapsed > (data.delay + data.duration)) { data.elapsed = data.delay + data.duration; data.finish = true; } if (data.type == INTER_CALLBACK) { if (data.finish) { if (data.call_deferred) { switch (data.args) { case 0: object->call_deferred(data.key[0]); break; case 1: object->call_deferred(data.key[0], data.arg[0]); break; case 2: object->call_deferred(data.key[0], data.arg[0], data.arg[1]); break; case 3: object->call_deferred(data.key[0], data.arg[0], data.arg[1], data.arg[2]); break; case 4: object->call_deferred(data.key[0], data.arg[0], data.arg[1], data.arg[2], data.arg[3]); break; case 5: object->call_deferred(data.key[0], data.arg[0], data.arg[1], data.arg[2], data.arg[3], data.arg[4]); break; } } else { Variant::CallError error; Variant *arg[5] = { &data.arg[0], &data.arg[1], &data.arg[2], &data.arg[3], &data.arg[4], }; object->call(data.key[0], (const Variant **)arg, data.args, error); } } } else { Variant result = _run_equation(data); _apply_tween_value(data, result); emit_signal("tween_step", object, NodePath(Vector(), data.key, false), data.elapsed, result); } if (data.finish) { _apply_tween_value(data, data.final_val); data.elapsed = 0; emit_signal("tween_completed", object, NodePath(Vector(), data.key, false)); // not repeat mode, remove completed action if (!repeat) call_deferred("_remove_by_uid", data.uid); } else if (!repeat) all_finished = all_finished && data.finish; } pending_update--; if (all_finished) set_active(false); } void Tween::set_tween_process_mode(TweenProcessMode p_mode) { tween_process_mode = p_mode; } Tween::TweenProcessMode Tween::get_tween_process_mode() const { return tween_process_mode; } bool Tween::is_active() const { return is_processing_internal() || is_physics_processing_internal(); } void Tween::set_active(bool p_active) { if (is_active() == p_active) return; switch (tween_process_mode) { case TWEEN_PROCESS_IDLE: set_process_internal(p_active); break; case TWEEN_PROCESS_PHYSICS: set_physics_process_internal(p_active); break; } } bool Tween::is_repeat() const { return repeat; } void Tween::set_repeat(bool p_repeat) { repeat = p_repeat; } void Tween::set_speed_scale(float p_speed) { speed_scale = p_speed; } float Tween::get_speed_scale() const { return speed_scale; } bool Tween::start() { if (pending_update != 0) { call_deferred("start"); return true; } set_active(true); return true; } bool Tween::reset(Object *p_object, StringName p_key) { pending_update++; for (List::Element *E = interpolates.front(); E; E = E->next()) { InterpolateData &data = E->get(); Object *object = ObjectDB::get_instance(data.id); if (object == NULL) continue; if (object == p_object && (data.concatenated_key == p_key || p_key == "")) { data.elapsed = 0; data.finish = false; if (data.delay == 0) _apply_tween_value(data, data.initial_val); } } pending_update--; return true; } bool Tween::reset_all() { pending_update++; for (List::Element *E = interpolates.front(); E; E = E->next()) { InterpolateData &data = E->get(); data.elapsed = 0; data.finish = false; if (data.delay == 0) _apply_tween_value(data, data.initial_val); } pending_update--; return true; } bool Tween::stop(Object *p_object, StringName p_key) { pending_update++; for (List::Element *E = interpolates.front(); E; E = E->next()) { InterpolateData &data = E->get(); Object *object = ObjectDB::get_instance(data.id); if (object == NULL) continue; if (object == p_object && (data.concatenated_key == p_key || p_key == "")) data.active = false; } pending_update--; return true; } bool Tween::stop_all() { set_active(false); pending_update++; for (List::Element *E = interpolates.front(); E; E = E->next()) { InterpolateData &data = E->get(); data.active = false; } pending_update--; return true; } bool Tween::resume(Object *p_object, StringName p_key) { set_active(true); pending_update++; for (List::Element *E = interpolates.front(); E; E = E->next()) { InterpolateData &data = E->get(); Object *object = ObjectDB::get_instance(data.id); if (object == NULL) continue; if (object == p_object && (data.concatenated_key == p_key || p_key == "")) data.active = true; } pending_update--; return true; } bool Tween::resume_all() { set_active(true); pending_update++; for (List::Element *E = interpolates.front(); E; E = E->next()) { InterpolateData &data = E->get(); data.active = true; } pending_update--; return true; } bool Tween::remove(Object *p_object, StringName p_key) { if (pending_update != 0) { call_deferred("remove", p_object, p_key); return true; } List::Element *> for_removal; for (List::Element *E = interpolates.front(); E; E = E->next()) { InterpolateData &data = E->get(); Object *object = ObjectDB::get_instance(data.id); if (object == NULL) continue; if (object == p_object && (data.concatenated_key == p_key || p_key == "")) { for_removal.push_back(E); } } for (List::Element *>::Element *E = for_removal.front(); E; E = E->next()) { interpolates.erase(E->get()); } return true; } void Tween::_remove_by_uid(int uid) { if (pending_update != 0) { call_deferred("_remove_by_uid", uid); return; } for (List::Element *E = interpolates.front(); E; E = E->next()) { if (uid == E->get().uid) { E->erase(); break; } } } void Tween::_push_interpolate_data(InterpolateData &p_data) { pending_update++; p_data.uid = ++uid; interpolates.push_back(p_data); pending_update--; } bool Tween::remove_all() { if (pending_update != 0) { call_deferred("remove_all"); return true; } set_active(false); interpolates.clear(); uid = 0; return true; } bool Tween::seek(real_t p_time) { pending_update++; for (List::Element *E = interpolates.front(); E; E = E->next()) { InterpolateData &data = E->get(); data.elapsed = p_time; if (data.elapsed < data.delay) { data.finish = false; continue; } else if (data.elapsed >= (data.delay + data.duration)) { data.finish = true; data.elapsed = (data.delay + data.duration); } else { data.finish = false; } if (data.type == INTER_CALLBACK) { continue; } Variant result = _run_equation(data); _apply_tween_value(data, result); } pending_update--; return true; } real_t Tween::tell() const { pending_update++; real_t pos = 0; for (const List::Element *E = interpolates.front(); E; E = E->next()) { const InterpolateData &data = E->get(); if (data.elapsed > pos) pos = data.elapsed; } pending_update--; return pos; } real_t Tween::get_runtime() const { if (speed_scale == 0) { return INFINITY; } pending_update++; real_t runtime = 0; for (const List::Element *E = interpolates.front(); E; E = E->next()) { const InterpolateData &data = E->get(); real_t t = data.delay + data.duration; if (t > runtime) runtime = t; } pending_update--; return runtime / speed_scale; } bool Tween::_calc_delta_val(const Variant &p_initial_val, const Variant &p_final_val, Variant &p_delta_val) { const Variant &initial_val = p_initial_val; const Variant &final_val = p_final_val; Variant &delta_val = p_delta_val; switch (initial_val.get_type()) { case Variant::BOOL: //delta_val = p_final_val; delta_val = (int)p_final_val - (int)p_initial_val; break; case Variant::INT: delta_val = (int)final_val - (int)initial_val; break; case Variant::REAL: delta_val = (real_t)final_val - (real_t)initial_val; break; case Variant::VECTOR2: delta_val = final_val.operator Vector2() - initial_val.operator Vector2(); break; case Variant::VECTOR3: delta_val = final_val.operator Vector3() - initial_val.operator Vector3(); break; case Variant::BASIS: { Basis i = initial_val; Basis f = final_val; delta_val = Basis(f.elements[0][0] - i.elements[0][0], f.elements[0][1] - i.elements[0][1], f.elements[0][2] - i.elements[0][2], f.elements[1][0] - i.elements[1][0], f.elements[1][1] - i.elements[1][1], f.elements[1][2] - i.elements[1][2], f.elements[2][0] - i.elements[2][0], f.elements[2][1] - i.elements[2][1], f.elements[2][2] - i.elements[2][2]); } break; case Variant::TRANSFORM2D: { Transform2D i = initial_val; Transform2D f = final_val; Transform2D d = Transform2D(); d[0][0] = f.elements[0][0] - i.elements[0][0]; d[0][1] = f.elements[0][1] - i.elements[0][1]; d[1][0] = f.elements[1][0] - i.elements[1][0]; d[1][1] = f.elements[1][1] - i.elements[1][1]; d[2][0] = f.elements[2][0] - i.elements[2][0]; d[2][1] = f.elements[2][1] - i.elements[2][1]; delta_val = d; } break; case Variant::QUAT: delta_val = final_val.operator Quat() - initial_val.operator Quat(); break; case Variant::AABB: { AABB i = initial_val; AABB f = final_val; delta_val = AABB(f.position - i.position, f.size - i.size); } break; case Variant::TRANSFORM: { Transform i = initial_val; Transform f = final_val; Transform d; d.set(f.basis.elements[0][0] - i.basis.elements[0][0], f.basis.elements[0][1] - i.basis.elements[0][1], f.basis.elements[0][2] - i.basis.elements[0][2], f.basis.elements[1][0] - i.basis.elements[1][0], f.basis.elements[1][1] - i.basis.elements[1][1], f.basis.elements[1][2] - i.basis.elements[1][2], f.basis.elements[2][0] - i.basis.elements[2][0], f.basis.elements[2][1] - i.basis.elements[2][1], f.basis.elements[2][2] - i.basis.elements[2][2], f.origin.x - i.origin.x, f.origin.y - i.origin.y, f.origin.z - i.origin.z); delta_val = d; } break; case Variant::COLOR: { Color i = initial_val; Color f = final_val; delta_val = Color(f.r - i.r, f.g - i.g, f.b - i.b, f.a - i.a); } break; default: ERR_PRINT("Invalid param type, except(int/real/vector2/vector/matrix/matrix32/quat/aabb/transform/color)"); return false; }; return true; } bool Tween::interpolate_property(Object *p_object, NodePath p_property, Variant p_initial_val, Variant p_final_val, real_t p_duration, TransitionType p_trans_type, EaseType p_ease_type, real_t p_delay) { if (pending_update != 0) { _add_pending_command("interpolate_property", p_object, p_property, p_initial_val, p_final_val, p_duration, p_trans_type, p_ease_type, p_delay); return true; } p_property = p_property.get_as_property_path(); if (p_initial_val.get_type() == Variant::NIL) p_initial_val = p_object->get_indexed(p_property.get_subnames()); // convert INT to REAL is better for interpolaters if (p_initial_val.get_type() == Variant::INT) p_initial_val = p_initial_val.operator real_t(); if (p_final_val.get_type() == Variant::INT) p_final_val = p_final_val.operator real_t(); ERR_FAIL_COND_V(p_object == NULL, false); ERR_FAIL_COND_V(!ObjectDB::instance_validate(p_object), false); ERR_FAIL_COND_V(p_initial_val.get_type() != p_final_val.get_type(), false); ERR_FAIL_COND_V(p_duration <= 0, false); ERR_FAIL_COND_V(p_trans_type < 0 || p_trans_type >= TRANS_COUNT, false); ERR_FAIL_COND_V(p_ease_type < 0 || p_ease_type >= EASE_COUNT, false); ERR_FAIL_COND_V(p_delay < 0, false); bool prop_valid = false; p_object->get_indexed(p_property.get_subnames(), &prop_valid); ERR_FAIL_COND_V(!prop_valid, false); InterpolateData data; data.active = true; data.type = INTER_PROPERTY; data.finish = false; data.elapsed = 0; data.id = p_object->get_instance_id(); data.key = p_property.get_subnames(); data.concatenated_key = p_property.get_concatenated_subnames(); data.initial_val = p_initial_val; data.final_val = p_final_val; data.duration = p_duration; data.trans_type = p_trans_type; data.ease_type = p_ease_type; data.delay = p_delay; if (!_calc_delta_val(data.initial_val, data.final_val, data.delta_val)) return false; _push_interpolate_data(data); return true; } bool Tween::interpolate_method(Object *p_object, StringName p_method, Variant p_initial_val, Variant p_final_val, real_t p_duration, TransitionType p_trans_type, EaseType p_ease_type, real_t p_delay) { if (pending_update != 0) { _add_pending_command("interpolate_method", p_object, p_method, p_initial_val, p_final_val, p_duration, p_trans_type, p_ease_type, p_delay); return true; } // convert INT to REAL is better for interpolaters if (p_initial_val.get_type() == Variant::INT) p_initial_val = p_initial_val.operator real_t(); if (p_final_val.get_type() == Variant::INT) p_final_val = p_final_val.operator real_t(); ERR_FAIL_COND_V(p_object == NULL, false); ERR_FAIL_COND_V(!ObjectDB::instance_validate(p_object), false); ERR_FAIL_COND_V(p_initial_val.get_type() != p_final_val.get_type(), false); ERR_FAIL_COND_V(p_duration <= 0, false); ERR_FAIL_COND_V(p_trans_type < 0 || p_trans_type >= TRANS_COUNT, false); ERR_FAIL_COND_V(p_ease_type < 0 || p_ease_type >= EASE_COUNT, false); ERR_FAIL_COND_V(p_delay < 0, false); ERR_EXPLAIN("Object has no method named: %s" + p_method); ERR_FAIL_COND_V(!p_object->has_method(p_method), false); InterpolateData data; data.active = true; data.type = INTER_METHOD; data.finish = false; data.elapsed = 0; data.id = p_object->get_instance_id(); data.key.push_back(p_method); data.concatenated_key = p_method; data.initial_val = p_initial_val; data.final_val = p_final_val; data.duration = p_duration; data.trans_type = p_trans_type; data.ease_type = p_ease_type; data.delay = p_delay; if (!_calc_delta_val(data.initial_val, data.final_val, data.delta_val)) return false; _push_interpolate_data(data); return true; } bool Tween::interpolate_callback(Object *p_object, real_t p_duration, String p_callback, VARIANT_ARG_DECLARE) { if (pending_update != 0) { _add_pending_command("interpolate_callback", p_object, p_duration, p_callback, p_arg1, p_arg2, p_arg3, p_arg4, p_arg5); return true; } ERR_FAIL_COND_V(p_object == NULL, false); ERR_FAIL_COND_V(!ObjectDB::instance_validate(p_object), false); ERR_FAIL_COND_V(p_duration < 0, false); ERR_EXPLAIN("Object has no callback named: %s" + p_callback); ERR_FAIL_COND_V(!p_object->has_method(p_callback), false); InterpolateData data; data.active = true; data.type = INTER_CALLBACK; data.finish = false; data.call_deferred = false; data.elapsed = 0; data.id = p_object->get_instance_id(); data.key.push_back(p_callback); data.concatenated_key = p_callback; data.duration = p_duration; data.delay = 0; int args = 0; if (p_arg5.get_type() != Variant::NIL) args = 5; else if (p_arg4.get_type() != Variant::NIL) args = 4; else if (p_arg3.get_type() != Variant::NIL) args = 3; else if (p_arg2.get_type() != Variant::NIL) args = 2; else if (p_arg1.get_type() != Variant::NIL) args = 1; else args = 0; data.args = args; data.arg[0] = p_arg1; data.arg[1] = p_arg2; data.arg[2] = p_arg3; data.arg[3] = p_arg4; data.arg[4] = p_arg5; _push_interpolate_data(data); return true; } bool Tween::interpolate_deferred_callback(Object *p_object, real_t p_duration, String p_callback, VARIANT_ARG_DECLARE) { if (pending_update != 0) { _add_pending_command("interpolate_deferred_callback", p_object, p_duration, p_callback, p_arg1, p_arg2, p_arg3, p_arg4, p_arg5); return true; } ERR_FAIL_COND_V(p_object == NULL, false); ERR_FAIL_COND_V(!ObjectDB::instance_validate(p_object), false); ERR_FAIL_COND_V(p_duration < 0, false); ERR_EXPLAIN("Object has no callback named: %s" + p_callback); ERR_FAIL_COND_V(!p_object->has_method(p_callback), false); InterpolateData data; data.active = true; data.type = INTER_CALLBACK; data.finish = false; data.call_deferred = true; data.elapsed = 0; data.id = p_object->get_instance_id(); data.key.push_back(p_callback); data.concatenated_key = p_callback; data.duration = p_duration; data.delay = 0; int args = 0; if (p_arg5.get_type() != Variant::NIL) args = 5; else if (p_arg4.get_type() != Variant::NIL) args = 4; else if (p_arg3.get_type() != Variant::NIL) args = 3; else if (p_arg2.get_type() != Variant::NIL) args = 2; else if (p_arg1.get_type() != Variant::NIL) args = 1; else args = 0; data.args = args; data.arg[0] = p_arg1; data.arg[1] = p_arg2; data.arg[2] = p_arg3; data.arg[3] = p_arg4; data.arg[4] = p_arg5; _push_interpolate_data(data); return true; } bool Tween::follow_property(Object *p_object, NodePath p_property, Variant p_initial_val, Object *p_target, NodePath p_target_property, real_t p_duration, TransitionType p_trans_type, EaseType p_ease_type, real_t p_delay) { if (pending_update != 0) { _add_pending_command("follow_property", p_object, p_property, p_initial_val, p_target, p_target_property, p_duration, p_trans_type, p_ease_type, p_delay); return true; } p_property = p_property.get_as_property_path(); p_target_property = p_target_property.get_as_property_path(); if (p_initial_val.get_type() == Variant::NIL) p_initial_val = p_object->get_indexed(p_property.get_subnames()); // convert INT to REAL is better for interpolaters if (p_initial_val.get_type() == Variant::INT) p_initial_val = p_initial_val.operator real_t(); ERR_FAIL_COND_V(p_object == NULL, false); ERR_FAIL_COND_V(!ObjectDB::instance_validate(p_object), false); ERR_FAIL_COND_V(p_target == NULL, false); ERR_FAIL_COND_V(!ObjectDB::instance_validate(p_target), false); ERR_FAIL_COND_V(p_duration <= 0, false); ERR_FAIL_COND_V(p_trans_type < 0 || p_trans_type >= TRANS_COUNT, false); ERR_FAIL_COND_V(p_ease_type < 0 || p_ease_type >= EASE_COUNT, false); ERR_FAIL_COND_V(p_delay < 0, false); bool prop_valid = false; p_object->get_indexed(p_property.get_subnames(), &prop_valid); ERR_FAIL_COND_V(!prop_valid, false); bool target_prop_valid = false; Variant target_val = p_target->get_indexed(p_target_property.get_subnames(), &target_prop_valid); ERR_FAIL_COND_V(!target_prop_valid, false); // convert INT to REAL is better for interpolaters if (target_val.get_type() == Variant::INT) target_val = target_val.operator real_t(); ERR_FAIL_COND_V(target_val.get_type() != p_initial_val.get_type(), false); InterpolateData data; data.active = true; data.type = FOLLOW_PROPERTY; data.finish = false; data.elapsed = 0; data.id = p_object->get_instance_id(); data.key = p_property.get_subnames(); data.concatenated_key = p_property.get_concatenated_subnames(); data.initial_val = p_initial_val; data.target_id = p_target->get_instance_id(); data.target_key = p_target_property.get_subnames(); data.duration = p_duration; data.trans_type = p_trans_type; data.ease_type = p_ease_type; data.delay = p_delay; _push_interpolate_data(data); return true; } bool Tween::follow_method(Object *p_object, StringName p_method, Variant p_initial_val, Object *p_target, StringName p_target_method, real_t p_duration, TransitionType p_trans_type, EaseType p_ease_type, real_t p_delay) { if (pending_update != 0) { _add_pending_command("follow_method", p_object, p_method, p_initial_val, p_target, p_target_method, p_duration, p_trans_type, p_ease_type, p_delay); return true; } // convert INT to REAL is better for interpolaters if (p_initial_val.get_type() == Variant::INT) p_initial_val = p_initial_val.operator real_t(); ERR_FAIL_COND_V(p_object == NULL, false); ERR_FAIL_COND_V(!ObjectDB::instance_validate(p_object), false); ERR_FAIL_COND_V(p_target == NULL, false); ERR_FAIL_COND_V(!ObjectDB::instance_validate(p_target), false); ERR_FAIL_COND_V(p_duration <= 0, false); ERR_FAIL_COND_V(p_trans_type < 0 || p_trans_type >= TRANS_COUNT, false); ERR_FAIL_COND_V(p_ease_type < 0 || p_ease_type >= EASE_COUNT, false); ERR_FAIL_COND_V(p_delay < 0, false); ERR_EXPLAIN("Object has no method named: %s" + p_method); ERR_FAIL_COND_V(!p_object->has_method(p_method), false); ERR_EXPLAIN("Target has no method named: %s" + p_target_method); ERR_FAIL_COND_V(!p_target->has_method(p_target_method), false); Variant::CallError error; Variant target_val = p_target->call(p_target_method, NULL, 0, error); ERR_FAIL_COND_V(error.error != Variant::CallError::CALL_OK, false); // convert INT to REAL is better for interpolaters if (target_val.get_type() == Variant::INT) target_val = target_val.operator real_t(); ERR_FAIL_COND_V(target_val.get_type() != p_initial_val.get_type(), false); InterpolateData data; data.active = true; data.type = FOLLOW_METHOD; data.finish = false; data.elapsed = 0; data.id = p_object->get_instance_id(); data.key.push_back(p_method); data.concatenated_key = p_method; data.initial_val = p_initial_val; data.target_id = p_target->get_instance_id(); data.target_key.push_back(p_target_method); data.duration = p_duration; data.trans_type = p_trans_type; data.ease_type = p_ease_type; data.delay = p_delay; _push_interpolate_data(data); return true; } bool Tween::targeting_property(Object *p_object, NodePath p_property, Object *p_initial, NodePath p_initial_property, Variant p_final_val, real_t p_duration, TransitionType p_trans_type, EaseType p_ease_type, real_t p_delay) { if (pending_update != 0) { _add_pending_command("targeting_property", p_object, p_property, p_initial, p_initial_property, p_final_val, p_duration, p_trans_type, p_ease_type, p_delay); return true; } p_property = p_property.get_as_property_path(); p_initial_property = p_initial_property.get_as_property_path(); // convert INT to REAL is better for interpolaters if (p_final_val.get_type() == Variant::INT) p_final_val = p_final_val.operator real_t(); ERR_FAIL_COND_V(p_object == NULL, false); ERR_FAIL_COND_V(!ObjectDB::instance_validate(p_object), false); ERR_FAIL_COND_V(p_initial == NULL, false); ERR_FAIL_COND_V(!ObjectDB::instance_validate(p_initial), false); ERR_FAIL_COND_V(p_duration <= 0, false); ERR_FAIL_COND_V(p_trans_type < 0 || p_trans_type >= TRANS_COUNT, false); ERR_FAIL_COND_V(p_ease_type < 0 || p_ease_type >= EASE_COUNT, false); ERR_FAIL_COND_V(p_delay < 0, false); bool prop_valid = false; p_object->get_indexed(p_property.get_subnames(), &prop_valid); ERR_FAIL_COND_V(!prop_valid, false); bool initial_prop_valid = false; Variant initial_val = p_initial->get_indexed(p_initial_property.get_subnames(), &initial_prop_valid); ERR_FAIL_COND_V(!initial_prop_valid, false); // convert INT to REAL is better for interpolaters if (initial_val.get_type() == Variant::INT) initial_val = initial_val.operator real_t(); ERR_FAIL_COND_V(initial_val.get_type() != p_final_val.get_type(), false); InterpolateData data; data.active = true; data.type = TARGETING_PROPERTY; data.finish = false; data.elapsed = 0; data.id = p_object->get_instance_id(); data.key = p_property.get_subnames(); data.concatenated_key = p_property.get_concatenated_subnames(); data.target_id = p_initial->get_instance_id(); data.target_key = p_initial_property.get_subnames(); data.initial_val = initial_val; data.final_val = p_final_val; data.duration = p_duration; data.trans_type = p_trans_type; data.ease_type = p_ease_type; data.delay = p_delay; if (!_calc_delta_val(data.initial_val, data.final_val, data.delta_val)) return false; _push_interpolate_data(data); return true; } bool Tween::targeting_method(Object *p_object, StringName p_method, Object *p_initial, StringName p_initial_method, Variant p_final_val, real_t p_duration, TransitionType p_trans_type, EaseType p_ease_type, real_t p_delay) { if (pending_update != 0) { _add_pending_command("targeting_method", p_object, p_method, p_initial, p_initial_method, p_final_val, p_duration, p_trans_type, p_ease_type, p_delay); return true; } // convert INT to REAL is better for interpolaters if (p_final_val.get_type() == Variant::INT) p_final_val = p_final_val.operator real_t(); ERR_FAIL_COND_V(p_object == NULL, false); ERR_FAIL_COND_V(!ObjectDB::instance_validate(p_object), false); ERR_FAIL_COND_V(p_initial == NULL, false); ERR_FAIL_COND_V(!ObjectDB::instance_validate(p_initial), false); ERR_FAIL_COND_V(p_duration <= 0, false); ERR_FAIL_COND_V(p_trans_type < 0 || p_trans_type >= TRANS_COUNT, false); ERR_FAIL_COND_V(p_ease_type < 0 || p_ease_type >= EASE_COUNT, false); ERR_FAIL_COND_V(p_delay < 0, false); ERR_EXPLAIN("Object has no method named: %s" + p_method); ERR_FAIL_COND_V(!p_object->has_method(p_method), false); ERR_EXPLAIN("Initial Object has no method named: %s" + p_initial_method); ERR_FAIL_COND_V(!p_initial->has_method(p_initial_method), false); Variant::CallError error; Variant initial_val = p_initial->call(p_initial_method, NULL, 0, error); ERR_FAIL_COND_V(error.error != Variant::CallError::CALL_OK, false); // convert INT to REAL is better for interpolaters if (initial_val.get_type() == Variant::INT) initial_val = initial_val.operator real_t(); ERR_FAIL_COND_V(initial_val.get_type() != p_final_val.get_type(), false); InterpolateData data; data.active = true; data.type = TARGETING_METHOD; data.finish = false; data.elapsed = 0; data.id = p_object->get_instance_id(); data.key.push_back(p_method); data.concatenated_key = p_method; data.target_id = p_initial->get_instance_id(); data.target_key.push_back(p_initial_method); data.initial_val = initial_val; data.final_val = p_final_val; data.duration = p_duration; data.trans_type = p_trans_type; data.ease_type = p_ease_type; data.delay = p_delay; if (!_calc_delta_val(data.initial_val, data.final_val, data.delta_val)) return false; _push_interpolate_data(data); return true; } Tween::Tween() { //String autoplay; tween_process_mode = TWEEN_PROCESS_IDLE; repeat = false; speed_scale = 1; pending_update = 0; uid = 0; } Tween::~Tween() { }