godot/scene/animation/animation_blend_tree.cpp

/**************************************************************************/
/*  animation_blend_tree.cpp                                              */
/**************************************************************************/
/*                         This file is part of:                          */
/*                             GODOT ENGINE                               */
/*                        https://godotengine.org                         */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* 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_blend_tree.h"

#include "scene/resources/animation.h"

void AnimationNodeAnimation::set_animation(const StringName &p_name) { … }

StringName AnimationNodeAnimation::get_animation() const { … }

Vector<String> (*AnimationNodeAnimation::get_editable_animation_list)() = …;

void AnimationNodeAnimation::get_parameter_list(List<PropertyInfo> *r_list) const { … }

AnimationNode::NodeTimeInfo AnimationNodeAnimation::get_node_time_info() const { … }

void AnimationNodeAnimation::_validate_property(PropertyInfo &p_property) const { … }

AnimationNode::NodeTimeInfo AnimationNodeAnimation::process(const AnimationMixer::PlaybackInfo p_playback_info, bool p_test_only) { … }

AnimationNode::NodeTimeInfo AnimationNodeAnimation::_process(const AnimationMixer::PlaybackInfo p_playback_info, bool p_test_only) { … }

String AnimationNodeAnimation::get_caption() const { … }

void AnimationNodeAnimation::set_play_mode(PlayMode p_play_mode) { … }

AnimationNodeAnimation::PlayMode AnimationNodeAnimation::get_play_mode() const { … }

void AnimationNodeAnimation::set_backward(bool p_backward) { … }

bool AnimationNodeAnimation::is_backward() const { … }

void AnimationNodeAnimation::set_advance_on_start(bool p_advance_on_start) { … }

bool AnimationNodeAnimation::is_advance_on_start() const { … }

void AnimationNodeAnimation::set_use_custom_timeline(bool p_use_custom_timeline) { … }

bool AnimationNodeAnimation::is_using_custom_timeline() const { … }

void AnimationNodeAnimation::set_timeline_length(double p_length) { … }

double AnimationNodeAnimation::get_timeline_length() const { … }

void AnimationNodeAnimation::set_stretch_time_scale(bool p_strech_time_scale) { … }

bool AnimationNodeAnimation::is_stretching_time_scale() const { … }

void AnimationNodeAnimation::set_start_offset(double p_offset) { … }

double AnimationNodeAnimation::get_start_offset() const { … }

void AnimationNodeAnimation::set_loop_mode(Animation::LoopMode p_loop_mode) { … }

Animation::LoopMode AnimationNodeAnimation::get_loop_mode() const { … }

void AnimationNodeAnimation::_bind_methods() { … }

AnimationNodeAnimation::AnimationNodeAnimation() { … }

////////////////////////////////////////////////////////

void AnimationNodeSync::_bind_methods() { … }

void AnimationNodeSync::set_use_sync(bool p_sync) { … }

bool AnimationNodeSync::is_using_sync() const { … }

AnimationNodeSync::AnimationNodeSync() { … }

////////////////////////////////////////////////////////
void AnimationNodeOneShot::get_parameter_list(List<PropertyInfo> *r_list) const { … }

Variant AnimationNodeOneShot::get_parameter_default_value(const StringName &p_parameter) const { … }

bool AnimationNodeOneShot::is_parameter_read_only(const StringName &p_parameter) const { … }

void AnimationNodeOneShot::set_fade_in_time(double p_time) { … }

double AnimationNodeOneShot::get_fade_in_time() const { … }

void AnimationNodeOneShot::set_fade_out_time(double p_time) { … }

double AnimationNodeOneShot::get_fade_out_time() const { … }

void AnimationNodeOneShot::set_fade_in_curve(const Ref<Curve> &p_curve) { … }

Ref<Curve> AnimationNodeOneShot::get_fade_in_curve() const { … }

void AnimationNodeOneShot::set_fade_out_curve(const Ref<Curve> &p_curve) { … }

