diff options
Diffstat (limited to '')
| -rw-r--r-- | scene/animation/SCsub | 7 | ||||
| -rw-r--r-- | scene/animation/animation_cache.cpp | 386 | ||||
| -rw-r--r-- | scene/animation/animation_cache.h | 85 | ||||
| -rw-r--r-- | scene/animation/animation_player.cpp | 1258 | ||||
| -rw-r--r-- | scene/animation/animation_player.h | 300 | ||||
| -rw-r--r-- | scene/animation/animation_tree_player.cpp | 1782 | ||||
| -rw-r--r-- | scene/animation/animation_tree_player.h | 420 | ||||
| -rw-r--r-- | scene/animation/transitioner.cpp | 34 | ||||
| -rw-r--r-- | scene/animation/transitioner.h | 68 |
9 files changed, 4340 insertions, 0 deletions
diff --git a/scene/animation/SCsub b/scene/animation/SCsub new file mode 100644 index 000000000..055d2f247 --- /dev/null +++ b/scene/animation/SCsub @@ -0,0 +1,7 @@ +Import('env') + +env.add_source_files(env.scene_sources,"*.cpp") + +Export('env') + + diff --git a/scene/animation/animation_cache.cpp b/scene/animation/animation_cache.cpp new file mode 100644 index 000000000..38cfe0d8a --- /dev/null +++ b/scene/animation/animation_cache.cpp @@ -0,0 +1,386 @@ +/*************************************************************************/ +/* animation_cache.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_cache.h" + + + +void AnimationCache::_node_exit_scene(Node *p_node) { + + //it is one shot, so it disconnects upon arrival + + ERR_FAIL_COND(!connected_nodes.has(p_node)); + + connected_nodes.erase(p_node); + + for(int i=0;i<path_cache.size();i++) { + + + if (path_cache[i].node!=p_node) + continue; + + path_cache[i].valid=false; //invalidate path cache + } + +} + +void AnimationCache::_animation_changed() { + + + _clear_cache(); +} + +void AnimationCache::_clear_cache() { + + while(connected_nodes.size()) { + + connected_nodes.front()->get()->disconnect("exit_scene",this,"_node_exit_scene"); + connected_nodes.erase(connected_nodes.front()); + } + path_cache.clear();; + cache_valid=false; + cache_dirty=true; +} + + +void AnimationCache::_update_cache() { + + cache_valid=false; + + ERR_FAIL_COND(!root); + ERR_FAIL_COND(!root->is_inside_scene()); + ERR_FAIL_COND(animation.is_null()); + + for(int i=0;i<animation->get_track_count();i++) { + + + + NodePath np = animation->track_get_path(i); + + Node *node = root->get_node(np); + if (!node) { + + path_cache.push_back(Path()); + ERR_EXPLAIN("Invalid Track Path in Animation: "+np); + ERR_CONTINUE(!node); + } + + + Path path; + + Ref<Resource> res; + + if (np.get_subname_count()) { + + + if (animation->track_get_type(i)==Animation::TYPE_TRANSFORM) { + + path_cache.push_back(Path()); + ERR_EXPLAIN("Transform tracks can't have a subpath: "+np); + ERR_CONTINUE(animation->track_get_type(i)==Animation::TYPE_TRANSFORM); + + } + + RES res; + + for(int j=0;j<np.get_subname_count();j++) { + res = j==0 ? node->get(np.get_subname(j)) : res->get(np.get_subname(j)); + if (res.is_null()) + break; + + } + + if (res.is_null()) { + + path_cache.push_back(Path()); + ERR_EXPLAIN("Invalid Track SubPath in Animation: "+np); + ERR_CONTINUE(res.is_null()); + } + + path.resource=res; + path.object=res.ptr(); + + } else { + + + if (animation->track_get_type(i)==Animation::TYPE_TRANSFORM) { + StringName property = np.get_property(); + String ps = property; + + + Spatial *sp = node->cast_to<Spatial>(); + + if (!sp) { + + path_cache.push_back(Path()); + ERR_EXPLAIN("Transform track not of type Spatial: "+np); + ERR_CONTINUE(!sp); + } + + if (ps!="") { + + Skeleton *sk = node->cast_to<Skeleton>(); + if (!sk) { + + path_cache.push_back(Path()); + ERR_EXPLAIN("Property defined in Transform track, but not a Skeleton!: "+np); + ERR_CONTINUE(!sk); + } + + int idx = sk->find_bone(ps); + if (idx==-1) { + + path_cache.push_back(Path()); + ERR_EXPLAIN("Property defined in Transform track, but not a Skeleton Bone!: "+np); + ERR_CONTINUE(idx==-1); + + } + + path.bone_idx=idx; + path.skeleton=sk; + + } + + path.spatial=sp; + + } + + path.node=node; + path.object=node; + + } + + if (animation->track_get_type(i)==Animation::TYPE_VALUE) { + + if (np.get_property().operator String()=="") { + + path_cache.push_back(Path()); + ERR_EXPLAIN("Value Track lacks property: "+np); + ERR_CONTINUE(np.get_property().operator String()==""); + + } + + path.property=np.get_property(); + + } else if (animation->track_get_type(i)==Animation::TYPE_METHOD) { + + if (np.get_property().operator String()!="") { + + path_cache.push_back(Path()); + ERR_EXPLAIN("Method Track has property: "+np); + ERR_CONTINUE(np.get_property().operator String()!=""); + + } + + } + + + path.valid=true; + + path_cache.push_back(path); + + if (!connected_nodes.has(path.node)) { + connected_nodes.insert(path.node); + path.node->connect("exit_scene",this,"_node_exit_scene",Node::make_binds(path.node),CONNECT_ONESHOT); + } + + + + } + + + + cache_dirty=false; + cache_valid=true; +} + +void AnimationCache::set_track_transform(int p_idx,const Transform& p_transform) { + + if (cache_dirty) + _update_cache(); + + ERR_FAIL_COND(!cache_valid); + ERR_FAIL_INDEX(p_idx,path_cache.size()); + Path &p = path_cache[p_idx]; + if (!p.valid) + return; + + ERR_FAIL_COND(!p.node); + ERR_FAIL_COND(!p.spatial); + + if (p.skeleton) { + p.skeleton->set_bone_pose(p.bone_idx,p_transform); + } else { + p.spatial->set_transform(p_transform); + } + +} + +void AnimationCache::set_track_value(int p_idx,const Variant& p_value) { + + if (cache_dirty) + _update_cache(); + + ERR_FAIL_COND(!cache_valid); + ERR_FAIL_INDEX(p_idx,path_cache.size()); + Path &p = path_cache[p_idx]; + if (!p.valid) + return; + + ERR_FAIL_COND(!p.object); + p.object->set(p.property,p_value); +} + + +void AnimationCache::call_track(int p_idx,const StringName& p_method,const Variant** p_args,int p_argcount,Variant::CallError &r_error) { + + if (cache_dirty) + _update_cache(); + + + ERR_FAIL_COND(!cache_valid); + ERR_FAIL_INDEX(p_idx,path_cache.size()); + Path &p = path_cache[p_idx]; + if (!p.valid) + return; + + ERR_FAIL_COND(!p.object); + p.object->call(p_method,p_args,p_argcount,r_error); + +} + + +void AnimationCache::set_all(float p_time, float p_delta) { + + if (cache_dirty) + _update_cache(); + + ERR_FAIL_COND(!cache_valid); + + int tc = animation->get_track_count(); + for(int i=0;i<tc;i++) { + + switch(animation->track_get_type(i)) { + + case Animation::TYPE_TRANSFORM: { + + Vector3 loc,scale; + Quat rot; + animation->transform_track_interpolate(i,p_time,&loc,&rot,&scale); + Transform tr( Matrix3(rot), loc ); + tr.basis.scale(scale); + + set_track_transform(i,tr); + + + } break; + case Animation::TYPE_VALUE: { + + if (animation->value_track_is_continuous(i)) { + Variant v = animation->value_track_interpolate(i,p_time); + set_track_value(i,v); + } else { + + List<int> indices; + animation->value_track_get_key_indices(i,p_time,p_delta,&indices); + + for(List<int>::Element *E=indices.front();E;E=E->next()) { + + Variant v = animation->track_get_key_value(i,E->get()); + set_track_value(i,v); + } + + } + + } break; + case Animation::TYPE_METHOD: { + + List<int> indices; + animation->method_track_get_key_indices(i,p_time,p_delta,&indices); + + for(List<int>::Element *E=indices.front();E;E=E->next()) { + + Vector<Variant> args = animation->method_track_get_params(i,E->get()); + StringName name = animation->method_track_get_name(i,E->get()); + Variant::CallError err; + + if (!args.size()) { + + call_track(i,name,NULL,0,err); + } else { + + Vector<Variant*> argptrs; + argptrs.resize(args.size()); + for(int j=0;j<args.size();j++) { + + argptrs[j]=&args[j]; + } + + call_track(i,name,(const Variant**)&argptrs[0],args.size(),err); + } + + } + + } break; + default: {} + } + } + +} + +void AnimationCache::set_animation(const Ref<Animation>& p_animation) { + + _clear_cache(); + + if (animation.is_valid()) + animation->disconnect("changed",this,"_animation_changed"); + + animation=p_animation; + + if (animation.is_valid()) + animation->connect("changed",this,"_animation_changed"); +} + +void AnimationCache::_bind_methods() { + + ObjectTypeDB::bind_method(_MD("_node_exit_scene"),&AnimationCache::_node_exit_scene); + ObjectTypeDB::bind_method(_MD("_animation_changed"),&AnimationCache::_animation_changed); +} + +void AnimationCache::set_root(Node* p_root) { + + _clear_cache(); + root=p_root; +} + +AnimationCache::AnimationCache() { + + root=NULL; + cache_dirty=true; + cache_valid=false; +} diff --git a/scene/animation/animation_cache.h b/scene/animation/animation_cache.h new file mode 100644 index 000000000..72ee8f186 --- /dev/null +++ b/scene/animation/animation_cache.h @@ -0,0 +1,85 @@ +/*************************************************************************/ +/* animation_cache.h */ +/*************************************************************************/ +/* 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. */ +/*************************************************************************/ +#ifndef ANIMATION_CACHE_H +#define ANIMATION_CACHE_H + +#include "scene/resources/animation.h" +#include "scene/3d/skeleton.h" + +class AnimationCache : public Object { + + OBJ_TYPE(AnimationCache,Object); + + struct Path { + + RES resource; + Object *object; + Skeleton *skeleton; // haxor + Node *node; + Spatial *spatial; + + int bone_idx; + StringName property; + bool valid; + Path() { object=NULL; skeleton=NULL; node=NULL; bone_idx=-1; valid=false; spatial=NULL; } + }; + + Set<Node*> connected_nodes; + Vector<Path> path_cache; + + Node *root; + Ref<Animation> animation; + bool cache_dirty; + bool cache_valid; + + void _node_exit_scene(Node *p_node); + + void _clear_cache(); + void _update_cache(); + void _animation_changed(); + +protected: + + static void _bind_methods(); + +public: + + void set_track_transform(int p_idx,const Transform& p_transform); + void set_track_value(int p_idx,const Variant& p_value); + void call_track(int p_idx,const StringName& p_method,const Variant** p_args,int p_argcount,Variant::CallError &r_error); + + void set_all(float p_time, float p_delta=0); + + void set_animation(const Ref<Animation>& p_animation); + void set_root(Node* p_root); + + AnimationCache(); +}; + +#endif // ANIMATION_CACHE_H diff --git a/scene/animation/animation_player.cpp b/scene/animation/animation_player.cpp new file mode 100644 index 000000000..d0a569876 --- /dev/null +++ b/scene/animation/animation_player.cpp @@ -0,0 +1,1258 @@ +/*************************************************************************/ +/* animation_player.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_player.h" + +#include "message_queue.h" +#include "scene/scene_string_names.h" + +bool AnimationPlayer::_set(const StringName& p_name, const Variant& p_value) { + + String name=p_name; + + if (name=="playback/speed" || name=="speed") { //bw compatibility + set_speed(p_value); + + } else if (name=="playback/active") { + set_active(p_value); + } else if (name.begins_with("playback/play")) { + + String which=p_value; + + + if (which=="[stop]") + stop(); + else + play(which); + } else if (name.begins_with("anims/")) { + + + String which=name.get_slice("/",1); + + add_animation(which,p_value); + } else if (name.begins_with("next/")) { + + + String which=name.get_slice("/",1); + animation_set_next(which,p_value); + + } else if (name=="blend_times") { + + Array array=p_value; + int len = array.size(); + ERR_FAIL_COND_V(len%3,false); + + + for(int i=0;i<len/3;i++) { + + StringName from = array[i*3+0]; + StringName to = array[i*3+1]; + float time = array[i*3+2]; + + set_blend_time(from,to,time); + } + + } else if (name=="autoplay") { + autoplay=p_value; + + } else + return false; + + return true; + +} + +bool AnimationPlayer::_get(const StringName& p_name,Variant &r_ret) const { + + String name=p_name; + + if (name=="playback/speed") { //bw compatibility + + r_ret=speed_scale; + } else if (name=="playback/active") { + + r_ret=is_active(); + } else if (name=="playback/play") { + + if (is_active() && is_playing()) + r_ret=playback.assigned; + else + r_ret="[stop]"; + + } else if (name.begins_with("anims/")) { + + String which=name.get_slice("/",1); + + r_ret= get_animation(which).get_ref_ptr(); + } else if (name.begins_with("next/")) { + + String which=name.get_slice("/",1); + + r_ret= animation_get_next(which); + + + } else if (name=="blend_times") { + + Array array; + + array.resize(blend_times.size()*3); + int idx=0; + for(Map<BlendKey, float >::Element *E=blend_times.front();E;E=E->next()) { + + array.set(idx*3+0,E->key().from); + array.set(idx*3+1,E->key().to); + array.set(idx*3+2,E->get()); + idx++; + } + r_ret=array; + } else if (name=="autoplay") { + r_ret=autoplay; + + + } else + return false; + + return true; +} + +void AnimationPlayer::_get_property_list( List<PropertyInfo> *p_list) const { + + + + + List<String> names; + + for( Map<StringName, AnimationData>::Element *E=animation_set.front();E;E=E->next()) { + + p_list->push_back( PropertyInfo( Variant::OBJECT, "anims/"+String(E->key()), PROPERTY_HINT_RESOURCE_TYPE, "Animation",PROPERTY_USAGE_NOEDITOR) ); + if (E->get().next!=StringName()) + p_list->push_back( PropertyInfo( Variant::STRING, "next/"+String(E->key()), PROPERTY_HINT_NONE, "",PROPERTY_USAGE_NOEDITOR) ); + names.push_back(E->key()); + } + + + { + names.sort(); + names.push_front("[stop]"); + String hint; + for(List<String>::Element *E=names.front();E;E=E->next()) { + + if (E!=names.front()) + hint+=","; + hint+=E->get(); + } + + p_list->push_back( PropertyInfo( Variant::STRING, "playback/play", PROPERTY_HINT_ENUM, hint,PROPERTY_USAGE_EDITOR) ); + p_list->push_back( PropertyInfo( Variant::BOOL, "playback/active", PROPERTY_HINT_NONE,"" ) ); + p_list->push_back( PropertyInfo( Variant::REAL, "playback/speed", PROPERTY_HINT_RANGE, "-64,64,0.01") ); + + } + + + + p_list->push_back( PropertyInfo( Variant::ARRAY, "blend_times", PROPERTY_HINT_NONE, "",PROPERTY_USAGE_NOEDITOR) ); + p_list->push_back( PropertyInfo( Variant::STRING, "autoplay", PROPERTY_HINT_NONE, "",PROPERTY_USAGE_NOEDITOR) ); + +} + + +void AnimationPlayer::_notification(int p_what) { + + switch(p_what) { + + case NOTIFICATION_ENTER_SCENE: { + + if (!processing) { + //make sure that a previous process state was not saved + //only process if "processing" is set + set_fixed_process(false); + set_process(false); + } + //_set_process(false); + clear_caches(); + } break; + case NOTIFICATION_READY: { + + if (!get_scene()->is_editor_hint() && animation_set.has(autoplay)) { + play(autoplay); + } + } break; + case NOTIFICATION_PROCESS: { + if (animation_process_mode==ANIMATION_PROCESS_FIXED) + break; + + if (processing) + _animation_process( get_process_delta_time() ); + } break; + case NOTIFICATION_FIXED_PROCESS: { + + if (animation_process_mode==ANIMATION_PROCESS_IDLE) + break; + + if (processing) + _animation_process( get_fixed_process_delta_time() ); + } break; + case NOTIFICATION_EXIT_SCENE: { + + stop_all(); + clear_caches(); + } break; + } +} + +void AnimationPlayer::_generate_node_caches(AnimationData* p_anim) { + + Node *parent = get_node(root); + + ERR_FAIL_COND(!parent); + + Animation *a=p_anim->animation.operator->(); + + p_anim->node_cache.resize( a->get_track_count() ); + + for (int i=0;i<a->get_track_count();i++) { + + p_anim->node_cache[i]=NULL; + RES resource; + Node *child = parent->get_node_and_resource(a->track_get_path(i),resource); + ERR_CONTINUE(!child); // couldn't find the child node + uint32_t id=resource.is_valid()?resource->get_instance_ID():child->get_instance_ID(); + int bone_idx=-1; + + if (a->track_get_path(i).get_property() && child->cast_to<Skeleton>()) { + + bone_idx = child->cast_to<Skeleton>()->find_bone( a->track_get_path(i).get_property() ); + if (bone_idx==-1) { + + continue; + } + } + + { + if (!child->is_connected("exit_scene",this,"_node_removed")) + child->connect("exit_scene",this,"_node_removed",make_binds(child),CONNECT_ONESHOT); + } + + TrackNodeCacheKey key; + key.id=id; + key.bone_idx=bone_idx; + + if (node_cache_map.has(key)) { + + p_anim->node_cache[i]=&node_cache_map[key]; + } else { + + + node_cache_map[key]=TrackNodeCache(); + + p_anim->node_cache[i]=&node_cache_map[key]; + p_anim->node_cache[i]->node=child; + p_anim->node_cache[i]->resource=resource; + p_anim->node_cache[i]->node_2d=child->cast_to<Node2D>(); + if (a->track_get_type(i)==Animation::TYPE_TRANSFORM) { + // special cases and caches for transform tracks + + // cache spatial + p_anim->node_cache[i]->spatial=child->cast_to<Spatial>(); + // cache skeleton + p_anim->node_cache[i]->skeleton=child->cast_to<Skeleton>(); + if (p_anim->node_cache[i]->skeleton) { + + StringName bone_name=a->track_get_path(i).get_property(); + if (bone_name.operator String()!="") { + + p_anim->node_cache[i]->bone_idx=p_anim->node_cache[i]->skeleton->find_bone(bone_name); + if (p_anim->node_cache[i]->bone_idx<0) { + // broken track (unexisting bone) + p_anim->node_cache[i]->skeleton=NULL; + p_anim->node_cache[i]->spatial=NULL; + printf("bone is %ls\n", String(bone_name).c_str()); + ERR_CONTINUE( p_anim->node_cache[i]->bone_idx<0 ); + } else { + } + } else { + // no property, just use spatialnode + p_anim->node_cache[i]->skeleton=NULL; + } + + } + } + } + + if (a->track_get_type(i)==Animation::TYPE_VALUE) { + + StringName property = a->track_get_path(i).get_property(); + if (!p_anim->node_cache[i]->property_anim.has(property)) { + + TrackNodeCache::PropertyAnim pa; + pa.prop=property; + pa.object=resource.is_valid()?(Object*)resource.ptr():(Object*)child; + pa.special=SP_NONE; + if (false && p_anim->node_cache[i]->node_2d) { + + if (pa.prop==SceneStringNames::get_singleton()->transform_pos) + pa.special=SP_NODE2D_POS; + else if (pa.prop==SceneStringNames::get_singleton()->transform_rot) + pa.special=SP_NODE2D_ROT; + else if (pa.prop==SceneStringNames::get_singleton()->transform_scale) + pa.special=SP_NODE2D_SCALE; + } + p_anim->node_cache[i]->property_anim[property]=pa; + } + } + } +} + + +void AnimationPlayer::_animation_process_animation(AnimationData* p_anim,float p_time, float p_delta,float p_interp, bool p_allow_discrete) { + + if (p_anim->node_cache.size() != p_anim->animation->get_track_count()) { + // animation hasn't been "node-cached" + _generate_node_caches(p_anim); + } + + + ERR_FAIL_COND( p_anim->node_cache.size() != p_anim->animation->get_track_count() ); + + + Animation *a=p_anim->animation.operator->(); + bool can_call = is_inside_scene() && !get_scene()->is_editor_hint(); + + for (int i=0;i<a->get_track_count();i++) { + + TrackNodeCache *nc=p_anim->node_cache[i]; + + if (!nc) // no node cache for this track, skip it + continue; + + if (a->track_get_key_count(i)==0) + continue; // do nothing if track is empty + + switch(a->track_get_type(i)) { + + case Animation::TYPE_TRANSFORM: { + + if (!nc->spatial) + continue; + + + Vector3 loc; + Quat rot; + Vector3 scale; + + + Error err = a->transform_track_interpolate(i,p_time,&loc,&rot,&scale); + ERR_CONTINUE(err!=OK); //used for testing, should be removed + + + if (err!=OK) + continue; + + if (nc->accum_pass!=accum_pass) { + ERR_CONTINUE( cache_update_size >= NODE_CACHE_UPDATE_MAX ); + cache_update[cache_update_size++]=nc; + nc->accum_pass=accum_pass; + nc->loc_accum=loc; + nc->rot_accum=rot; + nc->scale_accum=scale; + + } else { + + nc->loc_accum=nc->loc_accum.linear_interpolate(loc,p_interp); + nc->rot_accum=nc->rot_accum.slerp(rot,p_interp); + nc->scale_accum=nc->scale_accum.linear_interpolate(scale,p_interp); + + } + + } break; + case Animation::TYPE_VALUE: { + + if (!nc->node) + continue; + + //StringName property=a->track_get_path(i).get_property(); + + Map<StringName,TrackNodeCache::PropertyAnim>::Element *E=nc->property_anim.find(a->track_get_path(i).get_property()); + ERR_CONTINUE(!E); //should it continue, or create a new one? + + TrackNodeCache::PropertyAnim *pa = &E->get(); + + + if (a->value_track_is_continuous(i) || p_delta==0) { + + + Variant value=a->value_track_interpolate(i,p_time); + if (p_delta==0 && value.get_type()==Variant::STRING) + continue; // doing this with strings is messy, should find another way + if (pa->accum_pass!=accum_pass) { + ERR_CONTINUE( cache_update_prop_size >= NODE_CACHE_UPDATE_MAX ); + cache_update_prop[cache_update_prop_size++]=pa; + pa->value_accum=value; + pa->accum_pass=accum_pass; + } else { + Variant::interpolate(pa->value_accum,value,p_interp,pa->value_accum); + } + + + } else if (p_allow_discrete) { + + List<int> indices; + a->value_track_get_key_indices(i,p_time,p_delta,&indices); + + for(List<int>::Element *F=indices.front();F;F=F->next()) { + + Variant value=a->track_get_key_value(i,F->get()); + switch(pa->special) { + + case SP_NONE: pa->object->set(pa->prop,value); break; //you are not speshul + case SP_NODE2D_POS: static_cast<Node2D*>(pa->object)->set_pos(value); break; + case SP_NODE2D_ROT: static_cast<Node2D*>(pa->object)->set_rot(Math::deg2rad(value)); break; + case SP_NODE2D_SCALE: static_cast<Node2D*>(pa->object)->set_scale(value); break; + } + + } + + } + + } break; + case Animation::TYPE_METHOD: { + + if (!nc->node) + continue; + if (p_delta==0) + continue; + if (!p_allow_discrete) + break; + + List<int> indices; + + a->method_track_get_key_indices(i,p_time,p_delta,&indices); + + for(List<int>::Element *E=indices.front();E;E=E->next()) { + + StringName method=a->method_track_get_name(i,E->get()); + Vector<Variant> params=a->method_track_get_params(i,E->get()); + + int s=params.size(); + + ERR_CONTINUE( s > VARIANT_ARG_MAX ); + if (can_call) { + MessageQueue::get_singleton()->push_call( + nc->node, + method, + s>=1 ? params[0] : Variant(), + s>=2 ? params[1] : Variant(), + s>=3 ? params[2] : Variant(), + s>=4 ? params[3] : Variant(), + s>=5 ? params[4] : Variant() + ); + } + } + + + } break; + } + } +} + +void AnimationPlayer::_animation_process_data(PlaybackData &cd,float p_delta,float p_blend) { + + float delta=p_delta*speed_scale*cd.speed_scale; + bool backwards=delta<0; + float next_pos=cd.pos+delta; + + float len=cd.from->animation->get_length(); + bool loop=cd.from->animation->has_loop(); + + if (!loop) { + + if (next_pos<0) + next_pos=0; + else if (next_pos>len) + next_pos=len; + + // fix delta + delta=next_pos-cd.pos; + + if (&cd == &playback.current) { + + if (!backwards && cd.pos < len && next_pos==len /*&& playback.blend.empty()*/) { + //playback finished + end_notify=true; + } + + if (backwards && cd.pos > 0 && next_pos==0 /*&& playback.blend.empty()*/) { + //playback finished + end_notify=true; + } + + } + + } else { + + next_pos=Math::fposmod(next_pos,len); + + } + + cd.pos=next_pos; + + _animation_process_animation(cd.from,cd.pos,delta,p_blend,&cd == &playback.current); + + + +} +void AnimationPlayer::_animation_process2(float p_delta) { + + + Playback &c=playback; + + float prev_blend=1.0; + accum_pass++; + + int pop_count=1; + int pop=0; // if >0, then amount of elements to pop from the back + + + for (List<Blend>::Element *E=c.blend.back();E;E=E->prev(),pop_count++) { + + Blend& b=E->get(); + _animation_process_data(b.data,p_delta,prev_blend); + + prev_blend=1.0-b.blend_left/b.blend_time; + + b.blend_left-=Math::absf(speed_scale*p_delta); + + if (b.blend_left<0) { + + pop=pop_count; + } + } + + while(pop--) { + + c.blend.pop_back(); + } + + + _animation_process_data(c.current,p_delta,prev_blend); + +} + +void AnimationPlayer::_animation_update_transforms() { + + + for (int i=0;i<cache_update_size;i++) { + + TrackNodeCache *nc=cache_update[i]; + + ERR_CONTINUE( nc->accum_pass!=accum_pass ); + + if (nc->spatial) { + + Transform t; + t.origin=nc->loc_accum; + t.basis=nc->rot_accum; + t.basis.scale( nc->scale_accum ); + + if (nc->skeleton && nc->bone_idx>=0) { + + nc->skeleton->set_bone_pose( nc->bone_idx, t ); + + } else if (nc->spatial) { + + nc->spatial->set_transform(t); + } + } + + } + + cache_update_size=0; + + for (int i=0;i<cache_update_prop_size;i++) { + + TrackNodeCache::PropertyAnim *pa=cache_update_prop[i]; + + ERR_CONTINUE( pa->accum_pass!=accum_pass ); + +#if 1 + switch(pa->special) { + + + case SP_NONE: pa->object->set(pa->prop,pa->value_accum); break; //you are not speshul + case SP_NODE2D_POS: static_cast<Node2D*>(pa->object)->set_pos(pa->value_accum); break; + case SP_NODE2D_ROT: static_cast<Node2D*>(pa->object)->set_rot(Math::deg2rad(pa->value_accum)); break; + case SP_NODE2D_SCALE: static_cast<Node2D*>(pa->object)->set_scale(pa->value_accum); break; + } +#else + + pa->object->set(pa->prop,pa->value_accum); +#endif + } + + cache_update_prop_size=0; +} + +void AnimationPlayer::_animation_process(float p_delta) { + + + +// bool any_active=false; + + if (playback.current.from) { + + end_notify=false; + _animation_process2(p_delta); + _animation_update_transforms(); + if (end_notify) { + if (queued.size()) { + String old = playback.assigned; + play(queued.front()->get()); + String new_name = playback.assigned; + queued.pop_front(); + emit_signal(SceneStringNames::get_singleton()->animation_changed, old, new_name); + } else { + //stop(); + playing = false; + _set_process(false); + emit_signal(SceneStringNames::get_singleton()->finished); + } + + } + + } else { + _set_process(false); + } + +} + + +Error AnimationPlayer::add_animation(const StringName& p_name, const Ref<Animation>& p_animation) { + + ERR_EXPLAIN("Invalid animation name: "+String(p_name)); + ERR_FAIL_COND_V( String(p_name).find("/")!=-1 || String(p_name).find(":")!=-1 || String(p_name).find(",")!=-1 || String(p_name).find("[")!=-1, ERR_INVALID_PARAMETER ); + ERR_FAIL_COND_V( p_animation.is_null() , ERR_INVALID_PARAMETER ); + + //print_line("Add anim: "+String(p_name)+" name: "+p_animation->get_name()); + + if (animation_set.has(p_name)) { + + _unref_anim(animation_set[p_name].animation); + animation_set[p_name].animation=p_animation; + clear_caches(); + } else { + + AnimationData ad; + ad.animation=p_animation; + ad.name=p_name; + animation_set[p_name]=ad; + } + + _ref_anim(p_animation); + _change_notify(); + return OK; +} + +void AnimationPlayer::remove_animation(const StringName& p_name) { + + ERR_FAIL_COND(!animation_set.has(p_name) ); + + stop_all(); + _unref_anim(animation_set[p_name].animation); + animation_set.erase(p_name); + + clear_caches(); + _change_notify(); + +} + +void AnimationPlayer::_ref_anim(const Ref<Animation>& p_anim) { + + if (used_anims.has(p_anim)) + used_anims[p_anim]++; + else { + used_anims[p_anim]=1; + Ref<Animation>(p_anim)->connect("changed",this,"_animation_changed"); + } + +} + +void AnimationPlayer::_unref_anim(const Ref<Animation>& p_anim) { + + ERR_FAIL_COND(!used_anims.has(p_anim)); + + + int & n = used_anims[p_anim]; + n--; + if (n==0) { + + Ref<Animation>(p_anim)->disconnect("changed",this,"_animation_changed"); + used_anims.erase(p_anim); + } + +} + + +void AnimationPlayer::rename_animation(const StringName& p_name,const StringName& p_new_name) { + + + ERR_FAIL_COND(!animation_set.has(p_name) ); + ERR_FAIL_COND( String(p_new_name).find("/")!=-1 || String(p_new_name).find(":")!=-1 ); + ERR_FAIL_COND( animation_set.has(p_new_name) ); + + //print_line("Rename anim: "+String(p_name)+" name: "+String(p_new_name)); + + stop_all(); + AnimationData ad = animation_set[p_name]; + ad.name=p_new_name; + animation_set.erase(p_name); + animation_set[p_new_name]=ad; + + List<BlendKey> to_erase; + Map<BlendKey,float> to_insert; + for(Map<BlendKey, float >::Element *E=blend_times.front();E;E=E->next()) { + + BlendKey bk=E->key(); + BlendKey new_bk=bk; + bool erase=false; + if (bk.from==p_name) { + new_bk.from=p_new_name; + erase=true; + } + if (bk.to==p_name) { + new_bk.to=p_new_name; + erase=true; + } + + if (erase) { + to_erase.push_back(bk); + to_insert[new_bk]=E->get(); + } + } + + while(to_erase.size()) { + + blend_times.erase(to_erase.front()->get()); + to_erase.pop_front();; + } + + while(to_insert.size()) { + blend_times[to_insert.front()->key()]=to_insert.front()->get(); + to_insert.erase(to_insert.front()); + } + + if (autoplay==p_name) + autoplay=p_new_name; + + clear_caches(); + _change_notify(); +} + + +bool AnimationPlayer::has_animation(const StringName& p_name) const { + + return animation_set.has(p_name); +} +Ref<Animation> AnimationPlayer::get_animation(const StringName& p_name) const { + + ERR_FAIL_COND_V( !animation_set.has(p_name), Ref<Animation>() ); + + const AnimationData& data = animation_set[p_name]; + + return data.animation; + +} +void AnimationPlayer::get_animation_list( List<StringName> * p_animations) const { + + List<String> anims; + + for( Map<StringName, AnimationData>::Element *E=animation_set.front();E;E=E->next()) { + + anims.push_back(E->key()); + } + + anims.sort(); + + for(List<String>::Element *E=anims.front();E;E=E->next()) { + + p_animations->push_back(E->get()); + } + +} + +void AnimationPlayer::set_blend_time(const StringName& p_animation1, const StringName& p_animation2, float p_time) { + + ERR_FAIL_COND(p_time<0); + + BlendKey bk; + bk.from=p_animation1; + bk.to=p_animation2; + if (p_time==0) + blend_times.erase(bk); + else + blend_times[bk]=p_time; + +} + + +float AnimationPlayer::get_blend_time( const StringName& p_animation1, const StringName& p_animation2) const { + + BlendKey bk; + bk.from=p_animation1; + bk.to=p_animation2; + + if (blend_times.has(bk)) + return blend_times[bk]; + else + return 0; + + +} + + +void AnimationPlayer::queue(const StringName& p_name) { + + if (!is_playing()) + play(p_name); + else + queued.push_back(p_name); +} + +void AnimationPlayer::clear_queue() { + queued.clear(); +}; + +void AnimationPlayer::play(const StringName& p_name, float p_custom_blend, float p_custom_scale,bool p_from_end) { + + //printf("animation is %ls\n", String(p_name).c_str()); + //ERR_FAIL_COND(!is_inside_scene()); + StringName name=p_name; + + if (String(name)=="") + name=playback.assigned; + + if (!animation_set.has(name)) { + ERR_EXPLAIN("Animation not found: "+name); + ERR_FAIL(); + } + + Playback &c=playback; + + if (c.current.from) { + + float blend_time=0; + // find if it can blend + BlendKey bk; + bk.from=c.current.from->name; + bk.to=name; + + if (p_custom_blend>=0) { + blend_time=p_custom_blend; + } else if (blend_times.has(bk)) { + + blend_time=blend_times[bk]; + } else { + + bk.from="*"; + if (blend_times.has(bk)) { + + blend_time=blend_times[bk]; + } else { + + bk.from=c.current.from->name; + bk.to="*"; + + if (blend_times.has(bk)) { + + blend_time=blend_times[bk]; + } + } + } + + if (p_custom_blend<0 && blend_time==0 && default_blend_time) + blend_time=default_blend_time; + if (blend_time>0) { + + Blend b; + b.data=c.current; + b.blend_time=b.blend_left=blend_time; + c.blend.push_back(b); + } + } + + c.current.pos=p_from_end ? c.current.from->animation->get_length() : 0; + c.current.from=&animation_set[name]; + c.current.speed_scale=p_custom_scale; + c.assigned=p_name; + + queued.clear(); + _set_process(true); // always process when starting an animation + playing = true; + + if (is_inside_scene() && get_scene()->is_editor_hint()) + return; // no next in this case + + + StringName next=animation_get_next(p_name); + if (next!=StringName()) { + queue(next); + } +} + +bool AnimationPlayer::is_playing() const { + + return playing; + /* + if (playback.current.from==NULL) + return false; + + float len=playback.current.from->animation->get_length(); + float pos = playback.current.pos; + bool loop=playback.current.from->animation->has_loop(); + if (!loop && pos >= len) { + return false; + }; + + return true; + */ +} +void AnimationPlayer::set_current_animation(const String& p_anim) { + + if (is_playing()) { + play(p_anim); + } else { + ERR_FAIL_COND(!animation_set.has(p_anim)); + playback.current.pos=0; + playback.current.from=&animation_set[p_anim]; + playback.assigned=p_anim; + } +} + +String AnimationPlayer::get_current_animation() const { + + return (playback.assigned); + +} + +void AnimationPlayer::stop() { + + Playback &c=playback; + c.blend.clear(); + c.current.from=NULL; + _set_process(false); + queued.clear(); + playing = false; +} + +void AnimationPlayer::stop_all() { + + stop(); + + _set_process(false); // always process when starting an animation + +} + +void AnimationPlayer::set_speed(float p_speed) { + + speed_scale=p_speed; + + +} +float AnimationPlayer::get_speed() const { + + return speed_scale; +} + +void AnimationPlayer::seek(float p_time,bool p_update) { + + + if (!playback.current.from) { + if (playback.assigned) + set_current_animation(playback.assigned); + ERR_FAIL_COND(!playback.current.from); + } + + playback.current.pos=p_time; + if (p_update) { + _animation_process(0); + } +} + +void AnimationPlayer::seek_delta(float p_time,float p_delta) { + + if (!playback.current.from) { + if (playback.assigned) + set_current_animation(playback.assigned); + ERR_FAIL_COND(!playback.current.from); + } + + + playback.current.pos=p_time-p_delta; + if (speed_scale!=0.0) + p_delta/=speed_scale; + _animation_process(p_delta); + //playback.current.pos=p_time; + +} + +bool AnimationPlayer::is_valid() const { + + return (playback.current.from); + +} + +float AnimationPlayer::get_current_animation_pos() const { + + ERR_FAIL_COND_V(!playback.current.from,0); + return playback.current.pos; +} + +float AnimationPlayer::get_current_animation_length() const { + + ERR_FAIL_COND_V(!playback.current.from,0); + return playback.current.from->animation->get_length(); +} + +void AnimationPlayer::_animation_changed() { + + clear_caches(); +} + +void AnimationPlayer::_node_removed(Node *p_node) { + + clear_caches(); // nodes contained here ar being removed, clear the caches +} + +void AnimationPlayer::clear_caches() { + + + node_cache_map.clear(); + + for( Map<StringName, AnimationData>::Element *E=animation_set.front();E;E=E->next()) { + + E->get().node_cache.clear(); + } + + cache_update_size=0; + cache_update_prop_size=0; +} + +void AnimationPlayer::set_active(bool p_active) { + + if (active==p_active) + return; + + active=p_active; + _set_process(processing,true); + + +} + +bool AnimationPlayer::is_active() const { + + return active; +} + +StringName AnimationPlayer::find_animation(const Ref<Animation>& p_animation) const { + + for( Map<StringName, AnimationData>::Element *E=animation_set.front();E;E=E->next()) { + + if (E->get().animation==p_animation) + return E->key(); + } + + return ""; +} + +void AnimationPlayer::set_autoplay(const String& p_name) { + + autoplay=p_name; +} + +String AnimationPlayer::get_autoplay() const{ + + return autoplay; +} + +void AnimationPlayer::set_animation_process_mode(AnimationProcessMode p_mode) { + + if (animation_process_mode==p_mode) + return; + + bool pr = processing; + if (pr) + _set_process(false); + animation_process_mode=p_mode; + if (pr) + _set_process(true); + +} + +AnimationPlayer::AnimationProcessMode AnimationPlayer::get_animation_process_mode() const{ + + return animation_process_mode; +} + + +void AnimationPlayer::_set_process(bool p_process,bool p_force) { + + if (processing==p_process && !p_force) + return; + + switch(animation_process_mode) { + + case ANIMATION_PROCESS_FIXED: set_fixed_process(p_process && active); break; + case ANIMATION_PROCESS_IDLE: set_process(p_process && active); break; + } + + processing=p_process; +} + +void AnimationPlayer::animation_set_next(const StringName& p_animation, const StringName& p_next) { + + ERR_FAIL_COND(!animation_set.has(p_animation)); + animation_set[p_animation].next=p_next; + +} + +StringName AnimationPlayer::animation_get_next(const StringName& p_animation) const{ + + if (!animation_set.has(p_animation)) + return StringName(); + return animation_set[p_animation].next; + +} + +void AnimationPlayer::set_default_blend_time(float p_default) { + + default_blend_time=p_default; +} + +float AnimationPlayer::get_default_blend_time() const { + + return default_blend_time; +} + + +void AnimationPlayer::set_root(const NodePath& p_root) { + + root=p_root; + clear_caches(); +} + +NodePath AnimationPlayer::get_root() const { + + return root; +} + + +void AnimationPlayer::_bind_methods() { + + ObjectTypeDB::bind_method(_MD("_node_removed"),&AnimationPlayer::_node_removed); + ObjectTypeDB::bind_method(_MD("_animation_changed"),&AnimationPlayer::_animation_changed); + + ObjectTypeDB::bind_method(_MD("add_animation","name","animation:Animation"),&AnimationPlayer::add_animation); + ObjectTypeDB::bind_method(_MD("remove_animation","name"),&AnimationPlayer::remove_animation); + ObjectTypeDB::bind_method(_MD("rename_animation","name","newname"),&AnimationPlayer::rename_animation); + ObjectTypeDB::bind_method(_MD("has_animation","name"),&AnimationPlayer::has_animation); + ObjectTypeDB::bind_method(_MD("get_animation:Animation","name"),&AnimationPlayer::get_animation); + ObjectTypeDB::bind_method(_MD("get_animation_list"),&AnimationPlayer::_get_animation_list); + + ObjectTypeDB::bind_method(_MD("set_blend_time","anim_from","anim_to","sec"),&AnimationPlayer::set_blend_time); + ObjectTypeDB::bind_method(_MD("get_blend_time","anim_from","anim_to"),&AnimationPlayer::get_blend_time); + + ObjectTypeDB::bind_method(_MD("set_default_blend_time","sec"),&AnimationPlayer::set_default_blend_time); + ObjectTypeDB::bind_method(_MD("get_default_blend_time"),&AnimationPlayer::get_default_blend_time); + + ObjectTypeDB::bind_method(_MD("play","name","custom_blend","custom_speed","from_end"),&AnimationPlayer::play,DEFVAL(""),DEFVAL(-1),DEFVAL(1.0),DEFVAL(false)); + ObjectTypeDB::bind_method(_MD("stop"),&AnimationPlayer::stop); + ObjectTypeDB::bind_method(_MD("stop_all"),&AnimationPlayer::stop_all); + ObjectTypeDB::bind_method(_MD("is_playing"),&AnimationPlayer::is_playing); + ObjectTypeDB::bind_method(_MD("set_current_animation","anim"),&AnimationPlayer::set_current_animation); + ObjectTypeDB::bind_method(_MD("get_current_animation"),&AnimationPlayer::get_current_animation); + ObjectTypeDB::bind_method(_MD("queue","name"),&AnimationPlayer::queue); + ObjectTypeDB::bind_method(_MD("clear_queue"),&AnimationPlayer::clear_queue); + + ObjectTypeDB::bind_method(_MD("set_active","active"),&AnimationPlayer::set_active); + ObjectTypeDB::bind_method(_MD("is_active"),&AnimationPlayer::is_active); + + ObjectTypeDB::bind_method(_MD("set_speed","speed"),&AnimationPlayer::set_speed); + ObjectTypeDB::bind_method(_MD("get_speed"),&AnimationPlayer::get_speed); + + ObjectTypeDB::bind_method(_MD("set_autoplay","name"),&AnimationPlayer::set_autoplay); + ObjectTypeDB::bind_method(_MD("get_autoplay"),&AnimationPlayer::get_autoplay); + + ObjectTypeDB::bind_method(_MD("set_root","path"),&AnimationPlayer::set_root); + ObjectTypeDB::bind_method(_MD("get_root"),&AnimationPlayer::get_root); + + ObjectTypeDB::bind_method(_MD("seek","pos_sec","update"),&AnimationPlayer::seek,DEFVAL(false)); + ObjectTypeDB::bind_method(_MD("get_pos"),&AnimationPlayer::get_current_animation_pos); + + ObjectTypeDB::bind_method(_MD("find_animation","animation:Animation"),&AnimationPlayer::find_animation); + + ObjectTypeDB::bind_method(_MD("clear_caches"),&AnimationPlayer::clear_caches); + + ObjectTypeDB::bind_method(_MD("set_animation_process_mode","mode"),&AnimationPlayer::set_animation_process_mode); + ObjectTypeDB::bind_method(_MD("get_animation_process_mode"),&AnimationPlayer::get_animation_process_mode); + + ObjectTypeDB::bind_method(_MD("get_current_animation_pos"),&AnimationPlayer::get_current_animation_pos); + ObjectTypeDB::bind_method(_MD("get_current_animation_length"),&AnimationPlayer::get_current_animation_length); + + + ADD_PROPERTY( PropertyInfo( Variant::INT, "playback/process_mode", PROPERTY_HINT_ENUM, "Fixed,Idle"), _SCS("set_animation_process_mode"), _SCS("get_animation_process_mode")); + ADD_PROPERTY( PropertyInfo( Variant::REAL, "playback/default_blend_time", PROPERTY_HINT_RANGE, "0,4096,0.01"), _SCS("set_default_blend_time"), _SCS("get_default_blend_time")); + ADD_PROPERTY( PropertyInfo( Variant::NODE_PATH, "root/root"), _SCS("set_root"), _SCS("get_root")); + + ADD_SIGNAL( MethodInfo("finished") ); + ADD_SIGNAL( MethodInfo("animation_changed", PropertyInfo(Variant::STRING,"old_name"), PropertyInfo(Variant::STRING,"new_name")) ); + + BIND_CONSTANT( ANIMATION_PROCESS_FIXED ); + BIND_CONSTANT( ANIMATION_PROCESS_IDLE ); +} + +AnimationPlayer::AnimationPlayer() { + + + accum_pass=1; + cache_update_size=0; + cache_update_prop_size=0; + speed_scale=1; + end_notify=false; + animation_process_mode=ANIMATION_PROCESS_IDLE; + processing=false; + default_blend_time=0; + root=NodePath(".."); + playing = false; + active=true; +} + + +AnimationPlayer::~AnimationPlayer() +{ +} + + diff --git a/scene/animation/animation_player.h b/scene/animation/animation_player.h new file mode 100644 index 000000000..51c000d4d --- /dev/null +++ b/scene/animation/animation_player.h @@ -0,0 +1,300 @@ +/*************************************************************************/ +/* animation_player.h */ +/*************************************************************************/ +/* 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. */ +/*************************************************************************/ +#ifndef ANIMATION_PLAYER_H +#define ANIMATION_PLAYER_H + + +#include "scene/resources/animation.h" +#include "scene/3d/spatial.h" +#include "scene/3d/skeleton.h" +#include "scene/main/misc.h" +#include "scene/2d/node_2d.h" +/** + @author Juan Linietsky <reduzio@gmail.com> +*/ + +class AnimationPlayer : public Node { + OBJ_TYPE( AnimationPlayer, Node ); + OBJ_CATEGORY("Animation Nodes"); + +public: + + enum AnimationProcessMode { + ANIMATION_PROCESS_FIXED, + ANIMATION_PROCESS_IDLE, + }; + +private: + + enum { + + NODE_CACHE_UPDATE_MAX=1024, + BLEND_FROM_MAX=3 + }; + + + enum SpecialProperty { + SP_NONE, + SP_NODE2D_POS, + SP_NODE2D_ROT, + SP_NODE2D_SCALE, + }; + + struct TrackNodeCache { + + uint32_t id; + RES resource; + Node *node; + Spatial* spatial; + Node2D* node_2d; + Skeleton *skeleton; + int bone_idx; + // accumulated transforms + + Vector3 loc_accum; + Quat rot_accum; + Vector3 scale_accum; + uint64_t accum_pass; + + struct PropertyAnim { + + SpecialProperty special; //small optimization + StringName prop; + Object *object; + Variant value_accum; + uint64_t accum_pass; + PropertyAnim() { accum_pass=0; object=NULL; } + }; + + Map<StringName,PropertyAnim> property_anim; + + + TrackNodeCache() { skeleton=NULL; spatial=NULL; node=NULL; accum_pass=0; bone_idx=-1; node_2d=NULL; } + + }; + + struct TrackNodeCacheKey { + + uint32_t id; + int bone_idx; + + inline bool operator<(const TrackNodeCacheKey& p_right) const { + + if (id<p_right.id) + return true; + else if (id>p_right.id) + return false; + else + return bone_idx<p_right.bone_idx; + } + }; + + Map<TrackNodeCacheKey,TrackNodeCache> node_cache_map; + + TrackNodeCache* cache_update[NODE_CACHE_UPDATE_MAX]; + int cache_update_size; + TrackNodeCache::PropertyAnim* cache_update_prop[NODE_CACHE_UPDATE_MAX]; + int cache_update_prop_size; + Map<Ref<Animation>,int> used_anims; + + uint64_t accum_pass; + float speed_scale; + float default_blend_time; + + + struct AnimationData { + String name; + StringName next; + Vector<TrackNodeCache*> node_cache; + Ref<Animation> animation; + + }; + + Map<StringName, AnimationData> animation_set; + struct BlendKey { + + StringName from; + StringName to; + bool operator<(const BlendKey& bk) const { return from==bk.from?to<bk.to:from<bk.from; } + }; + + + Map<BlendKey, float > blend_times; + + + struct PlaybackData { + + AnimationData* from; + float pos; + float speed_scale; + + PlaybackData() { + + pos=0; + speed_scale=1.0; + from=NULL; + + } + + }; + + struct Blend { + + PlaybackData data; + + float blend_time; + float blend_left; + + Blend() { + + blend_left=0; + blend_time=0; + } + }; + + struct Playback { + + List<Blend> blend; + PlaybackData current; + StringName assigned; + } playback; + + List<StringName> queued; + + bool end_notify; + + String autoplay; + AnimationProcessMode animation_process_mode; + bool processing; + bool active; + + NodePath root; + + void _animation_process_animation(AnimationData* p_anim,float p_time, float p_delta,float p_interp, bool p_allow_discrete=true); + + void _generate_node_caches(AnimationData* p_anim); + void _animation_process_data(PlaybackData &cd,float p_delta,float p_blend); + void _animation_process2(float p_delta); + void _animation_update_transforms(); + void _animation_process(float p_delta); + + void _node_removed(Node *p_node); + +// bind helpers + DVector<String> _get_animation_list() const { + + List<StringName> animations; + get_animation_list(&animations); + DVector<String> ret; + while(animations.size()) { + + ret.push_back( animations.front()->get()); + animations.pop_front(); + } + return ret; + } + + void _animation_changed(); + void _ref_anim(const Ref<Animation>& p_anim); + void _unref_anim(const Ref<Animation>& p_anim); + + + void _set_process(bool p_process,bool p_force=false); + + bool playing; + +protected: + bool _set(const StringName& p_name, const Variant& p_value); + bool _get(const StringName& p_name,Variant &r_ret) const; + void _get_property_list( List<PropertyInfo> *p_list) const; + void _notification(int p_what); + + static void _bind_methods(); + +public: + + StringName find_animation(const Ref<Animation>& p_animation) const; + + Error add_animation(const StringName& p_name, const Ref<Animation>& p_animation); + void remove_animation(const StringName& p_name); + void rename_animation(const StringName& p_name,const StringName& p_new_name); + bool has_animation(const StringName& p_name) const; + Ref<Animation> get_animation(const StringName& p_name) const; + void get_animation_list( List<StringName> * p_animations) const; + + void set_blend_time(const StringName& p_animation1, const StringName& p_animation2, float p_time); + float get_blend_time( const StringName& p_animation1, const StringName& p_animation2) const; + + void animation_set_next(const StringName& p_animation, const StringName& p_next); + StringName animation_get_next(const StringName& p_animation) const; + + void set_default_blend_time(float p_default); + float get_default_blend_time() const; + + void play(const StringName& p_name=StringName(),float p_custom_blend=-1,float p_custom_scale=1.0,bool p_from_end=false); + void queue(const StringName& p_name); + void clear_queue(); + void stop(); + bool is_playing() const; + String get_current_animation() const; + void set_current_animation(const String& p_anim); + void stop_all(); + void set_active(bool p_active); + bool is_active() const; + bool is_valid() const; + + void set_speed(float p_speed); + float get_speed() const; + + void set_autoplay(const String& pname); + String get_autoplay() const; + + void set_animation_process_mode(AnimationProcessMode p_mode); + AnimationProcessMode get_animation_process_mode() const; + + void seek(float p_time,bool p_update=false); + void seek_delta(float p_time,float p_delta); + float get_current_animation_pos() const; + float get_current_animation_length() const; + + void set_root(const NodePath& p_root); + NodePath get_root() const; + + void clear_caches(); ///< must be called by hand if an animation was modified after added + + AnimationPlayer(); + ~AnimationPlayer(); + +}; + + +VARIANT_ENUM_CAST( AnimationPlayer::AnimationProcessMode ); + + +#endif diff --git a/scene/animation/animation_tree_player.cpp b/scene/animation/animation_tree_player.cpp new file mode 100644 index 000000000..bd124746b --- /dev/null +++ b/scene/animation/animation_tree_player.cpp @@ -0,0 +1,1782 @@ +/*************************************************************************/ +/* animation_tree_player.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_tree_player.h" +#include "animation_player.h" + + +bool AnimationTreePlayer::_set(const StringName& p_name, const Variant& p_value) { + + if (String(p_name)=="base_path") { + set_base_path(p_value); + return true; + } + + if (String(p_name)=="master_player") { + set_master_player(p_value); + return true; + } + + if (String(p_name)!="data") + return false; + + + Dictionary data=p_value; + + Array nodes=data.get_valid("nodes"); + + for(int i=0;i<nodes.size();i++) { + + Dictionary node = nodes[i]; + + StringName id = node.get_valid("id"); + Point2 pos = node.get_valid("pos"); + + NodeType nt=NODE_MAX; + String type = node.get_valid("type"); + + if (type=="output") + nt=NODE_OUTPUT; + else if (type=="animation") + nt=NODE_ANIMATION; + else if (type=="oneshot") + nt=NODE_ONESHOT; + else if (type=="mix") + nt=NODE_MIX; + else if (type=="blend2") + nt=NODE_BLEND2; + else if (type=="blend3") + nt=NODE_BLEND3; + else if (type=="blend4") + nt=NODE_BLEND4; + else if (type=="timescale") + nt=NODE_TIMESCALE; + else if (type=="timeseek") + nt=NODE_TIMESEEK; + else if (type=="transition") + nt=NODE_TRANSITION; + + ERR_FAIL_COND_V(nt==NODE_MAX,false); + + add_node(nt,id); + node_set_pos(id,pos); + + + switch(nt) { + case NODE_OUTPUT: { + + } break; + case NODE_ANIMATION: { + + if (node.has("from")) + animation_node_set_master_animation(id,node.get_valid("from")); + else + animation_node_set_animation(id,node.get_valid("animation")); + } break; + case NODE_ONESHOT: { + + oneshot_node_set_fadein_time(id,node.get_valid("fade_in")); + oneshot_node_set_fadeout_time(id,node.get_valid("fade_out")); + oneshot_node_set_mix_mode(id,node.get_valid("mix")); + oneshot_node_set_autorestart(id,node.get_valid("autorestart")); + oneshot_node_set_autorestart_delay(id,node.get_valid("autorestart_delay")); + oneshot_node_set_autorestart_random_delay(id,node.get_valid("autorestart_random_delay")); + Array filters= node.get_valid("filter"); + for(int i=0;i<filters.size();i++) { + + oneshot_node_set_filter_path(id,filters[i],true); + } + + } break; + case NODE_MIX: { + mix_node_set_amount(id,node.get_valid("mix")); + } break; + case NODE_BLEND2: { + blend2_node_set_amount(id,node.get_valid("blend")); + Array filters= node.get_valid("filter"); + for(int i=0;i<filters.size();i++) { + + blend2_node_set_filter_path(id,filters[i],true); + } + } break; + case NODE_BLEND3: { + blend3_node_set_amount(id,node.get_valid("blend")); + } break; + case NODE_BLEND4: { + blend4_node_set_amount(id,node.get_valid("blend")); + } break; + case NODE_TIMESCALE: { + timescale_node_set_scale(id,node.get_valid("scale")); + } break; + case NODE_TIMESEEK: { + } break; + case NODE_TRANSITION: { + + transition_node_set_xfade_time(id,node.get_valid("xfade")); + + Array transitions = node.get_valid("transitions"); + transition_node_set_input_count(id,transitions.size()); + + for(int x=0;x<transitions.size();x++) { + + Dictionary d =transitions[x]; + bool aa = d.get_valid("auto_advance"); + transition_node_set_input_auto_advance(id,x,aa); + + } + + } break; + default: {}; + } + + } + + + Array connections = data.get_valid("connections"); + ERR_FAIL_COND_V(connections.size()%3,false); + + int cc=connections.size()/3; + + for(int i=0;i<cc;i++) { + + StringName src = connections[i*3+0]; + StringName dst = connections[i*3+1]; + int dst_in = connections[i*3+2]; + connect(src,dst,dst_in); + } + + set_active(data.get_valid("active")); + set_master_player(data.get_valid("master")); + + return true; + +} + +bool AnimationTreePlayer::_get(const StringName& p_name,Variant &r_ret) const { + + if (String(p_name)=="base_path") { + r_ret=base_path; + return true; + } + + if (String(p_name)=="master_player") { + r_ret=master; + return true; + } + + if (String(p_name)!="data") + return false; + + Dictionary data; + + Array nodes; + + for(Map<StringName,NodeBase*>::Element *E=node_map.front();E;E=E->next()) { + + NodeBase *n = node_map[E->key()]; + + Dictionary node; + node["id"]=E->key(); + node["pos"]=n->pos; + + switch(n->type) { + case NODE_OUTPUT: node["type"]= "output"; break; + case NODE_ANIMATION: node["type"]= "animation"; break; + case NODE_ONESHOT: node["type"]= "oneshot"; break; + case NODE_MIX: node["type"]= "mix"; break; + case NODE_BLEND2: node["type"]= "blend2"; break; + case NODE_BLEND3: node["type"]= "blend3"; break; + case NODE_BLEND4: node["type"]= "blend4"; break; + case NODE_TIMESCALE: node["type"]= "timescale"; break; + case NODE_TIMESEEK: node["type"]= "timeseek"; break; + case NODE_TRANSITION: node["type"]= "transition"; break; + default: node["type"]= ""; break; + } + + switch(n->type) { + case NODE_OUTPUT: { + + } break; + case NODE_ANIMATION: { + AnimationNode *an = static_cast<AnimationNode*>(n); + if (master!=NodePath() && an->from!="") { + node["from"]=an->from; + } else { + node["animation"]=an->animation; + } + } break; + case NODE_ONESHOT: { + OneShotNode *osn = static_cast<OneShotNode*>(n); + node["fade_in"]=osn->fade_in; + node["fade_out"]=osn->fade_out; + node["mix"]=osn->mix; + node["autorestart"]=osn->autorestart; + node["autorestart_delay"]=osn->autorestart_delay; + node["autorestart_random_delay"]=osn->autorestart_random_delay; + + Array k; + List<NodePath> keys; + osn->filter.get_key_list(&keys); + k.resize(keys.size()); + int i=0; + for(List<NodePath>::Element *E=keys.front();E;E=E->next()) { + k[i++]=E->get(); + } + node["filter"]=k; + + } break; + case NODE_MIX: { + MixNode *mn = static_cast<MixNode*>(n); + node["mix"]=mn->amount; + } break; + case NODE_BLEND2: { + Blend2Node *bn = static_cast<Blend2Node*>(n); + node["blend"]=bn->value; + Array k; + List<NodePath> keys; + bn->filter.get_key_list(&keys); + k.resize(keys.size()); + int i=0; + for(List<NodePath>::Element *E=keys.front();E;E=E->next()) { + k[i++]=E->get(); + } + node["filter"]=k; + + } break; + case NODE_BLEND3: { + Blend3Node *bn = static_cast<Blend3Node*>(n); + node["blend"]=bn->value; + } break; + case NODE_BLEND4: { + Blend4Node *bn = static_cast<Blend4Node*>(n); + node["blend"]=bn->value; + + } break; + case NODE_TIMESCALE: { + TimeScaleNode *tsn = static_cast<TimeScaleNode*>(n); + node["scale"]=tsn->scale; + } break; + case NODE_TIMESEEK: { + } break; + case NODE_TRANSITION: { + + TransitionNode *tn = static_cast<TransitionNode*>(n); + node["xfade"]=tn->xfade; + Array transitions; + + for(int i=0;i<tn->input_data.size();i++) { + + Dictionary d; + d["auto_advance"]=tn->input_data[i].auto_advance; + transitions.push_back(d); + + } + + node["transitions"]=transitions; + + } break; + default: {}; + } + + nodes.push_back(node); + } + + data["nodes"]=nodes; + //connectiosn + + List<Connection> connections; + get_connection_list(&connections); + Array connections_arr; + connections_arr.resize(connections.size()*3); + + int idx=0; + for (List<Connection>::Element *E=connections.front();E;E=E->next()) { + + connections_arr.set(idx+0,E->get().src_node); + connections_arr.set(idx+1,E->get().dst_node); + connections_arr.set(idx+2,E->get().dst_input); + + idx+=3; + } + + data["connections"]=connections_arr; + data["active"]=active; + data["master"]=master; + + r_ret=data; + + return true; + +} + +void AnimationTreePlayer::_get_property_list( List<PropertyInfo> *p_list) const { + + p_list->push_back( PropertyInfo(Variant::NODE_PATH,"base_path" ) ); + p_list->push_back( PropertyInfo(Variant::NODE_PATH,"master_player" ) ); + p_list->push_back( PropertyInfo(Variant::DICTIONARY,"data",PROPERTY_HINT_NONE,"",PROPERTY_USAGE_STORAGE|PROPERTY_USAGE_NETWORK) ); +} + + +void AnimationTreePlayer::_notification(int p_what) { + + switch(p_what) { + + case NOTIFICATION_READY: { + dirty_caches=true; + if (master!=NodePath()) { + _update_sources(); + } + } break; + case NOTIFICATION_PROCESS: { + _process_animation(); + } break; + } + +} + + +float AnimationTreePlayer::_process_node(const StringName& p_node,AnimationNode **r_prev_anim,float p_weight, float p_time, bool p_seek,const HashMap<NodePath,bool> *p_filter, float p_reverse_weight) { + + ERR_FAIL_COND_V(!node_map.has(p_node), 0); + NodeBase *nb=node_map[p_node]; + + //transform to seconds... + + + switch(nb->type) { + + case NODE_OUTPUT: { + + NodeOut *on = static_cast<NodeOut*>(nb); + return _process_node(on->inputs[0].node,r_prev_anim,p_weight,p_time,p_seek); + + } break; + case NODE_ANIMATION: { + + AnimationNode *an = static_cast<AnimationNode*>(nb); + + float rem = 0; + if (!an->animation.is_null()) { + + // float pos = an->time; +// float delta = p_time; + + // const Animation *a = an->animation.operator->(); + + if (p_seek) { + an->time=p_time; + an->step=0; + } else { + an->time+=p_time; + an->step=p_time; + } + + float anim_size = an->animation->get_length(); + + if (an->animation->has_loop()) { + + if (anim_size) + an->time=Math::fposmod(an->time,anim_size); + + } else if (an->time > anim_size) { + + an->time=anim_size; + } + + an->skip=true; + for (List<AnimationNode::TrackRef>::Element *E=an->tref.front();E;E=E->next()) { + + if (p_filter && p_filter->has(an->animation->track_get_path(E->get().local_track))) { + + if (p_reverse_weight<0) + E->get().weight=0; + else + E->get().weight=p_reverse_weight; + + } else { + E->get().weight=p_weight; + } + if (E->get().weight>CMP_EPSILON) + an->skip=false; + } + + rem = anim_size - an->time; + + } + + + if (!(*r_prev_anim)) + active_list=an; + else + (*r_prev_anim)->next=an; + + an->next=NULL; + *r_prev_anim=an; + + return rem; + + + } break; + case NODE_ONESHOT: { + + OneShotNode *osn = static_cast<OneShotNode*>(nb); + + if (!osn->active) { + //make it as if this node doesn't exist, pass input 0 by. + return _process_node(osn->inputs[0].node,r_prev_anim,p_weight,p_time,p_seek,p_filter,p_reverse_weight); + } + + if (p_seek) + osn->time=p_time; + if (osn->start) + osn->time=0; + + float blend; + + if (osn->time<osn->fade_in) { + + if (osn->fade_in>0) + blend = osn->time/osn->fade_in; + else + blend=0; //wtf + + } else if (!osn->start && osn->remaining<osn->fade_out) { + + if (osn->fade_out) + blend=(osn->remaining/osn->fade_out); + else + blend=1.0; + } else + blend=1.0; + + float main_rem; + float os_rem; + + if (!osn->filter.empty()) { + + main_rem = _process_node(osn->inputs[0].node,r_prev_anim,(osn->mix?p_weight:p_weight*(1.0-blend)),p_time,p_seek,&osn->filter,p_weight); + os_rem = _process_node(osn->inputs[1].node,r_prev_anim,p_weight*blend,p_time,p_seek,&osn->filter,-1); + + } else { + + main_rem = _process_node(osn->inputs[0].node,r_prev_anim,(osn->mix?p_weight:p_weight*(1.0-blend)),p_time,p_seek); + os_rem = _process_node(osn->inputs[1].node,r_prev_anim,p_weight*blend,p_time,p_seek); + } + + if (osn->start) { + osn->remaining=os_rem; + osn->start=false; + } + + if (!p_seek) { + osn->time+=p_time; + osn->remaining-=p_time; + if (osn->remaining<0) + osn->active=false; + } + + return MAX(main_rem,osn->remaining); + } break; + case NODE_MIX: { + MixNode *mn = static_cast<MixNode*>(nb); + + + float rem = _process_node(mn->inputs[0].node,r_prev_anim,p_weight,p_time,p_seek,p_filter,p_reverse_weight); + _process_node(mn->inputs[1].node,r_prev_anim,p_weight*mn->amount,p_time,p_seek,p_filter,p_reverse_weight); + return rem; + + } break; + case NODE_BLEND2: { + + Blend2Node *bn = static_cast<Blend2Node*>(nb); + + float rem; + if (!bn->filter.empty()) { + + rem = _process_node(bn->inputs[0].node,r_prev_anim,p_weight*(1.0-bn->value),p_time,p_seek,&bn->filter,p_weight); + _process_node(bn->inputs[1].node,r_prev_anim,p_weight*bn->value,p_time,p_seek,&bn->filter,-1); + + } else { + rem = _process_node(bn->inputs[0].node,r_prev_anim,p_weight*(1.0-bn->value),p_time,p_seek,p_filter,p_reverse_weight*(1.0-bn->value)); + _process_node(bn->inputs[1].node,r_prev_anim,p_weight*bn->value,p_time,p_seek,p_filter,p_reverse_weight*bn->value); + } + + return rem; + } break; + case NODE_BLEND3: { + Blend3Node *bn = static_cast<Blend3Node*>(nb); + + float rem; + + if (bn->value==0) { + rem = _process_node(bn->inputs[1].node,r_prev_anim,p_weight,p_time,p_seek,p_filter,p_reverse_weight); + } else if (bn->value>0) { + + rem = _process_node(bn->inputs[1].node,r_prev_anim,p_weight*(1.0-bn->value),p_time,p_seek,p_filter,p_reverse_weight*(1.0-bn->value)); + _process_node(bn->inputs[2].node,r_prev_anim,p_weight*bn->value,p_time,p_seek,p_filter,p_reverse_weight*bn->value); + + } else { + + rem = _process_node(bn->inputs[1].node,r_prev_anim,p_weight*(1.0+bn->value),p_time,p_seek,p_filter,p_reverse_weight*(1.0+bn->value)); + _process_node(bn->inputs[0].node,r_prev_anim,p_weight*-bn->value,p_time,p_seek,p_filter,p_reverse_weight*-bn->value); + } + + return rem; + } break; + case NODE_BLEND4: { + Blend4Node *bn = static_cast<Blend4Node*>(nb); + + float rem = _process_node(bn->inputs[0].node,r_prev_anim,p_weight*(1.0-bn->value.x),p_time,p_seek,p_filter,p_reverse_weight*(1.0-bn->value.x)); + _process_node(bn->inputs[1].node,r_prev_anim,p_weight*bn->value.x,p_time,p_seek,p_filter,p_reverse_weight*bn->value.x); + float rem2 = _process_node(bn->inputs[2].node,r_prev_anim,p_weight*(1.0-bn->value.y),p_time,p_seek,p_filter,p_reverse_weight*(1.0-bn->value.y)); + _process_node(bn->inputs[3].node,r_prev_anim,p_weight*bn->value.y,p_time,p_seek,p_filter,p_reverse_weight*bn->value.y); + + return MAX(rem,rem2); + + } break; + case NODE_TIMESCALE: { + TimeScaleNode *tsn = static_cast<TimeScaleNode*>(nb); + if (p_seek) + return _process_node(tsn->inputs[0].node,r_prev_anim,p_weight,p_time,true,p_filter,p_reverse_weight); + else + return _process_node(tsn->inputs[0].node,r_prev_anim,p_weight,p_time*tsn->scale,false,p_filter,p_reverse_weight); + + } break; + case NODE_TIMESEEK: { + + TimeSeekNode *tsn = static_cast<TimeSeekNode*>(nb); + if (tsn->seek_pos>=0) { + + float res = _process_node(tsn->inputs[0].node,r_prev_anim,p_weight,tsn->seek_pos,true,p_filter,p_reverse_weight); + tsn->seek_pos=-1; + return res; + + } else + return _process_node(tsn->inputs[0].node,r_prev_anim,p_weight,p_time,p_seek); + + } break; + case NODE_TRANSITION: { + + TransitionNode *tn = static_cast<TransitionNode*>(nb); + + if (tn->prev<0) { + + float rem = _process_node(tn->inputs[tn->current].node,r_prev_anim,p_weight,p_time,p_seek,p_filter,p_reverse_weight); + if (p_seek) + tn->time=p_time; + else + tn->time+=p_time; + + if (tn->input_data[tn->current].auto_advance && rem < tn->xfade) { + + tn->prev=tn->current; + tn->current++; + if (tn->current>=tn->inputs.size()) + tn->current=0; + tn->prev_xfading=tn->xfade; + tn->prev_time=tn->time; + tn->time=0; + tn->switched=true; + } + + + return rem; + } else { + + + float blend = tn->xfade? (tn->prev_xfading/tn->xfade) : 1; + + float rem; + + if (!p_seek && tn->switched) { //just switched + + rem = _process_node(tn->inputs[tn->current].node,r_prev_anim,p_weight*(1.0-blend),0,true,p_filter,p_reverse_weight*(1.0-blend)); + } else { + + rem = _process_node(tn->inputs[tn->current].node,r_prev_anim,p_weight*(1.0-blend),p_time,p_seek,p_filter,p_reverse_weight*(1.0-blend)); + + } + + tn->switched=false; + + //if (!p_seek) + + + if (p_seek) { + _process_node(tn->inputs[tn->prev].node,r_prev_anim,p_weight*blend,0,false,p_filter,p_reverse_weight*blend); + tn->time=p_time; + } else { + _process_node(tn->inputs[tn->prev].node,r_prev_anim,p_weight*blend,p_time,false,p_filter,p_reverse_weight*blend); + tn->time+=p_time; + tn->prev_xfading-=p_time; + if (tn->prev_xfading<0) { + + tn->prev=-1; + } + + } + + return rem; + } + + + } break; + default: {} + } + + + + return 0; +} + + +void AnimationTreePlayer::_process_animation() { + + if (!active) + return; + + if (last_error!=CONNECT_OK) + return; + + if (dirty_caches) + _recompute_caches(); + + + active_list=NULL; + AnimationNode *prev=NULL; + + if (reset_request) { + _process_node(out_name,&prev, 1.0, 0, true ); + reset_request=false; + } else + _process_node(out_name,&prev, 1.0, get_process_delta_time(), false ); + + if (dirty_caches) { + //some animation changed.. ignore this pass + return; + } + + //update the tracks.. + + + + /* STEP 1 CLEAR TRACKS */ + + for(TrackMap::Element *E=track_map.front();E;E=E->next()) { + + Track &t = E->get(); + + t.loc.zero(); + t.rot=Quat(); + t.scale.x=0; + t.scale.y=0; + t.scale.z=0; + } + + + /* STEP 2 PROCESS ANIMATIONS */ + + AnimationNode *anim_list=active_list; + Quat empty_rot; + + + int total = 0; + while(anim_list) { + + if (!anim_list->animation.is_null() && !anim_list->skip) { + ++total; + //check if animation is meaningful + Animation *a = anim_list->animation.operator->(); + + for(List<AnimationNode::TrackRef>::Element *E=anim_list->tref.front();E;E=E->next()) { + + + AnimationNode::TrackRef &tr = E->get(); + if (tr.track==NULL || tr.local_track<0 || tr.weight < CMP_EPSILON) + continue; + + float blend=tr.weight; + + switch(a->track_get_type(tr.local_track)) { + case Animation::TYPE_TRANSFORM: { ///< Transform a node or a bone. + + Vector3 loc; + Quat rot; + Vector3 scale; + a->transform_track_interpolate(tr.local_track,anim_list->time,&loc,&rot,&scale); + + tr.track->loc+=loc*blend; + + scale.x-=1.0; + scale.y-=1.0; + scale.z-=1.0; + tr.track->scale+=scale*blend; + + tr.track->rot = tr.track->rot * empty_rot.slerp(rot,blend); + + + } break; + case Animation::TYPE_VALUE: { ///< Set a value in a property, can be interpolated. + + if (a->value_track_is_continuous(tr.local_track)) { + Variant value = a->value_track_interpolate(tr.local_track,anim_list->time); + tr.track->node->set(tr.track->property,value); + } else { + + List<int> indices; + a->value_track_get_key_indices(tr.local_track,anim_list->time,anim_list->step,&indices); + for(List<int>::Element *E=indices.front();E;E=E->next()) { + + Variant value = a->track_get_key_value(tr.local_track,E->get()); + tr.track->node->set(tr.track->property,value); + } + } + } break; + case Animation::TYPE_METHOD: { ///< Call any method on a specific node. + + List<int> indices; + a->method_track_get_key_indices(tr.local_track,anim_list->time,anim_list->step,&indices); + for(List<int>::Element *E=indices.front();E;E=E->next()) { + + StringName method = a->method_track_get_name(tr.local_track,E->get()); + Vector<Variant> args=a->method_track_get_params(tr.local_track,E->get()); + ERR_CONTINUE(args.size()!=VARIANT_ARG_MAX); + tr.track->node->call(method,args[0],args[1],args[2],args[3],args[4]); + } + } break; + } + + } + } + + anim_list=anim_list->next; + } + + /* STEP 3 APPLY TRACKS */ + + for(TrackMap::Element *E=track_map.front();E;E=E->next()) { + + Track &t = E->get(); + + if (!t.node) + continue; + //if (E->get()->t.type!=Animation::TYPE_TRANSFORM) + // continue; + + Transform xform; + xform.basis=t.rot; + xform.origin=t.loc; + + t.scale.x+=1.0; + t.scale.y+=1.0; + t.scale.z+=1.0; + xform.basis.scale(t.scale); + + if (t.bone_idx>=0) { + if (t.skeleton) + t.skeleton->set_bone_pose(t.bone_idx,xform); + + } else if (t.spatial) { + + t.spatial->set_transform(xform); + } + } + + + +} + + +void AnimationTreePlayer::add_node(NodeType p_type, const StringName& p_node) { + + ERR_FAIL_COND( p_type == NODE_OUTPUT ); + ERR_FAIL_COND( node_map.has(p_node)); + + NodeBase *n=NULL; + + switch(p_type) { + + case NODE_ANIMATION: { + + n = memnew( AnimationNode ); + } break; + case NODE_ONESHOT: { + + n = memnew( OneShotNode ); + + } break; + case NODE_MIX: { + n = memnew( MixNode ); + + } break; + case NODE_BLEND2: { + n = memnew( Blend2Node ); + + } break; + case NODE_BLEND3: { + n = memnew( Blend3Node ); + + } break; + case NODE_BLEND4: { + n = memnew( Blend4Node ); + + } break; + case NODE_TIMESCALE: { + n = memnew( TimeScaleNode ); + + + } break; + case NODE_TIMESEEK: { + n = memnew( TimeSeekNode ); + + } break; + case NODE_TRANSITION: { + n = memnew( TransitionNode ); + + + } break; + default: {} + } + + //n->name+=" "+itos(p_node); + node_map[p_node]=n; +} + + +StringName AnimationTreePlayer::node_get_input_source(const StringName& p_node,int p_input) const { + + ERR_FAIL_COND_V(!node_map.has(p_node),StringName()); + ERR_FAIL_INDEX_V( p_input,node_map[p_node]->inputs.size(),StringName() ); + return node_map[p_node]->inputs[p_input].node; + +} + + +int AnimationTreePlayer::node_get_input_count(const StringName& p_node) const { + + ERR_FAIL_COND_V(!node_map.has(p_node),-1); + return node_map[p_node]->inputs.size(); + +} +#define GET_NODE( m_type, m_cast )\ + ERR_FAIL_COND(!node_map.has(p_node));\ + ERR_EXPLAIN("Invalid parameter for node type.");\ + ERR_FAIL_COND(node_map[p_node]->type!=m_type);\ + m_cast *n = static_cast<m_cast*>( node_map[p_node] );\ + + + +void AnimationTreePlayer::animation_node_set_animation(const StringName& p_node,const Ref<Animation>& p_animation) { + + GET_NODE( NODE_ANIMATION, AnimationNode ); + n->animation=p_animation; + dirty_caches=true; + + +} + +void AnimationTreePlayer::animation_node_set_master_animation(const StringName& p_node,const String& p_master_animation) { + + GET_NODE( NODE_ANIMATION, AnimationNode ); + n->from=p_master_animation; + dirty_caches=true; + if (master!=NodePath()) + _update_sources(); + + +} + +void AnimationTreePlayer::oneshot_node_set_fadein_time(const StringName& p_node,float p_time) { + + GET_NODE( NODE_ONESHOT, OneShotNode ); + n->fade_in=p_time; + +} + + +void AnimationTreePlayer::oneshot_node_set_fadeout_time(const StringName& p_node,float p_time) { + + GET_NODE( NODE_ONESHOT, OneShotNode ); + n->fade_out=p_time; + + +} + +void AnimationTreePlayer::oneshot_node_set_mix_mode(const StringName& p_node,bool p_mix) { + + GET_NODE( NODE_ONESHOT, OneShotNode ); + n->mix=p_mix; +} + + +void AnimationTreePlayer::oneshot_node_set_autorestart(const StringName& p_node,bool p_active) { + + GET_NODE( NODE_ONESHOT, OneShotNode ); + n->autorestart=p_active; + +} + +void AnimationTreePlayer::oneshot_node_set_autorestart_delay(const StringName& p_node,float p_time) { + + GET_NODE( NODE_ONESHOT, OneShotNode ); + n->autorestart_delay=p_time; + +} +void AnimationTreePlayer::oneshot_node_set_autorestart_random_delay(const StringName& p_node,float p_time) { + + GET_NODE( NODE_ONESHOT, OneShotNode ); + n->autorestart_random_delay=p_time; + +} + +void AnimationTreePlayer::oneshot_node_start(const StringName& p_node) { + + GET_NODE( NODE_ONESHOT, OneShotNode ); + n->active=true; + n->start=true; + +} + + +void AnimationTreePlayer::oneshot_node_stop(const StringName& p_node) { + + GET_NODE( NODE_ONESHOT, OneShotNode ); + n->active=false; + +} + + +void AnimationTreePlayer::oneshot_node_set_filter_path(const StringName& p_node,const NodePath& p_filter,bool p_enable) { + + GET_NODE( NODE_ONESHOT, OneShotNode ); + + if (p_enable) + n->filter[p_filter]=true; + else + n->filter.erase(p_filter); + +} + +void AnimationTreePlayer::oneshot_node_set_get_filtered_paths(const StringName& p_node,List<NodePath> *r_paths) const{ + + GET_NODE( NODE_ONESHOT, OneShotNode ); + + n->filter.get_key_list(r_paths); +} + + +void AnimationTreePlayer::mix_node_set_amount(const StringName& p_node,float p_amount) { + + GET_NODE( NODE_MIX, MixNode ); + n->amount=p_amount; + +} + + +void AnimationTreePlayer::blend2_node_set_amount(const StringName& p_node,float p_amount) { + + GET_NODE( NODE_BLEND2, Blend2Node ); + n->value=p_amount; + +} + +void AnimationTreePlayer::blend2_node_set_filter_path(const StringName& p_node,const NodePath& p_filter,bool p_enable) { + + GET_NODE( NODE_BLEND2, Blend2Node ); + + if (p_enable) + n->filter[p_filter]=true; + else + n->filter.erase(p_filter); + +} + +void AnimationTreePlayer::blend2_node_set_get_filtered_paths(const StringName& p_node,List<NodePath> *r_paths) const{ + + GET_NODE( NODE_BLEND2, Blend2Node ); + + n->filter.get_key_list(r_paths); +} + + +void AnimationTreePlayer::blend3_node_set_amount(const StringName& p_node,float p_amount) { + + GET_NODE( NODE_BLEND3, Blend3Node ); + n->value=p_amount; + +} +void AnimationTreePlayer::blend4_node_set_amount(const StringName& p_node,const Vector2& p_amount) { + + GET_NODE( NODE_BLEND4, Blend4Node ); + n->value=p_amount; + +} +void AnimationTreePlayer::timescale_node_set_scale(const StringName& p_node,float p_scale) { + + + GET_NODE( NODE_TIMESCALE, TimeScaleNode ); + n->scale=p_scale; + +} +void AnimationTreePlayer::timeseek_node_seek(const StringName& p_node,float p_pos) { + + +// GET_NODE( NODE_TIMESEEK, TimeSeekNode ); +//hmm +} +void AnimationTreePlayer::transition_node_set_input_count(const StringName& p_node, int p_inputs) { + + + GET_NODE( NODE_TRANSITION, TransitionNode ); + ERR_FAIL_COND(p_inputs<1); + + n->inputs.resize(p_inputs); + n->input_data.resize(p_inputs); + last_error=_cycle_test(out_name); + +} +void AnimationTreePlayer::transition_node_set_input_auto_advance(const StringName& p_node, int p_input,bool p_auto_advance) { + + GET_NODE( NODE_TRANSITION, TransitionNode ); + ERR_FAIL_INDEX(p_input,n->input_data.size()); + + n->input_data[p_input].auto_advance=p_auto_advance; + +} +void AnimationTreePlayer::transition_node_set_xfade_time(const StringName& p_node, float p_time) { + + + GET_NODE( NODE_TRANSITION, TransitionNode ); + n->xfade=p_time; +} + + +void AnimationTreePlayer::transition_node_set_current(const StringName& p_node, int p_current) { + + GET_NODE( NODE_TRANSITION, TransitionNode ); + ERR_FAIL_INDEX(p_current,n->inputs.size()); + + if (n->current==p_current) + return; + + n->prev=n->current; + n->prev_xfading=n->xfade; + n->prev_time=n->time; + n->time=0; + n->current=p_current; + +} + + +void AnimationTreePlayer::node_set_pos(const StringName& p_node, const Vector2& p_pos) { + + ERR_FAIL_COND(!node_map.has(p_node)); + node_map[p_node]->pos=p_pos; + +} + +AnimationTreePlayer::NodeType AnimationTreePlayer::node_get_type(const StringName& p_node) const { + + ERR_FAIL_COND_V(!node_map.has(p_node),NODE_OUTPUT); + return node_map[p_node]->type; + +} +Point2 AnimationTreePlayer::node_get_pos(const StringName& p_node) const { + + ERR_FAIL_COND_V(!node_map.has(p_node),Point2()); + return node_map[p_node]->pos; + + +} + +#define GET_NODE_V( m_type, m_cast, m_ret )\ + ERR_FAIL_COND_V(!node_map.has(p_node),m_ret);\ + ERR_EXPLAIN("Invalid parameter for node type.");\ + ERR_FAIL_COND_V(node_map[p_node]->type!=m_type,m_ret);\ + m_cast *n = static_cast<m_cast*>( node_map[p_node] );\ + +Ref<Animation> AnimationTreePlayer::animation_node_get_animation(const StringName& p_node) const { + + GET_NODE_V(NODE_ANIMATION, AnimationNode, Ref<Animation>()); + return n->animation; + +} + +String AnimationTreePlayer::animation_node_get_master_animation(const StringName& p_node) const { + + GET_NODE_V(NODE_ANIMATION, AnimationNode, String()); + return n->from; + +} + +float AnimationTreePlayer::oneshot_node_get_fadein_time(const StringName& p_node) const { + + + GET_NODE_V(NODE_ONESHOT, OneShotNode, 0 ); + return n->fade_in; + +} + +float AnimationTreePlayer::oneshot_node_get_fadeout_time(const StringName& p_node) const { + + GET_NODE_V(NODE_ONESHOT, OneShotNode, 0 ); + return n->fade_out; + +} + +bool AnimationTreePlayer::oneshot_node_get_mix_mode(const StringName& p_node) const { + + GET_NODE_V(NODE_ONESHOT, OneShotNode, 0 ); + return n->mix; + +} +bool AnimationTreePlayer::oneshot_node_has_autorestart(const StringName& p_node) const { + + GET_NODE_V(NODE_ONESHOT, OneShotNode, 0 ); + return n->autorestart; + +} +float AnimationTreePlayer::oneshot_node_get_autorestart_delay(const StringName& p_node) const { + + GET_NODE_V(NODE_ONESHOT, OneShotNode, 0 ); + return n->autorestart_delay; + +} +float AnimationTreePlayer::oneshot_node_get_autorestart_random_delay(const StringName& p_node) const { + + GET_NODE_V(NODE_ONESHOT, OneShotNode, 0 ); + return n->autorestart_random_delay; + +} + +bool AnimationTreePlayer::oneshot_node_is_active(const StringName& p_node) const { + + + GET_NODE_V(NODE_ONESHOT, OneShotNode, 0 ); + return n->active; + +} + +bool AnimationTreePlayer::oneshot_node_is_path_filtered(const StringName& p_node,const NodePath& p_path) const { + + GET_NODE_V(NODE_ONESHOT, OneShotNode, 0 ); + return n->filter.has(p_path); +} + + +float AnimationTreePlayer::mix_node_get_amount(const StringName& p_node) const { + + GET_NODE_V(NODE_MIX, MixNode, 0 ); + return n->amount; + +} +float AnimationTreePlayer::blend2_node_get_amount(const StringName& p_node) const { + + GET_NODE_V(NODE_BLEND2, Blend2Node, 0 ); + return n->value; + +} + +bool AnimationTreePlayer::blend2_node_is_path_filtered(const StringName& p_node,const NodePath& p_path) const { + + GET_NODE_V(NODE_BLEND2, Blend2Node, 0 ); + return n->filter.has(p_path); +} + +float AnimationTreePlayer::blend3_node_get_amount(const StringName& p_node) const { + + + GET_NODE_V(NODE_BLEND3, Blend3Node, 0 ); + return n->value; + +} +Vector2 AnimationTreePlayer::blend4_node_get_amount(const StringName& p_node) const { + + GET_NODE_V(NODE_BLEND4, Blend4Node, Vector2() ); + return n->value; + +} + +float AnimationTreePlayer::timescale_node_get_scale(const StringName& p_node) const { + + GET_NODE_V(NODE_TIMESCALE, TimeScaleNode, 0 ); + return n->scale; + +} + +void AnimationTreePlayer::transition_node_delete_input(const StringName& p_node, int p_input) { + + GET_NODE(NODE_TRANSITION, TransitionNode); + ERR_FAIL_INDEX(p_input,n->inputs.size()); + + if (n->inputs.size()<=1) + return; + + + n->inputs.remove(p_input); + n->input_data.remove(p_input); + last_error=_cycle_test(out_name); +} + + +int AnimationTreePlayer::transition_node_get_input_count(const StringName& p_node) const { + + GET_NODE_V(NODE_TRANSITION, TransitionNode, 0 ); + return n->inputs.size(); +} + +bool AnimationTreePlayer::transition_node_has_input_auto_advance(const StringName& p_node, int p_input) const { + + GET_NODE_V(NODE_TRANSITION, TransitionNode, false ); + ERR_FAIL_INDEX_V(p_input,n->inputs.size(),false); + return n->input_data[p_input].auto_advance; + +} +float AnimationTreePlayer::transition_node_get_xfade_time(const StringName& p_node) const { + + GET_NODE_V(NODE_TRANSITION, TransitionNode, 0 ); + return n->xfade; + +} + +int AnimationTreePlayer::transition_node_get_current(const StringName& p_node) const { + + GET_NODE_V(NODE_TRANSITION, TransitionNode, -1 ); + return n->current; + +} + + /*misc */ +void AnimationTreePlayer::get_node_list(List<StringName> *p_node_list) const { + + for(Map<StringName,NodeBase*>::Element *E=node_map.front();E;E=E->next()) { + + p_node_list->push_back( E->key() ); + } +} + +void AnimationTreePlayer::remove_node(const StringName& p_node) { + + ERR_FAIL_COND( !node_map.has(p_node) ); + ERR_EXPLAIN("Node 0 (output) can't be removed."); + ERR_FAIL_COND( p_node == out_name ); + + for(Map<StringName,NodeBase*>::Element *E=node_map.front();E;E=E->next()) { + + NodeBase *nb = E->get(); + for(int i=0;i<nb->inputs.size();i++) { + + if (nb->inputs[i].node==p_node) + nb->inputs[i].node=StringName(); + } + } + + node_map.erase(p_node); + + // compute last error again, just in case + last_error=_cycle_test(out_name); + dirty_caches=true; +} + + +AnimationTreePlayer::ConnectError AnimationTreePlayer::_cycle_test(const StringName& p_at_node) { + + ERR_FAIL_COND_V(!node_map.has(p_at_node), CONNECT_INCOMPLETE); + + NodeBase *nb = node_map[p_at_node]; + if (nb->cycletest) + return CONNECT_CYCLE; + + + nb->cycletest=true; + + for(int i=0;i<nb->inputs.size();i++) { + if (nb->inputs[i].node==StringName()) + return CONNECT_INCOMPLETE; + + ConnectError _err = _cycle_test(nb->inputs[i].node); + if (_err) + return _err; + } + + return CONNECT_OK; +} + + +Error AnimationTreePlayer::connect(const StringName& p_src_node,const StringName& p_dst_node, int p_dst_input) { + + ERR_FAIL_COND_V( !node_map.has(p_src_node) , ERR_INVALID_PARAMETER); + ERR_FAIL_COND_V( !node_map.has(p_dst_node) , ERR_INVALID_PARAMETER); + ERR_FAIL_COND_V( p_src_node==p_dst_node , ERR_INVALID_PARAMETER); + +// NodeBase *src = node_map[p_src_node]; + NodeBase *dst = node_map[p_dst_node]; + ERR_FAIL_INDEX_V( p_dst_input, dst->inputs.size(), ERR_INVALID_PARAMETER); + +// int oldval = dst->inputs[p_dst_input].node; + + for(Map<StringName,NodeBase*>::Element *E=node_map.front();E;E=E->next()) { + + NodeBase *nb = E->get(); + for(int i=0;i<nb->inputs.size();i++) { + + if (nb->inputs[i].node==p_src_node) + nb->inputs[i].node=StringName(); + } + } + + dst->inputs[p_dst_input].node=p_src_node; + + for(Map<StringName,NodeBase*>::Element *E=node_map.front();E;E=E->next()) { + + NodeBase *nb = E->get(); + nb->cycletest=false; + } + + last_error=_cycle_test(out_name); + if (last_error) { + + if (last_error==CONNECT_INCOMPLETE) + return ERR_UNCONFIGURED; + else if (last_error==CONNECT_CYCLE) + return ERR_CYCLIC_LINK; + } + dirty_caches=true; + return OK; +} + +bool AnimationTreePlayer::is_connected(const StringName& p_src_node,const StringName& p_dst_node, int p_dst_input) const { + + ERR_FAIL_COND_V( !node_map.has(p_src_node) , false); + ERR_FAIL_COND_V( !node_map.has(p_dst_node) , false); + ERR_FAIL_COND_V( p_src_node==p_dst_node , false); + + NodeBase *dst = node_map[p_dst_node]; + + return dst->inputs[p_dst_input].node==p_src_node; + +} + +void AnimationTreePlayer::disconnect(const StringName& p_node, int p_input) { + + ERR_FAIL_COND( !node_map.has(p_node)); + + NodeBase *dst = node_map[p_node]; + ERR_FAIL_INDEX(p_input,dst->inputs.size()); + dst->inputs[p_input].node=StringName(); + last_error=CONNECT_INCOMPLETE; + dirty_caches=true; +} + + +void AnimationTreePlayer::get_connection_list( List<Connection> *p_connections) const { + + for(Map<StringName,NodeBase*>::Element *E=node_map.front();E;E=E->next()) { + + NodeBase *nb = E->get(); + for(int i=0;i<nb->inputs.size();i++) { + + if (nb->inputs[i].node!=StringName()) { + Connection c; + c.src_node=nb->inputs[i].node; + c.dst_node=E->key(); + c.dst_input=i; + p_connections->push_back(c); + } + } + } +} + +AnimationTreePlayer::Track* AnimationTreePlayer::_find_track(const NodePath& p_path) { + + Node *parent=get_node(base_path); + ERR_FAIL_COND_V(!parent,NULL); + + Node *child=parent->get_node(p_path); + if (!child) { + String err = "Animation track references unknown Node: '"+String(p_path)+"'."; + WARN_PRINT(err.ascii().get_data()); + return NULL; + } + + ObjectID id=child->get_instance_ID(); + StringName property; + int bone_idx=-1; + + if (p_path.get_property()) { + + if (child->cast_to<Skeleton>()) + bone_idx = child->cast_to<Skeleton>()->find_bone( p_path.get_property() ); + if (bone_idx==-1) + property=p_path.get_property(); + } + + TrackKey key; + key.id=id; + key.bone_idx=bone_idx; + key.property=property; + + if (!track_map.has(key)) { + + Track tr; + tr.id=id; + tr.node=child; + tr.skeleton=child->cast_to<Skeleton>(); + tr.spatial=child->cast_to<Spatial>(); + tr.bone_idx=bone_idx; + tr.property=property; + + track_map[key]=tr; + } + + return &track_map[key]; + +} + +void AnimationTreePlayer::_recompute_caches() { + + track_map.clear(); + _recompute_caches(out_name); + dirty_caches=false; +} + +void AnimationTreePlayer::_recompute_caches(const StringName& p_node) { + + ERR_FAIL_COND( !node_map.has(p_node) ); + + NodeBase *nb = node_map[p_node]; + + if (nb->type==NODE_ANIMATION) { + + AnimationNode *an = static_cast<AnimationNode*>(nb); + an->tref.clear();; + + if (!an->animation.is_null()) { + + + Ref<Animation> a = an->animation; + + for(int i=0;i<an->animation->get_track_count();i++) { + + + Track *tr = _find_track(a->track_get_path(i)); + if (!tr) + continue; + + AnimationNode::TrackRef tref; + tref.local_track=i; + tref.track=tr; + tref.weight=0; + + an->tref.push_back(tref); + + } + } + } + + for(int i=0;i<nb->inputs.size();i++) { + + _recompute_caches(nb->inputs[i].node); + } + +} + +void AnimationTreePlayer::recompute_caches() { + + dirty_caches=true; + +} + + + + /* playback */ + +void AnimationTreePlayer::set_active(bool p_active) { + + active=p_active; + set_process(active); +} + +bool AnimationTreePlayer::is_active() const { + + return active; + +} + +AnimationTreePlayer::ConnectError AnimationTreePlayer::get_last_error() const { + + return last_error; +} + +void AnimationTreePlayer::reset() { + + + reset_request=false; +} + + +void AnimationTreePlayer::set_base_path(const NodePath& p_path) { + + base_path=p_path; + recompute_caches(); +} + +NodePath AnimationTreePlayer::get_base_path() const{ + + return base_path; +} + +void AnimationTreePlayer::set_master_player(const NodePath& p_path) { + + if (p_path==master) + return; + + master=p_path; + _update_sources(); + recompute_caches(); +} + +NodePath AnimationTreePlayer::get_master_player() const{ + + return master; +} + +DVector<String> AnimationTreePlayer::_get_node_list() { + + List<StringName> nl; + get_node_list(&nl); + DVector<String> ret; + ret.resize(nl.size()); + int idx=0; + for(List<StringName>::Element *E=nl.front();E;E=E->next()) { + ret.set(idx++,E->get()); + } + + return ret; +} + + +void AnimationTreePlayer::_update_sources() { + + if (master==NodePath()) + return; + if (!is_inside_scene()) + return; + + Node *m = get_node(master); + if (!m) { + master=NodePath(); + ERR_FAIL_COND(!m); + } + + AnimationPlayer *ap = m->cast_to<AnimationPlayer>(); + + if (!ap) { + + master=NodePath(); + ERR_FAIL_COND(!ap); + } + + for (Map<StringName,NodeBase*>::Element *E=node_map.front();E;E=E->next()) { + + if (E->get()->type==NODE_ANIMATION) { + + AnimationNode *an = static_cast<AnimationNode*>(E->get()); + + if (an->from!="") { + + an->animation = ap->get_animation(an->from); + } + } + } + + +} + +bool AnimationTreePlayer::node_exists(const StringName& p_name) const { + + return (node_map.has(p_name)); +} + +Error AnimationTreePlayer::node_rename(const StringName& p_node,const StringName& p_new_name) { + + if (p_new_name==p_node) + return OK; + ERR_FAIL_COND_V(!node_map.has(p_node),ERR_ALREADY_EXISTS); + ERR_FAIL_COND_V(node_map.has(p_new_name),ERR_ALREADY_EXISTS); + ERR_FAIL_COND_V(p_new_name==StringName(),ERR_INVALID_DATA); + ERR_FAIL_COND_V(p_node==out_name,ERR_INVALID_DATA); + ERR_FAIL_COND_V(p_new_name==out_name,ERR_INVALID_DATA); + + for(Map<StringName,NodeBase*>::Element *E=node_map.front();E;E=E->next()) { + + NodeBase *nb = E->get(); + for(int i=0;i<nb->inputs.size();i++) { + + if (nb->inputs[i].node==p_node) { + nb->inputs[i].node=p_new_name; + } + } + } + + node_map[p_new_name]=node_map[p_node]; + node_map.erase(p_node); + + return OK; + +} + + +void AnimationTreePlayer::_bind_methods() { + + ObjectTypeDB::bind_method(_MD("add_node","type","id"),&AnimationTreePlayer::add_node); + + ObjectTypeDB::bind_method(_MD("node_exists","node"),&AnimationTreePlayer::node_exists); + ObjectTypeDB::bind_method(_MD("node_rename","node","new_name"),&AnimationTreePlayer::node_rename); + + ObjectTypeDB::bind_method(_MD("node_get_type","id"),&AnimationTreePlayer::node_get_type); + ObjectTypeDB::bind_method(_MD("node_get_input_count","id"),&AnimationTreePlayer::node_get_input_count); + ObjectTypeDB::bind_method(_MD("node_get_input_sourcre","id","idx"),&AnimationTreePlayer::node_get_input_source); + + ObjectTypeDB::bind_method(_MD("animation_node_set_animation","id","animation:Animation"),&AnimationTreePlayer::animation_node_set_animation); + ObjectTypeDB::bind_method(_MD("animation_node_get_animation:Animation","id"),&AnimationTreePlayer::animation_node_get_animation); + + ObjectTypeDB::bind_method(_MD("animation_node_set_master_animation","id","source"),&AnimationTreePlayer::animation_node_set_master_animation); + ObjectTypeDB::bind_method(_MD("animation_node_get_master_animation","id"),&AnimationTreePlayer::animation_node_get_master_animation); + + ObjectTypeDB::bind_method(_MD("oneshot_node_set_fadein_time","id","time_sec"),&AnimationTreePlayer::oneshot_node_set_fadein_time); + ObjectTypeDB::bind_method(_MD("oneshot_node_get_fadein_time","id"),&AnimationTreePlayer::oneshot_node_get_fadein_time); + + ObjectTypeDB::bind_method(_MD("oneshot_node_set_fadeout_time","id","time_sec"),&AnimationTreePlayer::oneshot_node_set_fadeout_time); + ObjectTypeDB::bind_method(_MD("oneshot_node_get_fadeout_time","id"),&AnimationTreePlayer::oneshot_node_get_fadeout_time); + + + ObjectTypeDB::bind_method(_MD("oneshot_node_set_autorestart","id","enable"),&AnimationTreePlayer::oneshot_node_set_autorestart); + ObjectTypeDB::bind_method(_MD("oneshot_node_set_autorestart_delay","id","delay_sec"),&AnimationTreePlayer::oneshot_node_set_autorestart_delay); + ObjectTypeDB::bind_method(_MD("oneshot_node_set_autorestart_random_delay","id","rand_sec"),&AnimationTreePlayer::oneshot_node_set_autorestart_random_delay); + + + ObjectTypeDB::bind_method(_MD("oneshot_node_has_autorestart","id"),&AnimationTreePlayer::oneshot_node_has_autorestart); + ObjectTypeDB::bind_method(_MD("oneshot_node_get_autorestart_delay","id"),&AnimationTreePlayer::oneshot_node_get_autorestart_delay); + ObjectTypeDB::bind_method(_MD("oneshot_node_get_autorestart_random_delay","id"),&AnimationTreePlayer::oneshot_node_get_autorestart_random_delay); + + ObjectTypeDB::bind_method(_MD("oneshot_node_start","id"),&AnimationTreePlayer::oneshot_node_start); + ObjectTypeDB::bind_method(_MD("oneshot_node_stop","id"),&AnimationTreePlayer::oneshot_node_stop); + ObjectTypeDB::bind_method(_MD("oneshot_node_is_active","id"),&AnimationTreePlayer::oneshot_node_is_active); + ObjectTypeDB::bind_method(_MD("oneshot_node_set_filter_path","id","path","enable"),&AnimationTreePlayer::oneshot_node_set_filter_path); + + ObjectTypeDB::bind_method(_MD("mix_node_set_amount","id","ratio"),&AnimationTreePlayer::mix_node_set_amount); + ObjectTypeDB::bind_method(_MD("mix_node_get_amount","id"),&AnimationTreePlayer::mix_node_get_amount); + + ObjectTypeDB::bind_method(_MD("blend2_node_set_amount","id","blend"),&AnimationTreePlayer::blend2_node_set_amount); + ObjectTypeDB::bind_method(_MD("blend2_node_get_amount","id"),&AnimationTreePlayer::blend2_node_get_amount); + ObjectTypeDB::bind_method(_MD("blend2_node_set_filter_path","id","path","enable"),&AnimationTreePlayer::blend2_node_set_filter_path); + + ObjectTypeDB::bind_method(_MD("blend3_node_set_amount","id","blend"),&AnimationTreePlayer::blend3_node_set_amount); + ObjectTypeDB::bind_method(_MD("blend3_node_get_amount","id"),&AnimationTreePlayer::blend3_node_get_amount); + + ObjectTypeDB::bind_method(_MD("blend4_node_set_amount","id","blend"),&AnimationTreePlayer::blend4_node_set_amount); + ObjectTypeDB::bind_method(_MD("blend4_node_get_amount","id"),&AnimationTreePlayer::blend4_node_get_amount); + + ObjectTypeDB::bind_method(_MD("timescale_node_set_scale","id","scale"),&AnimationTreePlayer::timescale_node_set_scale); + ObjectTypeDB::bind_method(_MD("timescale_node_get_scale","id"),&AnimationTreePlayer::timescale_node_get_scale); + + ObjectTypeDB::bind_method(_MD("timeseek_node_seek","id","pos_sec"),&AnimationTreePlayer::timeseek_node_seek); + + ObjectTypeDB::bind_method(_MD("transition_node_set_input_count","id","count"),&AnimationTreePlayer::transition_node_set_input_count); + ObjectTypeDB::bind_method(_MD("transition_node_get_input_count","id"),&AnimationTreePlayer::transition_node_get_input_count); + ObjectTypeDB::bind_method(_MD("transition_node_delete_input","id","input_idx"),&AnimationTreePlayer::transition_node_delete_input); + + ObjectTypeDB::bind_method(_MD("transition_node_set_input_auto_advance","id","input_idx","enable"),&AnimationTreePlayer::transition_node_set_input_auto_advance); + ObjectTypeDB::bind_method(_MD("transition_node_has_input_auto_advance","id","input_idx"),&AnimationTreePlayer::transition_node_has_input_auto_advance); + + ObjectTypeDB::bind_method(_MD("transition_node_set_xfade_time","id","time_sec"),&AnimationTreePlayer::transition_node_set_xfade_time); + ObjectTypeDB::bind_method(_MD("transition_node_get_xfade_time","id"),&AnimationTreePlayer::transition_node_get_xfade_time); + + ObjectTypeDB::bind_method(_MD("transition_node_set_current","id","input_idx"),&AnimationTreePlayer::transition_node_set_current); + ObjectTypeDB::bind_method(_MD("transition_node_get_current","id"),&AnimationTreePlayer::transition_node_get_current); + + + ObjectTypeDB::bind_method(_MD("node_set_pos","id","screen_pos"),&AnimationTreePlayer::node_set_pos); + ObjectTypeDB::bind_method(_MD("node_get_pos","id"),&AnimationTreePlayer::node_get_pos); + + ObjectTypeDB::bind_method(_MD("remove_node","id"),&AnimationTreePlayer::remove_node); + ObjectTypeDB::bind_method(_MD("connect","id","dst_id","dst_input_idx"),&AnimationTreePlayer::connect); + ObjectTypeDB::bind_method(_MD("is_connected","id","dst_id","dst_input_idx"),&AnimationTreePlayer::is_connected); + ObjectTypeDB::bind_method(_MD("disconnect","id","dst_input_idx"),&AnimationTreePlayer::disconnect); + + ObjectTypeDB::bind_method(_MD("set_active","enabled"),&AnimationTreePlayer::set_active); + ObjectTypeDB::bind_method(_MD("is_active"),&AnimationTreePlayer::is_active); + + ObjectTypeDB::bind_method(_MD("set_base_path","path"),&AnimationTreePlayer::set_base_path); + ObjectTypeDB::bind_method(_MD("get_base_path"),&AnimationTreePlayer::get_base_path); + + ObjectTypeDB::bind_method(_MD("get_node_list"),&AnimationTreePlayer::_get_node_list); + + ObjectTypeDB::bind_method(_MD("reset"),&AnimationTreePlayer::reset); + + ObjectTypeDB::bind_method(_MD("recompute_caches"),&AnimationTreePlayer::recompute_caches); + + BIND_CONSTANT( NODE_OUTPUT ); + BIND_CONSTANT( NODE_ANIMATION ); + BIND_CONSTANT( NODE_ONESHOT ); + BIND_CONSTANT( NODE_MIX ); + BIND_CONSTANT( NODE_BLEND2 ); + BIND_CONSTANT( NODE_BLEND3 ); + BIND_CONSTANT( NODE_BLEND4 ); + BIND_CONSTANT( NODE_TIMESCALE ); + BIND_CONSTANT( NODE_TIMESEEK ); + BIND_CONSTANT( NODE_TRANSITION ); +} + + +AnimationTreePlayer::AnimationTreePlayer() { + + active_list=NULL; + out = memnew( NodeOut ) ; + out_name="out"; + out->pos=Point2(40,40); + node_map.insert( out_name , out); + active=false; + dirty_caches=true; + reset_request=false; + last_error=CONNECT_INCOMPLETE; + base_path=String(".."); +} + + +AnimationTreePlayer::~AnimationTreePlayer() { + + while(node_map.size()) { + memdelete( node_map.front()->get() ); + node_map.erase( node_map.front() ); + } +} + + + diff --git a/scene/animation/animation_tree_player.h b/scene/animation/animation_tree_player.h new file mode 100644 index 000000000..135e5f414 --- /dev/null +++ b/scene/animation/animation_tree_player.h @@ -0,0 +1,420 @@ +/*************************************************************************/ +/* animation_tree_player.h */ +/*************************************************************************/ +/* 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. */ +/*************************************************************************/ +#ifndef ANIMATION_TREE_PLAYER_H +#define ANIMATION_TREE_PLAYER_H + + +#include "scene/resources/animation.h" +#include "scene/3d/spatial.h" +#include "scene/3d/skeleton.h" +#include "scene/main/misc.h" + + +class AnimationTreePlayer : public Node { + + OBJ_TYPE( AnimationTreePlayer, Node ); + OBJ_CATEGORY("Animation Nodes"); + +public: + + + enum NodeType { + + NODE_OUTPUT, + NODE_ANIMATION, + NODE_ONESHOT, + NODE_MIX, + NODE_BLEND2, + NODE_BLEND3, + NODE_BLEND4, + NODE_TIMESCALE, + NODE_TIMESEEK, + NODE_TRANSITION, + + NODE_MAX, + }; + + enum ConnectError { + + CONNECT_OK, + CONNECT_INCOMPLETE, + CONNECT_CYCLE + }; + +private: + + enum { + + DISCONNECTED=-1, + }; + + struct TrackKey { + + uint32_t id; + StringName property; + int bone_idx; + + inline bool operator<(const TrackKey& p_right) const { + + if (id==p_right.id) { + if (bone_idx==p_right.bone_idx) { + return property<p_right.property; + } else + return bone_idx<p_right.bone_idx; + } else + return id<p_right.id; + } + }; + + + struct Track { + uint32_t id; + Node *node; + Spatial* spatial; + Skeleton *skeleton; + int bone_idx; + StringName property; + + Vector3 loc; + Quat rot; + Vector3 scale; + + }; + + + typedef Map<TrackKey,Track> TrackMap; + + TrackMap track_map; + + + struct Input { + + StringName node; + //Input() { node=-1; } + }; + + struct NodeBase { + + bool cycletest; + + NodeType type; + Point2 pos; + + + Vector<Input> inputs; + + NodeBase() { cycletest = false; }; + virtual ~NodeBase() { cycletest=false; } + }; + + struct NodeOut : public NodeBase { + + NodeOut() { type=NODE_OUTPUT; inputs.resize(1); } + }; + + struct AnimationNode : public NodeBase { + + Ref<Animation> animation; + + + struct TrackRef { + int local_track; + Track *track; + float weight; + }; + + uint64_t last_version; + List<TrackRef> tref; + AnimationNode *next; + float time; + float step; + String from; + bool skip; + AnimationNode() { type=NODE_ANIMATION; next=NULL; last_version=0; skip=false; } + }; + + + struct OneShotNode : public NodeBase { + + bool active; + bool start; + float fade_in; + float fade_out; + + bool autorestart; + float autorestart_delay; + float autorestart_random_delay; + bool mix; + + + float time; + float remaining; + float autorestart_remaining; + + HashMap<NodePath,bool> filter; + + OneShotNode() { type=NODE_ONESHOT; fade_in=0; fade_out=0; inputs.resize(2); autorestart=false; autorestart_delay=1; autorestart_remaining=0; mix=false; active=false; start=false;} + }; + + struct MixNode : public NodeBase { + + float amount; + MixNode() { type=NODE_MIX; inputs.resize(2); } + }; + + struct Blend2Node : public NodeBase { + + float value; + HashMap<NodePath,bool> filter; + Blend2Node() { type=NODE_BLEND2; value=0; inputs.resize(2); } + }; + + struct Blend3Node : public NodeBase { + + float value; + Blend3Node() { type=NODE_BLEND3; value=0; inputs.resize(3); } + }; + + struct Blend4Node : public NodeBase { + + Point2 value; + Blend4Node() { type=NODE_BLEND4; inputs.resize(4); } + }; + + struct TimeScaleNode : public NodeBase { + + float scale; + TimeScaleNode() { type=NODE_TIMESCALE; scale=1; inputs.resize(1); } + }; + + struct TimeSeekNode : public NodeBase { + + float seek_pos; + + TimeSeekNode() { type=NODE_TIMESEEK; inputs.resize(1); seek_pos=-1; } + }; + + struct TransitionNode : public NodeBase { + + struct InputData { + + bool auto_advance; + InputData() { auto_advance=false; } + }; + + Vector<InputData> input_data; + + float prev_time; + float prev_xfading; + int prev; + bool switched; + + + float time; + int current; + + float xfade; + + TransitionNode() { type=NODE_TRANSITION; xfade=0; inputs.resize(1); input_data.resize(1); current=0; prev=-1; prev_time=0; prev_xfading=0; switched=false; } + }; + + + void _update_sources(); + + StringName out_name; + NodeOut *out; + + + NodePath base_path; + NodePath master; + + ConnectError last_error; + AnimationNode *active_list; + bool active; + bool dirty_caches; + Map<StringName,NodeBase*> node_map; + + // return time left to finish animation + float _process_node(const StringName& p_node,AnimationNode **r_prev_anim, float p_weight,float p_step, bool p_seek=false,const HashMap<NodePath,bool> *p_filter=NULL, float p_reverse_weight=0); + void _process_animation(); + bool reset_request; + + ConnectError _cycle_test(const StringName &p_at_node); + + Track* _find_track(const NodePath& p_path); + void _recompute_caches(); + void _recompute_caches(const StringName& p_node); + DVector<String> _get_node_list(); + +protected: + + + + + bool _set(const StringName& p_name, const Variant& p_value); + bool _get(const StringName& p_name,Variant &r_ret) const; + void _get_property_list( List<PropertyInfo> *p_list) const; + void _notification(int p_what); + + static void _bind_methods(); + + +public: + + + void add_node(NodeType p_type, const StringName& p_node); // nodes must be >0 node 0 is built-in (exit) + bool node_exists(const StringName& p_name) const; + + Error node_rename(const StringName& p_node,const StringName& p_new_name); + int node_get_input_count(const StringName& p_node) const; + StringName node_get_input_source(const StringName& p_node,int p_input) const; + + /* ANIMATION NODE */ + void animation_node_set_animation(const StringName& p_node,const Ref<Animation>& p_animation); + Ref<Animation> animation_node_get_animation(const StringName& p_node) const; + void animation_node_set_master_animation(const StringName& p_node,const String& p_master_animation); + String animation_node_get_master_animation(const StringName& p_node) const; + + /* ONE SHOT NODE */ + + void oneshot_node_set_fadein_time(const StringName& p_node,float p_time); + void oneshot_node_set_fadeout_time(const StringName& p_node,float p_time); + + float oneshot_node_get_fadein_time(const StringName& p_node) const; + float oneshot_node_get_fadeout_time(const StringName& p_node) const; + + void oneshot_node_set_autorestart(const StringName& p_node,bool p_active); + void oneshot_node_set_autorestart_delay(const StringName& p_node,float p_time); + void oneshot_node_set_autorestart_random_delay(const StringName& p_node,float p_time); + + bool oneshot_node_has_autorestart(const StringName& p_node) const; + float oneshot_node_get_autorestart_delay(const StringName& p_node) const; + float oneshot_node_get_autorestart_random_delay(const StringName& p_node) const; + + void oneshot_node_set_mix_mode(const StringName& p_node,bool p_enabled); + bool oneshot_node_get_mix_mode(const StringName& p_node) const; + + void oneshot_node_start(const StringName& p_node); + void oneshot_node_stop(const StringName& p_node); + bool oneshot_node_is_active(const StringName& p_node) const; + + void oneshot_node_set_filter_path(const StringName& p_node,const NodePath& p_filter,bool p_enable); + void oneshot_node_set_get_filtered_paths(const StringName& p_node,List<NodePath> *r_paths) const; + bool oneshot_node_is_path_filtered(const StringName& p_node,const NodePath& p_path) const; + + + /* MIX/BLEND NODES */ + + void mix_node_set_amount(const StringName& p_node,float p_amount); + float mix_node_get_amount(const StringName& p_node) const; + + void blend2_node_set_amount(const StringName& p_node,float p_amount); + float blend2_node_get_amount(const StringName& p_node) const; + void blend2_node_set_filter_path(const StringName& p_node,const NodePath& p_filter,bool p_enable); + void blend2_node_set_get_filtered_paths(const StringName& p_node,List<NodePath> *r_paths) const; + bool blend2_node_is_path_filtered(const StringName& p_node,const NodePath& p_path) const; + + void blend3_node_set_amount(const StringName& p_node,float p_amount); + float blend3_node_get_amount(const StringName& p_node) const; + + void blend4_node_set_amount(const StringName& p_node,const Point2& p_amount); + Point2 blend4_node_get_amount(const StringName& p_node) const; + + /* TIMESCALE/TIMESEEK NODES */ + + void timescale_node_set_scale(const StringName& p_node,float p_scale); + float timescale_node_get_scale(const StringName& p_node) const; + + void timeseek_node_seek(const StringName& p_node,float p_pos); + + /* TRANSITION NODE */ + + void transition_node_set_input_count(const StringName& p_node, int p_inputs); // used for transition node + int transition_node_get_input_count(const StringName& p_node) const; + void transition_node_delete_input(const StringName& p_node, int p_input); // used for transition node + + void transition_node_set_input_auto_advance(const StringName& p_node, int p_input,bool p_auto_advance); // used for transition node + bool transition_node_has_input_auto_advance(const StringName& p_node, int p_input) const; + + void transition_node_set_xfade_time(const StringName& p_node, float p_time); // used for transition node + float transition_node_get_xfade_time(const StringName& p_node) const; + + void transition_node_set_current(const StringName& p_node, int p_current); + int transition_node_get_current(const StringName& p_node) const; + + + void node_set_pos(const StringName& p_node, const Vector2& p_pos); //for display + + /* GETS */ + Point2 node_get_pos(const StringName& p_node) const; //for display + + NodeType node_get_type(const StringName& p_node) const; + + void get_node_list(List<StringName> *p_node_list) const; + void remove_node(const StringName& p_node); + + Error connect(const StringName& p_src_node,const StringName& p_dst_node, int p_dst_input); + bool is_connected(const StringName& p_src_node,const StringName& p_dst_node, int p_input) const; + void disconnect(const StringName& p_src_node, int p_input); + + void set_base_path(const NodePath& p_path); + NodePath get_base_path() const; + + void set_master_player(const NodePath& p_path); + NodePath get_master_player() const; + + struct Connection { + + StringName src_node; + StringName dst_node; + int dst_input; + }; + + void get_connection_list( List<Connection> *p_connections) const; + + /* playback */ + + void set_active(bool p_active); + bool is_active() const; + + void reset(); + + void recompute_caches(); + + ConnectError get_last_error() const; + + AnimationTreePlayer(); + ~AnimationTreePlayer(); + +}; + +VARIANT_ENUM_CAST( AnimationTreePlayer::NodeType ); +#endif // ANIMATION_TREE_PLAYER_H + + diff --git a/scene/animation/transitioner.cpp b/scene/animation/transitioner.cpp new file mode 100644 index 000000000..990f55f9c --- /dev/null +++ b/scene/animation/transitioner.cpp @@ -0,0 +1,34 @@ +/*************************************************************************/ +/* transitioner.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 "transitioner.h" +/* +Transitioner::Transitioner() +{ +} +*/ diff --git a/scene/animation/transitioner.h b/scene/animation/transitioner.h new file mode 100644 index 000000000..3cff5e6d4 --- /dev/null +++ b/scene/animation/transitioner.h @@ -0,0 +1,68 @@ +/*************************************************************************/ +/* transitioner.h */ +/*************************************************************************/ +/* 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. */ +/*************************************************************************/ +#ifndef TRANSITIONER_H +#define TRANSITIONER_H + +/* +class Transitioner : public Node { + OBJ_TYPE(Transitioner, Node); +public: + enum Interpolation { + INTERPOLATION_NEAREST, + INTERPOLATION_LINEAR, + INTERPOLATION_CUBIC + }; + + enum TransitionType { + TYPE_PROPERTY, + TYPE_METHOD, + TYPE_TRANSITION + + }; + + + void create_transition(const String& p_transition, TransitionType p_type); + void transition_set_target(const NodePath& p_node,const String& p_target); + TransitionType transition_get_type() const; + void transition_add_key(const String& p_transition,float p_time, const Variant& p_key); + int transition_get_key_count(const String& p_transition) const; + Variant transition_get_key_time(const String& p_transition.int p_key_index) const + Variant transition_get_key(const String& p_transition,int p_key_index) const; + + void transition_remove_key(const String& p_transition, int p_key_index); + void transition_clear_keys(const String& p_transition); + void remove_transition(const String& p_transition); + + void transition_ + + + Transitioner(); +}; +*/ +#endif // TRANSITIONER_H |