mirror of
https://github.com/godotengine/godot-docs-l10n.git
synced 2026-01-04 10:09:56 +03:00
979 lines
58 KiB
ReStructuredText
979 lines
58 KiB
ReStructuredText
:github_url: hide
|
|
|
|
.. _class_AnimationMixer:
|
|
|
|
AnimationMixer
|
|
==============
|
|
|
|
**Hereda:** :ref:`Node<class_Node>` **<** :ref:`Object<class_Object>`
|
|
|
|
**Heredado por:** :ref:`AnimationPlayer<class_AnimationPlayer>`, :ref:`AnimationTree<class_AnimationTree>`
|
|
|
|
Clase base para :ref:`AnimationPlayer<class_AnimationPlayer>` y :ref:`AnimationTree<class_AnimationTree>`.
|
|
|
|
.. rst-class:: classref-introduction-group
|
|
|
|
Descripción
|
|
----------------------
|
|
|
|
Clase base para :ref:`AnimationPlayer<class_AnimationPlayer>` y :ref:`AnimationTree<class_AnimationTree>` para gestionar listas de animación. También tiene propiedades y métodos generales para la reproducción y la mezcla.
|
|
|
|
Después de instanciar los datos de información de reproducción dentro de la clase extendida, la mezcla es procesada por el **AnimationMixer**.
|
|
|
|
.. rst-class:: classref-introduction-group
|
|
|
|
Tutoriales
|
|
--------------------
|
|
|
|
- `Migración de Animaciones de Godot 4.0 a 4.3 <https://godotengine.org/article/migrating-animations-from-godot-4-0-to-4-3/>`__
|
|
|
|
.. rst-class:: classref-reftable-group
|
|
|
|
Propiedades
|
|
----------------------
|
|
|
|
.. table::
|
|
:widths: auto
|
|
|
|
+-----------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------+--------------------+
|
|
| :ref:`bool<class_bool>` | :ref:`active<class_AnimationMixer_property_active>` | ``true`` |
|
|
+-----------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------+--------------------+
|
|
| :ref:`int<class_int>` | :ref:`audio_max_polyphony<class_AnimationMixer_property_audio_max_polyphony>` | ``32`` |
|
|
+-----------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------+--------------------+
|
|
| :ref:`AnimationCallbackModeDiscrete<enum_AnimationMixer_AnimationCallbackModeDiscrete>` | :ref:`callback_mode_discrete<class_AnimationMixer_property_callback_mode_discrete>` | ``1`` |
|
|
+-----------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------+--------------------+
|
|
| :ref:`AnimationCallbackModeMethod<enum_AnimationMixer_AnimationCallbackModeMethod>` | :ref:`callback_mode_method<class_AnimationMixer_property_callback_mode_method>` | ``0`` |
|
|
+-----------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------+--------------------+
|
|
| :ref:`AnimationCallbackModeProcess<enum_AnimationMixer_AnimationCallbackModeProcess>` | :ref:`callback_mode_process<class_AnimationMixer_property_callback_mode_process>` | ``1`` |
|
|
+-----------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------+--------------------+
|
|
| :ref:`bool<class_bool>` | :ref:`deterministic<class_AnimationMixer_property_deterministic>` | ``false`` |
|
|
+-----------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------+--------------------+
|
|
| :ref:`bool<class_bool>` | :ref:`reset_on_save<class_AnimationMixer_property_reset_on_save>` | ``true`` |
|
|
+-----------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------+--------------------+
|
|
| :ref:`bool<class_bool>` | :ref:`root_motion_local<class_AnimationMixer_property_root_motion_local>` | ``false`` |
|
|
+-----------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------+--------------------+
|
|
| :ref:`NodePath<class_NodePath>` | :ref:`root_motion_track<class_AnimationMixer_property_root_motion_track>` | ``NodePath("")`` |
|
|
+-----------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------+--------------------+
|
|
| :ref:`NodePath<class_NodePath>` | :ref:`root_node<class_AnimationMixer_property_root_node>` | ``NodePath("..")`` |
|
|
+-----------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------+--------------------+
|
|
|
|
.. rst-class:: classref-reftable-group
|
|
|
|
Métodos
|
|
--------------
|
|
|
|
.. table::
|
|
:widths: auto
|
|
|
|
+------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`Variant<class_Variant>` | :ref:`_post_process_key_value<class_AnimationMixer_private_method__post_process_key_value>`\ (\ animation\: :ref:`Animation<class_Animation>`, track\: :ref:`int<class_int>`, value\: :ref:`Variant<class_Variant>`, object_id\: :ref:`int<class_int>`, object_sub_idx\: :ref:`int<class_int>`\ ) |virtual| |const| |
|
|
+------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`Error<enum_@GlobalScope_Error>` | :ref:`add_animation_library<class_AnimationMixer_method_add_animation_library>`\ (\ name\: :ref:`StringName<class_StringName>`, library\: :ref:`AnimationLibrary<class_AnimationLibrary>`\ ) |
|
|
+------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| |void| | :ref:`advance<class_AnimationMixer_method_advance>`\ (\ delta\: :ref:`float<class_float>`\ ) |
|
|
+------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| |void| | :ref:`capture<class_AnimationMixer_method_capture>`\ (\ name\: :ref:`StringName<class_StringName>`, duration\: :ref:`float<class_float>`, trans_type\: :ref:`TransitionType<enum_Tween_TransitionType>` = 0, ease_type\: :ref:`EaseType<enum_Tween_EaseType>` = 0\ ) |
|
|
+------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| |void| | :ref:`clear_caches<class_AnimationMixer_method_clear_caches>`\ (\ ) |
|
|
+------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`StringName<class_StringName>` | :ref:`find_animation<class_AnimationMixer_method_find_animation>`\ (\ animation\: :ref:`Animation<class_Animation>`\ ) |const| |
|
|
+------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`StringName<class_StringName>` | :ref:`find_animation_library<class_AnimationMixer_method_find_animation_library>`\ (\ animation\: :ref:`Animation<class_Animation>`\ ) |const| |
|
|
+------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`Animation<class_Animation>` | :ref:`get_animation<class_AnimationMixer_method_get_animation>`\ (\ name\: :ref:`StringName<class_StringName>`\ ) |const| |
|
|
+------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`AnimationLibrary<class_AnimationLibrary>` | :ref:`get_animation_library<class_AnimationMixer_method_get_animation_library>`\ (\ name\: :ref:`StringName<class_StringName>`\ ) |const| |
|
|
+------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`Array<class_Array>`\[:ref:`StringName<class_StringName>`\] | :ref:`get_animation_library_list<class_AnimationMixer_method_get_animation_library_list>`\ (\ ) |const| |
|
|
+------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`PackedStringArray<class_PackedStringArray>` | :ref:`get_animation_list<class_AnimationMixer_method_get_animation_list>`\ (\ ) |const| |
|
|
+------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`Vector3<class_Vector3>` | :ref:`get_root_motion_position<class_AnimationMixer_method_get_root_motion_position>`\ (\ ) |const| |
|
|
+------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`Vector3<class_Vector3>` | :ref:`get_root_motion_position_accumulator<class_AnimationMixer_method_get_root_motion_position_accumulator>`\ (\ ) |const| |
|
|
+------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`Quaternion<class_Quaternion>` | :ref:`get_root_motion_rotation<class_AnimationMixer_method_get_root_motion_rotation>`\ (\ ) |const| |
|
|
+------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`Quaternion<class_Quaternion>` | :ref:`get_root_motion_rotation_accumulator<class_AnimationMixer_method_get_root_motion_rotation_accumulator>`\ (\ ) |const| |
|
|
+------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`Vector3<class_Vector3>` | :ref:`get_root_motion_scale<class_AnimationMixer_method_get_root_motion_scale>`\ (\ ) |const| |
|
|
+------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`Vector3<class_Vector3>` | :ref:`get_root_motion_scale_accumulator<class_AnimationMixer_method_get_root_motion_scale_accumulator>`\ (\ ) |const| |
|
|
+------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`bool<class_bool>` | :ref:`has_animation<class_AnimationMixer_method_has_animation>`\ (\ name\: :ref:`StringName<class_StringName>`\ ) |const| |
|
|
+------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`bool<class_bool>` | :ref:`has_animation_library<class_AnimationMixer_method_has_animation_library>`\ (\ name\: :ref:`StringName<class_StringName>`\ ) |const| |
|
|
+------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| |void| | :ref:`remove_animation_library<class_AnimationMixer_method_remove_animation_library>`\ (\ name\: :ref:`StringName<class_StringName>`\ ) |
|
|
+------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| |void| | :ref:`rename_animation_library<class_AnimationMixer_method_rename_animation_library>`\ (\ name\: :ref:`StringName<class_StringName>`, newname\: :ref:`StringName<class_StringName>`\ ) |
|
|
+------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
|
|
.. rst-class:: classref-section-separator
|
|
|
|
----
|
|
|
|
.. rst-class:: classref-descriptions-group
|
|
|
|
Señales
|
|
--------------
|
|
|
|
.. _class_AnimationMixer_signal_animation_finished:
|
|
|
|
.. rst-class:: classref-signal
|
|
|
|
**animation_finished**\ (\ anim_name\: :ref:`StringName<class_StringName>`\ ) :ref:`🔗<class_AnimationMixer_signal_animation_finished>`
|
|
|
|
Notifica cuando una animación ha terminado de reproducirse.
|
|
|
|
\ **Nota:** Esta señal no se emite si una animación está en bucle.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_AnimationMixer_signal_animation_libraries_updated:
|
|
|
|
.. rst-class:: classref-signal
|
|
|
|
**animation_libraries_updated**\ (\ ) :ref:`🔗<class_AnimationMixer_signal_animation_libraries_updated>`
|
|
|
|
Notifica cuando las bibliotecas de animación han cambiado.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_AnimationMixer_signal_animation_list_changed:
|
|
|
|
.. rst-class:: classref-signal
|
|
|
|
**animation_list_changed**\ (\ ) :ref:`🔗<class_AnimationMixer_signal_animation_list_changed>`
|
|
|
|
Notifica cuando una lista de animación cambia.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_AnimationMixer_signal_animation_started:
|
|
|
|
.. rst-class:: classref-signal
|
|
|
|
**animation_started**\ (\ anim_name\: :ref:`StringName<class_StringName>`\ ) :ref:`🔗<class_AnimationMixer_signal_animation_started>`
|
|
|
|
Notifica cuando una animación comienza a reproducirse.
|
|
|
|
\ **Nota:** Esta señal no se emite si una animación está en bucle.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_AnimationMixer_signal_caches_cleared:
|
|
|
|
.. rst-class:: classref-signal
|
|
|
|
**caches_cleared**\ (\ ) :ref:`🔗<class_AnimationMixer_signal_caches_cleared>`
|
|
|
|
Notifica cuando las cachés se han limpiado, ya sea automáticamente o manualmente a través del :ref:`clear_caches()<class_AnimationMixer_method_clear_caches>`.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_AnimationMixer_signal_mixer_applied:
|
|
|
|
.. rst-class:: classref-signal
|
|
|
|
**mixer_applied**\ (\ ) :ref:`🔗<class_AnimationMixer_signal_mixer_applied>`
|
|
|
|
Notifica cuando el resultado de la mezcla se ha aplicado a los objetos de destino.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_AnimationMixer_signal_mixer_updated:
|
|
|
|
.. rst-class:: classref-signal
|
|
|
|
**mixer_updated**\ (\ ) :ref:`🔗<class_AnimationMixer_signal_mixer_updated>`
|
|
|
|
Notifica cuando se han actualizado los procesos relacionados con la propiedad.
|
|
|
|
.. rst-class:: classref-section-separator
|
|
|
|
----
|
|
|
|
.. rst-class:: classref-descriptions-group
|
|
|
|
Enumeraciones
|
|
--------------------------
|
|
|
|
.. _enum_AnimationMixer_AnimationCallbackModeProcess:
|
|
|
|
.. rst-class:: classref-enumeration
|
|
|
|
enum **AnimationCallbackModeProcess**: :ref:`🔗<enum_AnimationMixer_AnimationCallbackModeProcess>`
|
|
|
|
.. _class_AnimationMixer_constant_ANIMATION_CALLBACK_MODE_PROCESS_PHYSICS:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`AnimationCallbackModeProcess<enum_AnimationMixer_AnimationCallbackModeProcess>` **ANIMATION_CALLBACK_MODE_PROCESS_PHYSICS** = ``0``
|
|
|
|
Procesa la animación durante los frames de física (véase :ref:`Node.NOTIFICATION_INTERNAL_PHYSICS_PROCESS<class_Node_constant_NOTIFICATION_INTERNAL_PHYSICS_PROCESS>`). Esto es especialmente útil cuando se animan cuerpos físicos.
|
|
|
|
.. _class_AnimationMixer_constant_ANIMATION_CALLBACK_MODE_PROCESS_IDLE:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`AnimationCallbackModeProcess<enum_AnimationMixer_AnimationCallbackModeProcess>` **ANIMATION_CALLBACK_MODE_PROCESS_IDLE** = ``1``
|
|
|
|
Procesa la animación durante los frames de proceso (véase :ref:`Node.NOTIFICATION_INTERNAL_PROCESS<class_Node_constant_NOTIFICATION_INTERNAL_PROCESS>`).
|
|
|
|
.. _class_AnimationMixer_constant_ANIMATION_CALLBACK_MODE_PROCESS_MANUAL:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`AnimationCallbackModeProcess<enum_AnimationMixer_AnimationCallbackModeProcess>` **ANIMATION_CALLBACK_MODE_PROCESS_MANUAL** = ``2``
|
|
|
|
No procesar la animación. Utiliza :ref:`advance()<class_AnimationMixer_method_advance>` para procesar la animación manualmente.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _enum_AnimationMixer_AnimationCallbackModeMethod:
|
|
|
|
.. rst-class:: classref-enumeration
|
|
|
|
enum **AnimationCallbackModeMethod**: :ref:`🔗<enum_AnimationMixer_AnimationCallbackModeMethod>`
|
|
|
|
.. _class_AnimationMixer_constant_ANIMATION_CALLBACK_MODE_METHOD_DEFERRED:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`AnimationCallbackModeMethod<enum_AnimationMixer_AnimationCallbackModeMethod>` **ANIMATION_CALLBACK_MODE_METHOD_DEFERRED** = ``0``
|
|
|
|
Metodos de procesos por lotes llamados durante el proceso de animación, y despues que los eventos son procesados hacer los llamados. Esto evita los errores que implican borrar nodos o modificar el AnimationPlayer mientras se está reproduciendo.
|
|
|
|
.. _class_AnimationMixer_constant_ANIMATION_CALLBACK_MODE_METHOD_IMMEDIATE:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`AnimationCallbackModeMethod<enum_AnimationMixer_AnimationCallbackModeMethod>` **ANIMATION_CALLBACK_MODE_METHOD_IMMEDIATE** = ``1``
|
|
|
|
Hace llamadas a método inmediatamente cuando se alcanza en la animación.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _enum_AnimationMixer_AnimationCallbackModeDiscrete:
|
|
|
|
.. rst-class:: classref-enumeration
|
|
|
|
enum **AnimationCallbackModeDiscrete**: :ref:`🔗<enum_AnimationMixer_AnimationCallbackModeDiscrete>`
|
|
|
|
.. _class_AnimationMixer_constant_ANIMATION_CALLBACK_MODE_DISCRETE_DOMINANT:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`AnimationCallbackModeDiscrete<enum_AnimationMixer_AnimationCallbackModeDiscrete>` **ANIMATION_CALLBACK_MODE_DISCRETE_DOMINANT** = ``0``
|
|
|
|
Un valor de pista :ref:`Animation.UPDATE_DISCRETE<class_Animation_constant_UPDATE_DISCRETE>` tiene prioridad al mezclar valores de pista :ref:`Animation.UPDATE_CONTINUOUS<class_Animation_constant_UPDATE_CONTINUOUS>` o :ref:`Animation.UPDATE_CAPTURE<class_Animation_constant_UPDATE_CAPTURE>` y valores de pista :ref:`Animation.UPDATE_DISCRETE<class_Animation_constant_UPDATE_DISCRETE>`.
|
|
|
|
.. _class_AnimationMixer_constant_ANIMATION_CALLBACK_MODE_DISCRETE_RECESSIVE:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`AnimationCallbackModeDiscrete<enum_AnimationMixer_AnimationCallbackModeDiscrete>` **ANIMATION_CALLBACK_MODE_DISCRETE_RECESSIVE** = ``1``
|
|
|
|
Un valor de pista :ref:`Animation.UPDATE_CONTINUOUS<class_Animation_constant_UPDATE_CONTINUOUS>` o :ref:`Animation.UPDATE_CAPTURE<class_Animation_constant_UPDATE_CAPTURE>` tiene prioridad al mezclar los valores de pista :ref:`Animation.UPDATE_CONTINUOUS<class_Animation_constant_UPDATE_CONTINUOUS>` o :ref:`Animation.UPDATE_CAPTURE<class_Animation_constant_UPDATE_CAPTURE>` y los valores de pista :ref:`Animation.UPDATE_DISCRETE<class_Animation_constant_UPDATE_DISCRETE>`. Este es el comportamiento predeterminado para :ref:`AnimationPlayer<class_AnimationPlayer>`.
|
|
|
|
.. _class_AnimationMixer_constant_ANIMATION_CALLBACK_MODE_DISCRETE_FORCE_CONTINUOUS:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`AnimationCallbackModeDiscrete<enum_AnimationMixer_AnimationCallbackModeDiscrete>` **ANIMATION_CALLBACK_MODE_DISCRETE_FORCE_CONTINUOUS** = ``2``
|
|
|
|
Always treat the :ref:`Animation.UPDATE_DISCRETE<class_Animation_constant_UPDATE_DISCRETE>` track value as :ref:`Animation.UPDATE_CONTINUOUS<class_Animation_constant_UPDATE_CONTINUOUS>` with :ref:`Animation.INTERPOLATION_NEAREST<class_Animation_constant_INTERPOLATION_NEAREST>`. This is the default behavior for :ref:`AnimationTree<class_AnimationTree>`.
|
|
|
|
If a value track has un-interpolatable type key values, it is internally converted to use :ref:`ANIMATION_CALLBACK_MODE_DISCRETE_RECESSIVE<class_AnimationMixer_constant_ANIMATION_CALLBACK_MODE_DISCRETE_RECESSIVE>` with :ref:`Animation.UPDATE_DISCRETE<class_Animation_constant_UPDATE_DISCRETE>`.
|
|
|
|
Un-interpolatable type list:
|
|
|
|
- :ref:`@GlobalScope.TYPE_NIL<class_@GlobalScope_constant_TYPE_NIL>`\
|
|
|
|
- :ref:`@GlobalScope.TYPE_NODE_PATH<class_@GlobalScope_constant_TYPE_NODE_PATH>`\
|
|
|
|
- :ref:`@GlobalScope.TYPE_RID<class_@GlobalScope_constant_TYPE_RID>`\
|
|
|
|
- :ref:`@GlobalScope.TYPE_OBJECT<class_@GlobalScope_constant_TYPE_OBJECT>`\
|
|
|
|
- :ref:`@GlobalScope.TYPE_CALLABLE<class_@GlobalScope_constant_TYPE_CALLABLE>`\
|
|
|
|
- :ref:`@GlobalScope.TYPE_SIGNAL<class_@GlobalScope_constant_TYPE_SIGNAL>`\
|
|
|
|
- :ref:`@GlobalScope.TYPE_DICTIONARY<class_@GlobalScope_constant_TYPE_DICTIONARY>`\
|
|
|
|
- :ref:`@GlobalScope.TYPE_PACKED_BYTE_ARRAY<class_@GlobalScope_constant_TYPE_PACKED_BYTE_ARRAY>`\
|
|
|
|
\ :ref:`@GlobalScope.TYPE_BOOL<class_@GlobalScope_constant_TYPE_BOOL>` and :ref:`@GlobalScope.TYPE_INT<class_@GlobalScope_constant_TYPE_INT>` are treated as :ref:`@GlobalScope.TYPE_FLOAT<class_@GlobalScope_constant_TYPE_FLOAT>` during blending and rounded when the result is retrieved.
|
|
|
|
It is same for arrays and vectors with them such as :ref:`@GlobalScope.TYPE_PACKED_INT32_ARRAY<class_@GlobalScope_constant_TYPE_PACKED_INT32_ARRAY>` or :ref:`@GlobalScope.TYPE_VECTOR2I<class_@GlobalScope_constant_TYPE_VECTOR2I>`, they are treated as :ref:`@GlobalScope.TYPE_PACKED_FLOAT32_ARRAY<class_@GlobalScope_constant_TYPE_PACKED_FLOAT32_ARRAY>` or :ref:`@GlobalScope.TYPE_VECTOR2<class_@GlobalScope_constant_TYPE_VECTOR2>`. Also note that for arrays, the size is also interpolated.
|
|
|
|
\ :ref:`@GlobalScope.TYPE_STRING<class_@GlobalScope_constant_TYPE_STRING>` and :ref:`@GlobalScope.TYPE_STRING_NAME<class_@GlobalScope_constant_TYPE_STRING_NAME>` are interpolated between character codes and lengths, but note that there is a difference in algorithm between interpolation between keys and interpolation by blending.
|
|
|
|
.. rst-class:: classref-section-separator
|
|
|
|
----
|
|
|
|
.. rst-class:: classref-descriptions-group
|
|
|
|
Descripciones de Propiedades
|
|
--------------------------------------------------------
|
|
|
|
.. _class_AnimationMixer_property_active:
|
|
|
|
.. rst-class:: classref-property
|
|
|
|
:ref:`bool<class_bool>` **active** = ``true`` :ref:`🔗<class_AnimationMixer_property_active>`
|
|
|
|
.. rst-class:: classref-property-setget
|
|
|
|
- |void| **set_active**\ (\ value\: :ref:`bool<class_bool>`\ )
|
|
- :ref:`bool<class_bool>` **is_active**\ (\ )
|
|
|
|
Si es ``true``, el **AnimationMixer** estará procesando.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_AnimationMixer_property_audio_max_polyphony:
|
|
|
|
.. rst-class:: classref-property
|
|
|
|
:ref:`int<class_int>` **audio_max_polyphony** = ``32`` :ref:`🔗<class_AnimationMixer_property_audio_max_polyphony>`
|
|
|
|
.. rst-class:: classref-property-setget
|
|
|
|
- |void| **set_audio_max_polyphony**\ (\ value\: :ref:`int<class_int>`\ )
|
|
- :ref:`int<class_int>` **get_audio_max_polyphony**\ (\ )
|
|
|
|
El número de sonidos simultáneos posibles para cada uno de los AudioStreamPlayers asignados.
|
|
|
|
Por ejemplo, si este valor es ``32`` y la animación tiene dos pistas de audio, los dos :ref:`AudioStreamPlayer<class_AudioStreamPlayer>` asignados pueden reproducir simultáneamente hasta ``32`` voces cada uno.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_AnimationMixer_property_callback_mode_discrete:
|
|
|
|
.. rst-class:: classref-property
|
|
|
|
:ref:`AnimationCallbackModeDiscrete<enum_AnimationMixer_AnimationCallbackModeDiscrete>` **callback_mode_discrete** = ``1`` :ref:`🔗<class_AnimationMixer_property_callback_mode_discrete>`
|
|
|
|
.. rst-class:: classref-property-setget
|
|
|
|
- |void| **set_callback_mode_discrete**\ (\ value\: :ref:`AnimationCallbackModeDiscrete<enum_AnimationMixer_AnimationCallbackModeDiscrete>`\ )
|
|
- :ref:`AnimationCallbackModeDiscrete<enum_AnimationMixer_AnimationCallbackModeDiscrete>` **get_callback_mode_discrete**\ (\ )
|
|
|
|
Ordinarily, tracks can be set to :ref:`Animation.UPDATE_DISCRETE<class_Animation_constant_UPDATE_DISCRETE>` to update infrequently, usually when using nearest interpolation.
|
|
|
|
However, when blending with :ref:`Animation.UPDATE_CONTINUOUS<class_Animation_constant_UPDATE_CONTINUOUS>` several results are considered. The :ref:`callback_mode_discrete<class_AnimationMixer_property_callback_mode_discrete>` specify it explicitly. See also :ref:`AnimationCallbackModeDiscrete<enum_AnimationMixer_AnimationCallbackModeDiscrete>`.
|
|
|
|
To make the blended results look good, it is recommended to set this to :ref:`ANIMATION_CALLBACK_MODE_DISCRETE_FORCE_CONTINUOUS<class_AnimationMixer_constant_ANIMATION_CALLBACK_MODE_DISCRETE_FORCE_CONTINUOUS>` to update every frame during blending. Other values exist for compatibility and they are fine if there is no blending, but not so, may produce artifacts.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_AnimationMixer_property_callback_mode_method:
|
|
|
|
.. rst-class:: classref-property
|
|
|
|
:ref:`AnimationCallbackModeMethod<enum_AnimationMixer_AnimationCallbackModeMethod>` **callback_mode_method** = ``0`` :ref:`🔗<class_AnimationMixer_property_callback_mode_method>`
|
|
|
|
.. rst-class:: classref-property-setget
|
|
|
|
- |void| **set_callback_mode_method**\ (\ value\: :ref:`AnimationCallbackModeMethod<enum_AnimationMixer_AnimationCallbackModeMethod>`\ )
|
|
- :ref:`AnimationCallbackModeMethod<enum_AnimationMixer_AnimationCallbackModeMethod>` **get_callback_mode_method**\ (\ )
|
|
|
|
The call mode used for "Call Method" tracks.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_AnimationMixer_property_callback_mode_process:
|
|
|
|
.. rst-class:: classref-property
|
|
|
|
:ref:`AnimationCallbackModeProcess<enum_AnimationMixer_AnimationCallbackModeProcess>` **callback_mode_process** = ``1`` :ref:`🔗<class_AnimationMixer_property_callback_mode_process>`
|
|
|
|
.. rst-class:: classref-property-setget
|
|
|
|
- |void| **set_callback_mode_process**\ (\ value\: :ref:`AnimationCallbackModeProcess<enum_AnimationMixer_AnimationCallbackModeProcess>`\ )
|
|
- :ref:`AnimationCallbackModeProcess<enum_AnimationMixer_AnimationCallbackModeProcess>` **get_callback_mode_process**\ (\ )
|
|
|
|
La notificación de proceso en la que se actualizan las animaciones.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_AnimationMixer_property_deterministic:
|
|
|
|
.. rst-class:: classref-property
|
|
|
|
:ref:`bool<class_bool>` **deterministic** = ``false`` :ref:`🔗<class_AnimationMixer_property_deterministic>`
|
|
|
|
.. rst-class:: classref-property-setget
|
|
|
|
- |void| **set_deterministic**\ (\ value\: :ref:`bool<class_bool>`\ )
|
|
- :ref:`bool<class_bool>` **is_deterministic**\ (\ )
|
|
|
|
If ``true``, the blending uses the deterministic algorithm. The total weight is not normalized and the result is accumulated with an initial value (``0`` or a ``"RESET"`` animation if present).
|
|
|
|
This means that if the total amount of blending is ``0.0``, the result is equal to the ``"RESET"`` animation.
|
|
|
|
If the number of tracks between the blended animations is different, the animation with the missing track is treated as if it had the initial value.
|
|
|
|
If ``false``, The blend does not use the deterministic algorithm. The total weight is normalized and always ``1.0``. If the number of tracks between the blended animations is different, nothing is done about the animation that is missing a track.
|
|
|
|
\ **Note:** In :ref:`AnimationTree<class_AnimationTree>`, the blending with :ref:`AnimationNodeAdd2<class_AnimationNodeAdd2>`, :ref:`AnimationNodeAdd3<class_AnimationNodeAdd3>`, :ref:`AnimationNodeSub2<class_AnimationNodeSub2>` or the weight greater than ``1.0`` may produce unexpected results.
|
|
|
|
For example, if :ref:`AnimationNodeAdd2<class_AnimationNodeAdd2>` blends two nodes with the amount ``1.0``, then total weight is ``2.0`` but it will be normalized to make the total amount ``1.0`` and the result will be equal to :ref:`AnimationNodeBlend2<class_AnimationNodeBlend2>` with the amount ``0.5``.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_AnimationMixer_property_reset_on_save:
|
|
|
|
.. rst-class:: classref-property
|
|
|
|
:ref:`bool<class_bool>` **reset_on_save** = ``true`` :ref:`🔗<class_AnimationMixer_property_reset_on_save>`
|
|
|
|
.. rst-class:: classref-property-setget
|
|
|
|
- |void| **set_reset_on_save_enabled**\ (\ value\: :ref:`bool<class_bool>`\ )
|
|
- :ref:`bool<class_bool>` **is_reset_on_save_enabled**\ (\ )
|
|
|
|
Esto lo utiliza el editor. Si se establece en ``true``, la escena se guardará con los efectos de la animación de reinicio (la animación con la clave ``"RESET"``) aplicada como si se hubiera buscado hasta el tiempo 0, y el editor conservará los valores que la escena tenía antes de guardar.
|
|
|
|
Esto hace que sea más conveniente previsualizar y editar animaciones en el editor, ya que los cambios en la escena no se guardarán mientras estén establecidos en la animación de reinicio.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_AnimationMixer_property_root_motion_local:
|
|
|
|
.. rst-class:: classref-property
|
|
|
|
:ref:`bool<class_bool>` **root_motion_local** = ``false`` :ref:`🔗<class_AnimationMixer_property_root_motion_local>`
|
|
|
|
.. rst-class:: classref-property-setget
|
|
|
|
- |void| **set_root_motion_local**\ (\ value\: :ref:`bool<class_bool>`\ )
|
|
- :ref:`bool<class_bool>` **is_root_motion_local**\ (\ )
|
|
|
|
Si es ``true``, el valor de :ref:`get_root_motion_position()<class_AnimationMixer_method_get_root_motion_position>` se extrae como un valor de traslación local antes de la mezcla. En otras palabras, se trata como si la traslación se hiciera después de la rotación.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_AnimationMixer_property_root_motion_track:
|
|
|
|
.. rst-class:: classref-property
|
|
|
|
:ref:`NodePath<class_NodePath>` **root_motion_track** = ``NodePath("")`` :ref:`🔗<class_AnimationMixer_property_root_motion_track>`
|
|
|
|
.. rst-class:: classref-property-setget
|
|
|
|
- |void| **set_root_motion_track**\ (\ value\: :ref:`NodePath<class_NodePath>`\ )
|
|
- :ref:`NodePath<class_NodePath>` **get_root_motion_track**\ (\ )
|
|
|
|
The path to the Animation track used for root motion. Paths must be valid scene-tree paths to a node, and must be specified starting from the parent node of the node that will reproduce the animation. The :ref:`root_motion_track<class_AnimationMixer_property_root_motion_track>` uses the same format as :ref:`Animation.track_set_path()<class_Animation_method_track_set_path>`, but note that a bone must be specified.
|
|
|
|
If the track has type :ref:`Animation.TYPE_POSITION_3D<class_Animation_constant_TYPE_POSITION_3D>`, :ref:`Animation.TYPE_ROTATION_3D<class_Animation_constant_TYPE_ROTATION_3D>`, or :ref:`Animation.TYPE_SCALE_3D<class_Animation_constant_TYPE_SCALE_3D>` the transformation will be canceled visually, and the animation will appear to stay in place. See also :ref:`get_root_motion_position()<class_AnimationMixer_method_get_root_motion_position>`, :ref:`get_root_motion_rotation()<class_AnimationMixer_method_get_root_motion_rotation>`, :ref:`get_root_motion_scale()<class_AnimationMixer_method_get_root_motion_scale>`, and :ref:`RootMotionView<class_RootMotionView>`.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_AnimationMixer_property_root_node:
|
|
|
|
.. rst-class:: classref-property
|
|
|
|
:ref:`NodePath<class_NodePath>` **root_node** = ``NodePath("..")`` :ref:`🔗<class_AnimationMixer_property_root_node>`
|
|
|
|
.. rst-class:: classref-property-setget
|
|
|
|
- |void| **set_root_node**\ (\ value\: :ref:`NodePath<class_NodePath>`\ )
|
|
- :ref:`NodePath<class_NodePath>` **get_root_node**\ (\ )
|
|
|
|
El nodo desde el cual viajarán las referencias de la ruta del nodo.
|
|
|
|
.. rst-class:: classref-section-separator
|
|
|
|
----
|
|
|
|
.. rst-class:: classref-descriptions-group
|
|
|
|
Descripciones de Métodos
|
|
------------------------------------------------
|
|
|
|
.. _class_AnimationMixer_private_method__post_process_key_value:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`Variant<class_Variant>` **_post_process_key_value**\ (\ animation\: :ref:`Animation<class_Animation>`, track\: :ref:`int<class_int>`, value\: :ref:`Variant<class_Variant>`, object_id\: :ref:`int<class_int>`, object_sub_idx\: :ref:`int<class_int>`\ ) |virtual| |const| :ref:`🔗<class_AnimationMixer_private_method__post_process_key_value>`
|
|
|
|
Una función virtual para procesar después de obtener una clave durante la reproducción.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_AnimationMixer_method_add_animation_library:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`Error<enum_@GlobalScope_Error>` **add_animation_library**\ (\ name\: :ref:`StringName<class_StringName>`, library\: :ref:`AnimationLibrary<class_AnimationLibrary>`\ ) :ref:`🔗<class_AnimationMixer_method_add_animation_library>`
|
|
|
|
Añade ``library`` al reproductor de animación, bajo la clave ``name``.
|
|
|
|
AnimationMixer tiene una biblioteca global por defecto con una string vacía como clave. Para añadir una animación a la biblioteca global:
|
|
|
|
|
|
.. tabs::
|
|
|
|
.. code-tab:: gdscript
|
|
|
|
var global_library = mixer.get_animation_library("")
|
|
global_library.add_animation("animation_name", animation_resource)
|
|
|
|
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_AnimationMixer_method_advance:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
|void| **advance**\ (\ delta\: :ref:`float<class_float>`\ ) :ref:`🔗<class_AnimationMixer_method_advance>`
|
|
|
|
Avanza manualmente las animaciones en el tiempo especificado (en segundos).
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_AnimationMixer_method_capture:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
|void| **capture**\ (\ name\: :ref:`StringName<class_StringName>`, duration\: :ref:`float<class_float>`, trans_type\: :ref:`TransitionType<enum_Tween_TransitionType>` = 0, ease_type\: :ref:`EaseType<enum_Tween_EaseType>` = 0\ ) :ref:`🔗<class_AnimationMixer_method_capture>`
|
|
|
|
Si la pista de animación especificada por ``name`` tiene una opción :ref:`Animation.UPDATE_CAPTURE<class_Animation_constant_UPDATE_CAPTURE>`, almacena los valores actuales de los objetos indicados por la ruta de la pista como una caché. Si ya existe una caché capturada, la caché anterior se descarta.
|
|
|
|
Después de esto, se interpolará con el resultado actual de la mezcla de animación durante el proceso de reproducción durante el tiempo especificado por ``duration``, funcionando como un fundido cruzado.
|
|
|
|
Puedes especificar ``trans_type`` como la curva para la interpolación. Para obtener mejores resultados, puede ser apropiado especificar :ref:`Tween.TRANS_LINEAR<class_Tween_constant_TRANS_LINEAR>` para los casos en que la primera clave de la pista comience con un valor distinto de cero o donde el valor de la clave no cambie, y :ref:`Tween.TRANS_QUAD<class_Tween_constant_TRANS_QUAD>` para los casos en que el valor de la clave cambie linealmente.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_AnimationMixer_method_clear_caches:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
|void| **clear_caches**\ (\ ) :ref:`🔗<class_AnimationMixer_method_clear_caches>`
|
|
|
|
**AnimationMixer** guarda en caché los nodos animados. Es posible que no note si un nodo desaparece; :ref:`clear_caches()<class_AnimationMixer_method_clear_caches>` fuerza a actualizar la caché de nuevo.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_AnimationMixer_method_find_animation:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`StringName<class_StringName>` **find_animation**\ (\ animation\: :ref:`Animation<class_Animation>`\ ) |const| :ref:`🔗<class_AnimationMixer_method_find_animation>`
|
|
|
|
Devuelve la clave de ``animation`` o un :ref:`StringName<class_StringName>` vacío si no se encuentra.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_AnimationMixer_method_find_animation_library:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`StringName<class_StringName>` **find_animation_library**\ (\ animation\: :ref:`Animation<class_Animation>`\ ) |const| :ref:`🔗<class_AnimationMixer_method_find_animation_library>`
|
|
|
|
Devuelve la clave de la :ref:`AnimationLibrary<class_AnimationLibrary>` que contiene ``animation`` o un :ref:`StringName<class_StringName>` vacío si no se encuentra.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_AnimationMixer_method_get_animation:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`Animation<class_Animation>` **get_animation**\ (\ name\: :ref:`StringName<class_StringName>`\ ) |const| :ref:`🔗<class_AnimationMixer_method_get_animation>`
|
|
|
|
Devuelve la :ref:`Animation<class_Animation>` con la clave ``name``. Si la animación no existe, se devuelve ``null`` y se registra un error.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_AnimationMixer_method_get_animation_library:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`AnimationLibrary<class_AnimationLibrary>` **get_animation_library**\ (\ name\: :ref:`StringName<class_StringName>`\ ) |const| :ref:`🔗<class_AnimationMixer_method_get_animation_library>`
|
|
|
|
Devuelve la primera :ref:`AnimationLibrary<class_AnimationLibrary>` con la clave ``name`` o ``null`` si no se encuentra.
|
|
|
|
Para obtener la biblioteca de animación global de **AnimationMixer**, utiliza ``get_animation_library("")``.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_AnimationMixer_method_get_animation_library_list:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`Array<class_Array>`\[:ref:`StringName<class_StringName>`\] **get_animation_library_list**\ (\ ) |const| :ref:`🔗<class_AnimationMixer_method_get_animation_library_list>`
|
|
|
|
Devuelve la lista de claves de biblioteca almacenadas.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_AnimationMixer_method_get_animation_list:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`PackedStringArray<class_PackedStringArray>` **get_animation_list**\ (\ ) |const| :ref:`🔗<class_AnimationMixer_method_get_animation_list>`
|
|
|
|
Devuelve la lista de claves de animación almacenadas.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_AnimationMixer_method_get_root_motion_position:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`Vector3<class_Vector3>` **get_root_motion_position**\ (\ ) |const| :ref:`🔗<class_AnimationMixer_method_get_root_motion_position>`
|
|
|
|
Retrieve the motion delta of position with the :ref:`root_motion_track<class_AnimationMixer_property_root_motion_track>` as a :ref:`Vector3<class_Vector3>` that can be used elsewhere.
|
|
|
|
If :ref:`root_motion_track<class_AnimationMixer_property_root_motion_track>` is not a path to a track of type :ref:`Animation.TYPE_POSITION_3D<class_Animation_constant_TYPE_POSITION_3D>`, returns ``Vector3(0, 0, 0)``.
|
|
|
|
See also :ref:`root_motion_track<class_AnimationMixer_property_root_motion_track>` and :ref:`RootMotionView<class_RootMotionView>`.
|
|
|
|
The most basic example is applying position to :ref:`CharacterBody3D<class_CharacterBody3D>`:
|
|
|
|
|
|
.. tabs::
|
|
|
|
.. code-tab:: gdscript
|
|
|
|
var current_rotation
|
|
|
|
func _process(delta):
|
|
if Input.is_action_just_pressed("animate"):
|
|
current_rotation = get_quaternion()
|
|
state_machine.travel("Animate")
|
|
var velocity = current_rotation * animation_tree.get_root_motion_position() / delta
|
|
set_velocity(velocity)
|
|
move_and_slide()
|
|
|
|
|
|
|
|
By using this in combination with :ref:`get_root_motion_rotation_accumulator()<class_AnimationMixer_method_get_root_motion_rotation_accumulator>`, you can apply the root motion position more correctly to account for the rotation of the node.
|
|
|
|
|
|
.. tabs::
|
|
|
|
.. code-tab:: gdscript
|
|
|
|
func _process(delta):
|
|
if Input.is_action_just_pressed("animate"):
|
|
state_machine.travel("Animate")
|
|
set_quaternion(get_quaternion() * animation_tree.get_root_motion_rotation())
|
|
var velocity = (animation_tree.get_root_motion_rotation_accumulator().inverse() * get_quaternion()) * animation_tree.get_root_motion_position() / delta
|
|
set_velocity(velocity)
|
|
move_and_slide()
|
|
|
|
|
|
|
|
If :ref:`root_motion_local<class_AnimationMixer_property_root_motion_local>` is ``true``, returns the pre-multiplied translation value with the inverted rotation.
|
|
|
|
In this case, the code can be written as follows:
|
|
|
|
|
|
.. tabs::
|
|
|
|
.. code-tab:: gdscript
|
|
|
|
func _process(delta):
|
|
if Input.is_action_just_pressed("animate"):
|
|
state_machine.travel("Animate")
|
|
set_quaternion(get_quaternion() * animation_tree.get_root_motion_rotation())
|
|
var velocity = get_quaternion() * animation_tree.get_root_motion_position() / delta
|
|
set_velocity(velocity)
|
|
move_and_slide()
|
|
|
|
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_AnimationMixer_method_get_root_motion_position_accumulator:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`Vector3<class_Vector3>` **get_root_motion_position_accumulator**\ (\ ) |const| :ref:`🔗<class_AnimationMixer_method_get_root_motion_position_accumulator>`
|
|
|
|
Retrieve the blended value of the position tracks with the :ref:`root_motion_track<class_AnimationMixer_property_root_motion_track>` as a :ref:`Vector3<class_Vector3>` that can be used elsewhere.
|
|
|
|
This is useful in cases where you want to respect the initial key values of the animation.
|
|
|
|
For example, if an animation with only one key ``Vector3(0, 0, 0)`` is played in the previous frame and then an animation with only one key ``Vector3(1, 0, 1)`` is played in the next frame, the difference can be calculated as follows:
|
|
|
|
|
|
.. tabs::
|
|
|
|
.. code-tab:: gdscript
|
|
|
|
var prev_root_motion_position_accumulator
|
|
|
|
func _process(delta):
|
|
if Input.is_action_just_pressed("animate"):
|
|
state_machine.travel("Animate")
|
|
var current_root_motion_position_accumulator = animation_tree.get_root_motion_position_accumulator()
|
|
var difference = current_root_motion_position_accumulator - prev_root_motion_position_accumulator
|
|
prev_root_motion_position_accumulator = current_root_motion_position_accumulator
|
|
transform.origin += difference
|
|
|
|
|
|
|
|
However, if the animation loops, an unintended discrete change may occur, so this is only useful for some simple use cases.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_AnimationMixer_method_get_root_motion_rotation:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`Quaternion<class_Quaternion>` **get_root_motion_rotation**\ (\ ) |const| :ref:`🔗<class_AnimationMixer_method_get_root_motion_rotation>`
|
|
|
|
Recupera el delta de movimiento de rotación con :ref:`root_motion_track<class_AnimationMixer_property_root_motion_track>` como un :ref:`Quaternion<class_Quaternion>` que puede ser usado en otro lugar.
|
|
|
|
Si :ref:`root_motion_track<class_AnimationMixer_property_root_motion_track>` no es una ruta a una pista de tipo :ref:`Animation.TYPE_ROTATION_3D<class_Animation_constant_TYPE_ROTATION_3D>`, devuelve ``Quaternion(0, 0, 0, 1)``.
|
|
|
|
Véase también :ref:`root_motion_track<class_AnimationMixer_property_root_motion_track>` y :ref:`RootMotionView<class_RootMotionView>`.
|
|
|
|
El ejemplo más básico es aplicar la rotación a :ref:`CharacterBody3D<class_CharacterBody3D>`:
|
|
|
|
|
|
.. tabs::
|
|
|
|
.. code-tab:: gdscript
|
|
|
|
func _process(delta):
|
|
if Input.is_action_just_pressed("animate"):
|
|
state_machine.travel("Animate")
|
|
set_quaternion(get_quaternion() * animation_tree.get_root_motion_rotation())
|
|
|
|
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_AnimationMixer_method_get_root_motion_rotation_accumulator:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`Quaternion<class_Quaternion>` **get_root_motion_rotation_accumulator**\ (\ ) |const| :ref:`🔗<class_AnimationMixer_method_get_root_motion_rotation_accumulator>`
|
|
|
|
Retrieve the blended value of the rotation tracks with the :ref:`root_motion_track<class_AnimationMixer_property_root_motion_track>` as a :ref:`Quaternion<class_Quaternion>` that can be used elsewhere.
|
|
|
|
This is necessary to apply the root motion position correctly, taking rotation into account. See also :ref:`get_root_motion_position()<class_AnimationMixer_method_get_root_motion_position>`.
|
|
|
|
Also, this is useful in cases where you want to respect the initial key values of the animation.
|
|
|
|
For example, if an animation with only one key ``Quaternion(0, 0, 0, 1)`` is played in the previous frame and then an animation with only one key ``Quaternion(0, 0.707, 0, 0.707)`` is played in the next frame, the difference can be calculated as follows:
|
|
|
|
|
|
.. tabs::
|
|
|
|
.. code-tab:: gdscript
|
|
|
|
var prev_root_motion_rotation_accumulator
|
|
|
|
func _process(delta):
|
|
if Input.is_action_just_pressed("animate"):
|
|
state_machine.travel("Animate")
|
|
var current_root_motion_rotation_accumulator = animation_tree.get_root_motion_rotation_accumulator()
|
|
var difference = prev_root_motion_rotation_accumulator.inverse() * current_root_motion_rotation_accumulator
|
|
prev_root_motion_rotation_accumulator = current_root_motion_rotation_accumulator
|
|
transform.basis *= Basis(difference)
|
|
|
|
|
|
|
|
However, if the animation loops, an unintended discrete change may occur, so this is only useful for some simple use cases.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_AnimationMixer_method_get_root_motion_scale:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`Vector3<class_Vector3>` **get_root_motion_scale**\ (\ ) |const| :ref:`🔗<class_AnimationMixer_method_get_root_motion_scale>`
|
|
|
|
Recupera el delta de movimiento de la escala con :ref:`root_motion_track<class_AnimationMixer_property_root_motion_track>` como un :ref:`Vector3<class_Vector3>` que puede ser usado en otro lugar.
|
|
|
|
Si :ref:`root_motion_track<class_AnimationMixer_property_root_motion_track>` no es una ruta a una pista de tipo :ref:`Animation.TYPE_SCALE_3D<class_Animation_constant_TYPE_SCALE_3D>`, devuelve ``Vector3(0, 0, 0)``.
|
|
|
|
Véase también :ref:`root_motion_track<class_AnimationMixer_property_root_motion_track>` y :ref:`RootMotionView<class_RootMotionView>`.
|
|
|
|
El ejemplo más básico es aplicar la escala a :ref:`CharacterBody3D<class_CharacterBody3D>`:
|
|
|
|
|
|
.. tabs::
|
|
|
|
.. code-tab:: gdscript
|
|
|
|
var current_scale = Vector3(1, 1, 1)
|
|
var scale_accum = Vector3(1, 1, 1)
|
|
|
|
func _process(delta):
|
|
if Input.is_action_just_pressed("animate"):
|
|
current_scale = get_scale()
|
|
scale_accum = Vector3(1, 1, 1)
|
|
state_machine.travel("Animate")
|
|
scale_accum += animation_tree.get_root_motion_scale()
|
|
set_scale(current_scale * scale_accum)
|
|
|
|
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_AnimationMixer_method_get_root_motion_scale_accumulator:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`Vector3<class_Vector3>` **get_root_motion_scale_accumulator**\ (\ ) |const| :ref:`🔗<class_AnimationMixer_method_get_root_motion_scale_accumulator>`
|
|
|
|
Retrieve the blended value of the scale tracks with the :ref:`root_motion_track<class_AnimationMixer_property_root_motion_track>` as a :ref:`Vector3<class_Vector3>` that can be used elsewhere.
|
|
|
|
For example, if an animation with only one key ``Vector3(1, 1, 1)`` is played in the previous frame and then an animation with only one key ``Vector3(2, 2, 2)`` is played in the next frame, the difference can be calculated as follows:
|
|
|
|
|
|
.. tabs::
|
|
|
|
.. code-tab:: gdscript
|
|
|
|
var prev_root_motion_scale_accumulator
|
|
|
|
func _process(delta):
|
|
if Input.is_action_just_pressed("animate"):
|
|
state_machine.travel("Animate")
|
|
var current_root_motion_scale_accumulator = animation_tree.get_root_motion_scale_accumulator()
|
|
var difference = current_root_motion_scale_accumulator - prev_root_motion_scale_accumulator
|
|
prev_root_motion_scale_accumulator = current_root_motion_scale_accumulator
|
|
transform.basis = transform.basis.scaled(difference)
|
|
|
|
|
|
|
|
However, if the animation loops, an unintended discrete change may occur, so this is only useful for some simple use cases.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_AnimationMixer_method_has_animation:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`bool<class_bool>` **has_animation**\ (\ name\: :ref:`StringName<class_StringName>`\ ) |const| :ref:`🔗<class_AnimationMixer_method_has_animation>`
|
|
|
|
Devuelve ``true`` si el **AnimationMixer** almacena una :ref:`Animation<class_Animation>` con la clave ``name``.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_AnimationMixer_method_has_animation_library:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`bool<class_bool>` **has_animation_library**\ (\ name\: :ref:`StringName<class_StringName>`\ ) |const| :ref:`🔗<class_AnimationMixer_method_has_animation_library>`
|
|
|
|
Devuelve ``true`` si el **AnimationMixer** almacena una :ref:`AnimationLibrary<class_AnimationLibrary>` con la clave ``name``.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_AnimationMixer_method_remove_animation_library:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
|void| **remove_animation_library**\ (\ name\: :ref:`StringName<class_StringName>`\ ) :ref:`🔗<class_AnimationMixer_method_remove_animation_library>`
|
|
|
|
Elimina la :ref:`AnimationLibrary<class_AnimationLibrary>` asociada con la clave ``name``.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_AnimationMixer_method_rename_animation_library:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
|void| **rename_animation_library**\ (\ name\: :ref:`StringName<class_StringName>`, newname\: :ref:`StringName<class_StringName>`\ ) :ref:`🔗<class_AnimationMixer_method_rename_animation_library>`
|
|
|
|
Mueve la :ref:`AnimationLibrary<class_AnimationLibrary>` asociada con la clave ``name`` a la clave ``newname``.
|
|
|
|
.. |virtual| replace:: :abbr:`virtual (Normalmente, este método debería ser sobreescrito por el usuario para que tenga algún efecto.)`
|
|
.. |required| replace:: :abbr:`required (This method is required to be overridden when extending its base class.)`
|
|
.. |const| replace:: :abbr:`const (Este método no tiene efectos secundarios. No modifica ninguna de las variables miembro de la instancia.)`
|
|
.. |vararg| replace:: :abbr:`vararg (Este método permite agregar cualquier número de argumentos después de los descritos aquí.)`
|
|
.. |constructor| replace:: :abbr:`constructor (Este método se utiliza para construir un tipo.)`
|
|
.. |static| replace:: :abbr:`static (Este método no necesita una instancia para ser llamado, por lo que puede llamarse directamente utilizando el nombre de la clase.)`
|
|
.. |operator| replace:: :abbr:`operator (Este método describe un operador válido para usar con este tipo como operando izquierdo.)`
|
|
.. |bitfield| replace:: :abbr:`BitField (Este valor es un entero compuesto como una máscara de bits de las siguientes banderas.)`
|
|
.. |void| replace:: :abbr:`void (Sin valor de retorno.)`
|