Ref<Curve> AnimationNodeOneShot::get_fade_out_curve() const { … }

void AnimationNodeOneShot::set_auto_restart_enabled(bool p_enabled) { … }

void AnimationNodeOneShot::set_auto_restart_delay(double p_time) { … }

void AnimationNodeOneShot::set_auto_restart_random_delay(double p_time) { … }

bool AnimationNodeOneShot::is_auto_restart_enabled() const { … }

double AnimationNodeOneShot::get_auto_restart_delay() const { … }

double AnimationNodeOneShot::get_auto_restart_random_delay() const { … }

void AnimationNodeOneShot::set_mix_mode(MixMode p_mix) { … }

AnimationNodeOneShot::MixMode AnimationNodeOneShot::get_mix_mode() const { … }

void AnimationNodeOneShot::set_break_loop_at_end(bool p_enable) { … }

bool AnimationNodeOneShot::is_loop_broken_at_end() const { … }

String AnimationNodeOneShot::get_caption() const { … }

bool AnimationNodeOneShot::has_filter() const { … }

AnimationNode::NodeTimeInfo AnimationNodeOneShot::_process(const AnimationMixer::PlaybackInfo p_playback_info, bool p_test_only) { … }

void AnimationNodeOneShot::_bind_methods() { … }

AnimationNodeOneShot::AnimationNodeOneShot() { … }

////////////////////////////////////////////////

void AnimationNodeAdd2::get_parameter_list(List<PropertyInfo> *r_list) const { … }

Variant AnimationNodeAdd2::get_parameter_default_value(const StringName &p_parameter) const { … }

String AnimationNodeAdd2::get_caption() const { … }

bool AnimationNodeAdd2::has_filter() const { … }

AnimationNode::NodeTimeInfo AnimationNodeAdd2::_process(const AnimationMixer::PlaybackInfo p_playback_info, bool p_test_only) { … }

AnimationNodeAdd2::AnimationNodeAdd2() { … }

////////////////////////////////////////////////

void AnimationNodeAdd3::get_parameter_list(List<PropertyInfo> *r_list) const { … }

Variant AnimationNodeAdd3::get_parameter_default_value(const StringName &p_parameter) const { … }

String AnimationNodeAdd3::get_caption() const { … }

bool AnimationNodeAdd3::has_filter() const { … }

AnimationNode::NodeTimeInfo AnimationNodeAdd3::_process(const AnimationMixer::PlaybackInfo p_playback_info, bool p_test_only) { … }

AnimationNodeAdd3::AnimationNodeAdd3() { … }

/////////////////////////////////////////////

void AnimationNodeBlend2::get_parameter_list(List<PropertyInfo> *r_list) const { … }

Variant AnimationNodeBlend2::get_parameter_default_value(const StringName &p_parameter) const { … }

String AnimationNodeBlend2::get_caption() const { … }

AnimationNode::NodeTimeInfo AnimationNodeBlend2::_process(const AnimationMixer::PlaybackInfo p_playback_info, bool p_test_only) { … }

bool AnimationNodeBlend2::has_filter() const { … }

AnimationNodeBlend2::AnimationNodeBlend2() { … }

//////////////////////////////////////

void AnimationNodeBlend3::get_parameter_list(List<PropertyInfo> *r_list) const { … }

Variant AnimationNodeBlend3::get_parameter_default_value(const StringName &p_parameter) const { … }

String AnimationNodeBlend3::get_caption() const { … }

AnimationNode::NodeTimeInfo AnimationNodeBlend3::_process(const AnimationMixer::PlaybackInfo p_playback_info, bool p_test_only) { … }

AnimationNodeBlend3::AnimationNodeBlend3() { … }

////////////////////////////////////////////////

void AnimationNodeSub2::get_parameter_list(List<PropertyInfo> *r_list) const { … }

Variant AnimationNodeSub2::get_parameter_default_value(const StringName &p_parameter) const { … }

