Happy new year to the wonderful Godot community! We're starting a new decade with a well-established, non-profit, free and open source game engine, and tons of further improvements in the pipeline from hundreds of contributors. Godot will keep getting better, and we're looking forward to all the games that the community will keep developing and releasing with it.
1723 lines
59 KiB
C++
1723 lines
59 KiB
C++
/*************************************************************************/
|
|
/* tween.cpp */
|
|
/*************************************************************************/
|
|
/* This file is part of: */
|
|
/* GODOT ENGINE */
|
|
/* https://godotengine.org */
|
|
/*************************************************************************/
|
|
/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur. */
|
|
/* Copyright (c) 2014-2020 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) {
|
|
|
|
// Add a new pending command and reference it
|
|
pending_commands.push_back(PendingCommand());
|
|
PendingCommand &cmd = pending_commands.back()->get();
|
|
|
|
// Update the command with the target key
|
|
cmd.key = p_key;
|
|
|
|
// Determine command argument count
|
|
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;
|
|
else
|
|
count = 0;
|
|
|
|
// Add the specified arguments to the command
|
|
// TODO: Make this a switch statement?
|
|
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 each pending command...
|
|
for (List<PendingCommand>::Element *E = pending_commands.front(); E; E = E->next()) {
|
|
|
|
// Get the command
|
|
PendingCommand &cmd = E->get();
|
|
Variant::CallError err;
|
|
|
|
// Grab all of the arguments for the command
|
|
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],
|
|
};
|
|
|
|
// Execute the command (and retrieve any errors)
|
|
this->call(cmd.key, (const Variant **)arg, cmd.args, err);
|
|
}
|
|
|
|
// Clear the pending commands
|
|
pending_commands.clear();
|
|
}
|
|
|
|
bool Tween::_set(const StringName &p_name, const Variant &p_value) {
|
|
|
|
// Set the correct attribute based on the given name
|
|
String name = p_name;
|
|
if (name == "playback/speed" || name == "speed") { // Backwards 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 {
|
|
|
|
// Get the correct attribute based on the given name
|
|
String name = p_name;
|
|
if (name == "playback/speed") { // Backwards 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<PropertyInfo> *p_list) const {
|
|
// Add the property info for the Tween object
|
|
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) {
|
|
// What notification did we receive?
|
|
switch (p_what) {
|
|
|
|
case NOTIFICATION_ENTER_TREE: {
|
|
// Are we not already active?
|
|
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: {
|
|
// Do nothing
|
|
} break;
|
|
|
|
case NOTIFICATION_INTERNAL_PROCESS: {
|
|
// Are we processing during physics time?
|
|
if (tween_process_mode == TWEEN_PROCESS_PHYSICS)
|
|
// Do nothing since we aren't aligned with physics when we should be
|
|
break;
|
|
|
|
// Should we update?
|
|
if (is_active())
|
|
// Update the tweens
|
|
_tween_process(get_process_delta_time());
|
|
} break;
|
|
|
|
case NOTIFICATION_INTERNAL_PHYSICS_PROCESS: {
|
|
// Are we processing during 'regular' time?
|
|
if (tween_process_mode == TWEEN_PROCESS_IDLE)
|
|
// Do nothing since we would only process during idle time
|
|
break;
|
|
|
|
// Should we update?
|
|
if (is_active())
|
|
// Update the tweens
|
|
_tween_process(get_physics_process_delta_time());
|
|
} break;
|
|
|
|
case NOTIFICATION_EXIT_TREE: {
|
|
// We've left the tree. Stop all tweens
|
|
stop_all();
|
|
} break;
|
|
}
|
|
}
|
|
|
|
void Tween::_bind_methods() {
|
|
// Bind getters and setters
|
|
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);
|
|
|
|
// Bind the various Tween control methods
|
|
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);
|
|
|
|
// Bind interpolation and follow methods
|
|
ClassDB::bind_method(D_METHOD("interpolate_property", "object", "property", "initial_val", "final_val", "duration", "trans_type", "ease_type", "delay"), &Tween::interpolate_property, DEFVAL(TRANS_LINEAR), DEFVAL(EASE_IN_OUT), 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(TRANS_LINEAR), DEFVAL(EASE_IN_OUT), 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(TRANS_LINEAR), DEFVAL(EASE_IN_OUT), 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(TRANS_LINEAR), DEFVAL(EASE_IN_OUT), 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(TRANS_LINEAR), DEFVAL(EASE_IN_OUT), 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(TRANS_LINEAR), DEFVAL(EASE_IN_OUT), DEFVAL(0));
|
|
|
|
// Add the Tween signals
|
|
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_SIGNAL(MethodInfo("tween_all_completed"));
|
|
|
|
// Add the properties and tie them to the getters and setters
|
|
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 Idle vs Physics process
|
|
BIND_ENUM_CONSTANT(TWEEN_PROCESS_PHYSICS);
|
|
BIND_ENUM_CONSTANT(TWEEN_PROCESS_IDLE);
|
|
|
|
// Bind the Transition type constants
|
|
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 the easing constants
|
|
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(const InterpolateData &p_data) const {
|
|
|
|
// What type of data are we interpolating?
|
|
switch (p_data.type) {
|
|
case INTER_PROPERTY:
|
|
case INTER_METHOD:
|
|
case FOLLOW_PROPERTY:
|
|
case FOLLOW_METHOD:
|
|
// Simply use the given initial value
|
|
return p_data.initial_val;
|
|
|
|
case TARGETING_PROPERTY:
|
|
case TARGETING_METHOD: {
|
|
// Get the object that is being targeted
|
|
Object *object = ObjectDB::get_instance(p_data.target_id);
|
|
ERR_FAIL_COND_V(object == NULL, p_data.initial_val);
|
|
|
|
// Are we targeting a property or a method?
|
|
Variant initial_val;
|
|
if (p_data.type == TARGETING_PROPERTY) {
|
|
// Get the property from the target object
|
|
bool valid = false;
|
|
initial_val = object->get_indexed(p_data.target_key, &valid);
|
|
ERR_FAIL_COND_V(!valid, p_data.initial_val);
|
|
} else {
|
|
// Call the method and get the initial value from it
|
|
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:
|
|
// Callback does not have a special initial value
|
|
break;
|
|
}
|
|
// If we've made it here, just return the delta value as the initial value
|
|
return p_data.delta_val;
|
|
}
|
|
|
|
Variant Tween::_get_final_val(const InterpolateData &p_data) const {
|
|
switch (p_data.type) {
|
|
case FOLLOW_PROPERTY:
|
|
case FOLLOW_METHOD: {
|
|
// Get the object that is being followed
|
|
Object *target = ObjectDB::get_instance(p_data.target_id);
|
|
ERR_FAIL_COND_V(target == NULL, p_data.initial_val);
|
|
|
|
// We want to figure out the final value
|
|
Variant final_val;
|
|
if (p_data.type == FOLLOW_PROPERTY) {
|
|
// Read the property as-is
|
|
bool valid = false;
|
|
final_val = target->get_indexed(p_data.target_key, &valid);
|
|
ERR_FAIL_COND_V(!valid, p_data.initial_val);
|
|
} else {
|
|
// We're looking at a method. Call the method on the target object
|
|
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);
|
|
}
|
|
|
|
// If we're looking at an INT value, instead convert it to a REAL
|
|
// This is better for interpolation
|
|
if (final_val.get_type() == Variant::INT) final_val = final_val.operator real_t();
|
|
|
|
return final_val;
|
|
}
|
|
default: {
|
|
// If we're not following a final value/method, use the final value from the data
|
|
return p_data.final_val;
|
|
}
|
|
}
|
|
}
|
|
|
|
Variant &Tween::_get_delta_val(InterpolateData &p_data) {
|
|
|
|
// What kind of data are we interpolating?
|
|
switch (p_data.type) {
|
|
case INTER_PROPERTY:
|
|
case INTER_METHOD:
|
|
// Simply return the given delta value
|
|
return p_data.delta_val;
|
|
|
|
case FOLLOW_PROPERTY:
|
|
case FOLLOW_METHOD: {
|
|
// We're following an object, so grab that instance
|
|
Object *target = ObjectDB::get_instance(p_data.target_id);
|
|
ERR_FAIL_COND_V(target == NULL, p_data.initial_val);
|
|
|
|
// We want to figure out the final value
|
|
Variant final_val;
|
|
if (p_data.type == FOLLOW_PROPERTY) {
|
|
// Read the property as-is
|
|
bool valid = false;
|
|
final_val = target->get_indexed(p_data.target_key, &valid);
|
|
ERR_FAIL_COND_V(!valid, p_data.initial_val);
|
|
} else {
|
|
// We're looking at a method. Call the method on the target object
|
|
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);
|
|
}
|
|
|
|
// If we're looking at an INT value, instead convert it to a REAL
|
|
// This is better for interpolation
|
|
if (final_val.get_type() == Variant::INT) final_val = final_val.operator real_t();
|
|
|
|
// Calculate the delta based on the initial value and the final value
|
|
_calc_delta_val(p_data.initial_val, final_val, p_data.delta_val);
|
|
return p_data.delta_val;
|
|
}
|
|
|
|
case TARGETING_PROPERTY:
|
|
case TARGETING_METHOD: {
|
|
// Grab the initial value from the data to calculate delta
|
|
Variant initial_val = _get_initial_val(p_data);
|
|
|
|
// If we're looking at an INT value, instead convert it to a REAL
|
|
// This is better for interpolation
|
|
if (initial_val.get_type() == Variant::INT) initial_val = initial_val.operator real_t();
|
|
|
|
// Calculate the delta based on the initial value and the final value
|
|
_calc_delta_val(initial_val, p_data.final_val, p_data.delta_val);
|
|
return p_data.delta_val;
|
|
}
|
|
|
|
case INTER_CALLBACK:
|
|
// Callbacks have no special delta
|
|
break;
|
|
}
|
|
// If we've made it here, use the initial value as the delta
|
|
return p_data.initial_val;
|
|
}
|
|
|
|
Variant Tween::_run_equation(InterpolateData &p_data) {
|
|
// Get the initial and delta values from the 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);
|
|
|
|
// What type of data are we interpolating?
|
|
switch (initial_val.get_type()) {
|
|
|
|
case Variant::BOOL:
|
|
// Run the boolean specific equation (checking if it is at least 0.5)
|
|
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:
|
|
// Run the integer specific equation
|
|
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:
|
|
// Run the REAL specific equation
|
|
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: {
|
|
// Get vectors for initial and delta values
|
|
Vector2 i = initial_val;
|
|
Vector2 d = delta_val;
|
|
Vector2 r;
|
|
|
|
// Execute the equation and mutate the r vector
|
|
// This uses the custom APPLY_EQUATION macro defined above
|
|
APPLY_EQUATION(x);
|
|
APPLY_EQUATION(y);
|
|
result = r;
|
|
} break;
|
|
|
|
case Variant::VECTOR3: {
|
|
// Get vectors for initial and delta values
|
|
Vector3 i = initial_val;
|
|
Vector3 d = delta_val;
|
|
Vector3 r;
|
|
|
|
// Execute the equation and mutate the r vector
|
|
// This uses the custom APPLY_EQUATION macro defined above
|
|
APPLY_EQUATION(x);
|
|
APPLY_EQUATION(y);
|
|
APPLY_EQUATION(z);
|
|
result = r;
|
|
} break;
|
|
|
|
case Variant::BASIS: {
|
|
// Get the basis for initial and delta values
|
|
Basis i = initial_val;
|
|
Basis d = delta_val;
|
|
Basis r;
|
|
|
|
// Execute the equation on all the basis and mutate the r basis
|
|
// This uses the custom APPLY_EQUATION macro defined above
|
|
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: {
|
|
// Get the transforms for initial and delta values
|
|
Transform2D i = initial_val;
|
|
Transform2D d = delta_val;
|
|
Transform2D r;
|
|
|
|
// Execute the equation on the transforms and mutate the r transform
|
|
// This uses the custom APPLY_EQUATION macro defined above
|
|
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: {
|
|
// Get the quaternian for the initial and delta values
|
|
Quat i = initial_val;
|
|
Quat d = delta_val;
|
|
Quat r;
|
|
|
|
// Execute the equation on the quaternian values and mutate the r quaternian
|
|
// This uses the custom APPLY_EQUATION macro defined above
|
|
APPLY_EQUATION(x);
|
|
APPLY_EQUATION(y);
|
|
APPLY_EQUATION(z);
|
|
APPLY_EQUATION(w);
|
|
result = r;
|
|
} break;
|
|
case Variant::AABB: {
|
|
// Get the AABB's for the initial and delta values
|
|
AABB i = initial_val;
|
|
AABB d = delta_val;
|
|
AABB r;
|
|
|
|
// Execute the equation for the position and size of the AABB's and mutate the r AABB
|
|
// This uses the custom APPLY_EQUATION macro defined above
|
|
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: {
|
|
// Get the transforms for the initial and delta values
|
|
Transform i = initial_val;
|
|
Transform d = delta_val;
|
|
Transform r;
|
|
|
|
// Execute the equation for each of the transforms and their origin and mutate the r transform
|
|
// This uses the custom APPLY_EQUATION macro defined above
|
|
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: {
|
|
// Get the Color for initial and delta value
|
|
Color i = initial_val;
|
|
Color d = delta_val;
|
|
Color r;
|
|
|
|
// Apply the equation on the Color RGBA, and mutate the r color
|
|
// This uses the custom APPLY_EQUATION macro defined above
|
|
APPLY_EQUATION(r);
|
|
APPLY_EQUATION(g);
|
|
APPLY_EQUATION(b);
|
|
APPLY_EQUATION(a);
|
|
result = r;
|
|
} break;
|
|
default: {
|
|
// If unknown, just return the initial value
|
|
result = initial_val;
|
|
} break;
|
|
};
|
|
#undef APPLY_EQUATION
|
|
// Return the result that was computed
|
|
return result;
|
|
}
|
|
|
|
bool Tween::_apply_tween_value(InterpolateData &p_data, Variant &value) {
|
|
|
|
// Get the object we want to apply the new value to
|
|
Object *object = ObjectDB::get_instance(p_data.id);
|
|
ERR_FAIL_COND_V(object == NULL, false);
|
|
|
|
// What kind of data are we mutating?
|
|
switch (p_data.type) {
|
|
|
|
case INTER_PROPERTY:
|
|
case FOLLOW_PROPERTY:
|
|
case TARGETING_PROPERTY: {
|
|
// Simply set the property on the object
|
|
bool valid = false;
|
|
object->set_indexed(p_data.key, value, &valid);
|
|
return valid;
|
|
}
|
|
|
|
case INTER_METHOD:
|
|
case FOLLOW_METHOD:
|
|
case TARGETING_METHOD: {
|
|
// We want to call the method on the target object
|
|
Variant::CallError error;
|
|
|
|
// Do we have a non-nil value passed in?
|
|
if (value.get_type() != Variant::NIL) {
|
|
// Pass it as an argument to the function call
|
|
Variant *arg[1] = { &value };
|
|
object->call(p_data.key[0], (const Variant **)arg, 1, error);
|
|
} else {
|
|
// Don't pass any argument
|
|
object->call(p_data.key[0], NULL, 0, error);
|
|
}
|
|
|
|
// Did we get an error from the function call?
|
|
return error.error == Variant::CallError::CALL_OK;
|
|
}
|
|
|
|
case INTER_CALLBACK:
|
|
// Nothing to apply for a callback
|
|
break;
|
|
};
|
|
// No issues found!
|
|
return true;
|
|
}
|
|
|
|
void Tween::_tween_process(float p_delta) {
|
|
// Process all of the pending commands
|
|
_process_pending_commands();
|
|
|
|
// If the scale is 0, make no progress on the tweens
|
|
if (speed_scale == 0)
|
|
return;
|
|
|
|
// Update the delta and whether we are pending an update
|
|
p_delta *= speed_scale;
|
|
pending_update++;
|
|
|
|
// Are we repeating the interpolations?
|
|
if (repeat) {
|
|
// For each interpolation...
|
|
bool repeats_finished = true;
|
|
for (List<InterpolateData>::Element *E = interpolates.front(); E; E = E->next()) {
|
|
// Get the data from it
|
|
InterpolateData &data = E->get();
|
|
|
|
// Is not finished?
|
|
if (!data.finish) {
|
|
// We aren't finished yet, no need to check the rest
|
|
repeats_finished = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// If we are all finished, we can reset all of the tweens
|
|
if (repeats_finished)
|
|
reset_all();
|
|
}
|
|
|
|
// Are all of the tweens complete?
|
|
bool all_finished = true;
|
|
|
|
// For each tween we wish to interpolate...
|
|
for (List<InterpolateData>::Element *E = interpolates.front(); E; E = E->next()) {
|
|
|
|
// Get the data from it
|
|
InterpolateData &data = E->get();
|
|
|
|
// Track if we hit one that isn't finished yet
|
|
all_finished = all_finished && data.finish;
|
|
|
|
// Is the data not active or already finished? No need to go any further
|
|
if (!data.active || data.finish)
|
|
continue;
|
|
|
|
// Get the target object for this interpolation
|
|
Object *object = ObjectDB::get_instance(data.id);
|
|
if (object == NULL)
|
|
continue;
|
|
|
|
// Are we still delaying this tween?
|
|
bool prev_delaying = data.elapsed <= data.delay;
|
|
data.elapsed += p_delta;
|
|
if (data.elapsed < data.delay)
|
|
continue;
|
|
else if (prev_delaying) {
|
|
// We can apply the tween's value to the data and emit that the tween has started
|
|
_apply_tween_value(data, data.initial_val);
|
|
emit_signal("tween_started", object, NodePath(Vector<StringName>(), data.key, false));
|
|
}
|
|
|
|
// Are we at the end of the tween?
|
|
if (data.elapsed > (data.delay + data.duration)) {
|
|
// Set the elapsed time to the end and mark this one as finished
|
|
data.elapsed = data.delay + data.duration;
|
|
data.finish = true;
|
|
}
|
|
|
|
// Are we interpolating a callback?
|
|
if (data.type == INTER_CALLBACK) {
|
|
// Is the tween completed?
|
|
if (data.finish) {
|
|
// Are we calling this callback deferred or immediately?
|
|
if (data.call_deferred) {
|
|
// Run the deferred function callback, applying the correct number of arguments
|
|
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 {
|
|
// Call the function directly with the arguments
|
|
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 {
|
|
// We can apply the value directly
|
|
Variant result = _run_equation(data);
|
|
_apply_tween_value(data, result);
|
|
|
|
// Emit that the tween has taken a step
|
|
emit_signal("tween_step", object, NodePath(Vector<StringName>(), data.key, false), data.elapsed, result);
|
|
}
|
|
|
|
// Is the tween now finished?
|
|
if (data.finish) {
|
|
// Set it to the final value directly
|
|
Variant final_val = _get_final_val(data);
|
|
_apply_tween_value(data, final_val);
|
|
|
|
// Mark the tween as completed and emit the signal
|
|
data.elapsed = 0;
|
|
emit_signal("tween_completed", object, NodePath(Vector<StringName>(), data.key, false));
|
|
|
|
// If we are not repeating the tween, remove it
|
|
if (!repeat)
|
|
call_deferred("_remove_by_uid", data.uid);
|
|
} else if (!repeat) {
|
|
// Check whether all tweens are finished
|
|
all_finished = all_finished && data.finish;
|
|
}
|
|
}
|
|
// One less update left to go
|
|
pending_update--;
|
|
|
|
// If all tweens are completed, we no longer need to be active
|
|
if (all_finished) {
|
|
set_active(false);
|
|
emit_signal("tween_all_completed");
|
|
}
|
|
}
|
|
|
|
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) {
|
|
// Do nothing if it's the same active mode that we currently are
|
|
if (is_active() == p_active)
|
|
return;
|
|
|
|
// Depending on physics or idle, set processing
|
|
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() {
|
|
|
|
ERR_FAIL_COND_V_MSG(!is_inside_tree(), false, "Tween was not added to the SceneTree!");
|
|
|
|
// Are there any pending updates?
|
|
if (pending_update != 0) {
|
|
// Start the tweens after deferring
|
|
return true;
|
|
}
|
|
|
|
// We want to be activated
|
|
set_active(true);
|
|
return true;
|
|
}
|
|
|
|
bool Tween::reset(Object *p_object, StringName p_key) {
|
|
// Find all interpolations that use the same object and target string
|
|
pending_update++;
|
|
for (List<InterpolateData>::Element *E = interpolates.front(); E; E = E->next()) {
|
|
// Get the target object
|
|
InterpolateData &data = E->get();
|
|
Object *object = ObjectDB::get_instance(data.id);
|
|
if (object == NULL)
|
|
continue;
|
|
|
|
// Do we have the correct object and key?
|
|
if (object == p_object && (data.concatenated_key == p_key || p_key == "")) {
|
|
// Reset the tween to the initial state
|
|
data.elapsed = 0;
|
|
data.finish = false;
|
|
|
|
// Also apply the initial state if there isn't a delay
|
|
if (data.delay == 0)
|
|
_apply_tween_value(data, data.initial_val);
|
|
}
|
|
}
|
|
pending_update--;
|
|
return true;
|
|
}
|
|
|
|
bool Tween::reset_all() {
|
|
// Go through all interpolations
|
|
pending_update++;
|
|
for (List<InterpolateData>::Element *E = interpolates.front(); E; E = E->next()) {
|
|
// Get the target data and set it back to the initial state
|
|
InterpolateData &data = E->get();
|
|
data.elapsed = 0;
|
|
data.finish = false;
|
|
|
|
// If there isn't a delay, apply the value to the object
|
|
if (data.delay == 0)
|
|
_apply_tween_value(data, data.initial_val);
|
|
}
|
|
pending_update--;
|
|
return true;
|
|
}
|
|
|
|
bool Tween::stop(Object *p_object, StringName p_key) {
|
|
// Find the tween that has the given target object and string key
|
|
pending_update++;
|
|
for (List<InterpolateData>::Element *E = interpolates.front(); E; E = E->next()) {
|
|
|
|
// Get the object the tween is targeting
|
|
InterpolateData &data = E->get();
|
|
Object *object = ObjectDB::get_instance(data.id);
|
|
if (object == NULL)
|
|
continue;
|
|
|
|
// Is this the correct object and does it have the given key?
|
|
if (object == p_object && (data.concatenated_key == p_key || p_key == ""))
|
|
// Disable the tween
|
|
data.active = false;
|
|
}
|
|
pending_update--;
|
|
return true;
|
|
}
|
|
|
|
bool Tween::stop_all() {
|
|
// We no longer need to be active since all tweens have been stopped
|
|
set_active(false);
|
|
|
|
// For each interpolation...
|
|
pending_update++;
|
|
for (List<InterpolateData>::Element *E = interpolates.front(); E; E = E->next()) {
|
|
// Simply set it inactive
|
|
InterpolateData &data = E->get();
|
|
data.active = false;
|
|
}
|
|
pending_update--;
|
|
return true;
|
|
}
|
|
|
|
bool Tween::resume(Object *p_object, StringName p_key) {
|
|
// We need to be activated
|
|
// TODO: What if no tween is found??
|
|
set_active(true);
|
|
|
|
// Find the tween that uses the given target object and string key
|
|
pending_update++;
|
|
for (List<InterpolateData>::Element *E = interpolates.front(); E; E = E->next()) {
|
|
// Grab the object
|
|
InterpolateData &data = E->get();
|
|
Object *object = ObjectDB::get_instance(data.id);
|
|
if (object == NULL)
|
|
continue;
|
|
|
|
// If the object and string key match, activate it
|
|
if (object == p_object && (data.concatenated_key == p_key || p_key == ""))
|
|
data.active = true;
|
|
}
|
|
pending_update--;
|
|
return true;
|
|
}
|
|
|
|
bool Tween::resume_all() {
|
|
// Set ourselves active so we can process tweens
|
|
// TODO: What if there are no tweens? We get set to active for no reason!
|
|
set_active(true);
|
|
|
|
// For each interpolation...
|
|
pending_update++;
|
|
for (List<InterpolateData>::Element *E = interpolates.front(); E; E = E->next()) {
|
|
// Simply grab it and set it to active
|
|
InterpolateData &data = E->get();
|
|
data.active = true;
|
|
}
|
|
pending_update--;
|
|
return true;
|
|
}
|
|
|
|
bool Tween::remove(Object *p_object, StringName p_key) {
|
|
// If we are still updating, call this function again later
|
|
if (pending_update != 0) {
|
|
call_deferred("remove", p_object, p_key);
|
|
return true;
|
|
}
|
|
|
|
// For each interpolation...
|
|
List<List<InterpolateData>::Element *> for_removal;
|
|
for (List<InterpolateData>::Element *E = interpolates.front(); E; E = E->next()) {
|
|
// Get the target object
|
|
InterpolateData &data = E->get();
|
|
Object *object = ObjectDB::get_instance(data.id);
|
|
if (object == NULL)
|
|
continue;
|
|
|
|
// If the target object and string key match, queue it for removal
|
|
if (object == p_object && (data.concatenated_key == p_key || p_key == "")) {
|
|
for_removal.push_back(E);
|
|
}
|
|
}
|
|
|
|
// For each interpolation we wish to remove...
|
|
for (List<List<InterpolateData>::Element *>::Element *E = for_removal.front(); E; E = E->next()) {
|
|
// Erase it
|
|
interpolates.erase(E->get());
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void Tween::_remove_by_uid(int uid) {
|
|
// If we are still updating, call this function again later
|
|
if (pending_update != 0) {
|
|
call_deferred("_remove_by_uid", uid);
|
|
return;
|
|
}
|
|
|
|
// Find the interpolation that matches the given UID
|
|
for (List<InterpolateData>::Element *E = interpolates.front(); E; E = E->next()) {
|
|
if (uid == E->get().uid) {
|
|
// It matches, erase it and stop looking
|
|
E->erase();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void Tween::_push_interpolate_data(InterpolateData &p_data) {
|
|
pending_update++;
|
|
|
|
// Add the new interpolation
|
|
p_data.uid = ++uid;
|
|
interpolates.push_back(p_data);
|
|
|
|
pending_update--;
|
|
}
|
|
|
|
bool Tween::remove_all() {
|
|
// If we are still updating, call this function again later
|
|
if (pending_update != 0) {
|
|
call_deferred("remove_all");
|
|
return true;
|
|
}
|
|
// We no longer need to be active
|
|
set_active(false);
|
|
|
|
// Clear out all interpolations and reset the uid
|
|
interpolates.clear();
|
|
uid = 0;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool Tween::seek(real_t p_time) {
|
|
// Go through each interpolation...
|
|
pending_update++;
|
|
for (List<InterpolateData>::Element *E = interpolates.front(); E; E = E->next()) {
|
|
// Get the target data
|
|
InterpolateData &data = E->get();
|
|
|
|
// Update the elapsed data to be set to the target time
|
|
data.elapsed = p_time;
|
|
|
|
// Are we at the end?
|
|
if (data.elapsed < data.delay) {
|
|
// There is still time left to go
|
|
data.finish = false;
|
|
continue;
|
|
} else if (data.elapsed >= (data.delay + data.duration)) {
|
|
// We are past the end of it, set the elapsed time to the end and mark as finished
|
|
data.elapsed = (data.delay + data.duration);
|
|
data.finish = true;
|
|
} else {
|
|
// We are not finished with this interpolation yet
|
|
data.finish = false;
|
|
}
|
|
|
|
// If we are a callback, do nothing special
|
|
if (data.type == INTER_CALLBACK) {
|
|
continue;
|
|
}
|
|
|
|
// Run the equation on the data and apply the value
|
|
Variant result = _run_equation(data);
|
|
_apply_tween_value(data, result);
|
|
}
|
|
pending_update--;
|
|
return true;
|
|
}
|
|
|
|
real_t Tween::tell() const {
|
|
// We want to grab the position of the furthest along tween
|
|
pending_update++;
|
|
real_t pos = 0;
|
|
|
|
// For each interpolation...
|
|
for (const List<InterpolateData>::Element *E = interpolates.front(); E; E = E->next()) {
|
|
// Get the data and figure out if it's position is further along than the previous ones
|
|
const InterpolateData &data = E->get();
|
|
if (data.elapsed > pos)
|
|
// Save it if so
|
|
pos = data.elapsed;
|
|
}
|
|
pending_update--;
|
|
return pos;
|
|
}
|
|
|
|
real_t Tween::get_runtime() const {
|
|
// If the tween isn't moving, it'll last forever
|
|
if (speed_scale == 0) {
|
|
return INFINITY;
|
|
}
|
|
|
|
pending_update++;
|
|
|
|
// For each interpolation...
|
|
real_t runtime = 0;
|
|
for (const List<InterpolateData>::Element *E = interpolates.front(); E; E = E->next()) {
|
|
// Get the tween data and see if it's runtime is greater than the previous tweens
|
|
const InterpolateData &data = E->get();
|
|
real_t t = data.delay + data.duration;
|
|
if (t > runtime)
|
|
// This is the longest running tween
|
|
runtime = t;
|
|
}
|
|
pending_update--;
|
|
|
|
// Adjust the runtime for the current speed scale
|
|
return runtime / speed_scale;
|
|
}
|
|
|
|
bool Tween::_calc_delta_val(const Variant &p_initial_val, const Variant &p_final_val, Variant &p_delta_val) {
|
|
|
|
// Get the initial, final, and delta values
|
|
const Variant &initial_val = p_initial_val;
|
|
const Variant &final_val = p_final_val;
|
|
Variant &delta_val = p_delta_val;
|
|
|
|
// What kind of data are we interpolating?
|
|
switch (initial_val.get_type()) {
|
|
|
|
case Variant::BOOL:
|
|
// We'll treat booleans just like integers
|
|
case Variant::INT:
|
|
// Compute the integer delta
|
|
delta_val = (int)final_val - (int)initial_val;
|
|
break;
|
|
|
|
case Variant::REAL:
|
|
// Convert to REAL and find the delta
|
|
delta_val = (real_t)final_val - (real_t)initial_val;
|
|
break;
|
|
|
|
case Variant::VECTOR2:
|
|
// Convert to Vectors and find the delta
|
|
delta_val = final_val.operator Vector2() - initial_val.operator Vector2();
|
|
break;
|
|
|
|
case Variant::VECTOR3:
|
|
// Convert to Vectors and find the delta
|
|
delta_val = final_val.operator Vector3() - initial_val.operator Vector3();
|
|
break;
|
|
|
|
case Variant::BASIS: {
|
|
// Build a new basis which is the delta between the initial and final values
|
|
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: {
|
|
// Build a new transform which is the difference between the initial and final values
|
|
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:
|
|
// Convert to quaternianls and find the delta
|
|
delta_val = final_val.operator Quat() - initial_val.operator Quat();
|
|
break;
|
|
|
|
case Variant::AABB: {
|
|
// Build a new AABB and use the new position and sizes to make a delta
|
|
AABB i = initial_val;
|
|
AABB f = final_val;
|
|
delta_val = AABB(f.position - i.position, f.size - i.size);
|
|
} break;
|
|
|
|
case Variant::TRANSFORM: {
|
|
// Build a new transform which is the difference between the initial and final values
|
|
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: {
|
|
// Make a new color which is the difference between each the color's RGBA attributes
|
|
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:
|
|
// TODO: Should move away from a 'magic string'?
|
|
ERR_PRINT("Invalid param type, except(int/real/vector2/vector/matrix/matrix32/quat/aabb/transform/color)");
|
|
return false;
|
|
};
|
|
return true;
|
|
}
|
|
|
|
bool Tween::_build_interpolation(InterpolateType p_interpolation_type, Object *p_object, NodePath *p_property, 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) {
|
|
|
|
// TODO: Add initialization+implementation for remaining interpolation types
|
|
// TODO: Fix this method's organization to take advantage of the type
|
|
|
|
// Make a new interpolation data
|
|
InterpolateData data;
|
|
data.active = true;
|
|
data.type = p_interpolation_type;
|
|
data.finish = false;
|
|
data.elapsed = 0;
|
|
|
|
// Validate and apply interpolation data
|
|
|
|
// Give it the object
|
|
ERR_FAIL_COND_V_MSG(p_object == NULL, false, "Invalid object provided to Tween.");
|
|
ERR_FAIL_COND_V_MSG(!ObjectDB::instance_validate(p_object), false, "Invalid object provided to Tween.");
|
|
data.id = p_object->get_instance_id();
|
|
|
|
// Validate the initial and final values
|
|
ERR_FAIL_COND_V_MSG(p_initial_val.get_type() != p_final_val.get_type(), false, "Initial value type '" + Variant::get_type_name(p_initial_val.get_type()) + "' does not match final value type '" + Variant::get_type_name(p_final_val.get_type()) + "'.");
|
|
data.initial_val = p_initial_val;
|
|
data.final_val = p_final_val;
|
|
|
|
// Check the Duration
|
|
ERR_FAIL_COND_V_MSG(p_duration < 0, false, "Only non-negative duration values allowed in Tweens.");
|
|
data.duration = p_duration;
|
|
|
|
// Tween Delay
|
|
ERR_FAIL_COND_V_MSG(p_delay < 0, false, "Only non-negative delay values allowed in Tweens.");
|
|
data.delay = p_delay;
|
|
|
|
// Transition type
|
|
ERR_FAIL_COND_V_MSG(p_trans_type < 0 || p_trans_type >= TRANS_COUNT, false, "Invalid transition type provided to Tween.");
|
|
data.trans_type = p_trans_type;
|
|
|
|
// Easing type
|
|
ERR_FAIL_COND_V_MSG(p_ease_type < 0 || p_ease_type >= EASE_COUNT, false, "Invalid easing type provided to Tween.");
|
|
data.ease_type = p_ease_type;
|
|
|
|
// Is the property defined?
|
|
if (p_property) {
|
|
// Check that the object actually contains the given property
|
|
bool prop_valid = false;
|
|
p_object->get_indexed(p_property->get_subnames(), &prop_valid);
|
|
ERR_FAIL_COND_V_MSG(!prop_valid, false, "Tween target object has no property named: " + p_property->get_concatenated_subnames() + ".");
|
|
|
|
data.key = p_property->get_subnames();
|
|
data.concatenated_key = p_property->get_concatenated_subnames();
|
|
}
|
|
|
|
// Is the method defined?
|
|
if (p_method) {
|
|
// Does the object even have the requested method?
|
|
ERR_FAIL_COND_V_MSG(!p_object->has_method(*p_method), false, "Tween target object has no method named: " + *p_method + ".");
|
|
|
|
data.key.push_back(*p_method);
|
|
data.concatenated_key = *p_method;
|
|
}
|
|
|
|
// Is there not a valid delta?
|
|
if (!_calc_delta_val(data.initial_val, data.final_val, data.delta_val))
|
|
return false;
|
|
|
|
// Add this interpolation to the total
|
|
_push_interpolate_data(data);
|
|
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 we are busy updating, call this function again later
|
|
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;
|
|
}
|
|
|
|
// Get the property from the node path
|
|
p_property = p_property.get_as_property_path();
|
|
|
|
// If no initial value given, grab the initial value from the object
|
|
// TODO: Is this documented? This is very useful and removes a lot of clutter from tweens!
|
|
if (p_initial_val.get_type() == Variant::NIL) p_initial_val = p_object->get_indexed(p_property.get_subnames());
|
|
|
|
// Convert any integers into REALs as they are better for interpolation
|
|
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();
|
|
|
|
// Build the interpolation data
|
|
bool result = _build_interpolation(INTER_PROPERTY, p_object, &p_property, NULL, p_initial_val, p_final_val, p_duration, p_trans_type, p_ease_type, p_delay);
|
|
return result;
|
|
}
|
|
|
|
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 we are busy updating, call this function again later
|
|
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 any integers into REALs as they are better for interpolation
|
|
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();
|
|
|
|
// Build the interpolation data
|
|
bool result = _build_interpolation(INTER_METHOD, p_object, NULL, &p_method, p_initial_val, p_final_val, p_duration, p_trans_type, p_ease_type, p_delay);
|
|
return result;
|
|
}
|
|
|
|
bool Tween::interpolate_callback(Object *p_object, real_t p_duration, String p_callback, VARIANT_ARG_DECLARE) {
|
|
// If we are already updating, call this function again later
|
|
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;
|
|
}
|
|
|
|
// Check that the target object is valid
|
|
ERR_FAIL_COND_V(p_object == NULL, false);
|
|
ERR_FAIL_COND_V(!ObjectDB::instance_validate(p_object), false);
|
|
|
|
// Duration cannot be negative
|
|
ERR_FAIL_COND_V(p_duration < 0, false);
|
|
|
|
// Check whether the object even has the callback
|
|
ERR_FAIL_COND_V_MSG(!p_object->has_method(p_callback), false, "Object has no callback named: " + p_callback + ".");
|
|
|
|
// Build a new InterpolationData
|
|
InterpolateData data;
|
|
data.active = true;
|
|
data.type = INTER_CALLBACK;
|
|
data.finish = false;
|
|
data.call_deferred = false;
|
|
data.elapsed = 0;
|
|
|
|
// Give the data it's configuration
|
|
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;
|
|
|
|
// Add arguments to the interpolation
|
|
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;
|
|
|
|
// Add the new interpolation
|
|
_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 we are already updating, call this function again later
|
|
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;
|
|
}
|
|
|
|
// Check that the target object is valid
|
|
ERR_FAIL_COND_V(p_object == NULL, false);
|
|
ERR_FAIL_COND_V(!ObjectDB::instance_validate(p_object), false);
|
|
|
|
// No negative durations allowed
|
|
ERR_FAIL_COND_V(p_duration < 0, false);
|
|
|
|
// Confirm the callback exists on the object
|
|
ERR_FAIL_COND_V_MSG(!p_object->has_method(p_callback), false, "Object has no callback named: " + p_callback + ".");
|
|
|
|
// Create a new InterpolateData for the callback
|
|
InterpolateData data;
|
|
data.active = true;
|
|
data.type = INTER_CALLBACK;
|
|
data.finish = false;
|
|
data.call_deferred = true;
|
|
data.elapsed = 0;
|
|
|
|
// Give the data it's configuration
|
|
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;
|
|
|
|
// Collect arguments for the callback
|
|
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;
|
|
|
|
// Add the new interpolation
|
|
_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 we are already updating, call this function again later
|
|
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;
|
|
}
|
|
|
|
// Get the two properties from their paths
|
|
p_property = p_property.get_as_property_path();
|
|
p_target_property = p_target_property.get_as_property_path();
|
|
|
|
// If no initial value is given, grab it from the source object
|
|
// TODO: Is this documented? It's really helpful for decluttering tweens
|
|
if (p_initial_val.get_type() == Variant::NIL) p_initial_val = p_object->get_indexed(p_property.get_subnames());
|
|
|
|
// Convert initial INT values to REAL as they are better for interpolation
|
|
if (p_initial_val.get_type() == Variant::INT) p_initial_val = p_initial_val.operator real_t();
|
|
|
|
// Confirm the source and target objects are valid
|
|
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);
|
|
|
|
// No negative durations
|
|
ERR_FAIL_COND_V(p_duration < 0, false);
|
|
|
|
// Ensure transition and easing types are valid
|
|
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);
|
|
|
|
// No negative delays
|
|
ERR_FAIL_COND_V(p_delay < 0, false);
|
|
|
|
// Confirm the source and target objects have the desired properties
|
|
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 target INT to REAL since it is better for interpolation
|
|
if (target_val.get_type() == Variant::INT) target_val = target_val.operator real_t();
|
|
|
|
// Verify that the target value and initial value are the same type
|
|
ERR_FAIL_COND_V(target_val.get_type() != p_initial_val.get_type(), false);
|
|
|
|
// Create a new InterpolateData
|
|
InterpolateData data;
|
|
data.active = true;
|
|
data.type = FOLLOW_PROPERTY;
|
|
data.finish = false;
|
|
data.elapsed = 0;
|
|
|
|
// Give the InterpolateData it's configuration
|
|
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;
|
|
|
|
// Add the interpolation
|
|
_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 we are currently updating, call this function again later
|
|
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 initial INT values to REAL as they are better for interpolation
|
|
if (p_initial_val.get_type() == Variant::INT) p_initial_val = p_initial_val.operator real_t();
|
|
|
|
// Verify the source and target objects are valid
|
|
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);
|
|
|
|
// No negative durations
|
|
ERR_FAIL_COND_V(p_duration < 0, false);
|
|
|
|
// Ensure that the transition and ease types are valid
|
|
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);
|
|
|
|
// No negative delays
|
|
ERR_FAIL_COND_V(p_delay < 0, false);
|
|
|
|
// Confirm both objects have the target methods
|
|
ERR_FAIL_COND_V_MSG(!p_object->has_method(p_method), false, "Object has no method named: " + p_method + ".");
|
|
ERR_FAIL_COND_V_MSG(!p_target->has_method(p_target_method), false, "Target has no method named: " + p_target_method + ".");
|
|
|
|
// Call the method to get the target value
|
|
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 target INT values to REAL as they are better for interpolation
|
|
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);
|
|
|
|
// Make the new InterpolateData for the method follow
|
|
InterpolateData data;
|
|
data.active = true;
|
|
data.type = FOLLOW_METHOD;
|
|
data.finish = false;
|
|
data.elapsed = 0;
|
|
|
|
// Give the data it's configuration
|
|
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;
|
|
|
|
// Add the new interpolation
|
|
_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 we are currently updating, call this function again later
|
|
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;
|
|
}
|
|
// Grab the target property and the target property
|
|
p_property = p_property.get_as_property_path();
|
|
p_initial_property = p_initial_property.get_as_property_path();
|
|
|
|
// Convert the initial INT values to REAL as they are better for Interpolation
|
|
if (p_final_val.get_type() == Variant::INT) p_final_val = p_final_val.operator real_t();
|
|
|
|
// Verify both objects are valid
|
|
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);
|
|
|
|
// No negative durations
|
|
ERR_FAIL_COND_V(p_duration < 0, false);
|
|
|
|
// Ensure transition and easing types are valid
|
|
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);
|
|
|
|
// No negative delays
|
|
ERR_FAIL_COND_V(p_delay < 0, false);
|
|
|
|
// Ensure the initial and target properties exist on their objects
|
|
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 the initial INT value to REAL as it is better for interpolation
|
|
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);
|
|
|
|
// Build the InterpolateData object
|
|
InterpolateData data;
|
|
data.active = true;
|
|
data.type = TARGETING_PROPERTY;
|
|
data.finish = false;
|
|
data.elapsed = 0;
|
|
|
|
// Give the data it's configuration
|
|
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;
|
|
|
|
// Ensure there is a valid delta
|
|
if (!_calc_delta_val(data.initial_val, data.final_val, data.delta_val))
|
|
return false;
|
|
|
|
// Add the interpolation
|
|
_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 we are currently updating, call this function again later
|
|
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 final INT values to REAL as they are better for interpolation
|
|
if (p_final_val.get_type() == Variant::INT) p_final_val = p_final_val.operator real_t();
|
|
|
|
// Make sure the given objects are valid
|
|
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);
|
|
|
|
// No negative durations
|
|
ERR_FAIL_COND_V(p_duration < 0, false);
|
|
|
|
// Ensure transition and easing types are valid
|
|
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);
|
|
|
|
// No negative delays
|
|
ERR_FAIL_COND_V(p_delay < 0, false);
|
|
|
|
// Make sure both objects have the given method
|
|
ERR_FAIL_COND_V_MSG(!p_object->has_method(p_method), false, "Object has no method named: " + p_method + ".");
|
|
ERR_FAIL_COND_V_MSG(!p_initial->has_method(p_initial_method), false, "Initial Object has no method named: " + p_initial_method + ".");
|
|
|
|
// Call the method to get the initial value
|
|
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 initial INT values to REAL as they aer better for interpolation
|
|
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);
|
|
|
|
// Build the new InterpolateData object
|
|
InterpolateData data;
|
|
data.active = true;
|
|
data.type = TARGETING_METHOD;
|
|
data.finish = false;
|
|
data.elapsed = 0;
|
|
|
|
// Configure the data
|
|
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;
|
|
|
|
// Ensure there is a valid delta
|
|
if (!_calc_delta_val(data.initial_val, data.final_val, data.delta_val))
|
|
return false;
|
|
|
|
// Add the interpolation
|
|
_push_interpolate_data(data);
|
|
return true;
|
|
}
|
|
|
|
Tween::Tween() {
|
|
// Initialize tween attributes
|
|
tween_process_mode = TWEEN_PROCESS_IDLE;
|
|
repeat = false;
|
|
speed_scale = 1;
|
|
pending_update = 0;
|
|
uid = 0;
|
|
}
|
|
|
|
Tween::~Tween() {
|
|
}
|