godot/scene/animation/animation_mixer.cpp

/**************************************************************************/
/*  animation_mixer.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_mixer.h"
#include "animation_mixer.compat.inc"

#include "core/config/engine.h"
#include "core/config/project_settings.h"
#include "core/string/print_string.h"
#include "core/string/string_name.h"
#include "scene/2d/audio_stream_player_2d.h"
#include "scene/animation/animation_player.h"
#include "scene/audio/audio_stream_player.h"
#include "scene/resources/animation.h"
#include "servers/audio/audio_stream.h"
#include "servers/audio_server.h"

#ifndef _3D_DISABLED
#include "scene/3d/audio_stream_player_3d.h"
#include "scene/3d/mesh_instance_3d.h"
#include "scene/3d/node_3d.h"
#include "scene/3d/skeleton_3d.h"
#include "scene/3d/skeleton_modifier_3d.h"
#endif // _3D_DISABLED

#ifdef TOOLS_ENABLED
#include "editor/editor_node.h"
#include "editor/editor_undo_redo_manager.h"
#endif // TOOLS_ENABLED

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

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

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

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

/* -------------------------------------------- */
/* -- Data lists ------------------------------ */
/* -------------------------------------------- */

void AnimationMixer::_animation_set_cache_update() { … }

void AnimationMixer::_animation_added(const StringName &p_name, const StringName &p_library) { … }

void AnimationMixer::_animation_removed(const StringName &p_name, const StringName &p_library) { … }

void AnimationMixer::_animation_renamed(const StringName &p_name, const StringName &p_to_name, const StringName &p_library) { … }

void AnimationMixer::_animation_changed(const StringName &p_name) { … }

void AnimationMixer::_set_active(bool p_active) { … }

void AnimationMixer::_remove_animation(const StringName &p_name) { … }

void AnimationMixer::_rename_animation(const StringName &p_from_name, const StringName &p_to_name) { … }

TypedArray<StringName> AnimationMixer::_get_animation_library_list() const { … }

void AnimationMixer::get_animation_library_list(List<StringName> *p_libraries) const { … }

Ref<AnimationLibrary> AnimationMixer::get_animation_library(const StringName &p_name) const { … }

bool AnimationMixer::has_animation_library(const StringName &p_name) const { … }

StringName AnimationMixer::get_animation_library_name(const Ref<AnimationLibrary> &p_animation_library) const { … }

StringName AnimationMixer::find_animation_library(const Ref<Animation> &p_animation) const { … }

Error AnimationMixer::add_animation_library(const StringName &p_name, const Ref<AnimationLibrary> &p_animation_library) { … }

void AnimationMixer::remove_animation_library(const StringName &p_name) { … }

void AnimationMixer::rename_animation_library(const StringName &p_name, const StringName &p_new_name) { … }

void AnimationMixer::get_animation_list(List<StringName> *p_animations) const { … }

Ref<Animation> AnimationMixer::get_animation(const StringName &p_name) const { … }

bool AnimationMixer::has_animation(const StringName &p_name) const { … }

StringName AnimationMixer::find_animation(const Ref<Animation> &p_animation) const { … }

/* -------------------------------------------- */
/* -- General settings for animation ---------- */
/* -------------------------------------------- */

void AnimationMixer::_set_process(bool p_process, bool p_force) { … }

void AnimationMixer::set_active(bool p_active) { … }

bool AnimationMixer::is_active() const { … }

void AnimationMixer::set_root_node(const NodePath &p_path) { … }

NodePath AnimationMixer::get_root_node() const { … }

void AnimationMixer::set_deterministic(bool p_deterministic) { … }

bool AnimationMixer::is_deterministic() const { … }

void AnimationMixer::set_callback_mode_process(AnimationCallbackModeProcess p_mode) { … }

AnimationMixer::AnimationCallbackModeProcess AnimationMixer::get_callback_mode_process() const { … }

void AnimationMixer::set_callback_mode_method(AnimationCallbackModeMethod p_mode) { … }

AnimationMixer::AnimationCallbackModeMethod AnimationMixer::get_callback_mode_method() const { … }

void AnimationMixer::set_callback_mode_discrete(AnimationCallbackModeDiscrete p_mode) { … }

AnimationMixer::AnimationCallbackModeDiscrete AnimationMixer::get_callback_mode_discrete() const { … }

void AnimationMixer::set_audio_max_polyphony(int p_audio_max_polyphony) { … }

int AnimationMixer::get_audio_max_polyphony() const { … }

#ifdef TOOLS_ENABLED
void AnimationMixer::set_editing(bool p_editing) { … }

bool AnimationMixer::is_editing() const { … }

void AnimationMixer::set_dummy(bool p_dummy) { … }

bool AnimationMixer::is_dummy() const { … }
#endif // TOOLS_ENABLED