String AnimationNodeSub2::get_caption() const { … }

bool AnimationNodeSub2::has_filter() const { … }

AnimationNode::NodeTimeInfo AnimationNodeSub2::_process(const AnimationMixer::PlaybackInfo p_playback_info, bool p_test_only) { … }

AnimationNodeSub2::AnimationNodeSub2() { … }

/////////////////////////////////

void AnimationNodeTimeScale::get_parameter_list(List<PropertyInfo> *r_list) const { … }

Variant AnimationNodeTimeScale::get_parameter_default_value(const StringName &p_parameter) const { … }

String AnimationNodeTimeScale::get_caption() const { … }

AnimationNode::NodeTimeInfo AnimationNodeTimeScale::_process(const AnimationMixer::PlaybackInfo p_playback_info, bool p_test_only) { … }

AnimationNodeTimeScale::AnimationNodeTimeScale() { … }

////////////////////////////////////

void AnimationNodeTimeSeek::get_parameter_list(List<PropertyInfo> *r_list) const { … }

Variant AnimationNodeTimeSeek::get_parameter_default_value(const StringName &p_parameter) const { … }

String AnimationNodeTimeSeek::get_caption() const { … }

void AnimationNodeTimeSeek::set_explicit_elapse(bool p_enable) { … }

bool AnimationNodeTimeSeek::is_explicit_elapse() const { … }

AnimationNode::NodeTimeInfo AnimationNodeTimeSeek::_process(const AnimationMixer::PlaybackInfo p_playback_info, bool p_test_only) { … }

AnimationNodeTimeSeek::AnimationNodeTimeSeek() { … }

void AnimationNodeTimeSeek::_bind_methods() { … }

/////////////////////////////////////////////////

bool AnimationNodeTransition::_set(const StringName &p_path, const Variant &p_value) { … }

bool AnimationNodeTransition::_get(const StringName &p_path, Variant &r_ret) const { … }

void AnimationNodeTransition::get_parameter_list(List<PropertyInfo> *r_list) const { … }

Variant AnimationNodeTransition::get_parameter_default_value(const StringName &p_parameter) const { … }

bool AnimationNodeTransition::is_parameter_read_only(const StringName &p_parameter) const { … }

String AnimationNodeTransition::get_caption() const { … }

void AnimationNodeTransition::set_input_count(int p_inputs) { … }

bool AnimationNodeTransition::add_input(const String &p_name) { … }

void AnimationNodeTransition::remove_input(int p_index) { … }

bool AnimationNodeTransition::set_input_name(int p_input, const String &p_name) { … }

void AnimationNodeTransition::set_input_as_auto_advance(int p_input, bool p_enable) { … }

bool AnimationNodeTransition::is_input_set_as_auto_advance(int p_input) const { … }

void AnimationNodeTransition::set_input_break_loop_at_end(int p_input, bool p_enable) { … }

bool AnimationNodeTransition::is_input_loop_broken_at_end(int p_input) const { … }

void AnimationNodeTransition::set_input_reset(int p_input, bool p_enable) { … }

bool AnimationNodeTransition::is_input_reset(int p_input) const { … }

void AnimationNodeTransition::set_xfade_time(double p_fade) { … }

double AnimationNodeTransition::get_xfade_time() const { … }

void AnimationNodeTransition::set_xfade_curve(const Ref<Curve> &p_curve) { … }

Ref<Curve> AnimationNodeTransition::get_xfade_curve() const { … }

void AnimationNodeTransition::set_allow_transition_to_self(bool p_enable) { … }

bool AnimationNodeTransition::is_allow_transition_to_self() const { … }

AnimationNode::NodeTimeInfo AnimationNodeTransition::_process(const AnimationMixer::PlaybackInfo p_playback_info, bool p_test_only) { … }

void AnimationNodeTransition::_get_property_list(List<PropertyInfo> *p_list) const { … }

