diff options
Diffstat (limited to 'scene/resources/animation.cpp')
| -rw-r--r-- | scene/resources/animation.cpp | 1562 |
1 files changed, 729 insertions, 833 deletions
diff --git a/scene/resources/animation.cpp b/scene/resources/animation.cpp index b743834e63..4fddd55e20 100644 --- a/scene/resources/animation.cpp +++ b/scene/resources/animation.cpp @@ -29,33 +29,32 @@ #include "animation.h" #include "geometry.h" +bool Animation::_set(const StringName &p_name, const Variant &p_value) { -bool Animation::_set(const StringName& p_name, const Variant& p_value) { + String name = p_name; - String name=p_name; - - if (name=="length") + if (name == "length") set_length(p_value); - else if (name=="loop") + else if (name == "loop") set_loop(p_value); - else if (name=="step") + else if (name == "step") set_step(p_value); else if (name.begins_with("tracks/")) { - int track=name.get_slicec('/',1).to_int(); - String what=name.get_slicec('/',2); + int track = name.get_slicec('/', 1).to_int(); + String what = name.get_slicec('/', 2); - if (tracks.size()==track && what=="type") { + if (tracks.size() == track && what == "type") { - String type=p_value; + String type = p_value; - if (type=="transform") { + if (type == "transform") { add_track(TYPE_TRANSFORM); - } else if (type=="value") { + } else if (type == "value") { add_track(TYPE_VALUE); - } else if (type=="method") { + } else if (type == "method") { add_track(TYPE_METHOD); } else { @@ -66,23 +65,23 @@ bool Animation::_set(const StringName& p_name, const Variant& p_value) { return true; } - ERR_FAIL_INDEX_V( track, tracks.size(),false ); + ERR_FAIL_INDEX_V(track, tracks.size(), false); - 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); - else if (what == "keys" || what=="key_values") { + 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); + else if (what == "keys" || what == "key_values") { - if (track_get_type(track)==TYPE_TRANSFORM) { + if (track_get_type(track) == TYPE_TRANSFORM) { - TransformTrack *tt = static_cast<TransformTrack*>(tracks[track]); - PoolVector<float> values=p_value; - int vcount=values.size(); + TransformTrack *tt = static_cast<TransformTrack *>(tracks[track]); + PoolVector<float> values = p_value; + int vcount = values.size(); #if 0 // old compatibility hack if ((vcount%11) == 0) { @@ -121,137 +120,126 @@ bool Animation::_set(const StringName& p_name, const Variant& p_value) { } #endif - ERR_FAIL_COND_V(vcount%12,false); // shuld be multiple of 11 + ERR_FAIL_COND_V(vcount % 12, false); // shuld be multiple of 11 PoolVector<float>::Read r = values.read(); - tt->transforms.resize(vcount/12); - - - for(int i=0;i<(vcount/12);i++) { - + tt->transforms.resize(vcount / 12); - TKey<TransformKey> &tk=tt->transforms[i]; - const float *ofs=&r[i*12]; - tk.time=ofs[0]; - tk.transition=ofs[1]; + for (int i = 0; i < (vcount / 12); i++) { - tk.value.loc.x=ofs[2]; - tk.value.loc.y=ofs[3]; - tk.value.loc.z=ofs[4]; + TKey<TransformKey> &tk = tt->transforms[i]; + const float *ofs = &r[i * 12]; + tk.time = ofs[0]; + tk.transition = ofs[1]; - tk.value.rot.x=ofs[5]; - tk.value.rot.y=ofs[6]; - tk.value.rot.z=ofs[7]; - tk.value.rot.w=ofs[8]; - - tk.value.scale.x=ofs[9]; - tk.value.scale.y=ofs[10]; - tk.value.scale.z=ofs[11]; + tk.value.loc.x = ofs[2]; + tk.value.loc.y = ofs[3]; + tk.value.loc.z = ofs[4]; + tk.value.rot.x = ofs[5]; + tk.value.rot.y = ofs[6]; + tk.value.rot.z = ofs[7]; + tk.value.rot.w = ofs[8]; + tk.value.scale.x = ofs[9]; + tk.value.scale.y = ofs[10]; + tk.value.scale.z = ofs[11]; } - } else if (track_get_type(track)==TYPE_VALUE) { + } else if (track_get_type(track) == TYPE_VALUE) { - ValueTrack *vt = static_cast<ValueTrack*>(tracks[track]); + ValueTrack *vt = static_cast<ValueTrack *>(tracks[track]); Dictionary d = p_value; - ERR_FAIL_COND_V(!d.has("times"),false); - ERR_FAIL_COND_V(!d.has("values"),false); + ERR_FAIL_COND_V(!d.has("times"), false); + ERR_FAIL_COND_V(!d.has("values"), false); if (d.has("cont")) { bool v = d["cont"]; - vt->update_mode=v?UPDATE_CONTINUOUS:UPDATE_DISCRETE; + vt->update_mode = v ? UPDATE_CONTINUOUS : UPDATE_DISCRETE; } if (d.has("update")) { - int um =d["update"]; - if (um<0) - um=0; - else if (um>2) - um=2; - vt->update_mode=UpdateMode(um); + int um = d["update"]; + if (um < 0) + um = 0; + else if (um > 2) + um = 2; + vt->update_mode = UpdateMode(um); } + PoolVector<float> times = d["times"]; + Array values = d["values"]; - - PoolVector<float> times=d["times"]; - Array values=d["values"]; - - ERR_FAIL_COND_V(times.size()!=values.size(),false); + ERR_FAIL_COND_V(times.size() != values.size(), false); if (times.size()) { - int valcount=times.size(); + int valcount = times.size(); PoolVector<float>::Read rt = times.read(); vt->values.resize(valcount); - for(int i=0;i<valcount;i++) { + for (int i = 0; i < valcount; i++) { - vt->values[i].time=rt[i]; - vt->values[i].value=values[i]; + vt->values[i].time = rt[i]; + vt->values[i].value = values[i]; } if (d.has("transitions")) { PoolVector<float> transitions = d["transitions"]; - ERR_FAIL_COND_V(transitions.size()!=valcount,false); + ERR_FAIL_COND_V(transitions.size() != valcount, false); PoolVector<float>::Read rtr = transitions.read(); + for (int i = 0; i < valcount; i++) { - for(int i=0;i<valcount;i++) { - - vt->values[i].transition=rtr[i]; + vt->values[i].transition = rtr[i]; } } - } return true; } else { - while(track_get_key_count(track)) - track_remove_key(track,0); //well shouldn't be set anyway + while (track_get_key_count(track)) + track_remove_key(track, 0); //well shouldn't be set anyway Dictionary d = p_value; - ERR_FAIL_COND_V(!d.has("times"),false); - ERR_FAIL_COND_V(!d.has("values"),false); + ERR_FAIL_COND_V(!d.has("times"), false); + ERR_FAIL_COND_V(!d.has("values"), false); - PoolVector<float> times=d["times"]; - Array values=d["values"]; + PoolVector<float> times = d["times"]; + Array values = d["values"]; - ERR_FAIL_COND_V(times.size()!=values.size(),false); + ERR_FAIL_COND_V(times.size() != values.size(), false); if (times.size()) { - int valcount=times.size(); + int valcount = times.size(); PoolVector<float>::Read rt = times.read(); - for(int i=0;i<valcount;i++) { + for (int i = 0; i < valcount; i++) { - track_insert_key(track,rt[i],values[i]); + track_insert_key(track, rt[i], values[i]); } if (d.has("transitions")) { PoolVector<float> transitions = d["transitions"]; - ERR_FAIL_COND_V(transitions.size()!=valcount,false); + ERR_FAIL_COND_V(transitions.size() != valcount, false); PoolVector<float>::Read rtr = transitions.read(); - for(int i=0;i<valcount;i++) { + for (int i = 0; i < valcount; i++) { - track_set_key_transition(track,i,rtr[i]); + track_set_key_transition(track, i, rtr[i]); } } - } - - } } else return false; @@ -261,84 +249,81 @@ bool Animation::_set(const StringName& p_name, const Variant& p_value) { return true; } +bool Animation::_get(const StringName &p_name, Variant &r_ret) const { -bool Animation::_get(const StringName& p_name,Variant &r_ret) const { + String name = p_name; - String name=p_name; - - if (name=="length") - r_ret= length; - else if (name=="loop") - r_ret= loop; - else if (name=="step") - r_ret= step; + if (name == "length") + r_ret = length; + else if (name == "loop") + r_ret = loop; + else if (name == "step") + r_ret = step; else if (name.begins_with("tracks/")) { - 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") { - + 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") { switch (track_get_type(track)) { - case TYPE_TRANSFORM: r_ret= "transform"; break; - case TYPE_VALUE: r_ret= "value";break; - case TYPE_METHOD: r_ret= "method";break; + case TYPE_TRANSFORM: r_ret = "transform"; break; + case TYPE_VALUE: r_ret = "value"; break; + case TYPE_METHOD: r_ret = "method"; break; } return true; - } else if (what=="path") - r_ret=track_get_path(track); - else if (what=="interp") + } else if (what == "path") + r_ret = track_get_path(track); + else if (what == "interp") r_ret = track_get_interpolation_type(track); - else if (what=="loop_wrap") + else if (what == "loop_wrap") r_ret = track_get_interpolation_loop_wrap(track); - else if (what=="imported") + else if (what == "imported") r_ret = track_is_imported(track); - else if (what=="keys") { + else if (what == "keys") { - if (track_get_type(track)==TYPE_TRANSFORM) { + if (track_get_type(track) == TYPE_TRANSFORM) { PoolVector<real_t> keys; - int kk=track_get_key_count(track); - keys.resize(kk*12); + int kk = track_get_key_count(track); + keys.resize(kk * 12); PoolVector<real_t>::Write w = keys.write(); - int idx=0; - for(int i=0;i<track_get_key_count(track);i++) { + int idx = 0; + for (int i = 0; i < track_get_key_count(track); i++) { Vector3 loc; Quat rot; Vector3 scale; - 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; + 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; } w = PoolVector<real_t>::Write(); - r_ret=keys; + r_ret = keys; return true; - } else if (track_get_type(track)==TYPE_VALUE) { - + } else if (track_get_type(track) == TYPE_VALUE) { - const ValueTrack *vt = static_cast<const ValueTrack*>(tracks[track]); + const ValueTrack *vt = static_cast<const ValueTrack *>(tracks[track]); Dictionary d; @@ -346,82 +331,80 @@ bool Animation::_get(const StringName& p_name,Variant &r_ret) const { PoolVector<float> key_transitions; Array key_values; - int kk=vt->values.size(); + int kk = vt->values.size(); key_times.resize(kk); key_transitions.resize(kk); key_values.resize(kk); - PoolVector<float>::Write wti=key_times.write(); - PoolVector<float>::Write wtr=key_transitions.write(); + PoolVector<float>::Write wti = key_times.write(); + PoolVector<float>::Write wtr = key_transitions.write(); - int idx=0; + int idx = 0; const TKey<Variant> *vls = vt->values.ptr(); - for(int i=0;i<kk;i++) { + for (int i = 0; i < kk; i++) { - wti[idx]=vls[i].time; - wtr[idx]=vls[i].transition; - key_values[idx]=vls[i].value; + wti[idx] = vls[i].time; + wtr[idx] = vls[i].transition; + key_values[idx] = vls[i].value; idx++; } - wti=PoolVector<float>::Write(); - wtr=PoolVector<float>::Write(); + wti = PoolVector<float>::Write(); + wtr = PoolVector<float>::Write(); - 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); + 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); } - r_ret=d; + r_ret = d; return true; } else { - Dictionary d; PoolVector<float> key_times; PoolVector<float> key_transitions; Array key_values; - int kk=track_get_key_count(track); + int kk = track_get_key_count(track); key_times.resize(kk); key_transitions.resize(kk); key_values.resize(kk); - PoolVector<float>::Write wti=key_times.write(); - PoolVector<float>::Write wtr=key_transitions.write(); + PoolVector<float>::Write wti = key_times.write(); + PoolVector<float>::Write wtr = key_transitions.write(); - int idx=0; - for(int i=0;i<track_get_key_count(track);i++) { + int idx = 0; + for (int i = 0; i < track_get_key_count(track); i++) { - 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); + 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); idx++; } - wti=PoolVector<float>::Write(); - wtr=PoolVector<float>::Write(); + wti = PoolVector<float>::Write(); + wtr = PoolVector<float>::Write(); - 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); + 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); } - r_ret=d; + r_ret = d; return true; - } } else return false; @@ -429,47 +412,45 @@ bool Animation::_get(const StringName& p_name,Variant &r_ret) const { return false; return true; - } +void Animation::_get_property_list(List<PropertyInfo> *p_list) const { -void Animation::_get_property_list( List<PropertyInfo> *p_list) const { - - p_list->push_back( PropertyInfo( Variant::REAL, "length", PROPERTY_HINT_RANGE, "0.001,99999,0.001")); - p_list->push_back( PropertyInfo( Variant::BOOL, "loop" )); - p_list->push_back( PropertyInfo( Variant::REAL, "step", PROPERTY_HINT_RANGE, "0,4096,0.001" )); + p_list->push_back(PropertyInfo(Variant::REAL, "length", PROPERTY_HINT_RANGE, "0.001,99999,0.001")); + p_list->push_back(PropertyInfo(Variant::BOOL, "loop")); + p_list->push_back(PropertyInfo(Variant::REAL, "step", PROPERTY_HINT_RANGE, "0,4096,0.001")); - for (int i=0;i<tracks.size();i++) { + for (int i = 0; i < tracks.size(); i++) { - p_list->push_back( PropertyInfo( Variant::STRING, "tracks/"+itos(i)+"/type", PROPERTY_HINT_NONE,"",PROPERTY_USAGE_NOEDITOR) ); - p_list->push_back( PropertyInfo( Variant::NODE_PATH, "tracks/"+itos(i)+"/path", PROPERTY_HINT_NONE,"",PROPERTY_USAGE_NOEDITOR) ); - p_list->push_back( PropertyInfo( Variant::INT, "tracks/"+itos(i)+"/interp", PROPERTY_HINT_NONE,"",PROPERTY_USAGE_NOEDITOR) ); - p_list->push_back( PropertyInfo( Variant::BOOL, "tracks/"+itos(i)+"/loop_wrap", PROPERTY_HINT_NONE,"",PROPERTY_USAGE_NOEDITOR) ); - p_list->push_back( PropertyInfo( Variant::BOOL, "tracks/"+itos(i)+"/imported", PROPERTY_HINT_NONE,"",PROPERTY_USAGE_NOEDITOR) ); - p_list->push_back( PropertyInfo( Variant::ARRAY, "tracks/"+itos(i)+"/keys", PROPERTY_HINT_NONE,"",PROPERTY_USAGE_NOEDITOR) ); + p_list->push_back(PropertyInfo(Variant::STRING, "tracks/" + itos(i) + "/type", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR)); + p_list->push_back(PropertyInfo(Variant::NODE_PATH, "tracks/" + itos(i) + "/path", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR)); + p_list->push_back(PropertyInfo(Variant::INT, "tracks/" + itos(i) + "/interp", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR)); + p_list->push_back(PropertyInfo(Variant::BOOL, "tracks/" + itos(i) + "/loop_wrap", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR)); + p_list->push_back(PropertyInfo(Variant::BOOL, "tracks/" + itos(i) + "/imported", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR)); + p_list->push_back(PropertyInfo(Variant::ARRAY, "tracks/" + itos(i) + "/keys", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR)); } } -int Animation::add_track(TrackType p_type,int p_at_pos) { +int Animation::add_track(TrackType p_type, int p_at_pos) { - if (p_at_pos<0 || p_at_pos>=tracks.size()) - p_at_pos=tracks.size(); + if (p_at_pos < 0 || p_at_pos >= tracks.size()) + p_at_pos = tracks.size(); - switch( p_type ) { + switch (p_type) { case TYPE_TRANSFORM: { - TransformTrack *tt = memnew( TransformTrack ); - tracks.insert( p_at_pos,tt ); + TransformTrack *tt = memnew(TransformTrack); + tracks.insert(p_at_pos, tt); } break; case TYPE_VALUE: { - tracks.insert( p_at_pos,memnew( ValueTrack ) ); + tracks.insert(p_at_pos, memnew(ValueTrack)); } break; case TYPE_METHOD: { - tracks.insert( p_at_pos,memnew( MethodTrack ) ); + tracks.insert(p_at_pos, memnew(MethodTrack)); } break; default: { @@ -484,31 +465,31 @@ int Animation::add_track(TrackType p_type,int p_at_pos) { void Animation::remove_track(int p_track) { ERR_FAIL_INDEX(p_track, tracks.size()); - Track *t=tracks[p_track]; + Track *t = tracks[p_track]; - switch(t->type) { + switch (t->type) { case TYPE_TRANSFORM: { - TransformTrack * tt = static_cast<TransformTrack*>(t); + TransformTrack *tt = static_cast<TransformTrack *>(t); _clear(tt->transforms); } break; case TYPE_VALUE: { - ValueTrack * vt = static_cast<ValueTrack*>(t); + ValueTrack *vt = static_cast<ValueTrack *>(t); _clear(vt->values); } break; case TYPE_METHOD: { - MethodTrack * mt = static_cast<MethodTrack*>(t); + MethodTrack *mt = static_cast<MethodTrack *>(t); _clear(mt->methods); } break; } - memdelete( t ); + memdelete(t); tracks.remove(p_track); emit_changed(); } @@ -520,27 +501,26 @@ int Animation::get_track_count() const { Animation::TrackType Animation::track_get_type(int p_track) const { - ERR_FAIL_INDEX_V(p_track, tracks.size(), TYPE_TRANSFORM ); + ERR_FAIL_INDEX_V(p_track, tracks.size(), TYPE_TRANSFORM); return tracks[p_track]->type; } -void Animation::track_set_path(int p_track,const NodePath& p_path) { +void Animation::track_set_path(int p_track, const NodePath &p_path) { ERR_FAIL_INDEX(p_track, tracks.size()); - tracks[p_track]->path=p_path; + tracks[p_track]->path = p_path; emit_changed(); - } NodePath Animation::track_get_path(int p_track) const { - ERR_FAIL_INDEX_V(p_track, tracks.size(),NodePath()); + ERR_FAIL_INDEX_V(p_track, tracks.size(), NodePath()); return tracks[p_track]->path; } -int Animation::find_track(const NodePath& p_path) const { +int Animation::find_track(const NodePath &p_path) const { - for (int i=0; i<tracks.size(); i++) { + for (int i = 0; i < tracks.size(); i++) { if (tracks[i]->path == p_path) return i; @@ -548,34 +528,30 @@ int Animation::find_track(const NodePath& p_path) const { return -1; }; - -void Animation::track_set_interpolation_type(int p_track,InterpolationType p_interp) { +void Animation::track_set_interpolation_type(int p_track, InterpolationType p_interp) { ERR_FAIL_INDEX(p_track, tracks.size()); - ERR_FAIL_INDEX(p_interp,3); - tracks[p_track]->interpolation=p_interp; + ERR_FAIL_INDEX(p_interp, 3); + tracks[p_track]->interpolation = p_interp; emit_changed(); - } Animation::InterpolationType Animation::track_get_interpolation_type(int p_track) const { - ERR_FAIL_INDEX_V(p_track, tracks.size(),INTERPOLATION_NEAREST); + ERR_FAIL_INDEX_V(p_track, tracks.size(), INTERPOLATION_NEAREST); return tracks[p_track]->interpolation; } -void Animation::track_set_interpolation_loop_wrap(int p_track,bool p_enable) { +void Animation::track_set_interpolation_loop_wrap(int p_track, bool p_enable) { ERR_FAIL_INDEX(p_track, tracks.size()); - tracks[p_track]->loop_wrap=p_enable; + tracks[p_track]->loop_wrap = p_enable; emit_changed(); - } -bool Animation::track_get_interpolation_loop_wrap(int p_track) const{ +bool Animation::track_get_interpolation_loop_wrap(int p_track) const { - ERR_FAIL_INDEX_V(p_track, tracks.size(),INTERPOLATION_NEAREST); + ERR_FAIL_INDEX_V(p_track, tracks.size(), INTERPOLATION_NEAREST); return tracks[p_track]->loop_wrap; - } // transform @@ -605,23 +581,22 @@ int Animation::_insert_pos(float p_time, T& p_keys) { } */ -template<class T, class V> -int Animation::_insert(float p_time, T& p_keys, const V& p_value) { +template <class T, class V> +int Animation::_insert(float p_time, T &p_keys, const V &p_value) { - int idx=p_keys.size(); + int idx = p_keys.size(); - while(true) { + while (true) { - - if (idx==0 || p_keys[idx-1].time < p_time) { + if (idx == 0 || p_keys[idx - 1].time < p_time) { //condition for insertion. - p_keys.insert(idx,p_value); + p_keys.insert(idx, p_value); return idx; - } else if (p_keys[idx-1].time == p_time) { + } else if (p_keys[idx - 1].time == p_time) { // condition for replacing. - p_keys[idx-1]=p_value; - return idx-1; + p_keys[idx - 1] = p_value; + return idx - 1; } idx--; @@ -630,82 +605,81 @@ int Animation::_insert(float p_time, T& p_keys, const V& p_value) { return -1; } -template<class T> -void Animation::_clear(T& p_keys) { - +template <class T> +void Animation::_clear(T &p_keys) { p_keys.clear(); } -Error Animation::transform_track_get_key(int p_track, int p_key, Vector3* r_loc, Quat* r_rot, Vector3* r_scale) const { +Error Animation::transform_track_get_key(int p_track, int p_key, Vector3 *r_loc, Quat *r_rot, Vector3 *r_scale) const { - ERR_FAIL_INDEX_V(p_track, tracks.size(),ERR_INVALID_PARAMETER); - Track *t=tracks[p_track]; + ERR_FAIL_INDEX_V(p_track, tracks.size(), ERR_INVALID_PARAMETER); + Track *t = tracks[p_track]; - 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); + 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); if (r_loc) - *r_loc=tt->transforms[p_key].value.loc; + *r_loc = tt->transforms[p_key].value.loc; if (r_rot) - *r_rot=tt->transforms[p_key].value.rot; + *r_rot = tt->transforms[p_key].value.rot; if (r_scale) - *r_scale=tt->transforms[p_key].value.scale; + *r_scale = tt->transforms[p_key].value.scale; return OK; } -int Animation::transform_track_insert_key(int p_track, float p_time, const Vector3 p_loc, const Quat& p_rot, const Vector3& p_scale) { +int Animation::transform_track_insert_key(int p_track, float p_time, const Vector3 p_loc, const Quat &p_rot, const Vector3 &p_scale) { - ERR_FAIL_INDEX_V(p_track, tracks.size(),-1); - Track *t=tracks[p_track]; - ERR_FAIL_COND_V(t->type!=TYPE_TRANSFORM,-1); + ERR_FAIL_INDEX_V(p_track, tracks.size(), -1); + Track *t = tracks[p_track]; + ERR_FAIL_COND_V(t->type != TYPE_TRANSFORM, -1); - TransformTrack * tt = static_cast<TransformTrack*>(t); + TransformTrack *tt = static_cast<TransformTrack *>(t); TKey<TransformKey> tkey; - tkey.time=p_time; - tkey.value.loc=p_loc; - tkey.value.rot=p_rot; - tkey.value.scale=p_scale; + tkey.time = p_time; + tkey.value.loc = p_loc; + tkey.value.rot = p_rot; + tkey.value.scale = p_scale; - int ret = _insert( p_time, tt->transforms, tkey ); + int ret = _insert(p_time, tt->transforms, tkey); emit_changed(); return ret; } void Animation::track_remove_key_at_pos(int p_track, float p_pos) { - int idx = track_find_key(p_track,p_pos,true); + int idx = track_find_key(p_track, p_pos, true); ERR_FAIL_COND(idx < 0); - track_remove_key(p_track,idx); + track_remove_key(p_track, idx); } void Animation::track_remove_key(int p_track, int p_idx) { - ERR_FAIL_INDEX(p_track,tracks.size()); - Track *t=tracks[p_track]; + ERR_FAIL_INDEX(p_track, tracks.size()); + Track *t = tracks[p_track]; - switch(t->type) { + switch (t->type) { case TYPE_TRANSFORM: { - TransformTrack * tt = static_cast<TransformTrack*>(t); - ERR_FAIL_INDEX(p_idx,tt->transforms.size()); + TransformTrack *tt = static_cast<TransformTrack *>(t); + ERR_FAIL_INDEX(p_idx, tt->transforms.size()); tt->transforms.remove(p_idx); } break; case TYPE_VALUE: { - ValueTrack * vt = static_cast<ValueTrack*>(t); - ERR_FAIL_INDEX(p_idx,vt->values.size()); + ValueTrack *vt = static_cast<ValueTrack *>(t); + ERR_FAIL_INDEX(p_idx, vt->values.size()); vt->values.remove(p_idx); } break; case TYPE_METHOD: { - MethodTrack * mt = static_cast<MethodTrack*>(t); - ERR_FAIL_INDEX(p_idx,mt->methods.size()); + MethodTrack *mt = static_cast<MethodTrack *>(t); + ERR_FAIL_INDEX(p_idx, mt->methods.size()); mt->methods.remove(p_idx); } break; @@ -716,39 +690,39 @@ void Animation::track_remove_key(int p_track, int p_idx) { int Animation::track_find_key(int p_track, float p_time, bool p_exact) const { - ERR_FAIL_INDEX_V(p_track,tracks.size(),-1); - Track *t=tracks[p_track]; + ERR_FAIL_INDEX_V(p_track, tracks.size(), -1); + Track *t = tracks[p_track]; - switch(t->type) { + switch (t->type) { case TYPE_TRANSFORM: { - TransformTrack * tt = static_cast<TransformTrack*>(t); - int k = _find(tt->transforms,p_time); - if (k<0 || k>=tt->transforms.size()) + TransformTrack *tt = static_cast<TransformTrack *>(t); + int k = _find(tt->transforms, p_time); + if (k < 0 || k >= tt->transforms.size()) return -1; - if (tt->transforms[k].time!=p_time && p_exact) + if (tt->transforms[k].time != p_time && p_exact) return -1; return k; } break; case TYPE_VALUE: { - ValueTrack * vt = static_cast<ValueTrack*>(t); - int k = _find(vt->values,p_time); - if (k<0 || k>=vt->values.size()) + ValueTrack *vt = static_cast<ValueTrack *>(t); + int k = _find(vt->values, p_time); + if (k < 0 || k >= vt->values.size()) return -1; - if (vt->values[k].time!=p_time && p_exact) + if (vt->values[k].time != p_time && p_exact) return -1; return k; } break; case TYPE_METHOD: { - MethodTrack * mt = static_cast<MethodTrack*>(t); - int k = _find(mt->methods,p_time); - if (k<0 || k>=mt->methods.size()) + MethodTrack *mt = static_cast<MethodTrack *>(t); + int k = _find(mt->methods, p_time); + if (k < 0 || k >= mt->methods.size()) return -1; - if (mt->methods[k].time!=p_time && p_exact) + if (mt->methods[k].time != p_time && p_exact) return -1; return k; @@ -758,65 +732,63 @@ int Animation::track_find_key(int p_track, float p_time, bool p_exact) const { return -1; } - -void Animation::track_insert_key(int p_track, float p_time, const Variant& p_value,float p_transition) { +void Animation::track_insert_key(int p_track, float p_time, const Variant &p_value, float p_transition) { ERR_FAIL_INDEX(p_track, tracks.size()); - Track *t=tracks[p_track]; + Track *t = tracks[p_track]; - switch(t->type) { + switch (t->type) { case TYPE_TRANSFORM: { Dictionary d = p_value; Vector3 loc; if (d.has("loc")) - loc=d["loc"]; + loc = d["loc"]; Quat rot; if (d.has("rot")) - rot=d["rot"]; + rot = d["rot"]; Vector3 scale; if (d.has("scale")) - scale=d["scale"]; + scale = d["scale"]; - int idx = transform_track_insert_key(p_track,p_time,loc,rot,scale); - track_set_key_transition(p_track,idx,p_transition); + int idx = transform_track_insert_key(p_track, p_time, loc, rot, scale); + track_set_key_transition(p_track, idx, p_transition); } break; case TYPE_VALUE: { - ValueTrack * vt = static_cast<ValueTrack*>(t); + ValueTrack *vt = static_cast<ValueTrack *>(t); - TKey<Variant> k; - k.time=p_time; - k.transition=p_transition; - k.value=p_value; - _insert( p_time, vt->values, k ); + TKey<Variant> k; + k.time = p_time; + k.transition = p_transition; + k.value = p_value; + _insert(p_time, vt->values, k); } break; case TYPE_METHOD: { - MethodTrack * mt = static_cast<MethodTrack*>(t); + MethodTrack *mt = static_cast<MethodTrack *>(t); - ERR_FAIL_COND( p_value.get_type() != Variant::DICTIONARY ); + ERR_FAIL_COND(p_value.get_type() != Variant::DICTIONARY); - Dictionary d=p_value; - ERR_FAIL_COND(!d.has("method") || d["method"].get_type()!=Variant::STRING); + Dictionary d = p_value; + ERR_FAIL_COND(!d.has("method") || d["method"].get_type() != Variant::STRING); ERR_FAIL_COND(!d.has("args") || !d["args"].is_array()); MethodKey k; - k.time=p_time; - k.transition=p_transition; - k.method=d["method"]; - k.params=d["args"]; + k.time = p_time; + k.transition = p_transition; + k.method = d["method"]; + k.params = d["args"]; - _insert( p_time, mt->methods, k ); + _insert(p_time, mt->methods, k); } break; - } emit_changed(); @@ -824,25 +796,25 @@ void Animation::track_insert_key(int p_track, float p_time, const Variant& p_val int Animation::track_get_key_count(int p_track) const { - ERR_FAIL_INDEX_V(p_track, tracks.size(),-1); - Track *t=tracks[p_track]; + ERR_FAIL_INDEX_V(p_track, tracks.size(), -1); + Track *t = tracks[p_track]; - switch(t->type) { + switch (t->type) { case TYPE_TRANSFORM: { - TransformTrack * tt = static_cast<TransformTrack*>(t); + TransformTrack *tt = static_cast<TransformTrack *>(t); return tt->transforms.size(); } break; case TYPE_VALUE: { - ValueTrack * vt = static_cast<ValueTrack*>(t); + ValueTrack *vt = static_cast<ValueTrack *>(t); return vt->values.size(); } break; case TYPE_METHOD: { - MethodTrack * mt = static_cast<MethodTrack*>(t); + MethodTrack *mt = static_cast<MethodTrack *>(t); return mt->methods.size(); } break; } @@ -853,40 +825,39 @@ int Animation::track_get_key_count(int p_track) const { Variant Animation::track_get_key_value(int p_track, int p_key_idx) const { ERR_FAIL_INDEX_V(p_track, tracks.size(), Variant()); - Track *t=tracks[p_track]; + Track *t = tracks[p_track]; - switch(t->type) { + switch (t->type) { case TYPE_TRANSFORM: { - TransformTrack * tt = static_cast<TransformTrack*>(t); - ERR_FAIL_INDEX_V( p_key_idx, tt->transforms.size(), Variant() ); + TransformTrack *tt = static_cast<TransformTrack *>(t); + ERR_FAIL_INDEX_V(p_key_idx, tt->transforms.size(), Variant()); Dictionary d; - d["loc"]=tt->transforms[p_key_idx].value.loc; - d["rot"]=tt->transforms[p_key_idx].value.rot; - d["scale"]=tt->transforms[p_key_idx].value.scale; + d["loc"] = tt->transforms[p_key_idx].value.loc; + d["rot"] = tt->transforms[p_key_idx].value.rot; + d["scale"] = tt->transforms[p_key_idx].value.scale; return d; } break; case TYPE_VALUE: { - ValueTrack * vt = static_cast<ValueTrack*>(t); - ERR_FAIL_INDEX_V( p_key_idx, vt->values.size(), Variant() ); + ValueTrack *vt = static_cast<ValueTrack *>(t); + ERR_FAIL_INDEX_V(p_key_idx, vt->values.size(), Variant()); return vt->values[p_key_idx].value; } break; case TYPE_METHOD: { - MethodTrack * mt = static_cast<MethodTrack*>(t); - ERR_FAIL_INDEX_V( p_key_idx, mt->methods.size(), Variant() ); + MethodTrack *mt = static_cast<MethodTrack *>(t); + ERR_FAIL_INDEX_V(p_key_idx, mt->methods.size(), Variant()); Dictionary d; - d["method"]=mt->methods[p_key_idx].method; - d["args"]=mt->methods[p_key_idx].params; + d["method"] = mt->methods[p_key_idx].method; + d["args"] = mt->methods[p_key_idx].params; return d; } break; - } ERR_FAIL_V(Variant()); @@ -895,452 +866,431 @@ Variant Animation::track_get_key_value(int p_track, int p_key_idx) const { float Animation::track_get_key_time(int p_track, int p_key_idx) const { ERR_FAIL_INDEX_V(p_track, tracks.size(), -1); - Track *t=tracks[p_track]; + Track *t = tracks[p_track]; - switch(t->type) { + switch (t->type) { case TYPE_TRANSFORM: { - TransformTrack * tt = static_cast<TransformTrack*>(t); - ERR_FAIL_INDEX_V( p_key_idx, tt->transforms.size(), -1 ); + TransformTrack *tt = static_cast<TransformTrack *>(t); + ERR_FAIL_INDEX_V(p_key_idx, tt->transforms.size(), -1); return tt->transforms[p_key_idx].time; } break; case TYPE_VALUE: { - ValueTrack * vt = static_cast<ValueTrack*>(t); - ERR_FAIL_INDEX_V( p_key_idx, vt->values.size(), -1 ); + ValueTrack *vt = static_cast<ValueTrack *>(t); + ERR_FAIL_INDEX_V(p_key_idx, vt->values.size(), -1); return vt->values[p_key_idx].time; - } break; case TYPE_METHOD: { - MethodTrack * mt = static_cast<MethodTrack*>(t); - ERR_FAIL_INDEX_V( p_key_idx, mt->methods.size(), -1 ); + MethodTrack *mt = static_cast<MethodTrack *>(t); + ERR_FAIL_INDEX_V(p_key_idx, mt->methods.size(), -1); return mt->methods[p_key_idx].time; - } break; } ERR_FAIL_V(-1); - } float Animation::track_get_key_transition(int p_track, int p_key_idx) const { ERR_FAIL_INDEX_V(p_track, tracks.size(), -1); - Track *t=tracks[p_track]; + Track *t = tracks[p_track]; - switch(t->type) { + switch (t->type) { case TYPE_TRANSFORM: { - TransformTrack * tt = static_cast<TransformTrack*>(t); - ERR_FAIL_INDEX_V( p_key_idx, tt->transforms.size(), -1 ); + TransformTrack *tt = static_cast<TransformTrack *>(t); + ERR_FAIL_INDEX_V(p_key_idx, tt->transforms.size(), -1); return tt->transforms[p_key_idx].transition; } break; case TYPE_VALUE: { - ValueTrack * vt = static_cast<ValueTrack*>(t); - ERR_FAIL_INDEX_V( p_key_idx, vt->values.size(), -1 ); + ValueTrack *vt = static_cast<ValueTrack *>(t); + ERR_FAIL_INDEX_V(p_key_idx, vt->values.size(), -1); return vt->values[p_key_idx].transition; - } break; case TYPE_METHOD: { - MethodTrack * mt = static_cast<MethodTrack*>(t); - ERR_FAIL_INDEX_V( p_key_idx, mt->methods.size(), -1 ); + MethodTrack *mt = static_cast<MethodTrack *>(t); + ERR_FAIL_INDEX_V(p_key_idx, mt->methods.size(), -1); return mt->methods[p_key_idx].transition; - } break; } ERR_FAIL_V(0); - } -void Animation::track_set_key_value(int p_track, int p_key_idx,const Variant& p_value) { +void Animation::track_set_key_value(int p_track, int p_key_idx, const Variant &p_value) { ERR_FAIL_INDEX(p_track, tracks.size()); - Track *t=tracks[p_track]; + Track *t = tracks[p_track]; - switch(t->type) { + switch (t->type) { case TYPE_TRANSFORM: { - TransformTrack * tt = static_cast<TransformTrack*>(t); - ERR_FAIL_INDEX( p_key_idx, tt->transforms.size()); + TransformTrack *tt = static_cast<TransformTrack *>(t); + ERR_FAIL_INDEX(p_key_idx, tt->transforms.size()); Dictionary d = p_value; if (d.has("loc")) - tt->transforms[p_key_idx].value.loc=d["loc"]; + tt->transforms[p_key_idx].value.loc = d["loc"]; if (d.has("rot")) - tt->transforms[p_key_idx].value.rot=d["rot"]; + tt->transforms[p_key_idx].value.rot = d["rot"]; if (d.has("scale")) - tt->transforms[p_key_idx].value.scale=d["scale"]; + tt->transforms[p_key_idx].value.scale = d["scale"]; } break; case TYPE_VALUE: { - ValueTrack * vt = static_cast<ValueTrack*>(t); - ERR_FAIL_INDEX( p_key_idx, vt->values.size()); - vt->values[p_key_idx].value=p_value; + ValueTrack *vt = static_cast<ValueTrack *>(t); + ERR_FAIL_INDEX(p_key_idx, vt->values.size()); + vt->values[p_key_idx].value = p_value; } break; case TYPE_METHOD: { - MethodTrack * mt = static_cast<MethodTrack*>(t); - ERR_FAIL_INDEX( p_key_idx, mt->methods.size()); + MethodTrack *mt = static_cast<MethodTrack *>(t); + ERR_FAIL_INDEX(p_key_idx, mt->methods.size()); Dictionary d = p_value; if (d.has("method")) - mt->methods[p_key_idx].method=d["method"]; + mt->methods[p_key_idx].method = d["method"]; if (d.has("args")) - mt->methods[p_key_idx].params=d["args"]; + mt->methods[p_key_idx].params = d["args"]; } break; } - } -void Animation::track_set_key_transition(int p_track, int p_key_idx,float p_transition) { +void Animation::track_set_key_transition(int p_track, int p_key_idx, float p_transition) { ERR_FAIL_INDEX(p_track, tracks.size()); - Track *t=tracks[p_track]; + Track *t = tracks[p_track]; - switch(t->type) { + switch (t->type) { case TYPE_TRANSFORM: { - TransformTrack * tt = static_cast<TransformTrack*>(t); - ERR_FAIL_INDEX( p_key_idx, tt->transforms.size()); - tt->transforms[p_key_idx].transition=p_transition; + TransformTrack *tt = static_cast<TransformTrack *>(t); + ERR_FAIL_INDEX(p_key_idx, tt->transforms.size()); + tt->transforms[p_key_idx].transition = p_transition; } break; case TYPE_VALUE: { - ValueTrack * vt = static_cast<ValueTrack*>(t); - ERR_FAIL_INDEX( p_key_idx, vt->values.size()); - vt->values[p_key_idx].transition=p_transition; - + ValueTrack *vt = static_cast<ValueTrack *>(t); + ERR_FAIL_INDEX(p_key_idx, vt->values.size()); + vt->values[p_key_idx].transition = p_transition; } break; case TYPE_METHOD: { - MethodTrack * mt = static_cast<MethodTrack*>(t); - ERR_FAIL_INDEX( p_key_idx, mt->methods.size()); - mt->methods[p_key_idx].transition=p_transition; - + MethodTrack *mt = static_cast<MethodTrack *>(t); + ERR_FAIL_INDEX(p_key_idx, mt->methods.size()); + mt->methods[p_key_idx].transition = p_transition; } break; } - } +template <class K> +int Animation::_find(const Vector<K> &p_keys, float p_time) const { - -template<class K> -int Animation::_find( const Vector<K>& p_keys, float p_time) const { - - int len=p_keys.size(); - if (len==0) + int len = p_keys.size(); + if (len == 0) return -2; int low = 0; - int high = len -1; + int high = len - 1; int middle; - const K* keys =&p_keys[0]; + const K *keys = &p_keys[0]; - while( low <= high ) { + while (low <= high) { - middle = ( low + high ) / 2; + middle = (low + high) / 2; - if( p_time == keys[ middle ].time ) { //match + if (p_time == keys[middle].time) { //match return middle; - } else if( p_time < keys[middle].time ) + } else if (p_time < keys[middle].time) high = middle - 1; //search low end of array else low = middle + 1; //search high end of array } - if (keys[middle].time>p_time) + if (keys[middle].time > p_time) middle--; return middle; } -Animation::TransformKey Animation::_interpolate( const Animation::TransformKey& p_a, const Animation::TransformKey& p_b, float p_c) const { +Animation::TransformKey Animation::_interpolate(const Animation::TransformKey &p_a, const Animation::TransformKey &p_b, float p_c) const { TransformKey ret; - 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); + 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); return ret; } -Vector3 Animation::_interpolate( const Vector3& p_a, const Vector3& p_b, float p_c) const { +Vector3 Animation::_interpolate(const Vector3 &p_a, const Vector3 &p_b, float p_c) const { - return p_a.linear_interpolate(p_b,p_c); + return p_a.linear_interpolate(p_b, p_c); } -Quat Animation::_interpolate( const Quat& p_a, const Quat& p_b, float p_c) const { +Quat Animation::_interpolate(const Quat &p_a, const Quat &p_b, float p_c) const { - return p_a.slerp(p_b,p_c); + return p_a.slerp(p_b, p_c); } -Variant Animation::_interpolate( const Variant& p_a, const Variant& p_b, float p_c) const { +Variant Animation::_interpolate(const Variant &p_a, const Variant &p_b, float p_c) const { Variant dst; - Variant::interpolate(p_a,p_b,p_c,dst); + Variant::interpolate(p_a, p_b, p_c, dst); return dst; } +float Animation::_interpolate(const float &p_a, const float &p_b, float p_c) const { -float Animation::_interpolate( const float& p_a, const float& p_b, float p_c) const { - - return p_a*(1.0-p_c) + p_b*p_c; + return p_a * (1.0 - p_c) + p_b * p_c; } -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 { - +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 { Animation::TransformKey tk; - 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); + 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); return tk; - } -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 { +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 { - return p_a.cubic_interpolate(p_b,p_pre_a,p_post_b,p_c); + return p_a.cubic_interpolate(p_b, p_pre_a, p_post_b, p_c); } -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 { +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 { - return p_a.cubic_slerp(p_b,p_pre_a,p_post_b,p_c); + return p_a.cubic_slerp(p_b, p_pre_a, p_post_b, p_c); } -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 { +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 { - 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(); + 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(); //make int and real play along - uint32_t vformat=1<<type_a; - vformat|=1<<type_b; - vformat|=1<<type_pa; - vformat|=1<<type_pb; + uint32_t vformat = 1 << type_a; + vformat |= 1 << type_b; + vformat |= 1 << type_pa; + vformat |= 1 << type_pb; - if (vformat==((1<<Variant::INT)|(1<<Variant::REAL)) || vformat==(1<<Variant::REAL)) { + if (vformat == ((1 << Variant::INT) | (1 << Variant::REAL)) || vformat == (1 << Variant::REAL)) { //mix of real and int - real_t p0=p_pre_a; - real_t p1=p_a; - real_t p2=p_b; - real_t p3=p_post_b; + real_t p0 = p_pre_a; + real_t p1 = p_a; + real_t p2 = p_b; + real_t p3 = p_post_b; float t = p_c; float t2 = t * t; float t3 = t2 * t; - 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 ); - + 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); } else if ((vformat & (vformat - 1))) { return p_a; //can't interpolate, mix of types } - switch(type_a) { + switch (type_a) { case Variant::VECTOR2: { - Vector2 a=p_a; - Vector2 b=p_b; - Vector2 pa=p_pre_a; - Vector2 pb=p_post_b; + Vector2 a = p_a; + Vector2 b = p_b; + Vector2 pa = p_pre_a; + Vector2 pb = p_post_b; - return a.cubic_interpolate(b,pa,pb,p_c); + return a.cubic_interpolate(b, pa, pb, p_c); } break; case Variant::RECT2: { - Rect2 a=p_a; - Rect2 b=p_b; - Rect2 pa=p_pre_a; - Rect2 pb=p_post_b; + Rect2 a = p_a; + Rect2 b = p_b; + Rect2 pa = p_pre_a; + Rect2 pb = p_post_b; return Rect2( - a.pos.cubic_interpolate(b.pos,pa.pos,pb.pos,p_c), - a.size.cubic_interpolate(b.size,pa.size,pb.size,p_c) - ); + a.pos.cubic_interpolate(b.pos, pa.pos, pb.pos, p_c), + a.size.cubic_interpolate(b.size, pa.size, pb.size, p_c)); } break; case Variant::VECTOR3: { - Vector3 a=p_a; - Vector3 b=p_b; - Vector3 pa=p_pre_a; - Vector3 pb=p_post_b; + Vector3 a = p_a; + Vector3 b = p_b; + Vector3 pa = p_pre_a; + Vector3 pb = p_post_b; - return a.cubic_interpolate(b,pa,pb,p_c); + return a.cubic_interpolate(b, pa, pb, p_c); } break; case Variant::QUAT: { - Quat a=p_a; - Quat b=p_b; - Quat pa=p_pre_a; - Quat pb=p_post_b; + Quat a = p_a; + Quat b = p_b; + Quat pa = p_pre_a; + Quat pb = p_post_b; - return a.cubic_slerp(b,pa,pb,p_c); + return a.cubic_slerp(b, pa, pb, p_c); } break; case Variant::RECT3: { - Rect3 a=p_a; - Rect3 b=p_b; - Rect3 pa=p_pre_a; - Rect3 pb=p_post_b; + Rect3 a = p_a; + Rect3 b = p_b; + Rect3 pa = p_pre_a; + Rect3 pb = p_post_b; return Rect3( - a.pos.cubic_interpolate(b.pos,pa.pos,pb.pos,p_c), - a.size.cubic_interpolate(b.size,pa.size,pb.size,p_c) - ); + a.pos.cubic_interpolate(b.pos, pa.pos, pb.pos, p_c), + a.size.cubic_interpolate(b.size, pa.size, pb.size, p_c)); } break; default: { - return _interpolate(p_a,p_b,p_c); + return _interpolate(p_a, p_b, p_c); } } return Variant(); } -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 { +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 { - return _interpolate(p_a,p_b,p_c); + return _interpolate(p_a, p_b, p_c); } -template<class T> -T Animation::_interpolate( const Vector< TKey<T> >& p_keys, float p_time, InterpolationType p_interp, bool p_loop_wrap,bool *p_ok) const { +template <class T> +T Animation::_interpolate(const Vector<TKey<T> > &p_keys, float p_time, InterpolationType p_interp, bool p_loop_wrap, bool *p_ok) const { - int len=_find( p_keys, length )+1; // try to find last key (there may be more past the end) + int len = _find(p_keys, length) + 1; // try to find last key (there may be more past the end) - if (len<=0) { + if (len <= 0) { // (-1 or -2 returned originally) (plus one above) // meaning no keys, or only key time is larger than length if (p_ok) - *p_ok=false; + *p_ok = false; return T(); - } else if (len==1) { // one key found (0+1), return it + } else if (len == 1) { // one key found (0+1), return it if (p_ok) - *p_ok=true; + *p_ok = true; return p_keys[0].value; } - int idx=_find(p_keys, p_time); + int idx = _find(p_keys, p_time); - ERR_FAIL_COND_V( idx==-2, T()); + ERR_FAIL_COND_V(idx == -2, T()); if (p_ok) - *p_ok=true; + *p_ok = true; - int next=0; - float c=0; + int next = 0; + float c = 0; // prepare for all cases of interpolation if (loop && p_loop_wrap) { - // loop - if (idx>=0) { + // loop + if (idx >= 0) { - if ((idx+1) < len) { + if ((idx + 1) < len) { - next=idx+1; - float delta=p_keys[next].time - p_keys[idx].time; - float from=p_time-p_keys[idx].time; + next = idx + 1; + float delta = p_keys[next].time - p_keys[idx].time; + float from = p_time - p_keys[idx].time; - if (Math::absf(delta)>CMP_EPSILON) - c=from/delta; + if (Math::absf(delta) > CMP_EPSILON) + c = from / delta; else - c=0; + c = 0; } else { - next=0; - float delta=(length - p_keys[idx].time) + p_keys[next].time; - float from=p_time-p_keys[idx].time; + next = 0; + float delta = (length - p_keys[idx].time) + p_keys[next].time; + float from = p_time - p_keys[idx].time; - if (Math::absf(delta)>CMP_EPSILON) - c=from/delta; + if (Math::absf(delta) > CMP_EPSILON) + c = from / delta; else - c=0; - + c = 0; } } else { // on loop, behind first key - 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; - - if (Math::absf(delta)>CMP_EPSILON) - c=from/delta; + 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; + + if (Math::absf(delta) > CMP_EPSILON) + c = from / delta; else - c=0; + c = 0; } } else { // no loop - if (idx>=0) { + if (idx >= 0) { - if ((idx+1) < len) { + if ((idx + 1) < len) { - next=idx+1; - float delta=p_keys[next].time - p_keys[idx].time; - float from=p_time - p_keys[idx].time; + next = idx + 1; + float delta = p_keys[next].time - p_keys[idx].time; + float from = p_time - p_keys[idx].time; - if (Math::absf(delta)>CMP_EPSILON) - c=from/delta; + if (Math::absf(delta) > CMP_EPSILON) + c = from / delta; else - c=0; + c = 0; } else { - next=idx; + next = idx; } - } else if (idx<0) { + } else if (idx < 0) { - idx=next=0; + idx = next = 0; } - } float tr = p_keys[idx].transition; - if (tr==0 || idx==next) { + if (tr == 0 || idx == next) { // don't interpolate if not needed return p_keys[idx].value; } - if (tr!=1.0) { + if (tr != 1.0) { - c = Math::ease(c,tr); + c = Math::ease(c, tr); } - switch(p_interp) { + switch (p_interp) { case INTERPOLATION_NEAREST: { @@ -1351,66 +1301,59 @@ T Animation::_interpolate( const Vector< TKey<T> >& p_keys, float p_time, Inter return _interpolate(p_keys[idx].value, p_keys[next].value, c); } break; case INTERPOLATION_CUBIC: { - int pre = idx-1; - if (pre<0) - pre=0; - int post = next+1; - if (post>=len) - post=next; + int pre = idx - 1; + if (pre < 0) + pre = 0; + int post = next + 1; + if (post >= len) + post = next; - - return _cubic_interpolate(p_keys[pre].value,p_keys[idx].value, p_keys[next].value,p_keys[post].value, c); + return _cubic_interpolate(p_keys[pre].value, p_keys[idx].value, p_keys[next].value, p_keys[post].value, c); } break; default: return p_keys[idx].value; } // do a barrel roll - - } +Error Animation::transform_track_interpolate(int p_track, float p_time, Vector3 *r_loc, Quat *r_rot, Vector3 *r_scale) const { -Error Animation::transform_track_interpolate(int p_track, float p_time, Vector3 * r_loc, Quat *r_rot, Vector3 *r_scale) const { - - 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); + 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); - TransformTrack * tt = static_cast<TransformTrack*>(t); + TransformTrack *tt = static_cast<TransformTrack *>(t); bool ok; - TransformKey tk = _interpolate( tt->transforms, p_time, tt->interpolation, tt->loop_wrap, &ok ); + TransformKey tk = _interpolate(tt->transforms, p_time, tt->interpolation, tt->loop_wrap, &ok); if (!ok) // ?? return ERR_UNAVAILABLE; if (r_loc) - *r_loc=tk.loc; + *r_loc = tk.loc; if (r_rot) - *r_rot=tk.rot; + *r_rot = tk.rot; if (r_scale) - *r_scale=tk.scale; + *r_scale = tk.scale; return OK; - } Variant Animation::value_track_interpolate(int p_track, float p_time) const { - 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); + 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); bool ok; - - Variant res = _interpolate( vt->values, p_time, vt->update_mode==UPDATE_CONTINUOUS?vt->interpolation:INTERPOLATION_NEAREST,vt->loop_wrap, &ok ); - + Variant res = _interpolate(vt->values, p_time, vt->update_mode == UPDATE_CONTINUOUS ? vt->interpolation : INTERPOLATION_NEAREST, vt->loop_wrap, &ok); if (ok) { @@ -1420,219 +1363,203 @@ Variant Animation::value_track_interpolate(int p_track, float p_time) const { return Variant(); } -void Animation::_value_track_get_key_indices_in_range(const ValueTrack * vt, float from_time, float to_time,List<int> *p_indices) const { +void Animation::_value_track_get_key_indices_in_range(const ValueTrack *vt, 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( vt->values, to_time); + if (from_time != length && to_time == length) + to_time = length * 1.01; //include a little more if at the end + int to = _find(vt->values, 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 && vt->values[to].time>=to_time) + if (to >= 0 && vt->values[to].time >= to_time) to--; - if (to<0) + if (to < 0) return; // not bother - int from=_find( vt->values, from_time); + int from = _find(vt->values, from_time); // position in the right first event.+ - if (from<0 || vt->values[from].time<from_time) + if (from < 0 || vt->values[from].time < from_time) from++; - int max=vt->values.size(); + int max = vt->values.size(); - for (int i=from;i<=to;i++) { + for (int i = from; i <= to; i++) { - ERR_CONTINUE( i<0 || i>=max); // shouldn't happen + ERR_CONTINUE(i < 0 || i >= max); // shouldn't happen p_indices->push_back(i); } - - } -void Animation::value_track_get_key_indices(int p_track, float p_time, float p_delta,List<int> *p_indices) const { +void Animation::value_track_get_key_indices(int p_track, float p_time, float p_delta, List<int> *p_indices) const { ERR_FAIL_INDEX(p_track, tracks.size()); - Track *t=tracks[p_track]; - ERR_FAIL_COND( t->type != TYPE_VALUE ); + Track *t = tracks[p_track]; + ERR_FAIL_COND(t->type != TYPE_VALUE); - ValueTrack * vt = static_cast<ValueTrack*>(t); + ValueTrack *vt = static_cast<ValueTrack *>(t); - float from_time=p_time-p_delta; - float to_time=p_time; + float from_time = p_time - p_delta; + float to_time = p_time; - if (from_time>to_time) - SWAP(from_time,to_time); + if (from_time > to_time) + SWAP(from_time, to_time); if (loop) { - from_time=Math::fposmod(from_time,length); - to_time=Math::fposmod(to_time,length); + from_time = Math::fposmod(from_time, length); + to_time = Math::fposmod(to_time, length); - if (from_time>to_time) { + if (from_time > to_time) { // handle loop by splitting - _value_track_get_key_indices_in_range(vt,length-from_time,length,p_indices); - _value_track_get_key_indices_in_range(vt,0,to_time,p_indices); + _value_track_get_key_indices_in_range(vt, length - from_time, length, p_indices); + _value_track_get_key_indices_in_range(vt, 0, to_time, p_indices); 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; - + 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; } - _value_track_get_key_indices_in_range(vt,from_time,to_time,p_indices); - - + _value_track_get_key_indices_in_range(vt, from_time, to_time, p_indices); } void Animation::value_track_set_update_mode(int p_track, UpdateMode p_mode) { ERR_FAIL_INDEX(p_track, tracks.size()); - Track *t=tracks[p_track]; - ERR_FAIL_COND( t->type != TYPE_VALUE ); - ERR_FAIL_INDEX(p_mode,3); - - ValueTrack * vt = static_cast<ValueTrack*>(t); - vt->update_mode=p_mode; + Track *t = tracks[p_track]; + ERR_FAIL_COND(t->type != TYPE_VALUE); + ERR_FAIL_INDEX(p_mode, 3); + ValueTrack *vt = static_cast<ValueTrack *>(t); + vt->update_mode = p_mode; } Animation::UpdateMode Animation::value_track_get_update_mode(int p_track) const { ERR_FAIL_INDEX_V(p_track, tracks.size(), UPDATE_CONTINUOUS); - Track *t=tracks[p_track]; - ERR_FAIL_COND_V( t->type != TYPE_VALUE, UPDATE_CONTINUOUS ); + Track *t = tracks[p_track]; + ERR_FAIL_COND_V(t->type != TYPE_VALUE, UPDATE_CONTINUOUS); - ValueTrack * vt = static_cast<ValueTrack*>(t); + ValueTrack *vt = static_cast<ValueTrack *>(t); return vt->update_mode; - } +void Animation::_method_track_get_key_indices_in_range(const MethodTrack *mt, float from_time, float to_time, List<int> *p_indices) const { -void Animation::_method_track_get_key_indices_in_range(const MethodTrack * mt, 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 - + if (from_time != length && to_time == length) + to_time = length * 1.01; //include a little more if at the end - int to=_find( mt->methods, to_time); + int to = _find(mt->methods, 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 && mt->methods[to].time>=to_time) + if (to >= 0 && mt->methods[to].time >= to_time) to--; - if (to<0) + if (to < 0) return; // not bother - int from=_find( mt->methods, from_time); + int from = _find(mt->methods, from_time); // position in the right first event.+ - if (from<0 || mt->methods[from].time<from_time) + if (from < 0 || mt->methods[from].time < from_time) from++; - int max=mt->methods.size(); + int max = mt->methods.size(); - for (int i=from;i<=to;i++) { + for (int i = from; i <= to; i++) { - ERR_CONTINUE( i<0 || i>=max); // shouldn't happen + ERR_CONTINUE(i < 0 || i >= max); // shouldn't happen p_indices->push_back(i); } - } -void Animation::method_track_get_key_indices(int p_track, float p_time, float p_delta,List<int> *p_indices) const { +void Animation::method_track_get_key_indices(int p_track, float p_time, float p_delta, List<int> *p_indices) const { ERR_FAIL_INDEX(p_track, tracks.size()); - Track *t=tracks[p_track]; - ERR_FAIL_COND( t->type != TYPE_METHOD ); + Track *t = tracks[p_track]; + ERR_FAIL_COND(t->type != TYPE_METHOD); - MethodTrack * mt = static_cast<MethodTrack*>(t); + MethodTrack *mt = static_cast<MethodTrack *>(t); - float from_time=p_time-p_delta; - float to_time=p_time; + float from_time = p_time - p_delta; + float to_time = p_time; - if (from_time>to_time) - SWAP(from_time,to_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); + from_time = Math::fposmod(from_time, length); if (to_time > length || to_time < 0) - to_time=Math::fposmod(to_time,length); + to_time = Math::fposmod(to_time, length); - if (from_time>to_time) { + if (from_time > to_time) { // handle loop by splitting - _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); + _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); 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; + 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; } - _method_track_get_key_indices_in_range(mt,from_time,to_time,p_indices); - - + _method_track_get_key_indices_in_range(mt, from_time, to_time, p_indices); } -Vector<Variant> Animation::method_track_get_params(int p_track,int p_key_idx) const { +Vector<Variant> Animation::method_track_get_params(int p_track, int p_key_idx) const { - 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>() ); + 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>()); - MethodTrack * pm = static_cast<MethodTrack*>(t); + MethodTrack *pm = static_cast<MethodTrack *>(t); - ERR_FAIL_INDEX_V( p_key_idx, pm->methods.size(), Vector<Variant>() ); + ERR_FAIL_INDEX_V(p_key_idx, pm->methods.size(), Vector<Variant>()); - const MethodKey& mk=pm->methods[p_key_idx]; + const MethodKey &mk = pm->methods[p_key_idx]; return mk.params; } -StringName Animation::method_track_get_name(int p_track,int p_key_idx) const { - - ERR_FAIL_INDEX_V(p_track, tracks.size(),StringName()); - Track *t=tracks[p_track]; - ERR_FAIL_COND_V( t->type != TYPE_METHOD, StringName() ); +StringName Animation::method_track_get_name(int p_track, int p_key_idx) const { - MethodTrack * pm = static_cast<MethodTrack*>(t); + ERR_FAIL_INDEX_V(p_track, tracks.size(), StringName()); + Track *t = tracks[p_track]; + ERR_FAIL_COND_V(t->type != TYPE_METHOD, StringName()); - ERR_FAIL_INDEX_V( p_key_idx, pm->methods.size(), StringName() ); + MethodTrack *pm = static_cast<MethodTrack *>(t); - return pm->methods[ p_key_idx ].method; + ERR_FAIL_INDEX_V(p_key_idx, pm->methods.size(), StringName()); + return pm->methods[p_key_idx].method; } - void Animation::set_length(float p_length) { - ERR_FAIL_COND( length<0 ); - length=p_length; + ERR_FAIL_COND(length < 0); + length = p_length; emit_changed(); } float Animation::get_length() const { @@ -1642,7 +1569,7 @@ float Animation::get_length() const { void Animation::set_loop(bool p_enabled) { - loop=p_enabled; + loop = p_enabled; emit_changed(); } bool Animation::has_loop() const { @@ -1652,286 +1579,271 @@ bool Animation::has_loop() const { void Animation::track_move_up(int p_track) { + if (p_track >= 0 && p_track < (tracks.size() - 1)) { - if (p_track>=0 && p_track<(tracks.size()-1)) { - - SWAP( tracks[p_track], tracks[p_track+1] ); + SWAP(tracks[p_track], tracks[p_track + 1]); } emit_changed(); } -void Animation::track_set_imported(int p_track,bool p_imported) { +void Animation::track_set_imported(int p_track, bool p_imported) { - ERR_FAIL_INDEX(p_track,tracks.size()); - tracks[p_track]->imported=p_imported; + ERR_FAIL_INDEX(p_track, tracks.size()); + tracks[p_track]->imported = p_imported; } -bool Animation::track_is_imported(int p_track) const{ +bool Animation::track_is_imported(int p_track) const { - ERR_FAIL_INDEX_V(p_track,tracks.size(),false); + ERR_FAIL_INDEX_V(p_track, tracks.size(), false); return tracks[p_track]->imported; - } - void Animation::track_move_down(int p_track) { - if (p_track>0 && p_track<tracks.size()) { + if (p_track > 0 && p_track < tracks.size()) { - SWAP( tracks[p_track], tracks[p_track-1] ); + SWAP(tracks[p_track], tracks[p_track - 1]); } emit_changed(); } void Animation::set_step(float p_step) { - step=p_step; + step = p_step; emit_changed(); } -float Animation::get_step() const{ +float Animation::get_step() const { return step; } - void Animation::_bind_methods() { - ClassDB::bind_method(D_METHOD("add_track","type","at_pos"),&Animation::add_track,DEFVAL(-1)); - ClassDB::bind_method(D_METHOD("remove_track","idx"),&Animation::remove_track); - ClassDB::bind_method(D_METHOD("get_track_count"),&Animation::get_track_count); - ClassDB::bind_method(D_METHOD("track_get_type","idx"),&Animation::track_get_type); - ClassDB::bind_method(D_METHOD("track_get_path","idx"),&Animation::track_get_path); - ClassDB::bind_method(D_METHOD("track_set_path","idx","path"),&Animation::track_set_path); - ClassDB::bind_method(D_METHOD("find_track","path"),&Animation::find_track); - - ClassDB::bind_method(D_METHOD("track_move_up","idx"),&Animation::track_move_up); - ClassDB::bind_method(D_METHOD("track_move_down","idx"),&Animation::track_move_down); - - ClassDB::bind_method(D_METHOD("track_set_imported","idx","imported"),&Animation::track_set_imported); - ClassDB::bind_method(D_METHOD("track_is_imported","idx"),&Animation::track_is_imported); - + ClassDB::bind_method(D_METHOD("add_track", "type", "at_pos"), &Animation::add_track, DEFVAL(-1)); + ClassDB::bind_method(D_METHOD("remove_track", "idx"), &Animation::remove_track); + ClassDB::bind_method(D_METHOD("get_track_count"), &Animation::get_track_count); + ClassDB::bind_method(D_METHOD("track_get_type", "idx"), &Animation::track_get_type); + ClassDB::bind_method(D_METHOD("track_get_path", "idx"), &Animation::track_get_path); + ClassDB::bind_method(D_METHOD("track_set_path", "idx", "path"), &Animation::track_set_path); + ClassDB::bind_method(D_METHOD("find_track", "path"), &Animation::find_track); - ClassDB::bind_method(D_METHOD("transform_track_insert_key","idx","time","loc","rot","scale"),&Animation::transform_track_insert_key); - ClassDB::bind_method(D_METHOD("track_insert_key","idx","time","key","transition"),&Animation::track_insert_key,DEFVAL(1)); - ClassDB::bind_method(D_METHOD("track_remove_key","idx","key_idx"),&Animation::track_remove_key); - ClassDB::bind_method(D_METHOD("track_remove_key_at_pos","idx","pos"),&Animation::track_remove_key_at_pos); - ClassDB::bind_method(D_METHOD("track_set_key_value","idx","key","value"),&Animation::track_set_key_value); - ClassDB::bind_method(D_METHOD("track_set_key_transition","idx","key_idx","transition"),&Animation::track_set_key_transition); - ClassDB::bind_method(D_METHOD("track_get_key_transition","idx","key_idx"),&Animation::track_get_key_transition); + ClassDB::bind_method(D_METHOD("track_move_up", "idx"), &Animation::track_move_up); + ClassDB::bind_method(D_METHOD("track_move_down", "idx"), &Animation::track_move_down); - ClassDB::bind_method(D_METHOD("track_get_key_count","idx"),&Animation::track_get_key_count); - ClassDB::bind_method(D_METHOD("track_get_key_value","idx","key_idx"),&Animation::track_get_key_value); - ClassDB::bind_method(D_METHOD("track_get_key_time","idx","key_idx"),&Animation::track_get_key_time); - ClassDB::bind_method(D_METHOD("track_find_key","idx","time","exact"),&Animation::track_find_key,DEFVAL(false)); + ClassDB::bind_method(D_METHOD("track_set_imported", "idx", "imported"), &Animation::track_set_imported); + ClassDB::bind_method(D_METHOD("track_is_imported", "idx"), &Animation::track_is_imported); - ClassDB::bind_method(D_METHOD("track_set_interpolation_type","idx","interpolation"),&Animation::track_set_interpolation_type); - ClassDB::bind_method(D_METHOD("track_get_interpolation_type","idx"),&Animation::track_get_interpolation_type); + ClassDB::bind_method(D_METHOD("transform_track_insert_key", "idx", "time", "loc", "rot", "scale"), &Animation::transform_track_insert_key); + ClassDB::bind_method(D_METHOD("track_insert_key", "idx", "time", "key", "transition"), &Animation::track_insert_key, DEFVAL(1)); + ClassDB::bind_method(D_METHOD("track_remove_key", "idx", "key_idx"), &Animation::track_remove_key); + ClassDB::bind_method(D_METHOD("track_remove_key_at_pos", "idx", "pos"), &Animation::track_remove_key_at_pos); + ClassDB::bind_method(D_METHOD("track_set_key_value", "idx", "key", "value"), &Animation::track_set_key_value); + ClassDB::bind_method(D_METHOD("track_set_key_transition", "idx", "key_idx", "transition"), &Animation::track_set_key_transition); + ClassDB::bind_method(D_METHOD("track_get_key_transition", "idx", "key_idx"), &Animation::track_get_key_transition); - ClassDB::bind_method(D_METHOD("track_set_interpolation_loop_wrap","idx","interpolation"),&Animation::track_set_interpolation_loop_wrap); - ClassDB::bind_method(D_METHOD("track_get_interpolation_loop_wrap","idx"),&Animation::track_get_interpolation_loop_wrap); + ClassDB::bind_method(D_METHOD("track_get_key_count", "idx"), &Animation::track_get_key_count); + ClassDB::bind_method(D_METHOD("track_get_key_value", "idx", "key_idx"), &Animation::track_get_key_value); + ClassDB::bind_method(D_METHOD("track_get_key_time", "idx", "key_idx"), &Animation::track_get_key_time); + ClassDB::bind_method(D_METHOD("track_find_key", "idx", "time", "exact"), &Animation::track_find_key, DEFVAL(false)); + ClassDB::bind_method(D_METHOD("track_set_interpolation_type", "idx", "interpolation"), &Animation::track_set_interpolation_type); + ClassDB::bind_method(D_METHOD("track_get_interpolation_type", "idx"), &Animation::track_get_interpolation_type); - ClassDB::bind_method(D_METHOD("transform_track_interpolate","idx","time_sec"),&Animation::_transform_track_interpolate); - ClassDB::bind_method(D_METHOD("value_track_set_update_mode","idx","mode"),&Animation::value_track_set_update_mode); - ClassDB::bind_method(D_METHOD("value_track_get_update_mode","idx"),&Animation::value_track_get_update_mode); + ClassDB::bind_method(D_METHOD("track_set_interpolation_loop_wrap", "idx", "interpolation"), &Animation::track_set_interpolation_loop_wrap); + ClassDB::bind_method(D_METHOD("track_get_interpolation_loop_wrap", "idx"), &Animation::track_get_interpolation_loop_wrap); - ClassDB::bind_method(D_METHOD("value_track_get_key_indices","idx","time_sec","delta"),&Animation::_value_track_get_key_indices); + ClassDB::bind_method(D_METHOD("transform_track_interpolate", "idx", "time_sec"), &Animation::_transform_track_interpolate); + ClassDB::bind_method(D_METHOD("value_track_set_update_mode", "idx", "mode"), &Animation::value_track_set_update_mode); + ClassDB::bind_method(D_METHOD("value_track_get_update_mode", "idx"), &Animation::value_track_get_update_mode); - ClassDB::bind_method(D_METHOD("method_track_get_key_indices","idx","time_sec","delta"),&Animation::_method_track_get_key_indices); - ClassDB::bind_method(D_METHOD("method_track_get_name","idx","key_idx"),&Animation::method_track_get_name); - ClassDB::bind_method(D_METHOD("method_track_get_params","idx","key_idx"),&Animation::method_track_get_params); + ClassDB::bind_method(D_METHOD("value_track_get_key_indices", "idx", "time_sec", "delta"), &Animation::_value_track_get_key_indices); - ClassDB::bind_method(D_METHOD("set_length","time_sec"),&Animation::set_length); - ClassDB::bind_method(D_METHOD("get_length"),&Animation::get_length); + ClassDB::bind_method(D_METHOD("method_track_get_key_indices", "idx", "time_sec", "delta"), &Animation::_method_track_get_key_indices); + ClassDB::bind_method(D_METHOD("method_track_get_name", "idx", "key_idx"), &Animation::method_track_get_name); + ClassDB::bind_method(D_METHOD("method_track_get_params", "idx", "key_idx"), &Animation::method_track_get_params); - ClassDB::bind_method(D_METHOD("set_loop","enabled"),&Animation::set_loop); - ClassDB::bind_method(D_METHOD("has_loop"),&Animation::has_loop); + ClassDB::bind_method(D_METHOD("set_length", "time_sec"), &Animation::set_length); + ClassDB::bind_method(D_METHOD("get_length"), &Animation::get_length); - ClassDB::bind_method(D_METHOD("set_step","size_sec"),&Animation::set_step); - ClassDB::bind_method(D_METHOD("get_step"),&Animation::get_step); + ClassDB::bind_method(D_METHOD("set_loop", "enabled"), &Animation::set_loop); + ClassDB::bind_method(D_METHOD("has_loop"), &Animation::has_loop); - ClassDB::bind_method(D_METHOD("clear"),&Animation::clear); + ClassDB::bind_method(D_METHOD("set_step", "size_sec"), &Animation::set_step); + ClassDB::bind_method(D_METHOD("get_step"), &Animation::get_step); - BIND_CONSTANT( TYPE_VALUE ); - BIND_CONSTANT( TYPE_TRANSFORM ); - BIND_CONSTANT( TYPE_METHOD ); + ClassDB::bind_method(D_METHOD("clear"), &Animation::clear); - BIND_CONSTANT( INTERPOLATION_NEAREST ); - BIND_CONSTANT( INTERPOLATION_LINEAR ); - BIND_CONSTANT( INTERPOLATION_CUBIC ); - - BIND_CONSTANT( UPDATE_CONTINUOUS ); - BIND_CONSTANT( UPDATE_DISCRETE ); - BIND_CONSTANT( UPDATE_TRIGGER ); + BIND_CONSTANT(TYPE_VALUE); + BIND_CONSTANT(TYPE_TRANSFORM); + BIND_CONSTANT(TYPE_METHOD); + BIND_CONSTANT(INTERPOLATION_NEAREST); + BIND_CONSTANT(INTERPOLATION_LINEAR); + BIND_CONSTANT(INTERPOLATION_CUBIC); + BIND_CONSTANT(UPDATE_CONTINUOUS); + BIND_CONSTANT(UPDATE_DISCRETE); + BIND_CONSTANT(UPDATE_TRIGGER); } void Animation::clear() { - for(int i=0;i<tracks.size();i++) - memdelete( tracks[i] ); + for (int i = 0; i < tracks.size(); i++) + memdelete(tracks[i]); tracks.clear(); - loop=false; - length=1; - + loop = false; + length = 1; } +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) { - -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) { - - - real_t c = (t1.time-t0.time)/(t2.time-t0.time); - real_t t[3]={-1,-1,-1}; + real_t c = (t1.time - t0.time) / (t2.time - t0.time); + real_t t[3] = { -1, -1, -1 }; { //translation - const Vector3 &v0=t0.value.loc; - const Vector3 &v1=t1.value.loc; - const Vector3 &v2=t2.value.loc; + const Vector3 &v0 = t0.value.loc; + const Vector3 &v1 = t1.value.loc; + const Vector3 &v2 = t2.value.loc; - if (v0.distance_to(v2)<CMP_EPSILON) { + if (v0.distance_to(v2) < CMP_EPSILON) { //0 and 2 are close, let's see if 1 is close - if (v0.distance_to(v1)>CMP_EPSILON) { + if (v0.distance_to(v1) > CMP_EPSILON) { //not close, not optimizable return false; } } else { - Vector3 pd = (v2-v0); + Vector3 pd = (v2 - v0); float d0 = pd.dot(v0); float d1 = pd.dot(v1); float d2 = pd.dot(v2); - if (d1<d0 || d1>d2) { + if (d1 < d0 || d1 > d2) { return false; } - Vector3 s[2]={ v0, v2 }; - real_t d =Geometry::get_closest_point_to_segment(v1,s).distance_to(v1); + Vector3 s[2] = { v0, v2 }; + real_t d = Geometry::get_closest_point_to_segment(v1, s).distance_to(v1); - if (d>pd.length()*p_alowed_linear_err) { + if (d > pd.length() * p_alowed_linear_err) { return false; //beyond allowed error for colinearity } - if (p_norm!=Vector3() && Math::acos(pd.normalized().dot(p_norm))>p_alowed_angular_err) + if (p_norm != Vector3() && Math::acos(pd.normalized().dot(p_norm)) > p_alowed_angular_err) return false; - t[0] = (d1-d0)/(d2-d0); + t[0] = (d1 - d0) / (d2 - d0); } } { //rotation - const Quat &q0=t0.value.rot; - const Quat &q1=t1.value.rot; - const Quat &q2=t2.value.rot; + const Quat &q0 = t0.value.rot; + const Quat &q1 = t1.value.rot; + const Quat &q2 = t2.value.rot; //localize both to rotation from q0 - if ((q0-q2).length() < CMP_EPSILON) { + if ((q0 - q2).length() < CMP_EPSILON) { - if ((q0-q1).length() > CMP_EPSILON) + if ((q0 - q1).length() > CMP_EPSILON) return false; } else { - Quat r02 = (q0.inverse() * q2).normalized(); Quat r01 = (q0.inverse() * q1).normalized(); - Vector3 v02,v01; - real_t a02,a01; + Vector3 v02, v01; + real_t a02, a01; - r02.get_axis_and_angle(v02,a02); - r01.get_axis_and_angle(v01,a01); + r02.get_axis_and_angle(v02, a02); + r01.get_axis_and_angle(v01, a01); - if (Math::abs(a02)>p_max_optimizable_angle) + if (Math::abs(a02) > p_max_optimizable_angle) return false; - if (v01.dot(v02)<0) { + if (v01.dot(v02) < 0) { //make sure both rotations go the same way to compare - v02=-v02; - a02=-a02; + v02 = -v02; + a02 = -a02; } - real_t err_01 = Math::acos(v01.normalized().dot(v02.normalized()))/Math_PI; - if (err_01>p_alowed_angular_err) { + real_t err_01 = Math::acos(v01.normalized().dot(v02.normalized())) / Math_PI; + if (err_01 > p_alowed_angular_err) { //not rotating in the same axis return false; } - if (a01*a02 < 0 ) { + if (a01 * a02 < 0) { //not rotating in the same direction return false; } - real_t tr = a01/a02; - if (tr<0 || tr>1) + real_t tr = a01 / a02; + if (tr < 0 || tr > 1) return false; //rotating too much or too less - t[1]=tr; - + t[1] = tr; } - } { //scale - const Vector3 &v0=t0.value.scale; - const Vector3 &v1=t1.value.scale; - const Vector3 &v2=t2.value.scale; + const Vector3 &v0 = t0.value.scale; + const Vector3 &v1 = t1.value.scale; + const Vector3 &v2 = t2.value.scale; - if (v0.distance_to(v2)<CMP_EPSILON) { + if (v0.distance_to(v2) < CMP_EPSILON) { //0 and 2 are close, let's see if 1 is close - if (v0.distance_to(v1)>CMP_EPSILON) { + if (v0.distance_to(v1) > CMP_EPSILON) { //not close, not optimizable return false; } } else { - Vector3 pd = (v2-v0); + Vector3 pd = (v2 - v0); float d0 = pd.dot(v0); float d1 = pd.dot(v1); float d2 = pd.dot(v2); - if (d1<d0 || d1>d2) { + if (d1 < d0 || d1 > d2) { return false; //beyond segment range } - Vector3 s[2]={ v0, v2 }; - real_t d =Geometry::get_closest_point_to_segment(v1,s).distance_to(v1); + Vector3 s[2] = { v0, v2 }; + real_t d = Geometry::get_closest_point_to_segment(v1, s).distance_to(v1); - if (d>pd.length()*p_alowed_linear_err) { + if (d > pd.length() * p_alowed_linear_err) { return false; //beyond allowed error for colinearity } - t[2] = (d1-d0)/(d2-d0); + t[2] = (d1 - d0) / (d2 - d0); } } - bool erase=false; - if (t[0]==-1 && t[1]==-1 && t[2]==-1) { + bool erase = false; + if (t[0] == -1 && t[1] == -1 && t[2] == -1) { - erase=true; + erase = true; } else { - erase=true; - real_t lt=-1; - for(int j=0;j<3;j++) { + erase = true; + real_t lt = -1; + for (int j = 0; j < 3; j++) { //search for t on first, one must be it - if (t[j]!=-1) { - lt=t[j]; //official t + if (t[j] != -1) { + lt = t[j]; //official t //validate rest - for(int k=j+1;k<3;k++) { - if (t[k]==-1) + for (int k = j + 1; k < 3; k++) { + if (t[k] == -1) continue; - if (Math::abs(lt-t[k])>p_alowed_linear_err) { - erase=false; + if (Math::abs(lt - t[k]) > p_alowed_linear_err) { + erase = false; break; } } @@ -1939,102 +1851,86 @@ bool Animation::_transform_track_optimize_key(const TKey<TransformKey> &t0,const } } - ERR_FAIL_COND_V( lt==-1,false ); + ERR_FAIL_COND_V(lt == -1, false); if (erase) { - if (Math::abs(lt-c)>p_alowed_linear_err) { + if (Math::abs(lt - c) > p_alowed_linear_err) { //todo, evaluate changing the transition if this fails? //this could be done as a second pass and would be //able to optimize more - erase=false; + erase = false; } else { //print_line(itos(i)+"because of interp"); } } - } - return erase; - - } +void Animation::_transform_track_optimize(int p_idx, float p_alowed_linear_err, float p_alowed_angular_err, float p_max_optimizable_angle) { -void Animation::_transform_track_optimize(int p_idx,float p_alowed_linear_err,float p_alowed_angular_err,float p_max_optimizable_angle) { - - 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; + 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; TKey<TransformKey> first_erased; Vector3 norm; - for(int i=1;i<tt->transforms.size()-1;i++) { + for (int i = 1; i < tt->transforms.size() - 1; i++) { - TKey<TransformKey> &t0 = tt->transforms[i-1]; + TKey<TransformKey> &t0 = tt->transforms[i - 1]; TKey<TransformKey> &t1 = tt->transforms[i]; - TKey<TransformKey> &t2 = tt->transforms[i+1]; + TKey<TransformKey> &t2 = tt->transforms[i + 1]; - bool erase = _transform_track_optimize_key(t0,t1,t2,p_alowed_linear_err,p_alowed_angular_err,p_max_optimizable_angle,norm); + bool erase = _transform_track_optimize_key(t0, t1, t2, p_alowed_linear_err, p_alowed_angular_err, p_max_optimizable_angle, norm); if (erase && !prev_erased) { - norm=(t2.value.loc-t1.value.loc).normalized(); + norm = (t2.value.loc - t1.value.loc).normalized(); } - - if (prev_erased && !_transform_track_optimize_key(t0,first_erased,t2,p_alowed_linear_err,p_alowed_angular_err,p_max_optimizable_angle,norm)) { - //avoid error to go beyond first erased key - erase=false; + if (prev_erased && !_transform_track_optimize_key(t0, first_erased, t2, p_alowed_linear_err, p_alowed_angular_err, p_max_optimizable_angle, norm)) { + //avoid error to go beyond first erased key + erase = false; } - if (erase) { if (!prev_erased) { - first_erased=t1; - prev_erased=true; + first_erased = t1; + prev_erased = true; } tt->transforms.remove(i); i--; } else { - prev_erased=false; - norm=Vector3(); + prev_erased = false; + norm = Vector3(); } } - - } -void Animation::optimize(float p_allowed_linear_err,float p_allowed_angular_err,float p_angle_max) { +void Animation::optimize(float p_allowed_linear_err, float p_allowed_angular_err, float p_angle_max) { - for(int i=0;i<tracks.size();i++) { - - if (tracks[i]->type==TYPE_TRANSFORM) - _transform_track_optimize(i,p_allowed_linear_err,p_allowed_angular_err,p_angle_max); + for (int i = 0; i < tracks.size(); i++) { + if (tracks[i]->type == TYPE_TRANSFORM) + _transform_track_optimize(i, p_allowed_linear_err, p_allowed_angular_err, p_angle_max); } - } - Animation::Animation() { - step=0.1; - loop=false; - length=1; + step = 0.1; + loop = false; + length = 1; } - Animation::~Animation() { - for(int i=0;i<tracks.size();i++) - memdelete( tracks[i] ); - + for (int i = 0; i < tracks.size(); i++) + memdelete(tracks[i]); } - - |