2014-02-10 02:10:30 +01:00
|
|
|
/*************************************************************************/
|
|
|
|
/* animation.cpp */
|
|
|
|
/*************************************************************************/
|
|
|
|
/* This file is part of: */
|
|
|
|
/* GODOT ENGINE */
|
2017-08-27 14:16:55 +02:00
|
|
|
/* https://godotengine.org */
|
2014-02-10 02:10:30 +01:00
|
|
|
/*************************************************************************/
|
2020-01-01 11:16:22 +01:00
|
|
|
/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur. */
|
|
|
|
/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md). */
|
2014-02-10 02:10:30 +01:00
|
|
|
/* */
|
|
|
|
/* 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. */
|
|
|
|
/*************************************************************************/
|
2018-01-05 00:50:27 +01:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
#include "animation.h"
|
2019-02-14 14:19:03 +01:00
|
|
|
#include "scene/scene_string_names.h"
|
2017-08-27 21:07:15 +02:00
|
|
|
|
2018-09-11 18:13:45 +02:00
|
|
|
#include "core/math/geometry.h"
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2018-06-08 18:42:04 +02:00
|
|
|
#define ANIM_MIN_LENGTH 0.001
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
bool Animation::_set(const StringName &p_name, const Variant &p_value) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
String name = p_name;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2018-01-11 23:35:12 +01:00
|
|
|
if (name.begins_with("tracks/")) {
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
int track = name.get_slicec('/', 1).to_int();
|
|
|
|
String what = name.get_slicec('/', 2);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
if (tracks.size() == track && what == "type") {
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
String type = p_value;
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
if (type == "transform") {
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
add_track(TYPE_TRANSFORM);
|
2017-03-05 16:44:50 +01:00
|
|
|
} else if (type == "value") {
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
add_track(TYPE_VALUE);
|
2017-03-05 16:44:50 +01:00
|
|
|
} else if (type == "method") {
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
add_track(TYPE_METHOD);
|
2018-06-07 17:46:14 +02:00
|
|
|
} else if (type == "bezier") {
|
|
|
|
|
|
|
|
add_track(TYPE_BEZIER);
|
|
|
|
} else if (type == "audio") {
|
|
|
|
|
|
|
|
add_track(TYPE_AUDIO);
|
|
|
|
} else if (type == "animation") {
|
|
|
|
|
|
|
|
add_track(TYPE_ANIMATION);
|
2014-02-10 02:10:30 +01:00
|
|
|
} else {
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
return false;
|
|
|
|
}
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
return true;
|
|
|
|
}
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_INDEX_V(track, tracks.size(), false);
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
if (what == "path")
|
|
|
|
track_set_path(track, p_value);
|
|
|
|
else if (what == "interp")
|
|
|
|
track_set_interpolation_type(track, InterpolationType(p_value.operator int()));
|
|
|
|
else if (what == "loop_wrap")
|
|
|
|
track_set_interpolation_loop_wrap(track, p_value);
|
|
|
|
else if (what == "imported")
|
|
|
|
track_set_imported(track, p_value);
|
2017-11-28 16:46:37 +01:00
|
|
|
else if (what == "enabled")
|
|
|
|
track_set_enabled(track, p_value);
|
2017-03-05 16:44:50 +01:00
|
|
|
else if (what == "keys" || what == "key_values") {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
if (track_get_type(track) == TYPE_TRANSFORM) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
TransformTrack *tt = static_cast<TransformTrack *>(tracks[track]);
|
2020-02-17 22:06:54 +01:00
|
|
|
Vector<float> values = p_value;
|
2017-03-05 16:44:50 +01:00
|
|
|
int vcount = values.size();
|
2019-06-11 14:49:34 +02:00
|
|
|
ERR_FAIL_COND_V(vcount % 12, false); // should be multiple of 11
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2020-02-17 22:06:54 +01:00
|
|
|
const float *r = values.ptr();
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
tt->transforms.resize(vcount / 12);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
for (int i = 0; i < (vcount / 12); i++) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2018-07-25 03:11:03 +02:00
|
|
|
TKey<TransformKey> &tk = tt->transforms.write[i];
|
2017-03-05 16:44:50 +01:00
|
|
|
const float *ofs = &r[i * 12];
|
|
|
|
tk.time = ofs[0];
|
|
|
|
tk.transition = ofs[1];
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
tk.value.loc.x = ofs[2];
|
|
|
|
tk.value.loc.y = ofs[3];
|
|
|
|
tk.value.loc.z = ofs[4];
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
tk.value.rot.x = ofs[5];
|
|
|
|
tk.value.rot.y = ofs[6];
|
|
|
|
tk.value.rot.z = ofs[7];
|
|
|
|
tk.value.rot.w = ofs[8];
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
tk.value.scale.x = ofs[9];
|
|
|
|
tk.value.scale.y = ofs[10];
|
|
|
|
tk.value.scale.z = ofs[11];
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
} else if (track_get_type(track) == TYPE_VALUE) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ValueTrack *vt = static_cast<ValueTrack *>(tracks[track]);
|
2014-02-10 02:10:30 +01:00
|
|
|
Dictionary d = p_value;
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_COND_V(!d.has("times"), false);
|
|
|
|
ERR_FAIL_COND_V(!d.has("values"), false);
|
2016-06-19 06:43:02 +02:00
|
|
|
if (d.has("cont")) {
|
|
|
|
bool v = d["cont"];
|
2017-03-05 16:44:50 +01:00
|
|
|
vt->update_mode = v ? UPDATE_CONTINUOUS : UPDATE_DISCRETE;
|
2016-06-19 06:43:02 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (d.has("update")) {
|
2017-03-05 16:44:50 +01:00
|
|
|
int um = d["update"];
|
|
|
|
if (um < 0)
|
|
|
|
um = 0;
|
2018-06-29 14:13:20 +02:00
|
|
|
else if (um > 3)
|
|
|
|
um = 3;
|
2017-03-05 16:44:50 +01:00
|
|
|
vt->update_mode = UpdateMode(um);
|
2016-06-19 06:43:02 +02:00
|
|
|
}
|
|
|
|
|
2020-02-17 22:06:54 +01:00
|
|
|
Vector<float> times = d["times"];
|
2017-03-05 16:44:50 +01:00
|
|
|
Array values = d["values"];
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_COND_V(times.size() != values.size(), false);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
if (times.size()) {
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
int valcount = times.size();
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2020-02-17 22:06:54 +01:00
|
|
|
const float *rt = times.ptr();
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
vt->values.resize(valcount);
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
for (int i = 0; i < valcount; i++) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2018-07-25 03:11:03 +02:00
|
|
|
vt->values.write[i].time = rt[i];
|
|
|
|
vt->values.write[i].value = values[i];
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if (d.has("transitions")) {
|
|
|
|
|
2020-02-17 22:06:54 +01:00
|
|
|
Vector<float> transitions = d["transitions"];
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_COND_V(transitions.size() != valcount, false);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2020-02-17 22:06:54 +01:00
|
|
|
const float *rtr = transitions.ptr();
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
for (int i = 0; i < valcount; i++) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2018-07-25 03:11:03 +02:00
|
|
|
vt->values.write[i].transition = rtr[i];
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
|
2018-06-07 17:46:14 +02:00
|
|
|
} else if (track_get_type(track) == TYPE_METHOD) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
while (track_get_key_count(track))
|
|
|
|
track_remove_key(track, 0); //well shouldn't be set anyway
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
Dictionary d = p_value;
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_COND_V(!d.has("times"), false);
|
|
|
|
ERR_FAIL_COND_V(!d.has("values"), false);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2020-02-17 22:06:54 +01:00
|
|
|
Vector<float> times = d["times"];
|
2017-03-05 16:44:50 +01:00
|
|
|
Array values = d["values"];
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_COND_V(times.size() != values.size(), false);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
if (times.size()) {
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
int valcount = times.size();
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2020-02-17 22:06:54 +01:00
|
|
|
const float *rt = times.ptr();
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
for (int i = 0; i < valcount; i++) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
track_insert_key(track, rt[i], values[i]);
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if (d.has("transitions")) {
|
|
|
|
|
2020-02-17 22:06:54 +01:00
|
|
|
Vector<float> transitions = d["transitions"];
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_COND_V(transitions.size() != valcount, false);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2020-02-17 22:06:54 +01:00
|
|
|
const float *rtr = transitions.ptr();
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
for (int i = 0; i < valcount; i++) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
track_set_key_transition(track, i, rtr[i]);
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2018-06-07 17:46:14 +02:00
|
|
|
} else if (track_get_type(track) == TYPE_BEZIER) {
|
|
|
|
|
|
|
|
BezierTrack *bt = static_cast<BezierTrack *>(tracks[track]);
|
|
|
|
Dictionary d = p_value;
|
|
|
|
ERR_FAIL_COND_V(!d.has("times"), false);
|
|
|
|
ERR_FAIL_COND_V(!d.has("points"), false);
|
|
|
|
|
2020-02-17 22:06:54 +01:00
|
|
|
Vector<float> times = d["times"];
|
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT.
- Renames PackedIntArray to PackedInt32Array.
- Renames PackedFloatArray to PackedFloat32Array.
- Adds PackedInt64Array and PackedFloat64Array.
- Renames Variant::REAL to Variant::FLOAT for consistency.
Packed arrays are for storing large amount of data and creating stuff like
meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of
memory. That said, many users requested the ability to have 64 bits packed
arrays for their games, so this is just an optional added type.
For Variant, the float datatype is always 64 bits, and exposed as `float`.
We still have `real_t` which is the datatype that can change from 32 to 64
bits depending on a compile flag (not entirely working right now, but that's
the idea). It affects math related datatypes and code only.
Neither Variant nor PackedArray make use of real_t, which is only intended
for math precision, so the term is removed from there to keep only float.
2020-02-24 19:20:53 +01:00
|
|
|
PackedFloat32Array values = d["points"];
|
2018-06-07 17:46:14 +02:00
|
|
|
|
|
|
|
ERR_FAIL_COND_V(times.size() * 5 != values.size(), false);
|
|
|
|
|
|
|
|
if (times.size()) {
|
|
|
|
|
|
|
|
int valcount = times.size();
|
|
|
|
|
2020-02-17 22:06:54 +01:00
|
|
|
const float *rt = times.ptr();
|
|
|
|
const float *rv = values.ptr();
|
2018-06-07 17:46:14 +02:00
|
|
|
|
|
|
|
bt->values.resize(valcount);
|
|
|
|
|
|
|
|
for (int i = 0; i < valcount; i++) {
|
|
|
|
|
2018-07-25 03:11:03 +02:00
|
|
|
bt->values.write[i].time = rt[i];
|
|
|
|
bt->values.write[i].transition = 0; //unused in bezier
|
|
|
|
bt->values.write[i].value.value = rv[i * 5 + 0];
|
|
|
|
bt->values.write[i].value.in_handle.x = rv[i * 5 + 1];
|
|
|
|
bt->values.write[i].value.in_handle.y = rv[i * 5 + 2];
|
|
|
|
bt->values.write[i].value.out_handle.x = rv[i * 5 + 3];
|
|
|
|
bt->values.write[i].value.out_handle.y = rv[i * 5 + 4];
|
2018-06-07 17:46:14 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
} else if (track_get_type(track) == TYPE_AUDIO) {
|
|
|
|
|
|
|
|
AudioTrack *ad = static_cast<AudioTrack *>(tracks[track]);
|
|
|
|
Dictionary d = p_value;
|
|
|
|
ERR_FAIL_COND_V(!d.has("times"), false);
|
|
|
|
ERR_FAIL_COND_V(!d.has("clips"), false);
|
|
|
|
|
2020-02-17 22:06:54 +01:00
|
|
|
Vector<float> times = d["times"];
|
2018-06-07 17:46:14 +02:00
|
|
|
Array clips = d["clips"];
|
|
|
|
|
|
|
|
ERR_FAIL_COND_V(clips.size() != times.size(), false);
|
|
|
|
|
|
|
|
if (times.size()) {
|
|
|
|
|
|
|
|
int valcount = times.size();
|
|
|
|
|
2020-02-17 22:06:54 +01:00
|
|
|
const float *rt = times.ptr();
|
2018-06-07 17:46:14 +02:00
|
|
|
|
|
|
|
ad->values.clear();
|
|
|
|
|
|
|
|
for (int i = 0; i < valcount; i++) {
|
|
|
|
|
2019-02-12 21:10:08 +01:00
|
|
|
Dictionary d2 = clips[i];
|
|
|
|
if (!d2.has("start_offset"))
|
2018-06-07 17:46:14 +02:00
|
|
|
continue;
|
2019-02-12 21:10:08 +01:00
|
|
|
if (!d2.has("end_offset"))
|
2018-06-07 17:46:14 +02:00
|
|
|
continue;
|
2019-02-12 21:10:08 +01:00
|
|
|
if (!d2.has("stream"))
|
2018-06-07 17:46:14 +02:00
|
|
|
continue;
|
|
|
|
|
|
|
|
TKey<AudioKey> ak;
|
|
|
|
ak.time = rt[i];
|
2019-02-12 21:10:08 +01:00
|
|
|
ak.value.start_offset = d2["start_offset"];
|
|
|
|
ak.value.end_offset = d2["end_offset"];
|
|
|
|
ak.value.stream = d2["stream"];
|
2018-06-07 17:46:14 +02:00
|
|
|
|
|
|
|
ad->values.push_back(ak);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
} else if (track_get_type(track) == TYPE_ANIMATION) {
|
|
|
|
|
|
|
|
AnimationTrack *an = static_cast<AnimationTrack *>(tracks[track]);
|
|
|
|
Dictionary d = p_value;
|
|
|
|
ERR_FAIL_COND_V(!d.has("times"), false);
|
|
|
|
ERR_FAIL_COND_V(!d.has("clips"), false);
|
|
|
|
|
2020-02-17 22:06:54 +01:00
|
|
|
Vector<float> times = d["times"];
|
|
|
|
Vector<String> clips = d["clips"];
|
2018-06-07 17:46:14 +02:00
|
|
|
|
|
|
|
ERR_FAIL_COND_V(clips.size() != times.size(), false);
|
|
|
|
|
|
|
|
if (times.size()) {
|
|
|
|
|
|
|
|
int valcount = times.size();
|
|
|
|
|
2020-02-17 22:06:54 +01:00
|
|
|
const float *rt = times.ptr();
|
|
|
|
const String *rc = clips.ptr();
|
2018-06-07 17:46:14 +02:00
|
|
|
|
|
|
|
an->values.resize(valcount);
|
|
|
|
|
|
|
|
for (int i = 0; i < valcount; i++) {
|
|
|
|
|
|
|
|
TKey<StringName> ak;
|
|
|
|
ak.time = rt[i];
|
|
|
|
ak.value = rc[i];
|
2018-07-25 03:11:03 +02:00
|
|
|
an->values.write[i] = ak;
|
2018-06-07 17:46:14 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
} else {
|
|
|
|
return false;
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
} else
|
|
|
|
return false;
|
|
|
|
} else
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
bool Animation::_get(const StringName &p_name, Variant &r_ret) const {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
String name = p_name;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
if (name == "length")
|
|
|
|
r_ret = length;
|
|
|
|
else if (name == "loop")
|
|
|
|
r_ret = loop;
|
|
|
|
else if (name == "step")
|
|
|
|
r_ret = step;
|
2014-02-10 02:10:30 +01:00
|
|
|
else if (name.begins_with("tracks/")) {
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
int track = name.get_slicec('/', 1).to_int();
|
|
|
|
String what = name.get_slicec('/', 2);
|
|
|
|
ERR_FAIL_INDEX_V(track, tracks.size(), false);
|
|
|
|
if (what == "type") {
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
switch (track_get_type(track)) {
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
case TYPE_TRANSFORM: r_ret = "transform"; break;
|
|
|
|
case TYPE_VALUE: r_ret = "value"; break;
|
|
|
|
case TYPE_METHOD: r_ret = "method"; break;
|
2018-06-07 17:46:14 +02:00
|
|
|
case TYPE_BEZIER: r_ret = "bezier"; break;
|
|
|
|
case TYPE_AUDIO: r_ret = "audio"; break;
|
|
|
|
case TYPE_ANIMATION: r_ret = "animation"; break;
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
} else if (what == "path")
|
|
|
|
r_ret = track_get_path(track);
|
|
|
|
else if (what == "interp")
|
2014-02-10 02:10:30 +01:00
|
|
|
r_ret = track_get_interpolation_type(track);
|
2017-03-05 16:44:50 +01:00
|
|
|
else if (what == "loop_wrap")
|
2017-01-09 04:41:16 +01:00
|
|
|
r_ret = track_get_interpolation_loop_wrap(track);
|
2017-03-05 16:44:50 +01:00
|
|
|
else if (what == "imported")
|
2016-06-20 05:19:04 +02:00
|
|
|
r_ret = track_is_imported(track);
|
2017-11-28 16:46:37 +01:00
|
|
|
else if (what == "enabled")
|
|
|
|
r_ret = track_is_enabled(track);
|
2017-03-05 16:44:50 +01:00
|
|
|
else if (what == "keys") {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
if (track_get_type(track) == TYPE_TRANSFORM) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT.
- Renames PackedIntArray to PackedInt32Array.
- Renames PackedFloatArray to PackedFloat32Array.
- Adds PackedInt64Array and PackedFloat64Array.
- Renames Variant::REAL to Variant::FLOAT for consistency.
Packed arrays are for storing large amount of data and creating stuff like
meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of
memory. That said, many users requested the ability to have 64 bits packed
arrays for their games, so this is just an optional added type.
For Variant, the float datatype is always 64 bits, and exposed as `float`.
We still have `real_t` which is the datatype that can change from 32 to 64
bits depending on a compile flag (not entirely working right now, but that's
the idea). It affects math related datatypes and code only.
Neither Variant nor PackedArray make use of real_t, which is only intended
for math precision, so the term is removed from there to keep only float.
2020-02-24 19:20:53 +01:00
|
|
|
Vector<float> keys;
|
2017-03-05 16:44:50 +01:00
|
|
|
int kk = track_get_key_count(track);
|
|
|
|
keys.resize(kk * 12);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2020-02-17 22:06:54 +01:00
|
|
|
real_t *w = keys.ptrw();
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
int idx = 0;
|
|
|
|
for (int i = 0; i < track_get_key_count(track); i++) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
Vector3 loc;
|
|
|
|
Quat rot;
|
|
|
|
Vector3 scale;
|
2017-03-05 16:44:50 +01:00
|
|
|
transform_track_get_key(track, i, &loc, &rot, &scale);
|
|
|
|
|
|
|
|
w[idx++] = track_get_key_time(track, i);
|
|
|
|
w[idx++] = track_get_key_transition(track, i);
|
|
|
|
w[idx++] = loc.x;
|
|
|
|
w[idx++] = loc.y;
|
|
|
|
w[idx++] = loc.z;
|
|
|
|
|
|
|
|
w[idx++] = rot.x;
|
|
|
|
w[idx++] = rot.y;
|
|
|
|
w[idx++] = rot.z;
|
|
|
|
w[idx++] = rot.w;
|
|
|
|
|
|
|
|
w[idx++] = scale.x;
|
|
|
|
w[idx++] = scale.y;
|
|
|
|
w[idx++] = scale.z;
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
r_ret = keys;
|
2014-02-10 02:10:30 +01:00
|
|
|
return true;
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
} else if (track_get_type(track) == TYPE_VALUE) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
const ValueTrack *vt = static_cast<const ValueTrack *>(tracks[track]);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
Dictionary d;
|
|
|
|
|
2020-02-17 22:06:54 +01:00
|
|
|
Vector<float> key_times;
|
|
|
|
Vector<float> key_transitions;
|
2014-02-10 02:10:30 +01:00
|
|
|
Array key_values;
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
int kk = vt->values.size();
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
key_times.resize(kk);
|
|
|
|
key_transitions.resize(kk);
|
|
|
|
key_values.resize(kk);
|
|
|
|
|
2020-02-17 22:06:54 +01:00
|
|
|
float *wti = key_times.ptrw();
|
|
|
|
float *wtr = key_transitions.ptrw();
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
int idx = 0;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
const TKey<Variant> *vls = vt->values.ptr();
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
for (int i = 0; i < kk; i++) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
wti[idx] = vls[i].time;
|
|
|
|
wtr[idx] = vls[i].transition;
|
|
|
|
key_values[idx] = vls[i].value;
|
2014-02-10 02:10:30 +01:00
|
|
|
idx++;
|
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
d["times"] = key_times;
|
|
|
|
d["transitions"] = key_transitions;
|
|
|
|
d["values"] = key_values;
|
|
|
|
if (track_get_type(track) == TYPE_VALUE) {
|
|
|
|
d["update"] = value_track_get_update_mode(track);
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
r_ret = d;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
return true;
|
|
|
|
|
2018-06-07 17:46:14 +02:00
|
|
|
} else if (track_get_type(track) == TYPE_METHOD) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
Dictionary d;
|
|
|
|
|
2020-02-17 22:06:54 +01:00
|
|
|
Vector<float> key_times;
|
|
|
|
Vector<float> key_transitions;
|
2014-02-10 02:10:30 +01:00
|
|
|
Array key_values;
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
int kk = track_get_key_count(track);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
key_times.resize(kk);
|
|
|
|
key_transitions.resize(kk);
|
|
|
|
key_values.resize(kk);
|
|
|
|
|
2020-02-17 22:06:54 +01:00
|
|
|
float *wti = key_times.ptrw();
|
|
|
|
float *wtr = key_transitions.ptrw();
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
int idx = 0;
|
|
|
|
for (int i = 0; i < track_get_key_count(track); i++) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
wti[idx] = track_get_key_time(track, i);
|
|
|
|
wtr[idx] = track_get_key_transition(track, i);
|
|
|
|
key_values[idx] = track_get_key_value(track, i);
|
2014-02-10 02:10:30 +01:00
|
|
|
idx++;
|
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
d["times"] = key_times;
|
|
|
|
d["transitions"] = key_transitions;
|
|
|
|
d["values"] = key_values;
|
|
|
|
if (track_get_type(track) == TYPE_VALUE) {
|
|
|
|
d["update"] = value_track_get_update_mode(track);
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
r_ret = d;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2018-06-07 17:46:14 +02:00
|
|
|
return true;
|
|
|
|
} else if (track_get_type(track) == TYPE_BEZIER) {
|
|
|
|
|
|
|
|
const BezierTrack *bt = static_cast<const BezierTrack *>(tracks[track]);
|
|
|
|
|
|
|
|
Dictionary d;
|
|
|
|
|
2020-02-17 22:06:54 +01:00
|
|
|
Vector<float> key_times;
|
|
|
|
Vector<float> key_points;
|
2018-06-07 17:46:14 +02:00
|
|
|
|
|
|
|
int kk = bt->values.size();
|
|
|
|
|
|
|
|
key_times.resize(kk);
|
|
|
|
key_points.resize(kk * 5);
|
|
|
|
|
2020-02-17 22:06:54 +01:00
|
|
|
float *wti = key_times.ptrw();
|
|
|
|
float *wpo = key_points.ptrw();
|
2018-06-07 17:46:14 +02:00
|
|
|
|
|
|
|
int idx = 0;
|
|
|
|
|
|
|
|
const TKey<BezierKey> *vls = bt->values.ptr();
|
|
|
|
|
|
|
|
for (int i = 0; i < kk; i++) {
|
|
|
|
|
|
|
|
wti[idx] = vls[i].time;
|
|
|
|
wpo[idx * 5 + 0] = vls[i].value.value;
|
|
|
|
wpo[idx * 5 + 1] = vls[i].value.in_handle.x;
|
|
|
|
wpo[idx * 5 + 2] = vls[i].value.in_handle.y;
|
|
|
|
wpo[idx * 5 + 3] = vls[i].value.out_handle.x;
|
|
|
|
wpo[idx * 5 + 4] = vls[i].value.out_handle.y;
|
|
|
|
idx++;
|
|
|
|
}
|
|
|
|
|
|
|
|
d["times"] = key_times;
|
|
|
|
d["points"] = key_points;
|
|
|
|
|
|
|
|
r_ret = d;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
} else if (track_get_type(track) == TYPE_AUDIO) {
|
|
|
|
|
|
|
|
const AudioTrack *ad = static_cast<const AudioTrack *>(tracks[track]);
|
|
|
|
|
|
|
|
Dictionary d;
|
|
|
|
|
2020-02-17 22:06:54 +01:00
|
|
|
Vector<float> key_times;
|
2018-06-07 17:46:14 +02:00
|
|
|
Array clips;
|
|
|
|
|
|
|
|
int kk = ad->values.size();
|
|
|
|
|
|
|
|
key_times.resize(kk);
|
|
|
|
|
2020-02-17 22:06:54 +01:00
|
|
|
float *wti = key_times.ptrw();
|
2018-06-07 17:46:14 +02:00
|
|
|
|
|
|
|
int idx = 0;
|
|
|
|
|
|
|
|
const TKey<AudioKey> *vls = ad->values.ptr();
|
|
|
|
|
|
|
|
for (int i = 0; i < kk; i++) {
|
|
|
|
|
|
|
|
wti[idx] = vls[i].time;
|
|
|
|
Dictionary clip;
|
|
|
|
clip["start_offset"] = vls[i].value.start_offset;
|
|
|
|
clip["end_offset"] = vls[i].value.end_offset;
|
|
|
|
clip["stream"] = vls[i].value.stream;
|
|
|
|
clips.push_back(clip);
|
|
|
|
idx++;
|
|
|
|
}
|
|
|
|
|
|
|
|
d["times"] = key_times;
|
|
|
|
d["clips"] = clips;
|
|
|
|
|
|
|
|
r_ret = d;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
} else if (track_get_type(track) == TYPE_ANIMATION) {
|
|
|
|
|
|
|
|
const AnimationTrack *an = static_cast<const AnimationTrack *>(tracks[track]);
|
|
|
|
|
|
|
|
Dictionary d;
|
|
|
|
|
2020-02-17 22:06:54 +01:00
|
|
|
Vector<float> key_times;
|
|
|
|
Vector<String> clips;
|
2018-06-07 17:46:14 +02:00
|
|
|
|
|
|
|
int kk = an->values.size();
|
|
|
|
|
|
|
|
key_times.resize(kk);
|
|
|
|
clips.resize(kk);
|
|
|
|
|
2020-02-17 22:06:54 +01:00
|
|
|
float *wti = key_times.ptrw();
|
|
|
|
String *wcl = clips.ptrw();
|
2018-06-07 17:46:14 +02:00
|
|
|
|
|
|
|
const TKey<StringName> *vls = an->values.ptr();
|
|
|
|
|
|
|
|
for (int i = 0; i < kk; i++) {
|
|
|
|
|
|
|
|
wti[i] = vls[i].time;
|
|
|
|
wcl[i] = vls[i].value;
|
|
|
|
}
|
|
|
|
|
|
|
|
d["times"] = key_times;
|
|
|
|
d["clips"] = clips;
|
|
|
|
|
|
|
|
r_ret = d;
|
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
} else
|
|
|
|
return false;
|
|
|
|
} else
|
|
|
|
return false;
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
void Animation::_get_property_list(List<PropertyInfo> *p_list) const {
|
|
|
|
for (int i = 0; i < tracks.size(); i++) {
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2018-01-11 23:35:12 +01:00
|
|
|
p_list->push_back(PropertyInfo(Variant::STRING, "tracks/" + itos(i) + "/type", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL));
|
|
|
|
p_list->push_back(PropertyInfo(Variant::NODE_PATH, "tracks/" + itos(i) + "/path", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL));
|
|
|
|
p_list->push_back(PropertyInfo(Variant::INT, "tracks/" + itos(i) + "/interp", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL));
|
|
|
|
p_list->push_back(PropertyInfo(Variant::BOOL, "tracks/" + itos(i) + "/loop_wrap", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL));
|
|
|
|
p_list->push_back(PropertyInfo(Variant::BOOL, "tracks/" + itos(i) + "/imported", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL));
|
|
|
|
p_list->push_back(PropertyInfo(Variant::BOOL, "tracks/" + itos(i) + "/enabled", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL));
|
|
|
|
p_list->push_back(PropertyInfo(Variant::ARRAY, "tracks/" + itos(i) + "/keys", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL));
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
int Animation::add_track(TrackType p_type, int p_at_pos) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
if (p_at_pos < 0 || p_at_pos >= tracks.size())
|
|
|
|
p_at_pos = tracks.size();
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
switch (p_type) {
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
case TYPE_TRANSFORM: {
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
TransformTrack *tt = memnew(TransformTrack);
|
|
|
|
tracks.insert(p_at_pos, tt);
|
2014-02-10 02:10:30 +01:00
|
|
|
} break;
|
|
|
|
case TYPE_VALUE: {
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
tracks.insert(p_at_pos, memnew(ValueTrack));
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
} break;
|
|
|
|
case TYPE_METHOD: {
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
tracks.insert(p_at_pos, memnew(MethodTrack));
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2018-06-07 17:46:14 +02:00
|
|
|
} break;
|
|
|
|
case TYPE_BEZIER: {
|
|
|
|
|
|
|
|
tracks.insert(p_at_pos, memnew(BezierTrack));
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case TYPE_AUDIO: {
|
|
|
|
|
|
|
|
tracks.insert(p_at_pos, memnew(AudioTrack));
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case TYPE_ANIMATION: {
|
|
|
|
|
|
|
|
tracks.insert(p_at_pos, memnew(AnimationTrack));
|
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
} break;
|
|
|
|
default: {
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
ERR_PRINT("Unknown track type");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
emit_changed();
|
2019-02-14 14:19:03 +01:00
|
|
|
emit_signal(SceneStringNames::get_singleton()->tracks_changed);
|
2014-02-10 02:10:30 +01:00
|
|
|
return p_at_pos;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Animation::remove_track(int p_track) {
|
|
|
|
|
|
|
|
ERR_FAIL_INDEX(p_track, tracks.size());
|
2017-03-05 16:44:50 +01:00
|
|
|
Track *t = tracks[p_track];
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
switch (t->type) {
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
case TYPE_TRANSFORM: {
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
TransformTrack *tt = static_cast<TransformTrack *>(t);
|
2014-02-10 02:10:30 +01:00
|
|
|
_clear(tt->transforms);
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
} break;
|
|
|
|
case TYPE_VALUE: {
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ValueTrack *vt = static_cast<ValueTrack *>(t);
|
2014-02-10 02:10:30 +01:00
|
|
|
_clear(vt->values);
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
} break;
|
|
|
|
case TYPE_METHOD: {
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
MethodTrack *mt = static_cast<MethodTrack *>(t);
|
2014-02-10 02:10:30 +01:00
|
|
|
_clear(mt->methods);
|
2016-03-09 00:00:52 +01:00
|
|
|
|
|
|
|
} break;
|
2018-06-07 17:46:14 +02:00
|
|
|
case TYPE_BEZIER: {
|
|
|
|
|
|
|
|
BezierTrack *bz = static_cast<BezierTrack *>(t);
|
|
|
|
_clear(bz->values);
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case TYPE_AUDIO: {
|
|
|
|
|
|
|
|
AudioTrack *ad = static_cast<AudioTrack *>(t);
|
|
|
|
_clear(ad->values);
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case TYPE_ANIMATION: {
|
|
|
|
|
|
|
|
AnimationTrack *an = static_cast<AnimationTrack *>(t);
|
|
|
|
_clear(an->values);
|
|
|
|
|
|
|
|
} break;
|
2016-03-09 00:00:52 +01:00
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
memdelete(t);
|
2014-02-10 02:10:30 +01:00
|
|
|
tracks.remove(p_track);
|
|
|
|
emit_changed();
|
2019-02-14 14:19:03 +01:00
|
|
|
emit_signal(SceneStringNames::get_singleton()->tracks_changed);
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
int Animation::get_track_count() const {
|
|
|
|
|
|
|
|
return tracks.size();
|
|
|
|
}
|
|
|
|
|
|
|
|
Animation::TrackType Animation::track_get_type(int p_track) const {
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_INDEX_V(p_track, tracks.size(), TYPE_TRANSFORM);
|
2014-02-10 02:10:30 +01:00
|
|
|
return tracks[p_track]->type;
|
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
void Animation::track_set_path(int p_track, const NodePath &p_path) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
ERR_FAIL_INDEX(p_track, tracks.size());
|
2017-03-05 16:44:50 +01:00
|
|
|
tracks[p_track]->path = p_path;
|
2014-02-10 02:10:30 +01:00
|
|
|
emit_changed();
|
2019-02-14 14:19:03 +01:00
|
|
|
emit_signal(SceneStringNames::get_singleton()->tracks_changed);
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
NodePath Animation::track_get_path(int p_track) const {
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_INDEX_V(p_track, tracks.size(), NodePath());
|
2014-02-10 02:10:30 +01:00
|
|
|
return tracks[p_track]->path;
|
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
int Animation::find_track(const NodePath &p_path) const {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
for (int i = 0; i < tracks.size(); i++) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
if (tracks[i]->path == p_path)
|
|
|
|
return i;
|
|
|
|
};
|
|
|
|
return -1;
|
|
|
|
};
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
void Animation::track_set_interpolation_type(int p_track, InterpolationType p_interp) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
ERR_FAIL_INDEX(p_track, tracks.size());
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_INDEX(p_interp, 3);
|
|
|
|
tracks[p_track]->interpolation = p_interp;
|
2014-02-10 02:10:30 +01:00
|
|
|
emit_changed();
|
|
|
|
}
|
|
|
|
|
|
|
|
Animation::InterpolationType Animation::track_get_interpolation_type(int p_track) const {
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_INDEX_V(p_track, tracks.size(), INTERPOLATION_NEAREST);
|
2014-02-10 02:10:30 +01:00
|
|
|
return tracks[p_track]->interpolation;
|
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
void Animation::track_set_interpolation_loop_wrap(int p_track, bool p_enable) {
|
2017-01-09 04:41:16 +01:00
|
|
|
ERR_FAIL_INDEX(p_track, tracks.size());
|
2017-03-05 16:44:50 +01:00
|
|
|
tracks[p_track]->loop_wrap = p_enable;
|
2017-01-09 04:41:16 +01:00
|
|
|
emit_changed();
|
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
bool Animation::track_get_interpolation_loop_wrap(int p_track) const {
|
2017-01-09 04:41:16 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_INDEX_V(p_track, tracks.size(), INTERPOLATION_NEAREST);
|
2017-01-09 04:41:16 +01:00
|
|
|
return tracks[p_track]->loop_wrap;
|
|
|
|
}
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
// transform
|
|
|
|
/*
|
|
|
|
template<class T>
|
|
|
|
int Animation::_insert_pos(float p_time, T& p_keys) {
|
|
|
|
|
|
|
|
// simple, linear time inset that should be fast enough in reality.
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
int idx=p_keys.size();
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
while(true) {
|
2016-03-09 00:00:52 +01:00
|
|
|
|
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
if (idx==0 || p_keys[idx-1].time < p_time) {
|
|
|
|
//condition for insertion.
|
|
|
|
p_keys.insert(idx,T());
|
|
|
|
return idx;
|
|
|
|
} else if (p_keys[idx-1].time == p_time) {
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
// condition for replacing.
|
|
|
|
return idx-1;
|
2016-03-09 00:00:52 +01:00
|
|
|
}
|
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
idx--;
|
|
|
|
}
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
*/
|
2017-03-05 16:44:50 +01:00
|
|
|
template <class T, class V>
|
|
|
|
int Animation::_insert(float p_time, T &p_keys, const V &p_value) {
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
int idx = p_keys.size();
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
while (true) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2019-01-15 16:36:22 +01:00
|
|
|
// Condition for replacement.
|
|
|
|
if (idx > 0 && Math::is_equal_approx(p_keys[idx - 1].time, p_time)) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2018-07-25 03:11:03 +02:00
|
|
|
p_keys.write[idx - 1] = p_value;
|
2017-03-05 16:44:50 +01:00
|
|
|
return idx - 1;
|
2019-01-15 16:36:22 +01:00
|
|
|
|
|
|
|
// Condition for insert.
|
|
|
|
} else if (idx == 0 || p_keys[idx - 1].time < p_time) {
|
|
|
|
|
|
|
|
p_keys.insert(idx, p_value);
|
|
|
|
return idx;
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
idx--;
|
|
|
|
}
|
|
|
|
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
template <class T>
|
|
|
|
void Animation::_clear(T &p_keys) {
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
p_keys.clear();
|
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
Error Animation::transform_track_get_key(int p_track, int p_key, Vector3 *r_loc, Quat *r_rot, Vector3 *r_scale) const {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_INDEX_V(p_track, tracks.size(), ERR_INVALID_PARAMETER);
|
|
|
|
Track *t = tracks[p_track];
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
TransformTrack *tt = static_cast<TransformTrack *>(t);
|
|
|
|
ERR_FAIL_COND_V(t->type != TYPE_TRANSFORM, ERR_INVALID_PARAMETER);
|
|
|
|
ERR_FAIL_INDEX_V(p_key, tt->transforms.size(), ERR_INVALID_PARAMETER);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
if (r_loc)
|
2017-03-05 16:44:50 +01:00
|
|
|
*r_loc = tt->transforms[p_key].value.loc;
|
2014-02-10 02:10:30 +01:00
|
|
|
if (r_rot)
|
2017-03-05 16:44:50 +01:00
|
|
|
*r_rot = tt->transforms[p_key].value.rot;
|
2014-02-10 02:10:30 +01:00
|
|
|
if (r_scale)
|
2017-03-05 16:44:50 +01:00
|
|
|
*r_scale = tt->transforms[p_key].value.scale;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
return OK;
|
|
|
|
}
|
|
|
|
|
2019-07-10 11:54:12 +02:00
|
|
|
int Animation::transform_track_insert_key(int p_track, float p_time, const Vector3 &p_loc, const Quat &p_rot, const Vector3 &p_scale) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_INDEX_V(p_track, tracks.size(), -1);
|
|
|
|
Track *t = tracks[p_track];
|
|
|
|
ERR_FAIL_COND_V(t->type != TYPE_TRANSFORM, -1);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
TransformTrack *tt = static_cast<TransformTrack *>(t);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
TKey<TransformKey> tkey;
|
2017-03-05 16:44:50 +01:00
|
|
|
tkey.time = p_time;
|
|
|
|
tkey.value.loc = p_loc;
|
|
|
|
tkey.value.rot = p_rot;
|
|
|
|
tkey.value.scale = p_scale;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
int ret = _insert(p_time, tt->transforms, tkey);
|
2014-02-10 02:10:30 +01:00
|
|
|
emit_changed();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2017-09-10 15:37:49 +02:00
|
|
|
void Animation::track_remove_key_at_position(int p_track, float p_pos) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
int idx = track_find_key(p_track, p_pos, true);
|
2014-02-10 02:10:30 +01:00
|
|
|
ERR_FAIL_COND(idx < 0);
|
2017-03-05 16:44:50 +01:00
|
|
|
track_remove_key(p_track, idx);
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void Animation::track_remove_key(int p_track, int p_idx) {
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_INDEX(p_track, tracks.size());
|
|
|
|
Track *t = tracks[p_track];
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
switch (t->type) {
|
2014-02-10 02:10:30 +01:00
|
|
|
case TYPE_TRANSFORM: {
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
TransformTrack *tt = static_cast<TransformTrack *>(t);
|
|
|
|
ERR_FAIL_INDEX(p_idx, tt->transforms.size());
|
2014-02-10 02:10:30 +01:00
|
|
|
tt->transforms.remove(p_idx);
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case TYPE_VALUE: {
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ValueTrack *vt = static_cast<ValueTrack *>(t);
|
|
|
|
ERR_FAIL_INDEX(p_idx, vt->values.size());
|
2014-02-10 02:10:30 +01:00
|
|
|
vt->values.remove(p_idx);
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case TYPE_METHOD: {
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
MethodTrack *mt = static_cast<MethodTrack *>(t);
|
|
|
|
ERR_FAIL_INDEX(p_idx, mt->methods.size());
|
2014-02-10 02:10:30 +01:00
|
|
|
mt->methods.remove(p_idx);
|
|
|
|
|
|
|
|
} break;
|
2018-06-07 17:46:14 +02:00
|
|
|
case TYPE_BEZIER: {
|
|
|
|
|
|
|
|
BezierTrack *bz = static_cast<BezierTrack *>(t);
|
|
|
|
ERR_FAIL_INDEX(p_idx, bz->values.size());
|
|
|
|
bz->values.remove(p_idx);
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case TYPE_AUDIO: {
|
|
|
|
|
|
|
|
AudioTrack *ad = static_cast<AudioTrack *>(t);
|
|
|
|
ERR_FAIL_INDEX(p_idx, ad->values.size());
|
|
|
|
ad->values.remove(p_idx);
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case TYPE_ANIMATION: {
|
|
|
|
|
|
|
|
AnimationTrack *an = static_cast<AnimationTrack *>(t);
|
|
|
|
ERR_FAIL_INDEX(p_idx, an->values.size());
|
|
|
|
an->values.remove(p_idx);
|
|
|
|
|
|
|
|
} break;
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
emit_changed();
|
|
|
|
}
|
|
|
|
|
|
|
|
int Animation::track_find_key(int p_track, float p_time, bool p_exact) const {
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_INDEX_V(p_track, tracks.size(), -1);
|
|
|
|
Track *t = tracks[p_track];
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
switch (t->type) {
|
2014-02-10 02:10:30 +01:00
|
|
|
case TYPE_TRANSFORM: {
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
TransformTrack *tt = static_cast<TransformTrack *>(t);
|
|
|
|
int k = _find(tt->transforms, p_time);
|
|
|
|
if (k < 0 || k >= tt->transforms.size())
|
2014-02-10 02:10:30 +01:00
|
|
|
return -1;
|
2017-03-05 16:44:50 +01:00
|
|
|
if (tt->transforms[k].time != p_time && p_exact)
|
2014-02-10 02:10:30 +01:00
|
|
|
return -1;
|
|
|
|
return k;
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case TYPE_VALUE: {
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ValueTrack *vt = static_cast<ValueTrack *>(t);
|
|
|
|
int k = _find(vt->values, p_time);
|
|
|
|
if (k < 0 || k >= vt->values.size())
|
2014-02-10 02:10:30 +01:00
|
|
|
return -1;
|
2017-03-05 16:44:50 +01:00
|
|
|
if (vt->values[k].time != p_time && p_exact)
|
2014-02-10 02:10:30 +01:00
|
|
|
return -1;
|
|
|
|
return k;
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case TYPE_METHOD: {
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
MethodTrack *mt = static_cast<MethodTrack *>(t);
|
|
|
|
int k = _find(mt->methods, p_time);
|
|
|
|
if (k < 0 || k >= mt->methods.size())
|
2014-02-10 02:10:30 +01:00
|
|
|
return -1;
|
2017-03-05 16:44:50 +01:00
|
|
|
if (mt->methods[k].time != p_time && p_exact)
|
2014-02-10 02:10:30 +01:00
|
|
|
return -1;
|
|
|
|
return k;
|
|
|
|
|
|
|
|
} break;
|
2018-06-07 17:46:14 +02:00
|
|
|
case TYPE_BEZIER: {
|
|
|
|
|
|
|
|
BezierTrack *bt = static_cast<BezierTrack *>(t);
|
|
|
|
int k = _find(bt->values, p_time);
|
|
|
|
if (k < 0 || k >= bt->values.size())
|
|
|
|
return -1;
|
|
|
|
if (bt->values[k].time != p_time && p_exact)
|
|
|
|
return -1;
|
|
|
|
return k;
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case TYPE_AUDIO: {
|
|
|
|
|
|
|
|
AudioTrack *at = static_cast<AudioTrack *>(t);
|
|
|
|
int k = _find(at->values, p_time);
|
|
|
|
if (k < 0 || k >= at->values.size())
|
|
|
|
return -1;
|
|
|
|
if (at->values[k].time != p_time && p_exact)
|
|
|
|
return -1;
|
|
|
|
return k;
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case TYPE_ANIMATION: {
|
|
|
|
|
|
|
|
AnimationTrack *at = static_cast<AnimationTrack *>(t);
|
|
|
|
int k = _find(at->values, p_time);
|
|
|
|
if (k < 0 || k >= at->values.size())
|
|
|
|
return -1;
|
|
|
|
if (at->values[k].time != p_time && p_exact)
|
|
|
|
return -1;
|
|
|
|
return k;
|
|
|
|
|
|
|
|
} break;
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2017-08-11 21:10:05 +02:00
|
|
|
void Animation::track_insert_key(int p_track, float p_time, const Variant &p_key, float p_transition) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
ERR_FAIL_INDEX(p_track, tracks.size());
|
2017-03-05 16:44:50 +01:00
|
|
|
Track *t = tracks[p_track];
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
switch (t->type) {
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
case TYPE_TRANSFORM: {
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2017-08-11 21:10:05 +02:00
|
|
|
Dictionary d = p_key;
|
2014-02-10 02:10:30 +01:00
|
|
|
Vector3 loc;
|
2017-09-10 15:37:49 +02:00
|
|
|
if (d.has("location"))
|
|
|
|
loc = d["location"];
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
Quat rot;
|
2017-09-10 15:37:49 +02:00
|
|
|
if (d.has("rotation"))
|
|
|
|
rot = d["rotation"];
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
Vector3 scale;
|
|
|
|
if (d.has("scale"))
|
2017-03-05 16:44:50 +01:00
|
|
|
scale = d["scale"];
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
int idx = transform_track_insert_key(p_track, p_time, loc, rot, scale);
|
|
|
|
track_set_key_transition(p_track, idx, p_transition);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
} break;
|
|
|
|
case TYPE_VALUE: {
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ValueTrack *vt = static_cast<ValueTrack *>(t);
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
TKey<Variant> k;
|
|
|
|
k.time = p_time;
|
|
|
|
k.transition = p_transition;
|
2017-08-11 21:10:05 +02:00
|
|
|
k.value = p_key;
|
2017-03-05 16:44:50 +01:00
|
|
|
_insert(p_time, vt->values, k);
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
} break;
|
|
|
|
case TYPE_METHOD: {
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
MethodTrack *mt = static_cast<MethodTrack *>(t);
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2017-08-11 21:10:05 +02:00
|
|
|
ERR_FAIL_COND(p_key.get_type() != Variant::DICTIONARY);
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2017-08-11 21:10:05 +02:00
|
|
|
Dictionary d = p_key;
|
2020-02-20 22:58:05 +01:00
|
|
|
ERR_FAIL_COND(!d.has("method") || (d["method"].get_type() != Variant::STRING_NAME && d["method"].get_type() != Variant::STRING));
|
2014-02-10 02:10:30 +01:00
|
|
|
ERR_FAIL_COND(!d.has("args") || !d["args"].is_array());
|
|
|
|
|
|
|
|
MethodKey k;
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
k.time = p_time;
|
|
|
|
k.transition = p_transition;
|
|
|
|
k.method = d["method"];
|
|
|
|
k.params = d["args"];
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
_insert(p_time, mt->methods, k);
|
2016-03-09 00:00:52 +01:00
|
|
|
|
|
|
|
} break;
|
2018-06-07 17:46:14 +02:00
|
|
|
case TYPE_BEZIER: {
|
|
|
|
|
|
|
|
BezierTrack *bt = static_cast<BezierTrack *>(t);
|
|
|
|
|
|
|
|
Array arr = p_key;
|
|
|
|
ERR_FAIL_COND(arr.size() != 5);
|
|
|
|
|
|
|
|
TKey<BezierKey> k;
|
|
|
|
k.time = p_time;
|
|
|
|
k.value.value = arr[0];
|
|
|
|
k.value.in_handle.x = arr[1];
|
|
|
|
k.value.in_handle.y = arr[2];
|
|
|
|
k.value.out_handle.x = arr[3];
|
|
|
|
k.value.out_handle.y = arr[4];
|
|
|
|
_insert(p_time, bt->values, k);
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case TYPE_AUDIO: {
|
|
|
|
|
|
|
|
AudioTrack *at = static_cast<AudioTrack *>(t);
|
|
|
|
|
|
|
|
Dictionary k = p_key;
|
|
|
|
ERR_FAIL_COND(!k.has("start_offset"));
|
|
|
|
ERR_FAIL_COND(!k.has("end_offset"));
|
|
|
|
ERR_FAIL_COND(!k.has("stream"));
|
|
|
|
|
|
|
|
TKey<AudioKey> ak;
|
|
|
|
ak.time = p_time;
|
|
|
|
ak.value.start_offset = k["start_offset"];
|
|
|
|
ak.value.end_offset = k["end_offset"];
|
|
|
|
ak.value.stream = k["stream"];
|
|
|
|
_insert(p_time, at->values, ak);
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case TYPE_ANIMATION: {
|
|
|
|
|
|
|
|
AnimationTrack *at = static_cast<AnimationTrack *>(t);
|
|
|
|
|
|
|
|
TKey<StringName> ak;
|
|
|
|
ak.time = p_time;
|
|
|
|
ak.value = p_key;
|
|
|
|
|
|
|
|
_insert(p_time, at->values, ak);
|
|
|
|
|
|
|
|
} break;
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
emit_changed();
|
|
|
|
}
|
|
|
|
|
|
|
|
int Animation::track_get_key_count(int p_track) const {
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_INDEX_V(p_track, tracks.size(), -1);
|
|
|
|
Track *t = tracks[p_track];
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
switch (t->type) {
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
case TYPE_TRANSFORM: {
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
TransformTrack *tt = static_cast<TransformTrack *>(t);
|
2014-02-10 02:10:30 +01:00
|
|
|
return tt->transforms.size();
|
|
|
|
} break;
|
|
|
|
case TYPE_VALUE: {
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ValueTrack *vt = static_cast<ValueTrack *>(t);
|
2014-02-10 02:10:30 +01:00
|
|
|
return vt->values.size();
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
} break;
|
|
|
|
case TYPE_METHOD: {
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
MethodTrack *mt = static_cast<MethodTrack *>(t);
|
2014-02-10 02:10:30 +01:00
|
|
|
return mt->methods.size();
|
2016-03-09 00:00:52 +01:00
|
|
|
} break;
|
2018-06-07 17:46:14 +02:00
|
|
|
case TYPE_BEZIER: {
|
|
|
|
|
|
|
|
BezierTrack *bt = static_cast<BezierTrack *>(t);
|
|
|
|
return bt->values.size();
|
|
|
|
} break;
|
|
|
|
case TYPE_AUDIO: {
|
|
|
|
|
|
|
|
AudioTrack *at = static_cast<AudioTrack *>(t);
|
|
|
|
return at->values.size();
|
|
|
|
} break;
|
|
|
|
case TYPE_ANIMATION: {
|
|
|
|
|
|
|
|
AnimationTrack *at = static_cast<AnimationTrack *>(t);
|
|
|
|
return at->values.size();
|
|
|
|
} break;
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
ERR_FAIL_V(-1);
|
|
|
|
}
|
|
|
|
|
|
|
|
Variant Animation::track_get_key_value(int p_track, int p_key_idx) const {
|
|
|
|
|
|
|
|
ERR_FAIL_INDEX_V(p_track, tracks.size(), Variant());
|
2017-03-05 16:44:50 +01:00
|
|
|
Track *t = tracks[p_track];
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
switch (t->type) {
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
case TYPE_TRANSFORM: {
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
TransformTrack *tt = static_cast<TransformTrack *>(t);
|
|
|
|
ERR_FAIL_INDEX_V(p_key_idx, tt->transforms.size(), Variant());
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
Dictionary d;
|
2017-09-10 15:37:49 +02:00
|
|
|
d["location"] = tt->transforms[p_key_idx].value.loc;
|
|
|
|
d["rotation"] = tt->transforms[p_key_idx].value.rot;
|
2017-03-05 16:44:50 +01:00
|
|
|
d["scale"] = tt->transforms[p_key_idx].value.scale;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
return d;
|
|
|
|
} break;
|
|
|
|
case TYPE_VALUE: {
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ValueTrack *vt = static_cast<ValueTrack *>(t);
|
|
|
|
ERR_FAIL_INDEX_V(p_key_idx, vt->values.size(), Variant());
|
2014-02-10 02:10:30 +01:00
|
|
|
return vt->values[p_key_idx].value;
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case TYPE_METHOD: {
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
MethodTrack *mt = static_cast<MethodTrack *>(t);
|
|
|
|
ERR_FAIL_INDEX_V(p_key_idx, mt->methods.size(), Variant());
|
2014-02-10 02:10:30 +01:00
|
|
|
Dictionary d;
|
2017-03-05 16:44:50 +01:00
|
|
|
d["method"] = mt->methods[p_key_idx].method;
|
|
|
|
d["args"] = mt->methods[p_key_idx].params;
|
2016-03-09 00:00:52 +01:00
|
|
|
return d;
|
|
|
|
|
|
|
|
} break;
|
2018-06-07 17:46:14 +02:00
|
|
|
case TYPE_BEZIER: {
|
|
|
|
|
|
|
|
BezierTrack *bt = static_cast<BezierTrack *>(t);
|
|
|
|
ERR_FAIL_INDEX_V(p_key_idx, bt->values.size(), Variant());
|
|
|
|
|
|
|
|
Array arr;
|
|
|
|
arr.resize(5);
|
|
|
|
arr[0] = bt->values[p_key_idx].value.value;
|
|
|
|
arr[1] = bt->values[p_key_idx].value.in_handle.x;
|
|
|
|
arr[2] = bt->values[p_key_idx].value.in_handle.y;
|
|
|
|
arr[3] = bt->values[p_key_idx].value.out_handle.x;
|
|
|
|
arr[4] = bt->values[p_key_idx].value.out_handle.y;
|
|
|
|
return arr;
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case TYPE_AUDIO: {
|
|
|
|
|
|
|
|
AudioTrack *at = static_cast<AudioTrack *>(t);
|
|
|
|
ERR_FAIL_INDEX_V(p_key_idx, at->values.size(), Variant());
|
|
|
|
|
|
|
|
Dictionary k;
|
|
|
|
k["start_offset"] = at->values[p_key_idx].value.start_offset;
|
|
|
|
k["end_offset"] = at->values[p_key_idx].value.end_offset;
|
|
|
|
k["stream"] = at->values[p_key_idx].value.stream;
|
|
|
|
return k;
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case TYPE_ANIMATION: {
|
|
|
|
|
|
|
|
AnimationTrack *at = static_cast<AnimationTrack *>(t);
|
|
|
|
ERR_FAIL_INDEX_V(p_key_idx, at->values.size(), Variant());
|
|
|
|
|
|
|
|
return at->values[p_key_idx].value;
|
|
|
|
|
|
|
|
} break;
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
ERR_FAIL_V(Variant());
|
|
|
|
}
|
|
|
|
|
|
|
|
float Animation::track_get_key_time(int p_track, int p_key_idx) const {
|
|
|
|
|
|
|
|
ERR_FAIL_INDEX_V(p_track, tracks.size(), -1);
|
2017-03-05 16:44:50 +01:00
|
|
|
Track *t = tracks[p_track];
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
switch (t->type) {
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
case TYPE_TRANSFORM: {
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
TransformTrack *tt = static_cast<TransformTrack *>(t);
|
|
|
|
ERR_FAIL_INDEX_V(p_key_idx, tt->transforms.size(), -1);
|
2014-02-10 02:10:30 +01:00
|
|
|
return tt->transforms[p_key_idx].time;
|
|
|
|
} break;
|
|
|
|
case TYPE_VALUE: {
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ValueTrack *vt = static_cast<ValueTrack *>(t);
|
|
|
|
ERR_FAIL_INDEX_V(p_key_idx, vt->values.size(), -1);
|
2014-02-10 02:10:30 +01:00
|
|
|
return vt->values[p_key_idx].time;
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case TYPE_METHOD: {
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
MethodTrack *mt = static_cast<MethodTrack *>(t);
|
|
|
|
ERR_FAIL_INDEX_V(p_key_idx, mt->methods.size(), -1);
|
2014-02-10 02:10:30 +01:00
|
|
|
return mt->methods[p_key_idx].time;
|
2016-03-09 00:00:52 +01:00
|
|
|
|
|
|
|
} break;
|
2018-06-07 17:46:14 +02:00
|
|
|
case TYPE_BEZIER: {
|
|
|
|
|
|
|
|
BezierTrack *bt = static_cast<BezierTrack *>(t);
|
|
|
|
ERR_FAIL_INDEX_V(p_key_idx, bt->values.size(), -1);
|
|
|
|
return bt->values[p_key_idx].time;
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case TYPE_AUDIO: {
|
|
|
|
|
|
|
|
AudioTrack *at = static_cast<AudioTrack *>(t);
|
|
|
|
ERR_FAIL_INDEX_V(p_key_idx, at->values.size(), -1);
|
|
|
|
return at->values[p_key_idx].time;
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case TYPE_ANIMATION: {
|
|
|
|
|
|
|
|
AnimationTrack *at = static_cast<AnimationTrack *>(t);
|
|
|
|
ERR_FAIL_INDEX_V(p_key_idx, at->values.size(), -1);
|
|
|
|
return at->values[p_key_idx].time;
|
|
|
|
|
|
|
|
} break;
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
ERR_FAIL_V(-1);
|
|
|
|
}
|
|
|
|
|
2019-05-31 00:39:00 +02:00
|
|
|
void Animation::track_set_key_time(int p_track, int p_key_idx, float p_time) {
|
|
|
|
|
|
|
|
ERR_FAIL_INDEX(p_track, tracks.size());
|
|
|
|
Track *t = tracks[p_track];
|
|
|
|
|
|
|
|
switch (t->type) {
|
|
|
|
|
|
|
|
case TYPE_TRANSFORM: {
|
|
|
|
|
|
|
|
TransformTrack *tt = static_cast<TransformTrack *>(t);
|
|
|
|
ERR_FAIL_INDEX(p_key_idx, tt->transforms.size());
|
|
|
|
TKey<TransformKey> key = tt->transforms[p_key_idx];
|
|
|
|
key.time = p_time;
|
|
|
|
tt->transforms.remove(p_key_idx);
|
|
|
|
_insert(p_time, tt->transforms, key);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
case TYPE_VALUE: {
|
|
|
|
|
|
|
|
ValueTrack *vt = static_cast<ValueTrack *>(t);
|
|
|
|
ERR_FAIL_INDEX(p_key_idx, vt->values.size());
|
|
|
|
TKey<Variant> key = vt->values[p_key_idx];
|
|
|
|
key.time = p_time;
|
|
|
|
vt->values.remove(p_key_idx);
|
|
|
|
_insert(p_time, vt->values, key);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
case TYPE_METHOD: {
|
|
|
|
|
|
|
|
MethodTrack *mt = static_cast<MethodTrack *>(t);
|
|
|
|
ERR_FAIL_INDEX(p_key_idx, mt->methods.size());
|
|
|
|
MethodKey key = mt->methods[p_key_idx];
|
|
|
|
key.time = p_time;
|
|
|
|
mt->methods.remove(p_key_idx);
|
|
|
|
_insert(p_time, mt->methods, key);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
case TYPE_BEZIER: {
|
|
|
|
|
|
|
|
BezierTrack *bt = static_cast<BezierTrack *>(t);
|
|
|
|
ERR_FAIL_INDEX(p_key_idx, bt->values.size());
|
|
|
|
TKey<BezierKey> key = bt->values[p_key_idx];
|
|
|
|
key.time = p_time;
|
|
|
|
bt->values.remove(p_key_idx);
|
|
|
|
_insert(p_time, bt->values, key);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
case TYPE_AUDIO: {
|
|
|
|
|
|
|
|
AudioTrack *at = static_cast<AudioTrack *>(t);
|
|
|
|
ERR_FAIL_INDEX(p_key_idx, at->values.size());
|
|
|
|
TKey<AudioKey> key = at->values[p_key_idx];
|
|
|
|
key.time = p_time;
|
|
|
|
at->values.remove(p_key_idx);
|
|
|
|
_insert(p_time, at->values, key);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
case TYPE_ANIMATION: {
|
|
|
|
|
|
|
|
AnimationTrack *at = static_cast<AnimationTrack *>(t);
|
|
|
|
ERR_FAIL_INDEX(p_key_idx, at->values.size());
|
|
|
|
TKey<StringName> key = at->values[p_key_idx];
|
|
|
|
key.time = p_time;
|
|
|
|
at->values.remove(p_key_idx);
|
|
|
|
_insert(p_time, at->values, key);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ERR_FAIL();
|
|
|
|
}
|
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
float Animation::track_get_key_transition(int p_track, int p_key_idx) const {
|
|
|
|
|
|
|
|
ERR_FAIL_INDEX_V(p_track, tracks.size(), -1);
|
2017-03-05 16:44:50 +01:00
|
|
|
Track *t = tracks[p_track];
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
switch (t->type) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
case TYPE_TRANSFORM: {
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
TransformTrack *tt = static_cast<TransformTrack *>(t);
|
|
|
|
ERR_FAIL_INDEX_V(p_key_idx, tt->transforms.size(), -1);
|
2014-02-10 02:10:30 +01:00
|
|
|
return tt->transforms[p_key_idx].transition;
|
|
|
|
} break;
|
|
|
|
case TYPE_VALUE: {
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ValueTrack *vt = static_cast<ValueTrack *>(t);
|
|
|
|
ERR_FAIL_INDEX_V(p_key_idx, vt->values.size(), -1);
|
2014-02-10 02:10:30 +01:00
|
|
|
return vt->values[p_key_idx].transition;
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case TYPE_METHOD: {
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
MethodTrack *mt = static_cast<MethodTrack *>(t);
|
|
|
|
ERR_FAIL_INDEX_V(p_key_idx, mt->methods.size(), -1);
|
2014-02-10 02:10:30 +01:00
|
|
|
return mt->methods[p_key_idx].transition;
|
|
|
|
|
|
|
|
} break;
|
2018-06-07 17:46:14 +02:00
|
|
|
case TYPE_BEZIER: {
|
|
|
|
|
|
|
|
return 1; //bezier does not really use transitions
|
|
|
|
} break;
|
|
|
|
case TYPE_AUDIO: {
|
|
|
|
|
|
|
|
return 1; //audio does not really use transitions
|
|
|
|
} break;
|
|
|
|
case TYPE_ANIMATION: {
|
|
|
|
|
|
|
|
return 1; //animation does not really use transitions
|
|
|
|
} break;
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
ERR_FAIL_V(0);
|
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
void Animation::track_set_key_value(int p_track, int p_key_idx, const Variant &p_value) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
ERR_FAIL_INDEX(p_track, tracks.size());
|
2017-03-05 16:44:50 +01:00
|
|
|
Track *t = tracks[p_track];
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
switch (t->type) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
case TYPE_TRANSFORM: {
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
TransformTrack *tt = static_cast<TransformTrack *>(t);
|
|
|
|
ERR_FAIL_INDEX(p_key_idx, tt->transforms.size());
|
2019-06-18 22:12:32 +02:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
Dictionary d = p_value;
|
2019-06-18 22:12:32 +02:00
|
|
|
|
2017-09-10 15:37:49 +02:00
|
|
|
if (d.has("location"))
|
2018-07-25 03:11:03 +02:00
|
|
|
tt->transforms.write[p_key_idx].value.loc = d["location"];
|
2017-09-10 15:37:49 +02:00
|
|
|
if (d.has("rotation"))
|
2018-07-25 03:11:03 +02:00
|
|
|
tt->transforms.write[p_key_idx].value.rot = d["rotation"];
|
2014-02-10 02:10:30 +01:00
|
|
|
if (d.has("scale"))
|
2018-07-25 03:11:03 +02:00
|
|
|
tt->transforms.write[p_key_idx].value.scale = d["scale"];
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
} break;
|
|
|
|
case TYPE_VALUE: {
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ValueTrack *vt = static_cast<ValueTrack *>(t);
|
|
|
|
ERR_FAIL_INDEX(p_key_idx, vt->values.size());
|
2019-06-18 22:12:32 +02:00
|
|
|
|
2018-07-25 03:11:03 +02:00
|
|
|
vt->values.write[p_key_idx].value = p_value;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
} break;
|
|
|
|
case TYPE_METHOD: {
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
MethodTrack *mt = static_cast<MethodTrack *>(t);
|
|
|
|
ERR_FAIL_INDEX(p_key_idx, mt->methods.size());
|
2019-06-18 22:12:32 +02:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
Dictionary d = p_value;
|
2019-06-18 22:12:32 +02:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
if (d.has("method"))
|
2018-07-25 03:11:03 +02:00
|
|
|
mt->methods.write[p_key_idx].method = d["method"];
|
2014-02-10 02:10:30 +01:00
|
|
|
if (d.has("args"))
|
2018-07-25 03:11:03 +02:00
|
|
|
mt->methods.write[p_key_idx].params = d["args"];
|
2019-06-18 22:12:32 +02:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
} break;
|
2018-06-07 17:46:14 +02:00
|
|
|
case TYPE_BEZIER: {
|
|
|
|
|
|
|
|
BezierTrack *bt = static_cast<BezierTrack *>(t);
|
|
|
|
ERR_FAIL_INDEX(p_key_idx, bt->values.size());
|
|
|
|
|
|
|
|
Array arr = p_value;
|
|
|
|
ERR_FAIL_COND(arr.size() != 5);
|
|
|
|
|
2018-07-25 03:11:03 +02:00
|
|
|
bt->values.write[p_key_idx].value.value = arr[0];
|
|
|
|
bt->values.write[p_key_idx].value.in_handle.x = arr[1];
|
|
|
|
bt->values.write[p_key_idx].value.in_handle.y = arr[2];
|
|
|
|
bt->values.write[p_key_idx].value.out_handle.x = arr[3];
|
|
|
|
bt->values.write[p_key_idx].value.out_handle.y = arr[4];
|
2018-06-07 17:46:14 +02:00
|
|
|
|
|
|
|
} break;
|
|
|
|
case TYPE_AUDIO: {
|
|
|
|
|
|
|
|
AudioTrack *at = static_cast<AudioTrack *>(t);
|
2019-06-18 22:12:32 +02:00
|
|
|
ERR_FAIL_INDEX(p_key_idx, at->values.size());
|
2018-06-07 17:46:14 +02:00
|
|
|
|
|
|
|
Dictionary k = p_value;
|
|
|
|
ERR_FAIL_COND(!k.has("start_offset"));
|
|
|
|
ERR_FAIL_COND(!k.has("end_offset"));
|
|
|
|
ERR_FAIL_COND(!k.has("stream"));
|
|
|
|
|
2018-07-25 03:11:03 +02:00
|
|
|
at->values.write[p_key_idx].value.start_offset = k["start_offset"];
|
|
|
|
at->values.write[p_key_idx].value.end_offset = k["end_offset"];
|
|
|
|
at->values.write[p_key_idx].value.stream = k["stream"];
|
2018-06-07 17:46:14 +02:00
|
|
|
|
|
|
|
} break;
|
|
|
|
case TYPE_ANIMATION: {
|
|
|
|
|
|
|
|
AnimationTrack *at = static_cast<AnimationTrack *>(t);
|
2019-06-18 22:12:32 +02:00
|
|
|
ERR_FAIL_INDEX(p_key_idx, at->values.size());
|
2018-06-07 17:46:14 +02:00
|
|
|
|
2018-07-25 03:11:03 +02:00
|
|
|
at->values.write[p_key_idx].value = p_value;
|
2018-06-07 17:46:14 +02:00
|
|
|
|
|
|
|
} break;
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
2019-02-14 14:19:03 +01:00
|
|
|
|
|
|
|
emit_changed();
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
void Animation::track_set_key_transition(int p_track, int p_key_idx, float p_transition) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
ERR_FAIL_INDEX(p_track, tracks.size());
|
2017-03-05 16:44:50 +01:00
|
|
|
Track *t = tracks[p_track];
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
switch (t->type) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
case TYPE_TRANSFORM: {
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
TransformTrack *tt = static_cast<TransformTrack *>(t);
|
|
|
|
ERR_FAIL_INDEX(p_key_idx, tt->transforms.size());
|
2018-07-25 03:11:03 +02:00
|
|
|
tt->transforms.write[p_key_idx].transition = p_transition;
|
2014-02-10 02:10:30 +01:00
|
|
|
} break;
|
|
|
|
case TYPE_VALUE: {
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ValueTrack *vt = static_cast<ValueTrack *>(t);
|
|
|
|
ERR_FAIL_INDEX(p_key_idx, vt->values.size());
|
2018-07-25 03:11:03 +02:00
|
|
|
vt->values.write[p_key_idx].transition = p_transition;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
} break;
|
|
|
|
case TYPE_METHOD: {
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
MethodTrack *mt = static_cast<MethodTrack *>(t);
|
|
|
|
ERR_FAIL_INDEX(p_key_idx, mt->methods.size());
|
2018-07-25 03:11:03 +02:00
|
|
|
mt->methods.write[p_key_idx].transition = p_transition;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
} break;
|
2018-06-07 17:46:14 +02:00
|
|
|
case TYPE_BEZIER:
|
|
|
|
case TYPE_AUDIO:
|
|
|
|
case TYPE_ANIMATION: {
|
2018-09-13 03:38:39 +02:00
|
|
|
// they don't use transition
|
2018-06-07 17:46:14 +02:00
|
|
|
} break;
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
2019-02-14 14:19:03 +01:00
|
|
|
|
|
|
|
emit_changed();
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
template <class K>
|
|
|
|
int Animation::_find(const Vector<K> &p_keys, float p_time) const {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
int len = p_keys.size();
|
|
|
|
if (len == 0)
|
2014-02-10 02:10:30 +01:00
|
|
|
return -2;
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
int low = 0;
|
2017-03-05 16:44:50 +01:00
|
|
|
int high = len - 1;
|
2017-09-01 22:33:39 +02:00
|
|
|
int middle = 0;
|
|
|
|
|
2019-04-05 23:20:20 +02:00
|
|
|
#ifdef DEBUG_ENABLED
|
2017-09-01 22:33:39 +02:00
|
|
|
if (low > high)
|
|
|
|
ERR_PRINT("low > high, this may be a bug");
|
|
|
|
#endif
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
const K *keys = &p_keys[0];
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
while (low <= high) {
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
middle = (low + high) / 2;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2019-04-25 19:19:14 +02:00
|
|
|
if (Math::is_equal_approx(p_time, keys[middle].time)) { //match
|
2014-02-10 02:10:30 +01:00
|
|
|
return middle;
|
2017-03-05 16:44:50 +01:00
|
|
|
} else if (p_time < keys[middle].time)
|
2014-02-10 02:10:30 +01:00
|
|
|
high = middle - 1; //search low end of array
|
|
|
|
else
|
|
|
|
low = middle + 1; //search high end of array
|
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
if (keys[middle].time > p_time)
|
2014-02-10 02:10:30 +01:00
|
|
|
middle--;
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
return middle;
|
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
Animation::TransformKey Animation::_interpolate(const Animation::TransformKey &p_a, const Animation::TransformKey &p_b, float p_c) const {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
TransformKey ret;
|
2017-03-05 16:44:50 +01:00
|
|
|
ret.loc = _interpolate(p_a.loc, p_b.loc, p_c);
|
|
|
|
ret.rot = _interpolate(p_a.rot, p_b.rot, p_c);
|
|
|
|
ret.scale = _interpolate(p_a.scale, p_b.scale, p_c);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
Vector3 Animation::_interpolate(const Vector3 &p_a, const Vector3 &p_b, float p_c) const {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
return p_a.linear_interpolate(p_b, p_c);
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
2017-03-05 16:44:50 +01:00
|
|
|
Quat Animation::_interpolate(const Quat &p_a, const Quat &p_b, float p_c) const {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
return p_a.slerp(p_b, p_c);
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
2017-03-05 16:44:50 +01:00
|
|
|
Variant Animation::_interpolate(const Variant &p_a, const Variant &p_b, float p_c) const {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
Variant dst;
|
2017-03-05 16:44:50 +01:00
|
|
|
Variant::interpolate(p_a, p_b, p_c, dst);
|
2014-02-10 02:10:30 +01:00
|
|
|
return dst;
|
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
float Animation::_interpolate(const float &p_a, const float &p_b, float p_c) const {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
return p_a * (1.0 - p_c) + p_b * p_c;
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
Animation::TransformKey Animation::_cubic_interpolate(const Animation::TransformKey &p_pre_a, const Animation::TransformKey &p_a, const Animation::TransformKey &p_b, const Animation::TransformKey &p_post_b, float p_c) const {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
Animation::TransformKey tk;
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
tk.loc = p_a.loc.cubic_interpolate(p_b.loc, p_pre_a.loc, p_post_b.loc, p_c);
|
|
|
|
tk.scale = p_a.scale.cubic_interpolate(p_b.scale, p_pre_a.scale, p_post_b.scale, p_c);
|
|
|
|
tk.rot = p_a.rot.cubic_slerp(p_b.rot, p_pre_a.rot, p_post_b.rot, p_c);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
return tk;
|
|
|
|
}
|
2017-03-05 16:44:50 +01:00
|
|
|
Vector3 Animation::_cubic_interpolate(const Vector3 &p_pre_a, const Vector3 &p_a, const Vector3 &p_b, const Vector3 &p_post_b, float p_c) const {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
return p_a.cubic_interpolate(p_b, p_pre_a, p_post_b, p_c);
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
2017-03-05 16:44:50 +01:00
|
|
|
Quat Animation::_cubic_interpolate(const Quat &p_pre_a, const Quat &p_a, const Quat &p_b, const Quat &p_post_b, float p_c) const {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
return p_a.cubic_slerp(p_b, p_pre_a, p_post_b, p_c);
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
2017-03-05 16:44:50 +01:00
|
|
|
Variant Animation::_cubic_interpolate(const Variant &p_pre_a, const Variant &p_a, const Variant &p_b, const Variant &p_post_b, float p_c) const {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
Variant::Type type_a = p_a.get_type();
|
|
|
|
Variant::Type type_b = p_b.get_type();
|
|
|
|
Variant::Type type_pa = p_pre_a.get_type();
|
|
|
|
Variant::Type type_pb = p_post_b.get_type();
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
//make int and real play along
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
uint32_t vformat = 1 << type_a;
|
|
|
|
vformat |= 1 << type_b;
|
|
|
|
vformat |= 1 << type_pa;
|
|
|
|
vformat |= 1 << type_pb;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT.
- Renames PackedIntArray to PackedInt32Array.
- Renames PackedFloatArray to PackedFloat32Array.
- Adds PackedInt64Array and PackedFloat64Array.
- Renames Variant::REAL to Variant::FLOAT for consistency.
Packed arrays are for storing large amount of data and creating stuff like
meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of
memory. That said, many users requested the ability to have 64 bits packed
arrays for their games, so this is just an optional added type.
For Variant, the float datatype is always 64 bits, and exposed as `float`.
We still have `real_t` which is the datatype that can change from 32 to 64
bits depending on a compile flag (not entirely working right now, but that's
the idea). It affects math related datatypes and code only.
Neither Variant nor PackedArray make use of real_t, which is only intended
for math precision, so the term is removed from there to keep only float.
2020-02-24 19:20:53 +01:00
|
|
|
if (vformat == ((1 << Variant::INT) | (1 << Variant::FLOAT)) || vformat == (1 << Variant::FLOAT)) {
|
2014-02-10 02:10:30 +01:00
|
|
|
//mix of real and int
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
real_t p0 = p_pre_a;
|
|
|
|
real_t p1 = p_a;
|
|
|
|
real_t p2 = p_b;
|
|
|
|
real_t p3 = p_post_b;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
float t = p_c;
|
|
|
|
float t2 = t * t;
|
|
|
|
float t3 = t2 * t;
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
return 0.5f * ((p1 * 2.0f) +
|
|
|
|
(-p0 + p2) * t +
|
|
|
|
(2.0f * p0 - 5.0f * p1 + 4 * p2 - p3) * t2 +
|
|
|
|
(-p0 + 3.0f * p1 - 3.0f * p2 + p3) * t3);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
} else if ((vformat & (vformat - 1))) {
|
|
|
|
|
|
|
|
return p_a; //can't interpolate, mix of types
|
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
switch (type_a) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
case Variant::VECTOR2: {
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
Vector2 a = p_a;
|
|
|
|
Vector2 b = p_b;
|
|
|
|
Vector2 pa = p_pre_a;
|
|
|
|
Vector2 pb = p_post_b;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
return a.cubic_interpolate(b, pa, pb, p_c);
|
2019-07-20 08:09:57 +02:00
|
|
|
}
|
2014-02-10 02:10:30 +01:00
|
|
|
case Variant::RECT2: {
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
Rect2 a = p_a;
|
|
|
|
Rect2 b = p_b;
|
|
|
|
Rect2 pa = p_pre_a;
|
|
|
|
Rect2 pb = p_post_b;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
return Rect2(
|
2017-06-04 00:25:13 +02:00
|
|
|
a.position.cubic_interpolate(b.position, pa.position, pb.position, p_c),
|
2017-03-05 16:44:50 +01:00
|
|
|
a.size.cubic_interpolate(b.size, pa.size, pb.size, p_c));
|
2019-07-20 08:09:57 +02:00
|
|
|
}
|
2014-02-10 02:10:30 +01:00
|
|
|
case Variant::VECTOR3: {
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
Vector3 a = p_a;
|
|
|
|
Vector3 b = p_b;
|
|
|
|
Vector3 pa = p_pre_a;
|
|
|
|
Vector3 pb = p_post_b;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
return a.cubic_interpolate(b, pa, pb, p_c);
|
2019-07-20 08:09:57 +02:00
|
|
|
}
|
2014-02-10 02:10:30 +01:00
|
|
|
case Variant::QUAT: {
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
Quat a = p_a;
|
|
|
|
Quat b = p_b;
|
|
|
|
Quat pa = p_pre_a;
|
|
|
|
Quat pb = p_post_b;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
return a.cubic_slerp(b, pa, pb, p_c);
|
2019-07-20 08:09:57 +02:00
|
|
|
}
|
2017-11-17 03:09:00 +01:00
|
|
|
case Variant::AABB: {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-11-17 03:09:00 +01:00
|
|
|
AABB a = p_a;
|
|
|
|
AABB b = p_b;
|
|
|
|
AABB pa = p_pre_a;
|
|
|
|
AABB pb = p_post_b;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-11-17 03:09:00 +01:00
|
|
|
return AABB(
|
2017-06-06 20:33:51 +02:00
|
|
|
a.position.cubic_interpolate(b.position, pa.position, pb.position, p_c),
|
2017-03-05 16:44:50 +01:00
|
|
|
a.size.cubic_interpolate(b.size, pa.size, pb.size, p_c));
|
2019-07-20 08:09:57 +02:00
|
|
|
}
|
2014-02-10 02:10:30 +01:00
|
|
|
default: {
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
return _interpolate(p_a, p_b, p_c);
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2017-03-05 16:44:50 +01:00
|
|
|
float Animation::_cubic_interpolate(const float &p_pre_a, const float &p_a, const float &p_b, const float &p_post_b, float p_c) const {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
return _interpolate(p_a, p_b, p_c);
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
template <class T>
|
2020-03-17 07:33:00 +01:00
|
|
|
T Animation::_interpolate(const Vector<TKey<T>> &p_keys, float p_time, InterpolationType p_interp, bool p_loop_wrap, bool *p_ok) const {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
int len = _find(p_keys, length) + 1; // try to find last key (there may be more past the end)
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
if (len <= 0) {
|
2014-02-10 02:10:30 +01:00
|
|
|
// (-1 or -2 returned originally) (plus one above)
|
|
|
|
// meaning no keys, or only key time is larger than length
|
|
|
|
if (p_ok)
|
2017-03-05 16:44:50 +01:00
|
|
|
*p_ok = false;
|
2014-02-10 02:10:30 +01:00
|
|
|
return T();
|
2017-03-05 16:44:50 +01:00
|
|
|
} else if (len == 1) { // one key found (0+1), return it
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
if (p_ok)
|
2017-03-05 16:44:50 +01:00
|
|
|
*p_ok = true;
|
2014-02-10 02:10:30 +01:00
|
|
|
return p_keys[0].value;
|
|
|
|
}
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
int idx = _find(p_keys, p_time);
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_COND_V(idx == -2, T());
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2017-10-15 01:28:08 +02:00
|
|
|
bool result = true;
|
2017-03-05 16:44:50 +01:00
|
|
|
int next = 0;
|
|
|
|
float c = 0;
|
2014-02-10 02:10:30 +01:00
|
|
|
// prepare for all cases of interpolation
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2017-01-09 04:41:16 +01:00
|
|
|
if (loop && p_loop_wrap) {
|
2017-03-05 16:44:50 +01:00
|
|
|
// loop
|
|
|
|
if (idx >= 0) {
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
if ((idx + 1) < len) {
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
next = idx + 1;
|
|
|
|
float delta = p_keys[next].time - p_keys[idx].time;
|
|
|
|
float from = p_time - p_keys[idx].time;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2019-01-16 16:42:53 +01:00
|
|
|
if (Math::is_zero_approx(delta))
|
2017-03-05 16:44:50 +01:00
|
|
|
c = 0;
|
2019-01-16 16:42:53 +01:00
|
|
|
else
|
|
|
|
c = from / delta;
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
} else {
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
next = 0;
|
|
|
|
float delta = (length - p_keys[idx].time) + p_keys[next].time;
|
|
|
|
float from = p_time - p_keys[idx].time;
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2019-01-16 16:42:53 +01:00
|
|
|
if (Math::is_zero_approx(delta))
|
2017-03-05 16:44:50 +01:00
|
|
|
c = 0;
|
2019-01-16 16:42:53 +01:00
|
|
|
else
|
|
|
|
c = from / delta;
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
} else {
|
|
|
|
// on loop, behind first key
|
2017-03-05 16:44:50 +01:00
|
|
|
idx = len - 1;
|
|
|
|
next = 0;
|
|
|
|
float endtime = (length - p_keys[idx].time);
|
|
|
|
if (endtime < 0) // may be keys past the end
|
|
|
|
endtime = 0;
|
|
|
|
float delta = endtime + p_keys[next].time;
|
|
|
|
float from = endtime + p_time;
|
|
|
|
|
2019-01-16 16:42:53 +01:00
|
|
|
if (Math::is_zero_approx(delta))
|
2017-03-05 16:44:50 +01:00
|
|
|
c = 0;
|
2019-01-16 16:42:53 +01:00
|
|
|
else
|
|
|
|
c = from / delta;
|
2016-03-09 00:00:52 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
} else { // no loop
|
2014-11-02 15:31:01 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
if (idx >= 0) {
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
if ((idx + 1) < len) {
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
next = idx + 1;
|
|
|
|
float delta = p_keys[next].time - p_keys[idx].time;
|
|
|
|
float from = p_time - p_keys[idx].time;
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2019-01-16 16:42:53 +01:00
|
|
|
if (Math::is_zero_approx(delta))
|
2017-03-05 16:44:50 +01:00
|
|
|
c = 0;
|
2019-01-16 16:42:53 +01:00
|
|
|
else
|
|
|
|
c = from / delta;
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
} else {
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
next = idx;
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2019-07-07 23:08:51 +02:00
|
|
|
} else {
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2017-10-15 01:28:08 +02:00
|
|
|
// only allow extending first key to anim start if looping
|
|
|
|
if (loop)
|
|
|
|
idx = next = 0;
|
|
|
|
else
|
|
|
|
result = false;
|
2016-03-09 00:00:52 +01:00
|
|
|
}
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2017-10-15 01:28:08 +02:00
|
|
|
if (p_ok)
|
|
|
|
*p_ok = result;
|
|
|
|
if (!result)
|
|
|
|
return T();
|
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
float tr = p_keys[idx].transition;
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
if (tr == 0 || idx == next) {
|
2014-02-10 02:10:30 +01:00
|
|
|
// don't interpolate if not needed
|
|
|
|
return p_keys[idx].value;
|
|
|
|
}
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
if (tr != 1.0) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
c = Math::ease(c, tr);
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
switch (p_interp) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
case INTERPOLATION_NEAREST: {
|
|
|
|
|
|
|
|
return p_keys[idx].value;
|
|
|
|
} break;
|
|
|
|
case INTERPOLATION_LINEAR: {
|
|
|
|
|
|
|
|
return _interpolate(p_keys[idx].value, p_keys[next].value, c);
|
|
|
|
} break;
|
|
|
|
case INTERPOLATION_CUBIC: {
|
2017-03-05 16:44:50 +01:00
|
|
|
int pre = idx - 1;
|
|
|
|
if (pre < 0)
|
|
|
|
pre = 0;
|
|
|
|
int post = next + 1;
|
|
|
|
if (post >= len)
|
|
|
|
post = next;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
return _cubic_interpolate(p_keys[pre].value, p_keys[idx].value, p_keys[next].value, p_keys[post].value, c);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
} break;
|
|
|
|
default: return p_keys[idx].value;
|
|
|
|
}
|
|
|
|
|
|
|
|
// do a barrel roll
|
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
Error Animation::transform_track_interpolate(int p_track, float p_time, Vector3 *r_loc, Quat *r_rot, Vector3 *r_scale) const {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_INDEX_V(p_track, tracks.size(), ERR_INVALID_PARAMETER);
|
|
|
|
Track *t = tracks[p_track];
|
|
|
|
ERR_FAIL_COND_V(t->type != TYPE_TRANSFORM, ERR_INVALID_PARAMETER);
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
TransformTrack *tt = static_cast<TransformTrack *>(t);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-09-01 22:33:39 +02:00
|
|
|
bool ok = false;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
TransformKey tk = _interpolate(tt->transforms, p_time, tt->interpolation, tt->loop_wrap, &ok);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-10-15 01:28:08 +02:00
|
|
|
if (!ok)
|
2014-02-10 02:10:30 +01:00
|
|
|
return ERR_UNAVAILABLE;
|
|
|
|
|
|
|
|
if (r_loc)
|
2017-03-05 16:44:50 +01:00
|
|
|
*r_loc = tk.loc;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
if (r_rot)
|
2017-03-05 16:44:50 +01:00
|
|
|
*r_rot = tk.rot;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
if (r_scale)
|
2017-03-05 16:44:50 +01:00
|
|
|
*r_scale = tk.scale;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
return OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
Variant Animation::value_track_interpolate(int p_track, float p_time) const {
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_INDEX_V(p_track, tracks.size(), 0);
|
|
|
|
Track *t = tracks[p_track];
|
|
|
|
ERR_FAIL_COND_V(t->type != TYPE_VALUE, Variant());
|
|
|
|
ValueTrack *vt = static_cast<ValueTrack *>(t);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-09-01 22:33:39 +02:00
|
|
|
bool ok = false;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2019-01-18 21:07:45 +01:00
|
|
|
Variant res = _interpolate(vt->values, p_time, (vt->update_mode == UPDATE_CONTINUOUS || vt->update_mode == UPDATE_CAPTURE) ? vt->interpolation : INTERPOLATION_NEAREST, vt->loop_wrap, &ok);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
if (ok) {
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
return Variant();
|
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
void Animation::_value_track_get_key_indices_in_range(const ValueTrack *vt, float from_time, float to_time, List<int> *p_indices) const {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
if (from_time != length && to_time == length)
|
2019-03-02 15:07:13 +01:00
|
|
|
to_time = length * 1.001; //include a little more if at the end
|
2017-03-05 16:44:50 +01:00
|
|
|
int to = _find(vt->values, to_time);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2019-03-03 12:45:20 +01:00
|
|
|
if (to >= 0 && from_time == to_time && vt->values[to].time == from_time) {
|
2019-03-02 15:07:13 +01:00
|
|
|
//find exact (0 delta), return if found
|
|
|
|
p_indices->push_back(to);
|
|
|
|
return;
|
|
|
|
}
|
2014-02-10 02:10:30 +01:00
|
|
|
// can't really send the events == time, will be sent in the next frame.
|
|
|
|
// if event>=len then it will probably never be requested by the anim player.
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
if (to >= 0 && vt->values[to].time >= to_time)
|
2014-02-10 02:10:30 +01:00
|
|
|
to--;
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
if (to < 0)
|
2014-02-10 02:10:30 +01:00
|
|
|
return; // not bother
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
int from = _find(vt->values, from_time);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
// position in the right first event.+
|
2017-03-05 16:44:50 +01:00
|
|
|
if (from < 0 || vt->values[from].time < from_time)
|
2014-02-10 02:10:30 +01:00
|
|
|
from++;
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
int max = vt->values.size();
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
for (int i = from; i <= to; i++) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_CONTINUE(i < 0 || i >= max); // shouldn't happen
|
2014-02-10 02:10:30 +01:00
|
|
|
p_indices->push_back(i);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
void Animation::value_track_get_key_indices(int p_track, float p_time, float p_delta, List<int> *p_indices) const {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
ERR_FAIL_INDEX(p_track, tracks.size());
|
2017-03-05 16:44:50 +01:00
|
|
|
Track *t = tracks[p_track];
|
|
|
|
ERR_FAIL_COND(t->type != TYPE_VALUE);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ValueTrack *vt = static_cast<ValueTrack *>(t);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
float from_time = p_time - p_delta;
|
|
|
|
float to_time = p_time;
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
if (from_time > to_time)
|
|
|
|
SWAP(from_time, to_time);
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
if (loop) {
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
from_time = Math::fposmod(from_time, length);
|
|
|
|
to_time = Math::fposmod(to_time, length);
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
if (from_time > to_time) {
|
2014-02-10 02:10:30 +01:00
|
|
|
// handle loop by splitting
|
2019-03-02 15:07:13 +01:00
|
|
|
_value_track_get_key_indices_in_range(vt, from_time, length, p_indices);
|
2017-03-05 16:44:50 +01:00
|
|
|
_value_track_get_key_indices_in_range(vt, 0, to_time, p_indices);
|
2014-02-10 02:10:30 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
} else {
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
if (from_time < 0)
|
|
|
|
from_time = 0;
|
|
|
|
if (from_time > length)
|
|
|
|
from_time = length;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
if (to_time < 0)
|
|
|
|
to_time = 0;
|
|
|
|
if (to_time > length)
|
|
|
|
to_time = length;
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
_value_track_get_key_indices_in_range(vt, from_time, to_time, p_indices);
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
2016-06-19 06:43:02 +02:00
|
|
|
void Animation::value_track_set_update_mode(int p_track, UpdateMode p_mode) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
ERR_FAIL_INDEX(p_track, tracks.size());
|
2017-03-05 16:44:50 +01:00
|
|
|
Track *t = tracks[p_track];
|
|
|
|
ERR_FAIL_COND(t->type != TYPE_VALUE);
|
2018-10-04 09:17:59 +02:00
|
|
|
ERR_FAIL_INDEX((int)p_mode, 4);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ValueTrack *vt = static_cast<ValueTrack *>(t);
|
|
|
|
vt->update_mode = p_mode;
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
2016-06-19 06:43:02 +02:00
|
|
|
Animation::UpdateMode Animation::value_track_get_update_mode(int p_track) const {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2016-06-19 06:43:02 +02:00
|
|
|
ERR_FAIL_INDEX_V(p_track, tracks.size(), UPDATE_CONTINUOUS);
|
2017-03-05 16:44:50 +01:00
|
|
|
Track *t = tracks[p_track];
|
|
|
|
ERR_FAIL_COND_V(t->type != TYPE_VALUE, UPDATE_CONTINUOUS);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ValueTrack *vt = static_cast<ValueTrack *>(t);
|
2016-06-19 06:43:02 +02:00
|
|
|
return vt->update_mode;
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
2018-06-07 17:46:14 +02:00
|
|
|
template <class T>
|
|
|
|
void Animation::_track_get_key_indices_in_range(const Vector<T> &p_array, float from_time, float to_time, List<int> *p_indices) const {
|
|
|
|
|
|
|
|
if (from_time != length && to_time == length)
|
|
|
|
to_time = length * 1.01; //include a little more if at the end
|
|
|
|
|
|
|
|
int to = _find(p_array, to_time);
|
|
|
|
|
|
|
|
// can't really send the events == time, will be sent in the next frame.
|
|
|
|
// if event>=len then it will probably never be requested by the anim player.
|
|
|
|
|
|
|
|
if (to >= 0 && p_array[to].time >= to_time)
|
|
|
|
to--;
|
|
|
|
|
|
|
|
if (to < 0)
|
|
|
|
return; // not bother
|
|
|
|
|
|
|
|
int from = _find(p_array, from_time);
|
|
|
|
|
|
|
|
// position in the right first event.+
|
|
|
|
if (from < 0 || p_array[from].time < from_time)
|
|
|
|
from++;
|
|
|
|
|
|
|
|
int max = p_array.size();
|
|
|
|
|
|
|
|
for (int i = from; i <= to; i++) {
|
|
|
|
|
|
|
|
ERR_CONTINUE(i < 0 || i >= max); // shouldn't happen
|
|
|
|
p_indices->push_back(i);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Animation::track_get_key_indices_in_range(int p_track, float p_time, float p_delta, List<int> *p_indices) const {
|
|
|
|
|
|
|
|
ERR_FAIL_INDEX(p_track, tracks.size());
|
|
|
|
const Track *t = tracks[p_track];
|
|
|
|
|
|
|
|
float from_time = p_time - p_delta;
|
|
|
|
float to_time = p_time;
|
|
|
|
|
|
|
|
if (from_time > to_time)
|
|
|
|
SWAP(from_time, to_time);
|
|
|
|
|
|
|
|
if (loop) {
|
|
|
|
|
|
|
|
if (from_time > length || from_time < 0)
|
|
|
|
from_time = Math::fposmod(from_time, length);
|
|
|
|
|
|
|
|
if (to_time > length || to_time < 0)
|
|
|
|
to_time = Math::fposmod(to_time, length);
|
|
|
|
|
|
|
|
if (from_time > to_time) {
|
|
|
|
// handle loop by splitting
|
|
|
|
|
|
|
|
switch (t->type) {
|
|
|
|
|
|
|
|
case TYPE_TRANSFORM: {
|
|
|
|
|
|
|
|
const TransformTrack *tt = static_cast<const TransformTrack *>(t);
|
|
|
|
_track_get_key_indices_in_range(tt->transforms, from_time, length, p_indices);
|
|
|
|
_track_get_key_indices_in_range(tt->transforms, 0, to_time, p_indices);
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case TYPE_VALUE: {
|
|
|
|
|
|
|
|
const ValueTrack *vt = static_cast<const ValueTrack *>(t);
|
|
|
|
_track_get_key_indices_in_range(vt->values, from_time, length, p_indices);
|
|
|
|
_track_get_key_indices_in_range(vt->values, 0, to_time, p_indices);
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case TYPE_METHOD: {
|
|
|
|
|
|
|
|
const MethodTrack *mt = static_cast<const MethodTrack *>(t);
|
|
|
|
_track_get_key_indices_in_range(mt->methods, from_time, length, p_indices);
|
|
|
|
_track_get_key_indices_in_range(mt->methods, 0, to_time, p_indices);
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case TYPE_BEZIER: {
|
|
|
|
|
|
|
|
const BezierTrack *bz = static_cast<const BezierTrack *>(t);
|
|
|
|
_track_get_key_indices_in_range(bz->values, from_time, length, p_indices);
|
|
|
|
_track_get_key_indices_in_range(bz->values, 0, to_time, p_indices);
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case TYPE_AUDIO: {
|
|
|
|
|
|
|
|
const AudioTrack *ad = static_cast<const AudioTrack *>(t);
|
|
|
|
_track_get_key_indices_in_range(ad->values, from_time, length, p_indices);
|
|
|
|
_track_get_key_indices_in_range(ad->values, 0, to_time, p_indices);
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case TYPE_ANIMATION: {
|
|
|
|
|
|
|
|
const AnimationTrack *an = static_cast<const AnimationTrack *>(t);
|
|
|
|
_track_get_key_indices_in_range(an->values, from_time, length, p_indices);
|
|
|
|
_track_get_key_indices_in_range(an->values, 0, to_time, p_indices);
|
|
|
|
|
|
|
|
} break;
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
|
|
|
|
if (from_time < 0)
|
|
|
|
from_time = 0;
|
|
|
|
if (from_time > length)
|
|
|
|
from_time = length;
|
|
|
|
|
|
|
|
if (to_time < 0)
|
|
|
|
to_time = 0;
|
|
|
|
if (to_time > length)
|
|
|
|
to_time = length;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (t->type) {
|
|
|
|
|
|
|
|
case TYPE_TRANSFORM: {
|
|
|
|
|
|
|
|
const TransformTrack *tt = static_cast<const TransformTrack *>(t);
|
|
|
|
_track_get_key_indices_in_range(tt->transforms, from_time, to_time, p_indices);
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case TYPE_VALUE: {
|
|
|
|
|
|
|
|
const ValueTrack *vt = static_cast<const ValueTrack *>(t);
|
|
|
|
_track_get_key_indices_in_range(vt->values, from_time, to_time, p_indices);
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case TYPE_METHOD: {
|
|
|
|
|
|
|
|
const MethodTrack *mt = static_cast<const MethodTrack *>(t);
|
|
|
|
_track_get_key_indices_in_range(mt->methods, from_time, to_time, p_indices);
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case TYPE_BEZIER: {
|
|
|
|
|
|
|
|
const BezierTrack *bz = static_cast<const BezierTrack *>(t);
|
|
|
|
_track_get_key_indices_in_range(bz->values, from_time, to_time, p_indices);
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case TYPE_AUDIO: {
|
|
|
|
|
|
|
|
const AudioTrack *ad = static_cast<const AudioTrack *>(t);
|
|
|
|
_track_get_key_indices_in_range(ad->values, from_time, to_time, p_indices);
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case TYPE_ANIMATION: {
|
|
|
|
|
|
|
|
const AnimationTrack *an = static_cast<const AnimationTrack *>(t);
|
|
|
|
_track_get_key_indices_in_range(an->values, from_time, to_time, p_indices);
|
|
|
|
|
|
|
|
} break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Animation::_method_track_get_key_indices_in_range(const MethodTrack *mt, float from_time, float to_time, List<int> *p_indices) const {
|
2016-06-19 06:43:02 +02:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
if (from_time != length && to_time == length)
|
|
|
|
to_time = length * 1.01; //include a little more if at the end
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
int to = _find(mt->methods, to_time);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
// can't really send the events == time, will be sent in the next frame.
|
|
|
|
// if event>=len then it will probably never be requested by the anim player.
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
if (to >= 0 && mt->methods[to].time >= to_time)
|
2014-02-10 02:10:30 +01:00
|
|
|
to--;
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
if (to < 0)
|
2014-02-10 02:10:30 +01:00
|
|
|
return; // not bother
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
int from = _find(mt->methods, from_time);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
// position in the right first event.+
|
2017-03-05 16:44:50 +01:00
|
|
|
if (from < 0 || mt->methods[from].time < from_time)
|
2014-02-10 02:10:30 +01:00
|
|
|
from++;
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
int max = mt->methods.size();
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
for (int i = from; i <= to; i++) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_CONTINUE(i < 0 || i >= max); // shouldn't happen
|
2014-02-10 02:10:30 +01:00
|
|
|
p_indices->push_back(i);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
void Animation::method_track_get_key_indices(int p_track, float p_time, float p_delta, List<int> *p_indices) const {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
ERR_FAIL_INDEX(p_track, tracks.size());
|
2017-03-05 16:44:50 +01:00
|
|
|
Track *t = tracks[p_track];
|
|
|
|
ERR_FAIL_COND(t->type != TYPE_METHOD);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
MethodTrack *mt = static_cast<MethodTrack *>(t);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
float from_time = p_time - p_delta;
|
|
|
|
float to_time = p_time;
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
if (from_time > to_time)
|
|
|
|
SWAP(from_time, to_time);
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
if (loop) {
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
if (from_time > length || from_time < 0)
|
2017-03-05 16:44:50 +01:00
|
|
|
from_time = Math::fposmod(from_time, length);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
if (to_time > length || to_time < 0)
|
2017-03-05 16:44:50 +01:00
|
|
|
to_time = Math::fposmod(to_time, length);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
if (from_time > to_time) {
|
2014-02-10 02:10:30 +01:00
|
|
|
// handle loop by splitting
|
2017-03-05 16:44:50 +01:00
|
|
|
_method_track_get_key_indices_in_range(mt, from_time, length, p_indices);
|
|
|
|
_method_track_get_key_indices_in_range(mt, 0, to_time, p_indices);
|
2014-02-10 02:10:30 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
} else {
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
if (from_time < 0)
|
|
|
|
from_time = 0;
|
|
|
|
if (from_time > length)
|
|
|
|
from_time = length;
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
if (to_time < 0)
|
|
|
|
to_time = 0;
|
|
|
|
if (to_time > length)
|
|
|
|
to_time = length;
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
_method_track_get_key_indices_in_range(mt, from_time, to_time, p_indices);
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
2017-03-05 16:44:50 +01:00
|
|
|
Vector<Variant> Animation::method_track_get_params(int p_track, int p_key_idx) const {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_INDEX_V(p_track, tracks.size(), Vector<Variant>());
|
|
|
|
Track *t = tracks[p_track];
|
|
|
|
ERR_FAIL_COND_V(t->type != TYPE_METHOD, Vector<Variant>());
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
MethodTrack *pm = static_cast<MethodTrack *>(t);
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_INDEX_V(p_key_idx, pm->methods.size(), Vector<Variant>());
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
const MethodKey &mk = pm->methods[p_key_idx];
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
return mk.params;
|
|
|
|
}
|
2017-03-05 16:44:50 +01:00
|
|
|
StringName Animation::method_track_get_name(int p_track, int p_key_idx) const {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_INDEX_V(p_track, tracks.size(), StringName());
|
|
|
|
Track *t = tracks[p_track];
|
|
|
|
ERR_FAIL_COND_V(t->type != TYPE_METHOD, StringName());
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
MethodTrack *pm = static_cast<MethodTrack *>(t);
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_INDEX_V(p_key_idx, pm->methods.size(), StringName());
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
return pm->methods[p_key_idx].method;
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
2018-06-07 17:46:14 +02:00
|
|
|
int Animation::bezier_track_insert_key(int p_track, float p_time, float p_value, const Vector2 &p_in_handle, const Vector2 &p_out_handle) {
|
|
|
|
|
|
|
|
ERR_FAIL_INDEX_V(p_track, tracks.size(), -1);
|
|
|
|
Track *t = tracks[p_track];
|
|
|
|
ERR_FAIL_COND_V(t->type != TYPE_BEZIER, -1);
|
|
|
|
|
|
|
|
BezierTrack *bt = static_cast<BezierTrack *>(t);
|
|
|
|
|
|
|
|
TKey<BezierKey> k;
|
|
|
|
k.time = p_time;
|
|
|
|
k.value.value = p_value;
|
|
|
|
k.value.in_handle = p_in_handle;
|
|
|
|
if (k.value.in_handle.x > 0) {
|
|
|
|
k.value.in_handle.x = 0;
|
|
|
|
}
|
|
|
|
k.value.out_handle = p_out_handle;
|
|
|
|
if (k.value.out_handle.x < 0) {
|
|
|
|
k.value.out_handle.x = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int key = _insert(p_time, bt->values, k);
|
|
|
|
|
|
|
|
emit_changed();
|
|
|
|
|
|
|
|
return key;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Animation::bezier_track_set_key_value(int p_track, int p_index, float p_value) {
|
|
|
|
|
|
|
|
ERR_FAIL_INDEX(p_track, tracks.size());
|
|
|
|
Track *t = tracks[p_track];
|
|
|
|
ERR_FAIL_COND(t->type != TYPE_BEZIER);
|
|
|
|
|
|
|
|
BezierTrack *bt = static_cast<BezierTrack *>(t);
|
|
|
|
|
|
|
|
ERR_FAIL_INDEX(p_index, bt->values.size());
|
|
|
|
|
2018-07-25 03:11:03 +02:00
|
|
|
bt->values.write[p_index].value.value = p_value;
|
2018-06-07 17:46:14 +02:00
|
|
|
emit_changed();
|
|
|
|
}
|
|
|
|
|
|
|
|
void Animation::bezier_track_set_key_in_handle(int p_track, int p_index, const Vector2 &p_handle) {
|
|
|
|
|
|
|
|
ERR_FAIL_INDEX(p_track, tracks.size());
|
|
|
|
Track *t = tracks[p_track];
|
|
|
|
ERR_FAIL_COND(t->type != TYPE_BEZIER);
|
|
|
|
|
|
|
|
BezierTrack *bt = static_cast<BezierTrack *>(t);
|
|
|
|
|
|
|
|
ERR_FAIL_INDEX(p_index, bt->values.size());
|
|
|
|
|
2018-07-25 03:11:03 +02:00
|
|
|
bt->values.write[p_index].value.in_handle = p_handle;
|
2018-06-07 17:46:14 +02:00
|
|
|
if (bt->values[p_index].value.in_handle.x > 0) {
|
2018-07-25 03:11:03 +02:00
|
|
|
bt->values.write[p_index].value.in_handle.x = 0;
|
2018-06-07 17:46:14 +02:00
|
|
|
}
|
|
|
|
emit_changed();
|
|
|
|
}
|
|
|
|
void Animation::bezier_track_set_key_out_handle(int p_track, int p_index, const Vector2 &p_handle) {
|
|
|
|
|
|
|
|
ERR_FAIL_INDEX(p_track, tracks.size());
|
|
|
|
Track *t = tracks[p_track];
|
|
|
|
ERR_FAIL_COND(t->type != TYPE_BEZIER);
|
|
|
|
|
|
|
|
BezierTrack *bt = static_cast<BezierTrack *>(t);
|
|
|
|
|
|
|
|
ERR_FAIL_INDEX(p_index, bt->values.size());
|
|
|
|
|
2018-07-25 03:11:03 +02:00
|
|
|
bt->values.write[p_index].value.out_handle = p_handle;
|
2018-06-07 17:46:14 +02:00
|
|
|
if (bt->values[p_index].value.out_handle.x < 0) {
|
2018-07-25 03:11:03 +02:00
|
|
|
bt->values.write[p_index].value.out_handle.x = 0;
|
2018-06-07 17:46:14 +02:00
|
|
|
}
|
|
|
|
emit_changed();
|
|
|
|
}
|
|
|
|
float Animation::bezier_track_get_key_value(int p_track, int p_index) const {
|
|
|
|
|
|
|
|
ERR_FAIL_INDEX_V(p_track, tracks.size(), 0);
|
|
|
|
Track *t = tracks[p_track];
|
|
|
|
ERR_FAIL_COND_V(t->type != TYPE_BEZIER, 0);
|
|
|
|
|
|
|
|
BezierTrack *bt = static_cast<BezierTrack *>(t);
|
|
|
|
|
|
|
|
ERR_FAIL_INDEX_V(p_index, bt->values.size(), 0);
|
|
|
|
|
|
|
|
return bt->values[p_index].value.value;
|
|
|
|
}
|
|
|
|
Vector2 Animation::bezier_track_get_key_in_handle(int p_track, int p_index) const {
|
|
|
|
|
|
|
|
ERR_FAIL_INDEX_V(p_track, tracks.size(), Vector2());
|
|
|
|
Track *t = tracks[p_track];
|
|
|
|
ERR_FAIL_COND_V(t->type != TYPE_BEZIER, Vector2());
|
|
|
|
|
|
|
|
BezierTrack *bt = static_cast<BezierTrack *>(t);
|
|
|
|
|
|
|
|
ERR_FAIL_INDEX_V(p_index, bt->values.size(), Vector2());
|
|
|
|
|
|
|
|
return bt->values[p_index].value.in_handle;
|
|
|
|
}
|
|
|
|
Vector2 Animation::bezier_track_get_key_out_handle(int p_track, int p_index) const {
|
|
|
|
|
|
|
|
ERR_FAIL_INDEX_V(p_track, tracks.size(), Vector2());
|
|
|
|
Track *t = tracks[p_track];
|
|
|
|
ERR_FAIL_COND_V(t->type != TYPE_BEZIER, Vector2());
|
|
|
|
|
|
|
|
BezierTrack *bt = static_cast<BezierTrack *>(t);
|
|
|
|
|
|
|
|
ERR_FAIL_INDEX_V(p_index, bt->values.size(), Vector2());
|
|
|
|
|
|
|
|
return bt->values[p_index].value.out_handle;
|
|
|
|
}
|
|
|
|
|
|
|
|
static _FORCE_INLINE_ Vector2 _bezier_interp(real_t t, const Vector2 &start, const Vector2 &control_1, const Vector2 &control_2, const Vector2 &end) {
|
|
|
|
/* Formula from Wikipedia article on Bezier curves. */
|
|
|
|
real_t omt = (1.0 - t);
|
|
|
|
real_t omt2 = omt * omt;
|
|
|
|
real_t omt3 = omt2 * omt;
|
|
|
|
real_t t2 = t * t;
|
|
|
|
real_t t3 = t2 * t;
|
|
|
|
|
|
|
|
return start * omt3 + control_1 * omt2 * t * 3.0 + control_2 * omt * t2 * 3.0 + end * t3;
|
|
|
|
}
|
|
|
|
|
|
|
|
float Animation::bezier_track_interpolate(int p_track, float p_time) const {
|
|
|
|
//this uses a different interpolation scheme
|
|
|
|
ERR_FAIL_INDEX_V(p_track, tracks.size(), 0);
|
|
|
|
Track *track = tracks[p_track];
|
|
|
|
ERR_FAIL_COND_V(track->type != TYPE_BEZIER, 0);
|
|
|
|
|
|
|
|
BezierTrack *bt = static_cast<BezierTrack *>(track);
|
|
|
|
|
|
|
|
int len = _find(bt->values, length) + 1; // try to find last key (there may be more past the end)
|
|
|
|
|
|
|
|
if (len <= 0) {
|
|
|
|
// (-1 or -2 returned originally) (plus one above)
|
|
|
|
return 0;
|
|
|
|
} else if (len == 1) { // one key found (0+1), return it
|
|
|
|
return bt->values[0].value.value;
|
|
|
|
}
|
|
|
|
|
|
|
|
int idx = _find(bt->values, p_time);
|
|
|
|
|
|
|
|
ERR_FAIL_COND_V(idx == -2, 0);
|
|
|
|
|
|
|
|
//there really is no looping interpolation on bezier
|
|
|
|
|
|
|
|
if (idx < 0) {
|
|
|
|
return bt->values[0].value.value;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (idx >= bt->values.size() - 1) {
|
|
|
|
return bt->values[bt->values.size() - 1].value.value;
|
|
|
|
}
|
|
|
|
|
|
|
|
float t = p_time - bt->values[idx].time;
|
|
|
|
|
|
|
|
int iterations = 10;
|
|
|
|
|
2018-07-14 03:48:40 +02:00
|
|
|
float duration = bt->values[idx + 1].time - bt->values[idx].time; // time duration between our two keyframes
|
|
|
|
float low = 0; // 0% of the current animation segment
|
|
|
|
float high = 1; // 100% of the current animation segment
|
2019-01-14 23:04:47 +01:00
|
|
|
float middle;
|
2018-06-07 17:46:14 +02:00
|
|
|
|
|
|
|
Vector2 start(0, bt->values[idx].value.value);
|
|
|
|
Vector2 start_out = start + bt->values[idx].value.out_handle;
|
2018-07-14 03:48:40 +02:00
|
|
|
Vector2 end(duration, bt->values[idx + 1].value.value);
|
2018-06-07 17:46:14 +02:00
|
|
|
Vector2 end_in = end + bt->values[idx + 1].value.in_handle;
|
|
|
|
|
|
|
|
//narrow high and low as much as possible
|
|
|
|
for (int i = 0; i < iterations; i++) {
|
|
|
|
|
|
|
|
middle = (low + high) / 2;
|
|
|
|
|
|
|
|
Vector2 interp = _bezier_interp(middle, start, start_out, end_in, end);
|
|
|
|
|
|
|
|
if (interp.x < t) {
|
|
|
|
low = middle;
|
|
|
|
} else {
|
|
|
|
high = middle;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//interpolate the result:
|
|
|
|
Vector2 low_pos = _bezier_interp(low, start, start_out, end_in, end);
|
|
|
|
Vector2 high_pos = _bezier_interp(high, start, start_out, end_in, end);
|
|
|
|
float c = (t - low_pos.x) / (high_pos.x - low_pos.x);
|
|
|
|
|
|
|
|
return low_pos.linear_interpolate(high_pos, c).y;
|
|
|
|
}
|
|
|
|
|
|
|
|
int Animation::audio_track_insert_key(int p_track, float p_time, const RES &p_stream, float p_start_offset, float p_end_offset) {
|
|
|
|
|
|
|
|
ERR_FAIL_INDEX_V(p_track, tracks.size(), -1);
|
|
|
|
Track *t = tracks[p_track];
|
|
|
|
ERR_FAIL_COND_V(t->type != TYPE_AUDIO, -1);
|
|
|
|
|
|
|
|
AudioTrack *at = static_cast<AudioTrack *>(t);
|
|
|
|
|
|
|
|
TKey<AudioKey> k;
|
|
|
|
k.time = p_time;
|
|
|
|
k.value.stream = p_stream;
|
|
|
|
k.value.start_offset = p_start_offset;
|
|
|
|
if (k.value.start_offset < 0)
|
|
|
|
k.value.start_offset = 0;
|
|
|
|
k.value.end_offset = p_end_offset;
|
|
|
|
if (k.value.end_offset < 0)
|
|
|
|
k.value.end_offset = 0;
|
|
|
|
|
|
|
|
int key = _insert(p_time, at->values, k);
|
|
|
|
|
|
|
|
emit_changed();
|
|
|
|
|
|
|
|
return key;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Animation::audio_track_set_key_stream(int p_track, int p_key, const RES &p_stream) {
|
|
|
|
|
|
|
|
ERR_FAIL_INDEX(p_track, tracks.size());
|
|
|
|
Track *t = tracks[p_track];
|
|
|
|
ERR_FAIL_COND(t->type != TYPE_AUDIO);
|
|
|
|
|
|
|
|
AudioTrack *at = static_cast<AudioTrack *>(t);
|
|
|
|
|
|
|
|
ERR_FAIL_INDEX(p_key, at->values.size());
|
|
|
|
|
2018-07-25 03:11:03 +02:00
|
|
|
at->values.write[p_key].value.stream = p_stream;
|
2018-06-07 17:46:14 +02:00
|
|
|
|
|
|
|
emit_changed();
|
|
|
|
}
|
|
|
|
|
|
|
|
void Animation::audio_track_set_key_start_offset(int p_track, int p_key, float p_offset) {
|
|
|
|
|
|
|
|
ERR_FAIL_INDEX(p_track, tracks.size());
|
|
|
|
Track *t = tracks[p_track];
|
|
|
|
ERR_FAIL_COND(t->type != TYPE_AUDIO);
|
|
|
|
|
|
|
|
AudioTrack *at = static_cast<AudioTrack *>(t);
|
|
|
|
|
|
|
|
ERR_FAIL_INDEX(p_key, at->values.size());
|
|
|
|
|
|
|
|
if (p_offset < 0)
|
|
|
|
p_offset = 0;
|
|
|
|
|
2018-07-25 03:11:03 +02:00
|
|
|
at->values.write[p_key].value.start_offset = p_offset;
|
2018-06-07 17:46:14 +02:00
|
|
|
|
|
|
|
emit_changed();
|
|
|
|
}
|
|
|
|
|
|
|
|
void Animation::audio_track_set_key_end_offset(int p_track, int p_key, float p_offset) {
|
|
|
|
|
|
|
|
ERR_FAIL_INDEX(p_track, tracks.size());
|
|
|
|
Track *t = tracks[p_track];
|
|
|
|
ERR_FAIL_COND(t->type != TYPE_AUDIO);
|
|
|
|
|
|
|
|
AudioTrack *at = static_cast<AudioTrack *>(t);
|
|
|
|
|
|
|
|
ERR_FAIL_INDEX(p_key, at->values.size());
|
|
|
|
|
|
|
|
if (p_offset < 0)
|
|
|
|
p_offset = 0;
|
|
|
|
|
2018-07-25 03:11:03 +02:00
|
|
|
at->values.write[p_key].value.end_offset = p_offset;
|
2018-06-07 17:46:14 +02:00
|
|
|
|
|
|
|
emit_changed();
|
|
|
|
}
|
|
|
|
|
|
|
|
RES Animation::audio_track_get_key_stream(int p_track, int p_key) const {
|
|
|
|
|
|
|
|
ERR_FAIL_INDEX_V(p_track, tracks.size(), RES());
|
|
|
|
const Track *t = tracks[p_track];
|
|
|
|
ERR_FAIL_COND_V(t->type != TYPE_AUDIO, RES());
|
|
|
|
|
|
|
|
const AudioTrack *at = static_cast<const AudioTrack *>(t);
|
|
|
|
|
|
|
|
ERR_FAIL_INDEX_V(p_key, at->values.size(), RES());
|
|
|
|
|
|
|
|
return at->values[p_key].value.stream;
|
|
|
|
}
|
|
|
|
float Animation::audio_track_get_key_start_offset(int p_track, int p_key) const {
|
|
|
|
|
|
|
|
ERR_FAIL_INDEX_V(p_track, tracks.size(), 0);
|
|
|
|
const Track *t = tracks[p_track];
|
|
|
|
ERR_FAIL_COND_V(t->type != TYPE_AUDIO, 0);
|
|
|
|
|
|
|
|
const AudioTrack *at = static_cast<const AudioTrack *>(t);
|
|
|
|
|
|
|
|
ERR_FAIL_INDEX_V(p_key, at->values.size(), 0);
|
|
|
|
|
|
|
|
return at->values[p_key].value.start_offset;
|
|
|
|
}
|
|
|
|
float Animation::audio_track_get_key_end_offset(int p_track, int p_key) const {
|
|
|
|
|
|
|
|
ERR_FAIL_INDEX_V(p_track, tracks.size(), 0);
|
|
|
|
const Track *t = tracks[p_track];
|
|
|
|
ERR_FAIL_COND_V(t->type != TYPE_AUDIO, 0);
|
|
|
|
|
|
|
|
const AudioTrack *at = static_cast<const AudioTrack *>(t);
|
|
|
|
|
|
|
|
ERR_FAIL_INDEX_V(p_key, at->values.size(), 0);
|
|
|
|
|
|
|
|
return at->values[p_key].value.end_offset;
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
|
|
|
|
int Animation::animation_track_insert_key(int p_track, float p_time, const StringName &p_animation) {
|
|
|
|
|
|
|
|
ERR_FAIL_INDEX_V(p_track, tracks.size(), -1);
|
|
|
|
Track *t = tracks[p_track];
|
|
|
|
ERR_FAIL_COND_V(t->type != TYPE_ANIMATION, -1);
|
|
|
|
|
|
|
|
AnimationTrack *at = static_cast<AnimationTrack *>(t);
|
|
|
|
|
|
|
|
TKey<StringName> k;
|
|
|
|
k.time = p_time;
|
|
|
|
k.value = p_animation;
|
|
|
|
|
|
|
|
int key = _insert(p_time, at->values, k);
|
|
|
|
|
|
|
|
emit_changed();
|
|
|
|
|
|
|
|
return key;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Animation::animation_track_set_key_animation(int p_track, int p_key, const StringName &p_animation) {
|
|
|
|
|
|
|
|
ERR_FAIL_INDEX(p_track, tracks.size());
|
|
|
|
Track *t = tracks[p_track];
|
|
|
|
ERR_FAIL_COND(t->type != TYPE_ANIMATION);
|
|
|
|
|
|
|
|
AnimationTrack *at = static_cast<AnimationTrack *>(t);
|
|
|
|
|
|
|
|
ERR_FAIL_INDEX(p_key, at->values.size());
|
|
|
|
|
2018-07-25 03:11:03 +02:00
|
|
|
at->values.write[p_key].value = p_animation;
|
2018-06-07 17:46:14 +02:00
|
|
|
|
|
|
|
emit_changed();
|
|
|
|
}
|
|
|
|
|
|
|
|
StringName Animation::animation_track_get_key_animation(int p_track, int p_key) const {
|
|
|
|
|
|
|
|
ERR_FAIL_INDEX_V(p_track, tracks.size(), StringName());
|
|
|
|
const Track *t = tracks[p_track];
|
|
|
|
ERR_FAIL_COND_V(t->type != TYPE_ANIMATION, StringName());
|
|
|
|
|
|
|
|
const AnimationTrack *at = static_cast<const AnimationTrack *>(t);
|
|
|
|
|
|
|
|
ERR_FAIL_INDEX_V(p_key, at->values.size(), StringName());
|
|
|
|
|
|
|
|
return at->values[p_key].value;
|
|
|
|
}
|
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
void Animation::set_length(float p_length) {
|
|
|
|
|
2018-06-08 18:42:04 +02:00
|
|
|
if (p_length < ANIM_MIN_LENGTH) {
|
|
|
|
p_length = ANIM_MIN_LENGTH;
|
|
|
|
}
|
2017-03-05 16:44:50 +01:00
|
|
|
length = p_length;
|
2014-02-10 02:10:30 +01:00
|
|
|
emit_changed();
|
|
|
|
}
|
|
|
|
float Animation::get_length() const {
|
|
|
|
|
|
|
|
return length;
|
2016-03-09 00:00:52 +01:00
|
|
|
}
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
void Animation::set_loop(bool p_enabled) {
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
loop = p_enabled;
|
2014-02-10 02:10:30 +01:00
|
|
|
emit_changed();
|
|
|
|
}
|
|
|
|
bool Animation::has_loop() const {
|
|
|
|
|
|
|
|
return loop;
|
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
void Animation::track_set_imported(int p_track, bool p_imported) {
|
2016-06-20 05:19:04 +02:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_INDEX(p_track, tracks.size());
|
|
|
|
tracks[p_track]->imported = p_imported;
|
2016-06-20 05:19:04 +02:00
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
bool Animation::track_is_imported(int p_track) const {
|
2016-06-20 05:19:04 +02:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_INDEX_V(p_track, tracks.size(), false);
|
2016-06-20 05:19:04 +02:00
|
|
|
return tracks[p_track]->imported;
|
|
|
|
}
|
|
|
|
|
2017-11-28 16:46:37 +01:00
|
|
|
void Animation::track_set_enabled(int p_track, bool p_enabled) {
|
|
|
|
|
|
|
|
ERR_FAIL_INDEX(p_track, tracks.size());
|
|
|
|
tracks[p_track]->enabled = p_enabled;
|
|
|
|
emit_changed();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Animation::track_is_enabled(int p_track) const {
|
|
|
|
|
|
|
|
ERR_FAIL_INDEX_V(p_track, tracks.size(), false);
|
|
|
|
return tracks[p_track]->enabled;
|
|
|
|
}
|
|
|
|
|
2019-05-25 18:01:44 +02:00
|
|
|
void Animation::track_move_up(int p_track) {
|
|
|
|
|
|
|
|
if (p_track >= 0 && p_track < (tracks.size() - 1)) {
|
|
|
|
|
|
|
|
SWAP(tracks.write[p_track], tracks.write[p_track + 1]);
|
|
|
|
}
|
|
|
|
|
|
|
|
emit_changed();
|
|
|
|
emit_signal(SceneStringNames::get_singleton()->tracks_changed);
|
|
|
|
}
|
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
void Animation::track_move_down(int p_track) {
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
if (p_track > 0 && p_track < tracks.size()) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2018-07-25 03:11:03 +02:00
|
|
|
SWAP(tracks.write[p_track], tracks.write[p_track - 1]);
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
2019-05-25 18:01:44 +02:00
|
|
|
|
|
|
|
emit_changed();
|
|
|
|
emit_signal(SceneStringNames::get_singleton()->tracks_changed);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Animation::track_move_to(int p_track, int p_to_index) {
|
|
|
|
|
|
|
|
ERR_FAIL_INDEX(p_track, tracks.size());
|
|
|
|
ERR_FAIL_INDEX(p_to_index, tracks.size() + 1);
|
|
|
|
if (p_track == p_to_index || p_track == p_to_index - 1)
|
|
|
|
return;
|
|
|
|
|
|
|
|
Track *track = tracks.get(p_track);
|
|
|
|
tracks.remove(p_track);
|
|
|
|
// Take into account that the position of the tracks that come after the one removed will change.
|
|
|
|
tracks.insert(p_to_index > p_track ? p_to_index - 1 : p_to_index, track);
|
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
emit_changed();
|
2019-02-14 14:19:03 +01:00
|
|
|
emit_signal(SceneStringNames::get_singleton()->tracks_changed);
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
2018-06-07 17:46:14 +02:00
|
|
|
void Animation::track_swap(int p_track, int p_with_track) {
|
|
|
|
|
|
|
|
ERR_FAIL_INDEX(p_track, tracks.size());
|
|
|
|
ERR_FAIL_INDEX(p_with_track, tracks.size());
|
|
|
|
if (p_track == p_with_track)
|
|
|
|
return;
|
2018-07-25 03:11:03 +02:00
|
|
|
SWAP(tracks.write[p_track], tracks.write[p_with_track]);
|
2019-05-25 18:01:44 +02:00
|
|
|
|
2018-06-07 17:46:14 +02:00
|
|
|
emit_changed();
|
2019-02-14 14:19:03 +01:00
|
|
|
emit_signal(SceneStringNames::get_singleton()->tracks_changed);
|
2018-06-07 17:46:14 +02:00
|
|
|
}
|
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
void Animation::set_step(float p_step) {
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
step = p_step;
|
2014-02-10 02:10:30 +01:00
|
|
|
emit_changed();
|
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
float Animation::get_step() const {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
return step;
|
|
|
|
}
|
|
|
|
|
2018-02-01 09:57:10 +01:00
|
|
|
void Animation::copy_track(int p_track, Ref<Animation> p_to_animation) {
|
2017-12-07 14:18:55 +01:00
|
|
|
ERR_FAIL_COND(p_to_animation.is_null());
|
2018-02-01 09:57:10 +01:00
|
|
|
ERR_FAIL_INDEX(p_track, get_track_count());
|
2017-12-07 14:18:55 +01:00
|
|
|
int dst_track = p_to_animation->get_track_count();
|
2018-02-01 09:57:10 +01:00
|
|
|
p_to_animation->add_track(track_get_type(p_track));
|
|
|
|
|
|
|
|
p_to_animation->track_set_path(dst_track, track_get_path(p_track));
|
|
|
|
p_to_animation->track_set_imported(dst_track, track_is_imported(p_track));
|
|
|
|
p_to_animation->track_set_enabled(dst_track, track_is_enabled(p_track));
|
|
|
|
p_to_animation->track_set_interpolation_type(dst_track, track_get_interpolation_type(p_track));
|
|
|
|
p_to_animation->track_set_interpolation_loop_wrap(dst_track, track_get_interpolation_loop_wrap(p_track));
|
2019-03-26 00:02:11 +01:00
|
|
|
p_to_animation->value_track_set_update_mode(dst_track, value_track_get_update_mode(p_track));
|
2018-02-01 09:57:10 +01:00
|
|
|
for (int i = 0; i < track_get_key_count(p_track); i++) {
|
|
|
|
p_to_animation->track_insert_key(dst_track, track_get_key_time(p_track, i), track_get_key_value(p_track, i), track_get_key_transition(p_track, i));
|
2017-12-07 14:18:55 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
void Animation::_bind_methods() {
|
|
|
|
|
2017-09-10 15:37:49 +02:00
|
|
|
ClassDB::bind_method(D_METHOD("add_track", "type", "at_position"), &Animation::add_track, DEFVAL(-1));
|
2019-10-15 00:08:41 +02:00
|
|
|
ClassDB::bind_method(D_METHOD("remove_track", "track_idx"), &Animation::remove_track);
|
2017-03-05 16:44:50 +01:00
|
|
|
ClassDB::bind_method(D_METHOD("get_track_count"), &Animation::get_track_count);
|
2019-10-15 00:08:41 +02:00
|
|
|
ClassDB::bind_method(D_METHOD("track_get_type", "track_idx"), &Animation::track_get_type);
|
|
|
|
ClassDB::bind_method(D_METHOD("track_get_path", "track_idx"), &Animation::track_get_path);
|
|
|
|
ClassDB::bind_method(D_METHOD("track_set_path", "track_idx", "path"), &Animation::track_set_path);
|
2017-03-05 16:44:50 +01:00
|
|
|
ClassDB::bind_method(D_METHOD("find_track", "path"), &Animation::find_track);
|
2016-06-20 05:19:04 +02:00
|
|
|
|
2019-10-15 00:08:41 +02:00
|
|
|
ClassDB::bind_method(D_METHOD("track_move_up", "track_idx"), &Animation::track_move_up);
|
|
|
|
ClassDB::bind_method(D_METHOD("track_move_down", "track_idx"), &Animation::track_move_down);
|
|
|
|
ClassDB::bind_method(D_METHOD("track_move_to", "track_idx", "to_idx"), &Animation::track_move_to);
|
|
|
|
ClassDB::bind_method(D_METHOD("track_swap", "track_idx", "with_idx"), &Animation::track_swap);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2019-10-15 00:08:41 +02:00
|
|
|
ClassDB::bind_method(D_METHOD("track_set_imported", "track_idx", "imported"), &Animation::track_set_imported);
|
|
|
|
ClassDB::bind_method(D_METHOD("track_is_imported", "track_idx"), &Animation::track_is_imported);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2019-10-15 00:08:41 +02:00
|
|
|
ClassDB::bind_method(D_METHOD("track_set_enabled", "track_idx", "enabled"), &Animation::track_set_enabled);
|
|
|
|
ClassDB::bind_method(D_METHOD("track_is_enabled", "track_idx"), &Animation::track_is_enabled);
|
2017-11-28 16:46:37 +01:00
|
|
|
|
2019-10-15 00:08:41 +02:00
|
|
|
ClassDB::bind_method(D_METHOD("transform_track_insert_key", "track_idx", "time", "location", "rotation", "scale"), &Animation::transform_track_insert_key);
|
|
|
|
ClassDB::bind_method(D_METHOD("track_insert_key", "track_idx", "time", "key", "transition"), &Animation::track_insert_key, DEFVAL(1));
|
|
|
|
ClassDB::bind_method(D_METHOD("track_remove_key", "track_idx", "key_idx"), &Animation::track_remove_key);
|
|
|
|
ClassDB::bind_method(D_METHOD("track_remove_key_at_position", "track_idx", "position"), &Animation::track_remove_key_at_position);
|
|
|
|
ClassDB::bind_method(D_METHOD("track_set_key_value", "track_idx", "key", "value"), &Animation::track_set_key_value);
|
|
|
|
ClassDB::bind_method(D_METHOD("track_set_key_transition", "track_idx", "key_idx", "transition"), &Animation::track_set_key_transition);
|
|
|
|
ClassDB::bind_method(D_METHOD("track_set_key_time", "track_idx", "key_idx", "time"), &Animation::track_set_key_time);
|
|
|
|
ClassDB::bind_method(D_METHOD("track_get_key_transition", "track_idx", "key_idx"), &Animation::track_get_key_transition);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2019-10-15 00:08:41 +02:00
|
|
|
ClassDB::bind_method(D_METHOD("track_get_key_count", "track_idx"), &Animation::track_get_key_count);
|
|
|
|
ClassDB::bind_method(D_METHOD("track_get_key_value", "track_idx", "key_idx"), &Animation::track_get_key_value);
|
|
|
|
ClassDB::bind_method(D_METHOD("track_get_key_time", "track_idx", "key_idx"), &Animation::track_get_key_time);
|
|
|
|
ClassDB::bind_method(D_METHOD("track_find_key", "track_idx", "time", "exact"), &Animation::track_find_key, DEFVAL(false));
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2019-10-15 00:08:41 +02:00
|
|
|
ClassDB::bind_method(D_METHOD("track_set_interpolation_type", "track_idx", "interpolation"), &Animation::track_set_interpolation_type);
|
|
|
|
ClassDB::bind_method(D_METHOD("track_get_interpolation_type", "track_idx"), &Animation::track_get_interpolation_type);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2019-10-15 00:08:41 +02:00
|
|
|
ClassDB::bind_method(D_METHOD("track_set_interpolation_loop_wrap", "track_idx", "interpolation"), &Animation::track_set_interpolation_loop_wrap);
|
|
|
|
ClassDB::bind_method(D_METHOD("track_get_interpolation_loop_wrap", "track_idx"), &Animation::track_get_interpolation_loop_wrap);
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2019-10-15 00:08:41 +02:00
|
|
|
ClassDB::bind_method(D_METHOD("transform_track_interpolate", "track_idx", "time_sec"), &Animation::_transform_track_interpolate);
|
|
|
|
ClassDB::bind_method(D_METHOD("value_track_set_update_mode", "track_idx", "mode"), &Animation::value_track_set_update_mode);
|
|
|
|
ClassDB::bind_method(D_METHOD("value_track_get_update_mode", "track_idx"), &Animation::value_track_get_update_mode);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2019-10-15 00:08:41 +02:00
|
|
|
ClassDB::bind_method(D_METHOD("value_track_get_key_indices", "track_idx", "time_sec", "delta"), &Animation::_value_track_get_key_indices);
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2019-10-15 00:08:41 +02:00
|
|
|
ClassDB::bind_method(D_METHOD("method_track_get_key_indices", "track_idx", "time_sec", "delta"), &Animation::_method_track_get_key_indices);
|
|
|
|
ClassDB::bind_method(D_METHOD("method_track_get_name", "track_idx", "key_idx"), &Animation::method_track_get_name);
|
|
|
|
ClassDB::bind_method(D_METHOD("method_track_get_params", "track_idx", "key_idx"), &Animation::method_track_get_params);
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2019-10-15 00:08:41 +02:00
|
|
|
ClassDB::bind_method(D_METHOD("bezier_track_insert_key", "track_idx", "time", "value", "in_handle", "out_handle"), &Animation::bezier_track_insert_key, DEFVAL(Vector2()), DEFVAL(Vector2()));
|
2018-06-07 17:46:14 +02:00
|
|
|
|
2019-10-15 00:08:41 +02:00
|
|
|
ClassDB::bind_method(D_METHOD("bezier_track_set_key_value", "track_idx", "key_idx", "value"), &Animation::bezier_track_set_key_value);
|
|
|
|
ClassDB::bind_method(D_METHOD("bezier_track_set_key_in_handle", "track_idx", "key_idx", "in_handle"), &Animation::bezier_track_set_key_in_handle);
|
|
|
|
ClassDB::bind_method(D_METHOD("bezier_track_set_key_out_handle", "track_idx", "key_idx", "out_handle"), &Animation::bezier_track_set_key_out_handle);
|
2018-06-07 17:46:14 +02:00
|
|
|
|
2019-10-15 00:08:41 +02:00
|
|
|
ClassDB::bind_method(D_METHOD("bezier_track_get_key_value", "track_idx", "key_idx"), &Animation::bezier_track_get_key_value);
|
|
|
|
ClassDB::bind_method(D_METHOD("bezier_track_get_key_in_handle", "track_idx", "key_idx"), &Animation::bezier_track_get_key_in_handle);
|
|
|
|
ClassDB::bind_method(D_METHOD("bezier_track_get_key_out_handle", "track_idx", "key_idx"), &Animation::bezier_track_get_key_out_handle);
|
2018-06-07 17:46:14 +02:00
|
|
|
|
2019-10-15 00:08:41 +02:00
|
|
|
ClassDB::bind_method(D_METHOD("bezier_track_interpolate", "track_idx", "time"), &Animation::bezier_track_interpolate);
|
2018-06-07 17:46:14 +02:00
|
|
|
|
2019-10-15 00:08:41 +02:00
|
|
|
ClassDB::bind_method(D_METHOD("audio_track_insert_key", "track_idx", "time", "stream", "start_offset", "end_offset"), &Animation::audio_track_insert_key, DEFVAL(0), DEFVAL(0));
|
|
|
|
ClassDB::bind_method(D_METHOD("audio_track_set_key_stream", "track_idx", "key_idx", "stream"), &Animation::audio_track_set_key_stream);
|
|
|
|
ClassDB::bind_method(D_METHOD("audio_track_set_key_start_offset", "track_idx", "key_idx", "offset"), &Animation::audio_track_set_key_start_offset);
|
|
|
|
ClassDB::bind_method(D_METHOD("audio_track_set_key_end_offset", "track_idx", "key_idx", "offset"), &Animation::audio_track_set_key_end_offset);
|
|
|
|
ClassDB::bind_method(D_METHOD("audio_track_get_key_stream", "track_idx", "key_idx"), &Animation::audio_track_get_key_stream);
|
|
|
|
ClassDB::bind_method(D_METHOD("audio_track_get_key_start_offset", "track_idx", "key_idx"), &Animation::audio_track_get_key_start_offset);
|
|
|
|
ClassDB::bind_method(D_METHOD("audio_track_get_key_end_offset", "track_idx", "key_idx"), &Animation::audio_track_get_key_end_offset);
|
2018-06-07 17:46:14 +02:00
|
|
|
|
2019-10-15 00:08:41 +02:00
|
|
|
ClassDB::bind_method(D_METHOD("animation_track_insert_key", "track_idx", "time", "animation"), &Animation::animation_track_insert_key);
|
|
|
|
ClassDB::bind_method(D_METHOD("animation_track_set_key_animation", "track_idx", "key_idx", "animation"), &Animation::animation_track_set_key_animation);
|
|
|
|
ClassDB::bind_method(D_METHOD("animation_track_get_key_animation", "track_idx", "key_idx"), &Animation::animation_track_get_key_animation);
|
2018-06-07 17:46:14 +02:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ClassDB::bind_method(D_METHOD("set_length", "time_sec"), &Animation::set_length);
|
|
|
|
ClassDB::bind_method(D_METHOD("get_length"), &Animation::get_length);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ClassDB::bind_method(D_METHOD("set_loop", "enabled"), &Animation::set_loop);
|
|
|
|
ClassDB::bind_method(D_METHOD("has_loop"), &Animation::has_loop);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ClassDB::bind_method(D_METHOD("set_step", "size_sec"), &Animation::set_step);
|
|
|
|
ClassDB::bind_method(D_METHOD("get_step"), &Animation::get_step);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ClassDB::bind_method(D_METHOD("clear"), &Animation::clear);
|
2019-10-15 00:08:41 +02:00
|
|
|
ClassDB::bind_method(D_METHOD("copy_track", "track_idx", "to_animation"), &Animation::copy_track);
|
2016-03-09 00:00:52 +01:00
|
|
|
|
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT.
- Renames PackedIntArray to PackedInt32Array.
- Renames PackedFloatArray to PackedFloat32Array.
- Adds PackedInt64Array and PackedFloat64Array.
- Renames Variant::REAL to Variant::FLOAT for consistency.
Packed arrays are for storing large amount of data and creating stuff like
meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of
memory. That said, many users requested the ability to have 64 bits packed
arrays for their games, so this is just an optional added type.
For Variant, the float datatype is always 64 bits, and exposed as `float`.
We still have `real_t` which is the datatype that can change from 32 to 64
bits depending on a compile flag (not entirely working right now, but that's
the idea). It affects math related datatypes and code only.
Neither Variant nor PackedArray make use of real_t, which is only intended
for math precision, so the term is removed from there to keep only float.
2020-02-24 19:20:53 +01:00
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "length", PROPERTY_HINT_RANGE, "0.001,99999,0.001"), "set_length", "get_length");
|
2018-01-11 23:35:12 +01:00
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "loop"), "set_loop", "has_loop");
|
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT.
- Renames PackedIntArray to PackedInt32Array.
- Renames PackedFloatArray to PackedFloat32Array.
- Adds PackedInt64Array and PackedFloat64Array.
- Renames Variant::REAL to Variant::FLOAT for consistency.
Packed arrays are for storing large amount of data and creating stuff like
meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of
memory. That said, many users requested the ability to have 64 bits packed
arrays for their games, so this is just an optional added type.
For Variant, the float datatype is always 64 bits, and exposed as `float`.
We still have `real_t` which is the datatype that can change from 32 to 64
bits depending on a compile flag (not entirely working right now, but that's
the idea). It affects math related datatypes and code only.
Neither Variant nor PackedArray make use of real_t, which is only intended
for math precision, so the term is removed from there to keep only float.
2020-02-24 19:20:53 +01:00
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "step", PROPERTY_HINT_RANGE, "0,4096,0.001"), "set_step", "get_step");
|
2018-01-11 23:35:12 +01:00
|
|
|
|
2019-02-14 14:19:03 +01:00
|
|
|
ADD_SIGNAL(MethodInfo("tracks_changed"));
|
|
|
|
|
2017-08-20 17:45:01 +02:00
|
|
|
BIND_ENUM_CONSTANT(TYPE_VALUE);
|
|
|
|
BIND_ENUM_CONSTANT(TYPE_TRANSFORM);
|
|
|
|
BIND_ENUM_CONSTANT(TYPE_METHOD);
|
2018-06-07 17:46:14 +02:00
|
|
|
BIND_ENUM_CONSTANT(TYPE_BEZIER);
|
|
|
|
BIND_ENUM_CONSTANT(TYPE_AUDIO);
|
|
|
|
BIND_ENUM_CONSTANT(TYPE_ANIMATION);
|
2016-06-19 06:43:02 +02:00
|
|
|
|
2017-08-20 17:45:01 +02:00
|
|
|
BIND_ENUM_CONSTANT(INTERPOLATION_NEAREST);
|
|
|
|
BIND_ENUM_CONSTANT(INTERPOLATION_LINEAR);
|
|
|
|
BIND_ENUM_CONSTANT(INTERPOLATION_CUBIC);
|
2016-06-19 06:43:02 +02:00
|
|
|
|
2017-08-20 17:45:01 +02:00
|
|
|
BIND_ENUM_CONSTANT(UPDATE_CONTINUOUS);
|
|
|
|
BIND_ENUM_CONSTANT(UPDATE_DISCRETE);
|
|
|
|
BIND_ENUM_CONSTANT(UPDATE_TRIGGER);
|
2018-06-07 17:46:14 +02:00
|
|
|
BIND_ENUM_CONSTANT(UPDATE_CAPTURE);
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void Animation::clear() {
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
for (int i = 0; i < tracks.size(); i++)
|
|
|
|
memdelete(tracks[i]);
|
2014-02-10 02:10:30 +01:00
|
|
|
tracks.clear();
|
2017-03-05 16:44:50 +01:00
|
|
|
loop = false;
|
|
|
|
length = 1;
|
2019-02-14 14:19:03 +01:00
|
|
|
emit_changed();
|
|
|
|
emit_signal(SceneStringNames::get_singleton()->tracks_changed);
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
bool Animation::_transform_track_optimize_key(const TKey<TransformKey> &t0, const TKey<TransformKey> &t1, const TKey<TransformKey> &t2, float p_alowed_linear_err, float p_alowed_angular_err, float p_max_optimizable_angle, const Vector3 &p_norm) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
real_t c = (t1.time - t0.time) / (t2.time - t0.time);
|
|
|
|
real_t t[3] = { -1, -1, -1 };
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2014-11-12 15:23:23 +01:00
|
|
|
{ //translation
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
const Vector3 &v0 = t0.value.loc;
|
|
|
|
const Vector3 &v1 = t1.value.loc;
|
|
|
|
const Vector3 &v2 = t2.value.loc;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2019-10-02 22:31:09 +02:00
|
|
|
if (v0.is_equal_approx(v2)) {
|
2014-11-12 15:23:23 +01:00
|
|
|
//0 and 2 are close, let's see if 1 is close
|
2019-10-02 22:31:09 +02:00
|
|
|
if (!v0.is_equal_approx(v1)) {
|
2014-11-12 15:23:23 +01:00
|
|
|
//not close, not optimizable
|
|
|
|
return false;
|
|
|
|
}
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2014-11-12 15:23:23 +01:00
|
|
|
} else {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
Vector3 pd = (v2 - v0);
|
2014-11-12 15:23:23 +01:00
|
|
|
float d0 = pd.dot(v0);
|
|
|
|
float d1 = pd.dot(v1);
|
|
|
|
float d2 = pd.dot(v2);
|
2017-03-05 16:44:50 +01:00
|
|
|
if (d1 < d0 || d1 > d2) {
|
2014-11-12 15:23:23 +01:00
|
|
|
return false;
|
|
|
|
}
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
Vector3 s[2] = { v0, v2 };
|
|
|
|
real_t d = Geometry::get_closest_point_to_segment(v1, s).distance_to(v1);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
if (d > pd.length() * p_alowed_linear_err) {
|
2014-11-12 15:23:23 +01:00
|
|
|
return false; //beyond allowed error for colinearity
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
if (p_norm != Vector3() && Math::acos(pd.normalized().dot(p_norm)) > p_alowed_angular_err)
|
2015-06-30 16:28:43 +02:00
|
|
|
return false;
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
t[0] = (d1 - d0) / (d2 - d0);
|
2014-11-12 15:23:23 +01:00
|
|
|
}
|
|
|
|
}
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2014-11-12 15:23:23 +01:00
|
|
|
{ //rotation
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
const Quat &q0 = t0.value.rot;
|
|
|
|
const Quat &q1 = t1.value.rot;
|
|
|
|
const Quat &q2 = t2.value.rot;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2014-11-12 15:23:23 +01:00
|
|
|
//localize both to rotation from q0
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2019-10-02 22:31:09 +02:00
|
|
|
if (q0.is_equal_approx(q2)) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2019-10-02 22:31:09 +02:00
|
|
|
if (!q0.is_equal_approx(q1))
|
2014-11-12 15:23:23 +01:00
|
|
|
return false;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2014-11-12 15:23:23 +01:00
|
|
|
} else {
|
2014-10-03 05:10:51 +02:00
|
|
|
|
2014-11-12 15:23:23 +01:00
|
|
|
Quat r02 = (q0.inverse() * q2).normalized();
|
|
|
|
Quat r01 = (q0.inverse() * q1).normalized();
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
Vector3 v02, v01;
|
|
|
|
real_t a02, a01;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-04-06 00:47:13 +02:00
|
|
|
r02.get_axis_angle(v02, a02);
|
|
|
|
r01.get_axis_angle(v01, a01);
|
2014-10-03 05:10:51 +02:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
if (Math::abs(a02) > p_max_optimizable_angle)
|
2014-11-12 15:23:23 +01:00
|
|
|
return false;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
if (v01.dot(v02) < 0) {
|
2014-11-12 15:23:23 +01:00
|
|
|
//make sure both rotations go the same way to compare
|
2017-03-05 16:44:50 +01:00
|
|
|
v02 = -v02;
|
|
|
|
a02 = -a02;
|
2014-11-12 15:23:23 +01:00
|
|
|
}
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
real_t err_01 = Math::acos(v01.normalized().dot(v02.normalized())) / Math_PI;
|
|
|
|
if (err_01 > p_alowed_angular_err) {
|
2014-11-12 15:23:23 +01:00
|
|
|
//not rotating in the same axis
|
|
|
|
return false;
|
|
|
|
}
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
if (a01 * a02 < 0) {
|
2014-11-12 15:23:23 +01:00
|
|
|
//not rotating in the same direction
|
|
|
|
return false;
|
|
|
|
}
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
real_t tr = a01 / a02;
|
|
|
|
if (tr < 0 || tr > 1)
|
2014-11-12 15:23:23 +01:00
|
|
|
return false; //rotating too much or too less
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
t[1] = tr;
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
2014-11-12 15:23:23 +01:00
|
|
|
}
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2014-11-12 15:23:23 +01:00
|
|
|
{ //scale
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
const Vector3 &v0 = t0.value.scale;
|
|
|
|
const Vector3 &v1 = t1.value.scale;
|
|
|
|
const Vector3 &v2 = t2.value.scale;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2019-10-02 22:31:09 +02:00
|
|
|
if (v0.is_equal_approx(v2)) {
|
2014-11-12 15:23:23 +01:00
|
|
|
//0 and 2 are close, let's see if 1 is close
|
2019-10-02 22:31:09 +02:00
|
|
|
if (!v0.is_equal_approx(v1)) {
|
2014-11-12 15:23:23 +01:00
|
|
|
//not close, not optimizable
|
|
|
|
return false;
|
|
|
|
}
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2014-11-12 15:23:23 +01:00
|
|
|
} else {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
Vector3 pd = (v2 - v0);
|
2014-11-12 15:23:23 +01:00
|
|
|
float d0 = pd.dot(v0);
|
|
|
|
float d1 = pd.dot(v1);
|
|
|
|
float d2 = pd.dot(v2);
|
2017-03-05 16:44:50 +01:00
|
|
|
if (d1 < d0 || d1 > d2) {
|
2014-11-12 15:23:23 +01:00
|
|
|
return false; //beyond segment range
|
|
|
|
}
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
Vector3 s[2] = { v0, v2 };
|
|
|
|
real_t d = Geometry::get_closest_point_to_segment(v1, s).distance_to(v1);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
if (d > pd.length() * p_alowed_linear_err) {
|
2014-11-12 15:23:23 +01:00
|
|
|
return false; //beyond allowed error for colinearity
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
2014-11-12 15:23:23 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
t[2] = (d1 - d0) / (d2 - d0);
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
2014-11-12 15:23:23 +01:00
|
|
|
}
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
bool erase = false;
|
|
|
|
if (t[0] == -1 && t[1] == -1 && t[2] == -1) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
erase = true;
|
2014-11-12 15:23:23 +01:00
|
|
|
} else {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
erase = true;
|
|
|
|
real_t lt = -1;
|
|
|
|
for (int j = 0; j < 3; j++) {
|
2014-11-12 15:23:23 +01:00
|
|
|
//search for t on first, one must be it
|
2017-03-05 16:44:50 +01:00
|
|
|
if (t[j] != -1) {
|
|
|
|
lt = t[j]; //official t
|
2014-11-12 15:23:23 +01:00
|
|
|
//validate rest
|
2017-03-05 16:44:50 +01:00
|
|
|
for (int k = j + 1; k < 3; k++) {
|
|
|
|
if (t[k] == -1)
|
2014-11-12 15:23:23 +01:00
|
|
|
continue;
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
if (Math::abs(lt - t[k]) > p_alowed_linear_err) {
|
|
|
|
erase = false;
|
2014-11-12 15:23:23 +01:00
|
|
|
break;
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
}
|
2014-11-12 15:23:23 +01:00
|
|
|
break;
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
2014-11-12 15:23:23 +01:00
|
|
|
}
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_COND_V(lt == -1, false);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2014-11-12 15:23:23 +01:00
|
|
|
if (erase) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
if (Math::abs(lt - c) > p_alowed_linear_err) {
|
2014-11-12 15:23:23 +01:00
|
|
|
//todo, evaluate changing the transition if this fails?
|
|
|
|
//this could be done as a second pass and would be
|
|
|
|
//able to optimize more
|
2017-03-05 16:44:50 +01:00
|
|
|
erase = false;
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
2014-11-12 15:23:23 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return erase;
|
|
|
|
}
|
|
|
|
|
2017-08-11 21:10:05 +02:00
|
|
|
void Animation::_transform_track_optimize(int p_idx, float p_allowed_linear_err, float p_allowed_angular_err, float p_max_optimizable_angle) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_INDEX(p_idx, tracks.size());
|
|
|
|
ERR_FAIL_COND(tracks[p_idx]->type != TYPE_TRANSFORM);
|
|
|
|
TransformTrack *tt = static_cast<TransformTrack *>(tracks[p_idx]);
|
|
|
|
bool prev_erased = false;
|
2014-11-12 15:23:23 +01:00
|
|
|
TKey<TransformKey> first_erased;
|
|
|
|
|
2015-06-30 16:28:43 +02:00
|
|
|
Vector3 norm;
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
for (int i = 1; i < tt->transforms.size() - 1; i++) {
|
2014-11-12 15:23:23 +01:00
|
|
|
|
2018-07-25 03:11:03 +02:00
|
|
|
TKey<TransformKey> &t0 = tt->transforms.write[i - 1];
|
|
|
|
TKey<TransformKey> &t1 = tt->transforms.write[i];
|
|
|
|
TKey<TransformKey> &t2 = tt->transforms.write[i + 1];
|
2014-11-12 15:23:23 +01:00
|
|
|
|
2017-08-11 21:10:05 +02:00
|
|
|
bool erase = _transform_track_optimize_key(t0, t1, t2, p_allowed_linear_err, p_allowed_angular_err, p_max_optimizable_angle, norm);
|
2015-06-30 16:28:43 +02:00
|
|
|
if (erase && !prev_erased) {
|
2017-03-05 16:44:50 +01:00
|
|
|
norm = (t2.value.loc - t1.value.loc).normalized();
|
2015-06-30 16:28:43 +02:00
|
|
|
}
|
2014-11-12 15:23:23 +01:00
|
|
|
|
2017-08-11 21:10:05 +02:00
|
|
|
if (prev_erased && !_transform_track_optimize_key(t0, first_erased, t2, p_allowed_linear_err, p_allowed_angular_err, p_max_optimizable_angle, norm)) {
|
2017-03-05 16:44:50 +01:00
|
|
|
//avoid error to go beyond first erased key
|
|
|
|
erase = false;
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if (erase) {
|
2014-11-12 15:23:23 +01:00
|
|
|
|
|
|
|
if (!prev_erased) {
|
2017-03-05 16:44:50 +01:00
|
|
|
first_erased = t1;
|
|
|
|
prev_erased = true;
|
2014-11-12 15:23:23 +01:00
|
|
|
}
|
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
tt->transforms.remove(i);
|
|
|
|
i--;
|
2014-11-12 15:23:23 +01:00
|
|
|
|
|
|
|
} else {
|
2017-03-05 16:44:50 +01:00
|
|
|
prev_erased = false;
|
|
|
|
norm = Vector3();
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-08-11 21:10:05 +02:00
|
|
|
void Animation::optimize(float p_allowed_linear_err, float p_allowed_angular_err, float p_max_optimizable_angle) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
for (int i = 0; i < tracks.size(); i++) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
if (tracks[i]->type == TYPE_TRANSFORM)
|
2017-08-11 21:10:05 +02:00
|
|
|
_transform_track_optimize(i, p_allowed_linear_err, p_allowed_angular_err, p_max_optimizable_angle);
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Animation::Animation() {
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
step = 0.1;
|
|
|
|
loop = false;
|
|
|
|
length = 1;
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
Animation::~Animation() {
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
for (int i = 0; i < tracks.size(); i++)
|
|
|
|
memdelete(tracks[i]);
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|