void AnimationNodeTransition::_bind_methods() { … }

AnimationNodeTransition::AnimationNodeTransition() { … }

/////////////////////

String AnimationNodeOutput::get_caption() const { … }

AnimationNode::NodeTimeInfo AnimationNodeOutput::_process(const AnimationMixer::PlaybackInfo p_playback_info, bool p_test_only) { … }

AnimationNodeOutput::AnimationNodeOutput() { … }

///////////////////////////////////////////////////////
void AnimationNodeBlendTree::add_node(const StringName &p_name, Ref<AnimationNode> p_node, const Vector2 &p_position) { … }

Ref<AnimationNode> AnimationNodeBlendTree::get_node(const StringName &p_name) const { … }

StringName AnimationNodeBlendTree::get_node_name(const Ref<AnimationNode> &p_node) const { … }

void AnimationNodeBlendTree::set_node_position(const StringName &p_node, const Vector2 &p_position) { … }

Vector2 AnimationNodeBlendTree::get_node_position(const StringName &p_node) const { … }

void AnimationNodeBlendTree::get_child_nodes(List<ChildNode> *r_child_nodes) { … }

bool AnimationNodeBlendTree::has_node(const StringName &p_name) const { … }

Vector<StringName> AnimationNodeBlendTree::get_node_connection_array(const StringName &p_name) const { … }

void AnimationNodeBlendTree::remove_node(const StringName &p_name) { … }

void AnimationNodeBlendTree::rename_node(const StringName &p_name, const StringName &p_new_name) { … }

void AnimationNodeBlendTree::connect_node(const StringName &p_input_node, int p_input_index, const StringName &p_output_node) { … }

void AnimationNodeBlendTree::disconnect_node(const StringName &p_node, int p_input_index) { … }

AnimationNodeBlendTree::ConnectionError AnimationNodeBlendTree::can_connect_node(const StringName &p_input_node, int p_input_index, const StringName &p_output_node) const { … }

void AnimationNodeBlendTree::get_node_connections(List<NodeConnection> *r_connections) const { … }

String AnimationNodeBlendTree::get_caption() const { … }

AnimationNode::NodeTimeInfo AnimationNodeBlendTree::_process(const AnimationMixer::PlaybackInfo p_playback_info, bool p_test_only) { … }

void AnimationNodeBlendTree::get_node_list(List<StringName> *r_list) { … }

void AnimationNodeBlendTree::set_graph_offset(const Vector2 &p_graph_offset) { … }

Vector2 AnimationNodeBlendTree::get_graph_offset() const { … }

Ref<AnimationNode> AnimationNodeBlendTree::get_child_by_name(const StringName &p_name) const { … }

bool AnimationNodeBlendTree::_set(const StringName &p_name, const Variant &p_value) { … }

bool AnimationNodeBlendTree::_get(const StringName &p_name, Variant &r_ret) const { … }

void AnimationNodeBlendTree::_get_property_list(List<PropertyInfo> *p_list) const { … }

void AnimationNodeBlendTree::_tree_changed() { … }

void AnimationNodeBlendTree::_animation_node_renamed(const ObjectID &p_oid, const String &p_old_name, const String &p_new_name) { … }

void AnimationNodeBlendTree::_animation_node_removed(const ObjectID &p_oid, const StringName &p_node) { … }

void AnimationNodeBlendTree::reset_state() { … }

void AnimationNodeBlendTree::_node_changed(const StringName &p_node) { … }

#ifdef TOOLS_ENABLED
void AnimationNodeBlendTree::get_argument_options(const StringName &p_function, int p_idx, List<String> *r_options) const { … }
#endif

void AnimationNodeBlendTree::_bind_methods() { … }

void AnimationNodeBlendTree::_initialize_node_tree() { … }

AnimationNodeBlendTree::AnimationNodeBlendTree() { … }

AnimationNodeBlendTree::~AnimationNodeBlendTree() { … }