/* -------------------------------------------- */
/* -- Caches for blending --------------------- */
/* -------------------------------------------- */

void AnimationMixer::_clear_caches() { … }

void AnimationMixer::_clear_audio_streams() { … }

void AnimationMixer::_clear_playing_caches() { … }

void AnimationMixer::_init_root_motion_cache() { … }

void AnimationMixer::_create_track_num_to_track_cashe_for_animation(Ref<Animation> &p_animation) { … }

bool AnimationMixer::_update_caches() { … }

/* -------------------------------------------- */
/* -- Blending processor ---------------------- */
/* -------------------------------------------- */

void AnimationMixer::_process_animation(double p_delta, bool p_update_only) { … }

Variant AnimationMixer::_post_process_key_value(const Ref<Animation> &p_anim, int p_track, Variant &p_value, ObjectID p_object_id, int p_object_sub_idx) { … }

Variant AnimationMixer::post_process_key_value(const Ref<Animation> &p_anim, int p_track, Variant p_value, ObjectID p_object_id, int p_object_sub_idx) { … }

void AnimationMixer::_blend_init() { … }

bool AnimationMixer::_blend_pre_process(double p_delta, int p_track_count, const AHashMap<NodePath, int> &p_track_map) { … }

void AnimationMixer::_blend_post_process() { … }

void AnimationMixer::_blend_capture(double p_delta) { … }

void AnimationMixer::blend_capture(double p_delta) { … }

void AnimationMixer::_blend_calc_total_weight() { … }

void AnimationMixer::_blend_process(double p_delta, bool p_update_only) { … }

void AnimationMixer::_blend_apply() { … }

void AnimationMixer::_call_object(ObjectID p_object_id, const StringName &p_method, const Vector<Variant> &p_params, bool p_deferred) { … }

void AnimationMixer::make_animation_instance(const StringName &p_name, const PlaybackInfo p_playback_info) { … }

void AnimationMixer::clear_animation_instances() { … }

void AnimationMixer::advance(double p_time) { … }

void AnimationMixer::clear_caches() { … }

/* -------------------------------------------- */
/* -- Root motion ----------------------------- */
/* -------------------------------------------- */

void AnimationMixer::set_root_motion_track(const NodePath &p_track) { … }

NodePath AnimationMixer::get_root_motion_track() const { … }

void AnimationMixer::set_root_motion_local(bool p_enabled) { … }

bool AnimationMixer::is_root_motion_local() const { … }

Vector3 AnimationMixer::get_root_motion_position() const { … }

Quaternion AnimationMixer::get_root_motion_rotation() const { … }

Vector3 AnimationMixer::get_root_motion_scale() const { … }

Vector3 AnimationMixer::get_root_motion_position_accumulator() const { … }

Quaternion AnimationMixer::get_root_motion_rotation_accumulator() const { … }

Vector3 AnimationMixer::get_root_motion_scale_accumulator() const { … }

/* -------------------------------------------- */
/* -- Reset on save --------------------------- */
/* -------------------------------------------- */

void AnimationMixer::set_reset_on_save_enabled(bool p_enabled) { … }

bool AnimationMixer::is_reset_on_save_enabled() const { … }

bool AnimationMixer::can_apply_reset() const { … }

void AnimationMixer::_build_backup_track_cache() { … }

Ref<AnimatedValuesBackup> AnimationMixer::make_backup() { … }

void AnimationMixer::reset() { … }

void AnimationMixer::restore(const Ref<AnimatedValuesBackup> &p_backup) { … }

#ifdef TOOLS_ENABLED
Ref<AnimatedValuesBackup> AnimationMixer::apply_reset(bool p_user_initiated) { … }
#endif // TOOLS_ENABLED

/* -------------------------------------------- */
/* -- Capture feature ------------------------- */
/* -------------------------------------------- */

void AnimationMixer::capture(const StringName &p_name, double p_duration, Tween::TransitionType p_trans_type, Tween::EaseType p_ease_type) { … }

/* -------------------------------------------- */
/* -- General functions ----------------------- */
/* -------------------------------------------- */

void AnimationMixer::_node_removed(Node *p_node) { … }

void AnimationMixer::_notification(int p_what) { … }

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

void AnimationMixer::_bind_methods() { … }

AnimationMixer::AnimationMixer() { … }

AnimationMixer::~AnimationMixer() { … }

void AnimatedValuesBackup::set_data(const AHashMap<Animation::TypeHash, AnimationMixer::TrackCache *, HashHasher> p_data) { … }

AHashMap<Animation::TypeHash, AnimationMixer::TrackCache *, HashHasher> AnimatedValuesBackup::get_data() const { … }

void AnimatedValuesBackup::clear_data() { … }

AnimationMixer::TrackCache *AnimatedValuesBackup::get_cache_copy(AnimationMixer::TrackCache *p_cache) const { … }