diff options
Diffstat (limited to 'scene/resources/animation.cpp')
| -rw-r--r-- | scene/resources/animation.cpp | 1938 |
1 files changed, 1938 insertions, 0 deletions
diff --git a/scene/resources/animation.cpp b/scene/resources/animation.cpp new file mode 100644 index 000000000..7fa606f5d --- /dev/null +++ b/scene/resources/animation.cpp @@ -0,0 +1,1938 @@ +/*************************************************************************/ +/* animation.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#include "animation.h" +#include "geometry.h" + + +bool Animation::_set(const StringName& p_name, const Variant& p_value) { + + String name=p_name; + + if (name=="length") + set_length(p_value); + else if (name=="loop") + set_loop(p_value); + else if (name=="step") + set_step(p_value); + else if (name.begins_with("tracks/")) { + + int track=name.get_slice("/",1).to_int(); + String what=name.get_slice("/",2); + + if (tracks.size()==track && what=="type") { + + String type=p_value; + + if (type=="transform") { + + add_track(TYPE_TRANSFORM); + } else if (type=="value") { + + add_track(TYPE_VALUE); + } else if (type=="method") { + + add_track(TYPE_METHOD); + } else { + + return false; + } + + return true; + } + + 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 == "keys" || what=="key_values") { + + if (track_get_type(track)==TYPE_TRANSFORM) { + + TransformTrack *tt = static_cast<TransformTrack*>(tracks[track]); + DVector<float> values=p_value; + int vcount=values.size(); + +#if 0 // old compatibility hack + if ((vcount%11) == 0) { + + + DVector<float>::Read r = values.read(); + + tt->transforms.resize(vcount/11); + + + for(int i=0;i<(vcount/11);i++) { + + + TKey<TransformKey> &tk=tt->transforms[i]; + const float *ofs=&r[i*11]; + tk.time=ofs[0]; + + tk.value.loc.x=ofs[1]; + tk.value.loc.y=ofs[2]; + tk.value.loc.z=ofs[3]; + + tk.value.rot.x=ofs[4]; + tk.value.rot.y=ofs[5]; + tk.value.rot.z=ofs[6]; + tk.value.rot.w=ofs[7]; + + tk.value.scale.x=ofs[8]; + tk.value.scale.y=ofs[9]; + tk.value.scale.z=ofs[10]; + + + } + return true; + + + + } +#endif + ERR_FAIL_COND_V(vcount%12,false); // shuld be multiple of 11 + + DVector<float>::Read r = values.read(); + + tt->transforms.resize(vcount/12); + + + for(int i=0;i<(vcount/12);i++) { + + + TKey<TransformKey> &tk=tt->transforms[i]; + const float *ofs=&r[i*12]; + tk.time=ofs[0]; + tk.transition=ofs[1]; + + 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) { + + 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); + if (d.has("cont")) + vt->continuous=d["cont"]; + + DVector<float> times=d["times"]; + Array values=d["values"]; + + ERR_FAIL_COND_V(times.size()!=values.size(),false); + + if (times.size()) { + + int valcount=times.size(); + + DVector<float>::Read rt = times.read(); + + vt->values.resize(valcount); + + for(int i=0;i<valcount;i++) { + + vt->values[i].time=rt[i]; + vt->values[i].value=values[i]; + } + + if (d.has("transitions")) { + + DVector<float> transitions = d["transitions"]; + ERR_FAIL_COND_V(transitions.size()!=valcount,false); + + DVector<float>::Read rtr = transitions.read(); + + + for(int i=0;i<valcount;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 + + Dictionary d = p_value; + ERR_FAIL_COND_V(!d.has("times"),false); + ERR_FAIL_COND_V(!d.has("values"),false); + + DVector<float> times=d["times"]; + Array values=d["values"]; + + ERR_FAIL_COND_V(times.size()!=values.size(),false); + + if (times.size()) { + + int valcount=times.size(); + + DVector<float>::Read rt = times.read(); + + for(int i=0;i<valcount;i++) { + + track_insert_key(track,rt[i],values[i]); + } + + if (d.has("transitions")) { + + DVector<float> transitions = d["transitions"]; + ERR_FAIL_COND_V(transitions.size()!=valcount,false); + + DVector<float>::Read rtr = transitions.read(); + + for(int i=0;i<valcount;i++) { + + track_set_key_transition(track,i,rtr[i]); + } + } + + } + + + } + } else + return false; + } else + return false; + + return true; +} + + +bool Animation::_get(const StringName& p_name,Variant &r_ret) const { + + String name=p_name; + + 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_slice("/",1).to_int(); + String what=name.get_slice("/",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; + } + + return true; + + } else if (what=="path") + r_ret=track_get_path(track); + else if (what=="interp") + r_ret = track_get_interpolation_type(track); + else if (what=="keys") { + + if (track_get_type(track)==TYPE_TRANSFORM) { + + DVector<real_t> keys; + int kk=track_get_key_count(track); + keys.resize(kk*12); + + DVector<real_t>::Write w = keys.write(); + + 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; + } + + w = DVector<real_t>::Write(); + r_ret=keys; + return true; + + } else if (track_get_type(track)==TYPE_VALUE) { + + + const ValueTrack *vt = static_cast<const ValueTrack*>(tracks[track]); + + Dictionary d; + + DVector<float> key_times; + DVector<float> key_transitions; + Array key_values; + + int kk=vt->values.size(); + + key_times.resize(kk); + key_transitions.resize(kk); + key_values.resize(kk); + + DVector<float>::Write wti=key_times.write(); + DVector<float>::Write wtr=key_transitions.write(); + + int idx=0; + + const TKey<Variant> *vls = vt->values.ptr(); + + for(int i=0;i<kk;i++) { + + wti[idx]=vls[i].time; + wtr[idx]=vls[i].transition; + key_values[idx]=vls[i].value; + idx++; + } + + wti=DVector<float>::Write(); + wtr=DVector<float>::Write(); + + d["times"]=key_times; + d["transitions"]=key_transitions; + d["values"]=key_values; + if (track_get_type(track)==TYPE_VALUE) { + d["cont"]=value_track_is_continuous(track); + } + + r_ret=d; + + return true; + + } else { + + + Dictionary d; + + DVector<float> key_times; + DVector<float> key_transitions; + Array key_values; + + int kk=track_get_key_count(track); + + key_times.resize(kk); + key_transitions.resize(kk); + key_values.resize(kk); + + DVector<float>::Write wti=key_times.write(); + DVector<float>::Write wtr=key_transitions.write(); + + 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); + idx++; + } + + wti=DVector<float>::Write(); + wtr=DVector<float>::Write(); + + d["times"]=key_times; + d["transitions"]=key_transitions; + d["values"]=key_values; + if (track_get_type(track)==TYPE_VALUE) { + d["cont"]=value_track_is_continuous(track); + } + + r_ret=d; + + return true; + + } + } else + return false; + } else + return false; + + return true; + +} + + +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" )); + + 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::ARRAY, "tracks/"+itos(i)+"/keys", PROPERTY_HINT_NONE,"",PROPERTY_USAGE_NOEDITOR) ); + } +} + +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(); + + switch( p_type ) { + + case TYPE_TRANSFORM: { + + TransformTrack *tt = memnew( TransformTrack ); + tracks.insert( p_at_pos,tt ); + } break; + case TYPE_VALUE: { + + tracks.insert( p_at_pos,memnew( ValueTrack ) ); + + } break; + case TYPE_METHOD: { + + tracks.insert( p_at_pos,memnew( MethodTrack ) ); + + } break; + default: { + + ERR_PRINT("Unknown track type"); + } + } + emit_changed(); + return p_at_pos; +} + +void Animation::remove_track(int p_track) { + + ERR_FAIL_INDEX(p_track, tracks.size()); + Track *t=tracks[p_track]; + + switch(t->type) { + + case TYPE_TRANSFORM: { + + TransformTrack * tt = static_cast<TransformTrack*>(t); + _clear(tt->transforms); + + } break; + case TYPE_VALUE: { + + ValueTrack * vt = static_cast<ValueTrack*>(t); + _clear(vt->values); + + } break; + case TYPE_METHOD: { + + MethodTrack * mt = static_cast<MethodTrack*>(t); + _clear(mt->methods); + + } break; + } + + memdelete( t ); + tracks.remove(p_track); + emit_changed(); +} + +int Animation::get_track_count() const { + + return tracks.size(); +} + +Animation::TrackType Animation::track_get_type(int p_track) const { + + 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) { + + ERR_FAIL_INDEX(p_track, tracks.size()); + 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()); + return tracks[p_track]->path; +} + +int Animation::find_track(const NodePath& p_path) const { + + for (int i=0; i<tracks.size(); i++) { + + if (tracks[i]->path == p_path) + return i; + }; + return -1; +}; + + +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; + emit_changed(); + +} + +Animation::InterpolationType Animation::track_get_interpolation_type(int p_track) const { + + ERR_FAIL_INDEX_V(p_track, tracks.size(),INTERPOLATION_NEAREST); + return tracks[p_track]->interpolation; +} + + +// 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. + + int idx=p_keys.size(); + + while(true) { + + + 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) { + + // condition for replacing. + return idx-1; + } + + idx--; + } + +} +*/ +template<class T, class V> +int Animation::_insert(float p_time, T& p_keys, const V& p_value) { + + int idx=p_keys.size(); + + while(true) { + + + if (idx==0 || p_keys[idx-1].time < p_time) { + //condition for insertion. + p_keys.insert(idx,p_value); + return idx; + } else if (p_keys[idx-1].time == p_time) { + + // condition for replacing. + p_keys[idx-1]=p_value; + return idx-1; + } + + idx--; + } + + return -1; +} + +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 { + + 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); + + if (r_loc) + *r_loc=tt->transforms[p_key].value.loc; + if (r_rot) + *r_rot=tt->transforms[p_key].value.rot; + if (r_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) { + + 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); + + TKey<TransformKey> tkey; + 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 ); + 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); + ERR_FAIL_COND(idx < 0); + 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]; + + switch(t->type) { + case TYPE_TRANSFORM: { + + 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()); + vt->values.remove(p_idx); + + } break; + case TYPE_METHOD: { + + MethodTrack * mt = static_cast<MethodTrack*>(t); + ERR_FAIL_INDEX(p_idx,mt->methods.size()); + mt->methods.remove(p_idx); + + } break; + } + + emit_changed(); +} + +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]; + + 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()) + return -1; + 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()) + return -1; + 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()) + return -1; + if (mt->methods[k].time!=p_time && p_exact) + return -1; + return k; + + } break; + } + + return -1; +} + + +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]; + + switch(t->type) { + + case TYPE_TRANSFORM: { + + Dictionary d = p_value; + Vector3 loc; + if (d.has("loc")) + loc=d["loc"]; + + Quat rot; + if (d.has("rot")) + rot=d["rot"]; + + Vector3 scale; + if (d.has("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); + + } break; + case TYPE_VALUE: { + + 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 ); + + } break; + case TYPE_METHOD: { + + MethodTrack * mt = static_cast<MethodTrack*>(t); + + 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); + 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"]; + + _insert( p_time, mt->methods, k ); + + } break; + + } + + emit_changed(); +} + +int Animation::track_get_key_count(int p_track) const { + + ERR_FAIL_INDEX_V(p_track, tracks.size(),-1); + Track *t=tracks[p_track]; + + switch(t->type) { + + case TYPE_TRANSFORM: { + + TransformTrack * tt = static_cast<TransformTrack*>(t); + return tt->transforms.size(); + } break; + case TYPE_VALUE: { + + ValueTrack * vt = static_cast<ValueTrack*>(t); + return vt->values.size(); + + } break; + case TYPE_METHOD: { + + MethodTrack * mt = static_cast<MethodTrack*>(t); + return mt->methods.size(); + } break; + } + + 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()); + Track *t=tracks[p_track]; + + switch(t->type) { + + case TYPE_TRANSFORM: { + + 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; + + return d; + } break; + case TYPE_VALUE: { + + 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() ); + Dictionary d; + d["method"]=mt->methods[p_key_idx].method; + d["args"]=mt->methods[p_key_idx].params; + return d; + + } break; + + } + + 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); + Track *t=tracks[p_track]; + + switch(t->type) { + + case TYPE_TRANSFORM: { + + 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 ); + 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 ); + 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]; + + switch(t->type) { + + case TYPE_TRANSFORM: { + + 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 ); + 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 ); + 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) { + + 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()); + Dictionary d = p_value; + if (d.has("loc")) + tt->transforms[p_key_idx].value.loc=d["loc"]; + if (d.has("rot")) + tt->transforms[p_key_idx].value.rot=d["rot"]; + if (d.has("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; + + } break; + case TYPE_METHOD: { + + 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"]; + if (d.has("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) { + + 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()); + 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; + + + } 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; + + + } break; + } + +} + + + +template<class K> +int Animation::_find( const Vector<K>& p_keys, float p_time) const { + + int len=p_keys.size(); + if (len==0) + return -2; + + int low = 0; + int high = len -1; + int middle; + + const K* keys =&p_keys[0]; + + while( low <= high ) { + + middle = ( low + high ) / 2; + + if( p_time == keys[ middle ].time ) { //match + return middle; + } 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) + middle--; + + return middle; +} + +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); + + return ret; +} + +Vector3 Animation::_interpolate( const Vector3& p_a, const Vector3& p_b, float p_c) const { + + return p_a.linear_interpolate(p_b,p_c); +} +Quat Animation::_interpolate( const Quat& p_a, const Quat& p_b, float p_c) const { + + return p_a.slerp(p_b,p_c); +} +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); + return dst; +} + + +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; +} + +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); + + 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 { + + 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 { + + 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::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; + + 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; + + 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 ); + + + } else if ((vformat & (vformat - 1))) { + + return p_a; //can't interpolate, mix of types + } + + switch(type_a) { + + case Variant::VECTOR2: { + + 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); + + } break; + case Variant::RECT2: { + + 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) + ); + + } break; + case Variant::VECTOR3: { + + 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); + + } break; + case Variant::QUAT: { + + 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); + + } break; + case Variant::_AABB: { + + AABB a=p_a; + AABB b=p_b; + AABB pa=p_pre_a; + AABB pb=p_post_b; + + return AABB( + 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 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 { + + 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_ok) const { + + int len=_find( p_keys, 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) + // meaning no keys, or only key time is larger than length + if (p_ok) + *p_ok=false; + return T(); + } else if (len==1) { // one key found (0+1), return it + + if (p_ok) + *p_ok=true; + return p_keys[0].value; + } + + int idx=_find(p_keys, p_time); + + ERR_FAIL_COND_V( idx==-2, T()); + + if (p_ok) + *p_ok=true; + + int next; + float c=0; + // prepare for all cases of interpolation + + if (loop) { + // loop + if (idx>=0) { + + 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; + + if (Math::absf(delta)>CMP_EPSILON) + c=from/delta; + else + c=0; + + } else { + + 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; + else + 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; + else + c=0; + } + + } else { // no loop + + if (idx>=0) { + + 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; + + if (Math::absf(delta)>CMP_EPSILON) + c=from/delta; + else + c=0; + + } else { + + next=idx; + } + + } else if (idx<0) { + + idx=next=0; + } + + } + + float tr = p_keys[idx].transition; + + if (tr==0 || idx==next) { + // don't interpolate if not needed + return p_keys[idx].value; + } + + if (tr!=1.0) { + + c = Math::ease(c,tr); + } + + switch(p_interp) { + + 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: { + 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); + + } 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 { + + 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); + + bool ok; + + TransformKey tk = _interpolate( tt->transforms, p_time, tt->interpolation, &ok ); + + if (!ok) // ?? + return ERR_UNAVAILABLE; + + if (r_loc) + *r_loc=tk.loc; + + if (r_rot) + *r_rot=tk.rot; + + if (r_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); + + bool ok; + + + Variant res = _interpolate( vt->values, p_time, vt->interpolation, &ok ); + + + if (ok) { + + return res; + } + + 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 { + + 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) + to--; + + if (to<0) + return; // not bother + + int from=_find( vt->values, from_time); + + // position in the right first event.+ + if (from<0 || vt->values[from].time<from_time) + from++; + + int max=vt->values.size(); + + for (int i=from;i<=to;i++) { + + 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 { + + ERR_FAIL_INDEX(p_track, tracks.size()); + Track *t=tracks[p_track]; + ERR_FAIL_COND( t->type != TYPE_VALUE ); + + ValueTrack * vt = static_cast<ValueTrack*>(t); + + float from_time=p_time-p_delta; + float to_time=p_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); + + 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); + 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; + + + } + + _value_track_get_key_indices_in_range(vt,from_time,to_time,p_indices); + + +} + +void Animation::value_track_set_continuous(int p_track, bool p_continuous) { + + ERR_FAIL_INDEX(p_track, tracks.size()); + Track *t=tracks[p_track]; + ERR_FAIL_COND( t->type != TYPE_VALUE ); + + ValueTrack * vt = static_cast<ValueTrack*>(t); + vt->continuous=p_continuous; + +} + +bool Animation::value_track_is_continuous(int p_track) const{ + + ERR_FAIL_INDEX_V(p_track, tracks.size(), false); + Track *t=tracks[p_track]; + ERR_FAIL_COND_V( t->type != TYPE_VALUE, false ); + + ValueTrack * vt = static_cast<ValueTrack*>(t); + return vt->continuous; + +} + +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 + + + 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) + to--; + + if (to<0) + return; // not bother + + int from=_find( mt->methods, from_time); + + // position in the right first event.+ + if (from<0 || mt->methods[from].time<from_time) + from++; + + int max=mt->methods.size(); + + for (int i=from;i<=to;i++) { + + 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 { + + ERR_FAIL_INDEX(p_track, tracks.size()); + Track *t=tracks[p_track]; + ERR_FAIL_COND( t->type != TYPE_METHOD ); + + MethodTrack * mt = static_cast<MethodTrack*>(t); + + 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 + _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; + + } + + _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 { + + 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); + + ERR_FAIL_INDEX_V( p_key_idx, pm->methods.size(), Vector<Variant>() ); + + 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() ); + + MethodTrack * pm = static_cast<MethodTrack*>(t); + + 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; + emit_changed(); +} +float Animation::get_length() const { + + return length; +} + +void Animation::set_loop(bool p_enabled) { + + loop=p_enabled; + emit_changed(); +} +bool Animation::has_loop() const { + + return loop; +} + +void Animation::track_move_up(int p_track) { + + + if (p_track>=0 && p_track<(tracks.size()-1)) { + + SWAP( tracks[p_track], tracks[p_track+1] ); + } + + emit_changed(); +} + +void Animation::track_move_down(int p_track) { + + if (p_track>0 && p_track<tracks.size()) { + + SWAP( tracks[p_track], tracks[p_track-1] ); + } + emit_changed(); +} + +void Animation::set_step(float p_step) { + + step=p_step; + emit_changed(); +} + +float Animation::get_step() const{ + + return step; +} + + +void Animation::_bind_methods() { + + ObjectTypeDB::bind_method(_MD("add_track","type","at_pos"),&Animation::add_track,DEFVAL(-1)); + ObjectTypeDB::bind_method(_MD("remove_track","idx"),&Animation::remove_track); + ObjectTypeDB::bind_method(_MD("get_track_count"),&Animation::get_track_count); + ObjectTypeDB::bind_method(_MD("track_get_type","idx"),&Animation::track_get_type); + ObjectTypeDB::bind_method(_MD("track_get_path","idx"),&Animation::track_get_path); + ObjectTypeDB::bind_method(_MD("track_set_path","idx","path"),&Animation::track_set_path); + ObjectTypeDB::bind_method(_MD("find_track","path"),&Animation::find_track); + + ObjectTypeDB::bind_method(_MD("track_move_up","idx"),&Animation::track_move_up); + ObjectTypeDB::bind_method(_MD("track_move_down","idx"),&Animation::track_move_down); + + ObjectTypeDB::bind_method(_MD("transform_track_insert_key","idx","time","loc","rot","scale"),&Animation::transform_track_insert_key); + ObjectTypeDB::bind_method(_MD("track_insert_key","idx","time","key","transition"),&Animation::track_insert_key,DEFVAL(1)); + ObjectTypeDB::bind_method(_MD("track_remove_key","idx","key_idx"),&Animation::track_remove_key); + ObjectTypeDB::bind_method(_MD("track_remove_key_at_pos","idx","pos"),&Animation::track_remove_key_at_pos); + ObjectTypeDB::bind_method(_MD("track_set_key_value","idx","key","value"),&Animation::track_set_key_value); + ObjectTypeDB::bind_method(_MD("track_set_key_transition","idx","key_idx","transition"),&Animation::track_set_key_transition); + ObjectTypeDB::bind_method(_MD("track_get_key_transition","idx","key_idx"),&Animation::track_get_key_transition); + + ObjectTypeDB::bind_method(_MD("track_get_key_count","idx"),&Animation::track_get_key_count); + ObjectTypeDB::bind_method(_MD("track_get_key_value","idx","key_idx"),&Animation::track_get_key_value); + ObjectTypeDB::bind_method(_MD("track_get_key_time","idx","key_idx"),&Animation::track_get_key_time); + ObjectTypeDB::bind_method(_MD("track_find_key","idx","time","exact"),&Animation::track_find_key,DEFVAL(false)); + + ObjectTypeDB::bind_method(_MD("track_set_interpolation_type","idx","interpolation"),&Animation::track_set_interpolation_type); + ObjectTypeDB::bind_method(_MD("track_get_interpolation_type","idx"),&Animation::track_get_interpolation_type); + + + + ObjectTypeDB::bind_method(_MD("transform_track_interpolate","idx","time_sec"),&Animation::_transform_track_interpolate); + ObjectTypeDB::bind_method(_MD("value_track_set_continuous","idx","continuous"),&Animation::value_track_set_continuous); + ObjectTypeDB::bind_method(_MD("value_track_is_continuous","idx"),&Animation::value_track_is_continuous); + + ObjectTypeDB::bind_method(_MD("value_track_get_key_indices","idx","time_sec","delta"),&Animation::_value_track_get_key_indices); + + ObjectTypeDB::bind_method(_MD("method_track_get_key_indices","idx","time_sec","delta"),&Animation::_method_track_get_key_indices); + ObjectTypeDB::bind_method(_MD("method_track_get_name","idx","key_idx"),&Animation::method_track_get_name); + ObjectTypeDB::bind_method(_MD("method_track_get_params","idx","key_idx"),&Animation::method_track_get_params); + + ObjectTypeDB::bind_method(_MD("set_length","time_sec"),&Animation::set_length); + ObjectTypeDB::bind_method(_MD("get_length"),&Animation::get_length); + + ObjectTypeDB::bind_method(_MD("set_loop","enabled"),&Animation::set_loop); + ObjectTypeDB::bind_method(_MD("has_loop"),&Animation::has_loop); + + ObjectTypeDB::bind_method(_MD("set_step","size_sec"),&Animation::set_step); + ObjectTypeDB::bind_method(_MD("get_step"),&Animation::get_step); + + ObjectTypeDB::bind_method(_MD("clear"),&Animation::clear); + + BIND_CONSTANT( TYPE_VALUE ); + BIND_CONSTANT( TYPE_TRANSFORM ); + BIND_CONSTANT( TYPE_METHOD ); + + BIND_CONSTANT( INTERPOLATION_NEAREST ); + BIND_CONSTANT( INTERPOLATION_LINEAR ); + BIND_CONSTANT( INTERPOLATION_CUBIC ); + +} + +void Animation::clear() { + + for(int i=0;i<tracks.size();i++) + memdelete( tracks[i] ); + tracks.clear(); + loop=false; + length=1; + +} + +void Animation::_transform_track_optimize(int p_idx,float p_allowed_err) { + + ERR_FAIL_INDEX(p_idx,tracks.size()); + ERR_FAIL_COND(tracks[p_idx]->type!=TYPE_TRANSFORM); + TransformTrack *tt= static_cast<TransformTrack*>(tracks[p_idx]); + for(int i=1;i<tt->transforms.size()-1;i++) { + + TKey<TransformKey> &t0 = tt->transforms[i-1]; + TKey<TransformKey> &t1 = tt->transforms[i]; + TKey<TransformKey> &t2 = tt->transforms[i+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; + + 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) { + //not close, not optimizable + continue; + } + + } else { + + Vector3 pd = (v2-v0); + float d0 = pd.dot(v0); + float d1 = pd.dot(v1); + float d2 = pd.dot(v2); + if (d1<d0 || d1>d2) { + continue; //beyond segment range + } + + Vector3 s[2]={ v0, v2 }; + real_t d =Geometry::get_closest_point_to_segment(v1,s).distance_to(v1); + + if (d>pd.length()*p_allowed_err) { + continue; //beyond allowed error for colinearity + } + + 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; + + //localize both to rotation from q0 + + if ((q0-q2).length() < CMP_EPSILON) { + + if ((q0-q1).length() > CMP_EPSILON) + continue; + + } else { + + Quat r02 = (q0.inverse() * q2).normalized(); + Quat r01 = (q0.inverse() * q1).normalized(); + + Vector3 v02,v01; + real_t a02,a01; + + r02.get_axis_and_angle(v02,a02); + r01.get_axis_and_angle(v01,a01); + + if (v01.dot(v02)<0) { + //make sure both rotations go the same way to compare + v02=-v02; + a02=-a02; + } + + real_t err_01 = Math::acos(v01.normalized().dot(v02.normalized()))/Math_PI; + if (err_01>p_allowed_err) { + //not rotating in the same axis + continue; + } + + if (a01*a02 < 0 ) { + //not rotating in the same direction + continue; + } + + real_t tr = a01/a02; + if (tr<0 || tr>1) + continue; //rotating too much or too less + + t[1]=tr; + + } + + } + + { //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) { + //0 and 2 are close, let's see if 1 is close + if (v0.distance_to(v1)>CMP_EPSILON) { + //not close, not optimizable + continue; + } + + } else { + + Vector3 pd = (v2-v0); + float d0 = pd.dot(v0); + float d1 = pd.dot(v1); + float d2 = pd.dot(v2); + if (d1<d0 || d1>d2) { + continue; //beyond segment range + } + + Vector3 s[2]={ v0, v2 }; + real_t d =Geometry::get_closest_point_to_segment(v1,s).distance_to(v1); + + if (d>pd.length()*p_allowed_err) { + continue; //beyond allowed error for colinearity + } + + t[2] = (d1-d0)/(d2-d0); + } + } + + bool erase=false; + if (t[0]==-1 && t[1]==-1 && t[2]==-1) { + + erase=true; + } else { + + 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 + //validate rest + for(int k=j+1;k<3;k++) { + if (t[k]==-1) + continue; + + if (Math::abs(lt-t[k])>p_allowed_err) { + erase=false; + break; + } + } + break; + } + } + + ERR_CONTINUE( lt==-1 ); + + if (erase) { + + if (Math::abs(lt-c)>p_allowed_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; + } else { + + //print_line(itos(i)+"because of interp"); + } + } + + } + + if (erase) { + tt->transforms.remove(i); + i--; + } + + + // print_line(itos(i)+" could be eliminated: "+rtos(tr)); + //} + } + + +} + +void Animation::optimize(float p_allowed_err) { + + + int total_tt=0; + + for(int i=0;i<tracks.size();i++) { + + if (tracks[i]->type==TYPE_TRANSFORM) + _transform_track_optimize(i,p_allowed_err); + + } + +} + + +Animation::Animation() { + + step=0.1; + loop=false; + length=1; +} + + +Animation::~Animation() { + + for(int i=0;i<tracks.size();i++) + memdelete( tracks[i] ); + +} + + |