godotengine/godot-docs-l10n
1
0
Fork 0
mirror of https://github.com/godotengine/godot-docs-l10n.git synced 2025-12-31 09:49:22 +03:00
Code Issues Packages Projects Releases Wiki Activity
Files
4.x
godot-docs-l10n/classes/uk/class_animationmixer.rst

976 lines
65 KiB
ReStructuredText
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

:github_url: hide
.. _class_AnimationMixer:
AnimationMixer
==============
**Успадковує:** :ref:`Node<class_Node>` **<** :ref:`Object<class_Object>`
**Успадковано від:** :ref:`AnimationPlayer<class_AnimationPlayer>`, :ref:`AnimationTree<class_AnimationTree>`
Базовий клас для :ref:`AnimationPlayer<class_AnimationPlayer>` і :ref:`AnimationTree<class_AnimationTree>`.
.. rst-class:: classref-introduction-group
Опис
--------
Базовий клас для :ref:`AnimationPlayer<class_AnimationPlayer>` і :ref:`AnimationTree<class_AnimationTree>` для керування списками анімації. Він також має загальні властивості та методи для відтворення та змішування.
Після створення екземпляра даних інформації про відтворення в розширеному класі змішування обробляється **AnimationMixer**.
.. rst-class:: classref-introduction-group
Посібники
------------------
- `Перенесення анімацій з Godot 4.0 на 4.3 <https://godotengine.org/article/migrating-animations-from-godot-4-0-to-4-3/>`__
.. rst-class:: classref-reftable-group
Властивості
----------------------
.. 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
Методи
------------
.. 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
Сигнали
--------------
.. _class_AnimationMixer_signal_animation_finished:
.. rst-class:: classref-signal
**animation_finished**\ (\ anim_name\: :ref:`StringName<class_StringName>`\ ) :ref:`🔗<class_AnimationMixer_signal_animation_finished>`
Сповіщає про завершення відтворення анімації.
\ **Примітка:** Цей сигнал не випромінюється, якщо анімація зациклена.
.. 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>`
Сповіщає про зміни в бібліотеках анімації.
.. 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>`
Сповіщає про зміну списку анімацій.
.. 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>`
Сповіщає про початок відтворення анімації.
\ **Примітка:** Цей сигнал не випромінюється, якщо анімація відтворюється зациклено.
.. rst-class:: classref-item-separator
----
.. _class_AnimationMixer_signal_caches_cleared:
.. rst-class:: classref-signal
**caches_cleared**\ (\ ) :ref:`🔗<class_AnimationMixer_signal_caches_cleared>`
Сповіщає про очищення кешів, автоматично або вручну, за допомогою :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>`
Повідомляє, коли результат змішування застосовано до цільових об’єктів.
.. rst-class:: classref-item-separator
----
.. _class_AnimationMixer_signal_mixer_updated:
.. rst-class:: classref-signal
**mixer_updated**\ (\ ) :ref:`🔗<class_AnimationMixer_signal_mixer_updated>`
Повідомляє про оновлення процесу, пов’язаного з властивостями.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Переліки
----------------
.. _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``
Анімація процесу під час кадрів фізики (див. :ref:`Node.NOTIFICATION_INTERNAL_PHYSICS_PROCESS<class_Node_constant_NOTIFICATION_INTERNAL_PHYSICS_PROCESS>`). Це особливо корисно під час анімації фізичних тіл.
.. _class_AnimationMixer_constant_ANIMATION_CALLBACK_MODE_PROCESS_IDLE:
.. rst-class:: classref-enumeration-constant
:ref:`AnimationCallbackModeProcess<enum_AnimationMixer_AnimationCallbackModeProcess>` **ANIMATION_CALLBACK_MODE_PROCESS_IDLE** = ``1``
Анімація процесу під час кадрів процесу (див. :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``
Не обробляти анімацію. Використовуйте :ref:`advance()<class_AnimationMixer_method_advance>`, щоб обробити анімацію вручну.
.. 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``
Пакетні виклики методів під час процесу анімації, а потім виклики після обробки подій. Це дозволяє уникнути помилок, пов'язаних з видаленням вузлів або модифікацією AnimationPlayer під час відтворення.
.. _class_AnimationMixer_constant_ANIMATION_CALLBACK_MODE_METHOD_IMMEDIATE:
.. rst-class:: classref-enumeration-constant
:ref:`AnimationCallbackModeMethod<enum_AnimationMixer_AnimationCallbackModeMethod>` **ANIMATION_CALLBACK_MODE_METHOD_IMMEDIATE** = ``1``
Виклики методом робляться одразу після його досягнення в анімації.
.. 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``
Значення доріжки :ref:`Animation.UPDATE_DISCRETE<class_Animation_constant_UPDATE_DISCRETE>` має перевагу під час змішування значень доріжки :ref:`Animation.UPDATE_CONTINUOUS<class_Animation_constant_UPDATE_CONTINUOUS>` або :ref:`Animation.UPDATE_CAPTURE<class_Animation_constant_UPDATE_CAPTURE>` і значень доріжки :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``
Значення доріжки :ref:`Animation.UPDATE_CONTINUOUS<class_Animation_constant_UPDATE_CONTINUOUS>` або :ref:`Animation.UPDATE_CAPTURE<class_Animation_constant_UPDATE_CAPTURE>` має перевагу під час змішування значень доріжки :ref:`Animation.UPDATE_CONTINUOUS<class_Animation_constant_UPDATE_CONTINUOUS>` або :ref:`Animation.UPDATE_CAPTURE<class_Animation_constant_UPDATE_CAPTURE>` і значень доріжки :ref:`Animation.UPDATE_DISCRETE<class_Animation_constant_UPDATE_DISCRETE>`. Це типова поведінка для :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``
Завжди обробляйте значення доріжки :ref:`Animation.UPDATE_DISCRETE<class_Animation_constant_UPDATE_DISCRETE>` як :ref:`Animation.UPDATE_CONTINUOUS<class_Animation_constant_UPDATE_CONTINUOUS>` із :ref:`Animation.INTERPOLATION_NEAREST<class_Animation_constant_INTERPOLATION_NEAREST>`. Це стандартна поведінка для :ref:`AnimationTree<class_AnimationTree>`.
Якщо трек значень має неінтерполюємі значення типу ключа, вона внутрішньо перетворюється для використання :ref:`ANIMATION_CALLBACK_MODE_DISCRETE_RECESSIVE<class_AnimationMixer_constant_ANIMATION_CALLBACK_MODE_DISCRETE_RECESSIVE>` із :ref:`Animation.UPDATE_DISCRETE<class_Animation_constant_UPDATE_DISCRETE>`.
Список типів, що не підлягають інтерполяції:
- :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>` і :ref:`@GlobalScope.TYPE_INT<class_@GlobalScope_constant_TYPE_INT>` розглядаються як :ref:`@GlobalScope.TYPE_FLOAT<class_@GlobalScope_constant_TYPE_FLOAT>` під час змішування та округлюються під час отримання результату.
Те ж саме для масивів і векторів з ними, наприклад :ref:`@GlobalScope.TYPE_PACKED_INT32_ARRAY<class_@GlobalScope_constant_TYPE_PACKED_INT32_ARRAY>` або :ref:`@GlobalScope.TYPE_VECTOR2I<class_@GlobalScope_constant_TYPE_VECTOR2I>`, вони обробляються як :ref:`@GlobalScope.TYPE_PACKED_FLOAT32_ARRAY<class_@GlobalScope_constant_TYPE_PACKED_FLOAT32_ARRAY>` або :ref:`@GlobalScope.TYPE_VECTOR2<class_@GlobalScope_constant_TYPE_VECTOR2>`. Також зауважте, що для масивів розмір також інтерполюється.
\ :ref:`@GlobalScope.TYPE_STRING<class_@GlobalScope_constant_TYPE_STRING>` і :ref:`@GlobalScope.TYPE_STRING_NAME<class_@GlobalScope_constant_TYPE_STRING_NAME>` інтерполюються між кодами символів і довжиною, але зауважте, що існує різниця в алгоритмі між інтерполяцією між ключами та інтерполяцією шляхом змішування.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Описи властивостей
------------------------------------
.. _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**\ (\ )
Якщо ``true``, **AnimationMixer** оброблятиме.
.. 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**\ (\ )
Кількість можливих одночасних звуків для кожного з призначених AudioStreamPlayers.
Наприклад, якщо це значення дорівнює ``32`` і анімація має дві звукові доріжки, два призначені :ref:`AudioStreamPlayer<class_AudioStreamPlayer>` можуть відтворювати одночасно до ``32`` голосів кожен.
.. 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**\ (\ )
Зазвичай для доріжок можна встановити значення :ref:`Animation.UPDATE_DISCRETE<class_Animation_constant_UPDATE_DISCRETE>` для нечастого оновлення, як правило, під час використання найближчої інтерполяції.
Однак під час змішування з :ref:`Animation.UPDATE_CONTINUOUS<class_Animation_constant_UPDATE_CONTINUOUS>` враховуються кілька результатів. :ref:`callback_mode_discrete<class_AnimationMixer_property_callback_mode_discrete>` вказує це явно. Дивіться також :ref:`AnimationCallbackModeDiscrete<enum_AnimationMixer_AnimationCallbackModeDiscrete>`.
Щоб результати змішування мали гарний вигляд, рекомендується встановити це значення на :ref:`ANIMATION_CALLBACK_MODE_DISCRETE_FORCE_CONTINUOUS<class_AnimationMixer_constant_ANIMATION_CALLBACK_MODE_DISCRETE_FORCE_CONTINUOUS>` для оновлення кожного кадра під час змішування. Існують інші значення для сумісності, і вони підходять, якщо немає змішування, але інакше можуть виникнути артефакти.
.. 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**\ (\ )
Режим виклику, який використовується для треків "Метод виклику".
.. 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**\ (\ )
Сповіщення про процес, в якому потрібно оновити анімацію.
.. 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**\ (\ )
Якщо ``true``, змішування використовує детермінований алгоритм. Загальна вага не нормалізується, а результат накопичується з початковим значенням (``0`` або анімація ``"RESET"``, якщо є).
Це означає, що якщо загальна кількість змішування становить ``0,0``, результат дорівнює анімації ``"RESET"``.
Якщо кількість доріжок між змішаними анімаціями різна, анімація з відсутньою доріжкою розглядається так, ніби вона мала початкове значення.
Якщо ``false``, суміш не використовує детермінований алгоритм. Загальна вага нормалізується і завжди ``1.0``. Якщо кількість доріжок між змішаними анімаціями різна, нічого не буде зроблено щодо анімації, у якій відсутня доріжка.
\ **Примітка.** У :ref:`AnimationTree<class_AnimationTree>` змішування з :ref:`AnimationNodeAdd2<class_AnimationNodeAdd2>`, :ref:`AnimationNodeAdd3<class_AnimationNodeAdd3>`, :ref:`AnimationNodeSub2<class_AnimationNodeSub2>` або вагою, більшою за ``1.0``, може призвести до несподіваних результатів.
Наприклад, якщо :ref:`AnimationNodeAdd2<class_AnimationNodeAdd2>` поєднує два вузли з кількістю ``1.0``, тоді загальна вага буде ``2.0``, але вона буде нормалізована, щоб зробити загальну кількість ``1.0`` і результат дорівнюватиме :ref:`AnimationNodeBlend2<class_AnimationNodeBlend2>` із значенням ``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**\ (\ )
Цей параметр використовується редактором. Якщо встановлено значення ``true``, сцену буде збережено з ефектами анімації скидання (анімація з ключем ``"RESET"``), застосованими так, ніби її було створено в момент часу 0, при цьому редактор збереже значення, які сцена мала перед збереженням.
Це робить зручнішим попередній перегляд і редагування анімації у редакторі, оскільки зміни у сцені не будуть збережені, доки вони встановлені в анімації скидання.
.. 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**\ (\ )
Якщо ``true``, значення :ref:`get_root_motion_position()<class_AnimationMixer_method_get_root_motion_position>` витягується як значення локального перекладу перед змішуванням. Іншими словами, це трактується так, ніби переклад виконується після обертання.
.. 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**\ (\ )
Шлях до доріжки анімації, яка використовується для основного руху. Шляхи мають бути дійсними шляхами дерева сцен до вузла та мають бути вказані, починаючи з батьківського вузла вузла, який відтворюватиме анімацію. :ref:`root_motion_track<class_AnimationMixer_property_root_motion_track>` використовує той самий формат, що й :ref:`Animation.track_set_path()<class_Animation_method_track_set_path>`, але зауважте, що потрібно вказати кістку.
Якщо трек має тип :ref:`Animation.TYPE_POSITION_3D<class_Animation_constant_TYPE_POSITION_3D>`, :ref:`Animation.TYPE_ROTATION_3D<class_Animation_constant_TYPE_ROTATION_3D>` або :ref:`Animation.TYPE_SCALE_3D<class_Animation_constant_TYPE_SCALE_3D>`, трансформація буде візуально скасована, а анімація залишиться на місці. Дивіться також :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>` і :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**\ (\ )
Вузол, з якого буде проходити посилання на шлях вузла.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Описи методів
--------------------------
.. _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>`
Віртуальна функція обробки після отримання ключа під час відтворення.
.. 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>`
Додає ``library`` до програвача анімації під ключ ``name``.
AnimationMixer за замовчуванням має глобальну бібліотеку з порожнім рядком як ключ. Щоб додати анімацію до глобальної бібліотеки:
.. tabs::
.. code-tab:: gdscript
var global_library = mixer.get_animation_library("")
global_library.add_animation("назва_анімації", ресурс_анімації)
.. 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>`
Вручну перемотайте анімацію на вказаний час (у секундах).
.. 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>`
Якщо доріжка анімації, визначена ``name``, має опцію :ref:`Animation.UPDATE_CAPTURE<class_Animation_constant_UPDATE_CAPTURE>`, зберігає поточні значення об’єктів, указаних шляхом доріжки, як кеш. Якщо вже є захоплений кеш, старий кеш відкидається.
Після цього він буде інтерполювати з поточним результатом змішування анімації під час процесу відтворення протягом часу, визначеного параметром ``duration``, працюючи як крос-фейд.
Ви можете вказати ``trans_type`` як криву для інтерполяції. Для кращих результатів може бути доцільно вказати :ref:`Tween.TRANS_LINEAR<class_Tween_constant_TRANS_LINEAR>` для випадків, коли перша клавіша доріжки починається з ненульового значення або коли значення ключа не змінюється, і :ref:`Tween.TRANS_QUAD<class_Tween_constant_TRANS_QUAD>` для випадків де значення ключа змінюється лінійно.
.. rst-class:: classref-item-separator
----
.. _class_AnimationMixer_method_clear_caches:
.. rst-class:: classref-method
|void| **clear_caches**\ (\ ) :ref:`🔗<class_AnimationMixer_method_clear_caches>`
**AnimationMixer** кешує анімовані вузли. Він може не помітити, якщо вузол зникне. :ref:`clear_caches()<class_AnimationMixer_method_clear_caches>` змушує його знову оновити кеш.
.. 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>`
Повертає ключ ``animation`` або порожній :ref:`StringName<class_StringName>`, якщо його не знайдено.
.. 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>`
Повертає ключ до бібліотеки :ref:`AnimationLibrary<class_AnimationLibrary>`, яка містить ``animation`` або порожній рядок :ref:`StringName<class_StringName>`, якщо його не знайдено.
.. 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>`
Повертає :ref:`Animation<class_Animation>` за ключем ``name``. Якщо анімації не існує, повертається ``null`` і реєструється помилка.
.. 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>`
Повертає першу :ref:`AnimationLibrary<class_AnimationLibrary>` з ключем ``name`` або ``null``, якщо не знайдено.
Щоб отримати глобальну бібліотеку анімації **AnimationMixer**, використовуйте ``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>`
Повертає список збережених ключів бібліотеки.
.. 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>`
Повертає список збережених ключів анімації.
.. 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>`
Отримайте дельту руху позиції за допомогою :ref:`root_motion_track<class_AnimationMixer_property_root_motion_track>` як :ref:`Vector3<class_Vector3>`, який можна використовувати деінде.
Якщо :ref:`root_motion_track<class_AnimationMixer_property_root_motion_track>` не є шляхом до треку типу :ref:`Animation.TYPE_POSITION_3D<class_Animation_constant_TYPE_POSITION_3D>`, повертає ``Vector3(0, 0, 0)``.
Дивіться також :ref:`root_motion_track<class_AnimationMixer_property_root_motion_track>` і :ref:`RootMotionView<class_RootMotionView>`.
Найпростіший приклад — застосування позиції до :ref:`CharacterBody3D<class_CharacterBody3D>`:
.. tabs::
.. code-tab:: gdscript
змінна current_rotation
func _process(delta):
if Input.is_action_just_pressed("animate"):
current_rotation = get_quaternion()
state_machine.travel("Анімувати")
var velocity = current_rotation * animation_tree.get_root_motion_position() / delta
set_velocity(velocity)
move_and_slide()
Використовуючи це в поєднанні з :ref:`get_root_motion_rotation_accumulator()<class_AnimationMixer_method_get_root_motion_rotation_accumulator>`, ви можете більш правильно застосувати положення кореневого руху для врахування обертання вузла.
.. tabs::
.. code-tab:: gdscript
func _process(delta):
if Input.is_action_just_pressed("animate"):
state_machine.travel("Анімувати")
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()
Якщо :ref:`root_motion_local<class_AnimationMixer_property_root_motion_local>` має значення ``true``, повертає попередньо помножене значення перекладу з інвертованим обертанням.
У цьому випадку код можна записати наступним чином:
.. tabs::
.. code-tab:: gdscript
func _process(delta):
if Input.is_action_just_pressed("animate"):
state_machine.travel("Анімувати")
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>`
Отримує змішане значення доріжок переміщення з :ref:`root_motion_track<class_AnimationMixer_property_root_motion_track>` як :ref:`Vector3<class_Vector3>`, який можна десь використати.
Це корисно у випадках, коли ви хочете зберегти початкові значення ключів анімації.
Наприклад, якщо у попередньому кадрі відтворюється анімація з одним ключем ``Vector3(0, 0, 0)``, а у наступному кадрі відтворюється анімація з одним ключем ``Vector3(1, 0, 1)`` то різницю можна обчислити наступним чином:
.. tabs::
.. code-tab:: gdscript
var prev_root_motion_position_accumulator: Vector3
func _process(delta):
if Input.is_action_just_pressed("animate"):
state_machine.travel("Animate")
var current_root_motion_position_accumulator: Vector3 = animation_tree.get_root_motion_position_accumulator()
var difference: Vector3 = current_root_motion_position_accumulator - prev_root_motion_position_accumulator
prev_root_motion_position_accumulator = current_root_motion_position_accumulator
transform.origin += difference
Однак, якщо анімація зациклена, може відбутися ненавмисна дискретна зміна, тому це корисно лише для деяких простих випадків використання.
.. 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>`
Отримати дельту обертання з :ref:`root_motion_track<class_AnimationMixer_property_root_motion_track>` як :ref:`Quaternion<class_Quaternion>` який можна десь використати.
Якщо :ref:`root_motion_track<class_AnimationMixer_property_root_motion_track>` не є шляхом до типу доріжку :ref:`Animation.TYPE_ROTATION_3D<class_Animation_constant_TYPE_ROTATION_3D>`, повертає ``Quaternion(0, 0, 0, 1)``.
Дивіться також :ref:`root_motion_track<class_AnimationMixer_property_root_motion_track>` і :ref:`RootMotionView<class_RootMotionView>`.
Найпростішим прикладом є застосування обертання до :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>`
Отримайте змішане значення доріжок обертання за допомогою :ref:`root_motion_track<class_AnimationMixer_property_root_motion_track>` як :ref:`Quaternion<class_Quaternion>`, який можна використовувати деінде.
Це необхідно для правильного застосування положення руху кореня з урахуванням обертання. Дивіться також :ref:`get_root_motion_position()<class_AnimationMixer_method_get_root_motion_position>`.
Крім того, це корисно у випадках, коли потрібно дотримуватися початкових ключових значень анімації.
Наприклад, якщо в попередньому кадрі відтворюється анімація лише з одним ключем ``Quaternion(0, 0, 0, 1)``, а потім анімація лише з одним ключем ``Quaternion(0, 0,707, 0, 0,707)`` відтворюється в наступному кадрі, різницю можна обчислити наступним чином:
::
[gdscript]
var prev_root_motion_rotation_accumulator:
func _process(delta):
if Input.is_action_just_pressed("animate"):
state_machine.travel("Анімувати")
var current_root_motion_rotation_accumulator: Quaternion = animation_tree.get_root_motion_rotation_accumulator()
змінна різниця: Quaternion = 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)
[/gdscript][/codeblocks]
Однак, якщо анімація повторюється, може статися ненавмисна дискретна зміна, тому це корисно лише для деяких простих випадків використання.
.. 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>`
Отримує дельту маштабування з :ref:`root_motion_track<class_AnimationMixer_property_root_motion_track>` як :ref:`Vector3<class_Vector3>` який можна десь використати.
Якщо :ref:`root_motion_track<class_AnimationMixer_property_root_motion_track>` не є шляхом до доріжки типу :ref:`Animation.TYPE_SCALE_3D<class_Animation_constant_TYPE_SCALE_3D>`, повертає ``Vector3(0, 0, 0)``.
Дивіться також :ref:`root_motion_track<class_AnimationMixer_property_root_motion_track>` і :ref:`RootMotionView<class_RootMotionView>`.
Найпростішим прикладом є застосування масштабування до :ref:`CharacterBody3D<class_CharacterBody3D>`:
.. tabs::
.. code-tab:: gdscript
var current_scale: Vector3 = Vector3(1, 1, 1)
var scale_accum: Vector3 = 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>`
Отримує змішане значення доріжок масштабування з :ref:`root_motion_track<class_AnimationMixer_property_root_motion_track>` як :ref:`Vector3<class_Vector3>` який можна десь використати.
Наприклад, якщо у попередньому кадрі відтворено анімацію з ключем ``Vector3(1, 1, 1)``, а в наступному з ключем ``Vector3(2, 2, 2)``, то різницю можна вирахувати наступним чином:
.. tabs::
.. code-tab:: gdscript
var prev_root_motion_scale_accumulator: Vector3
func _process(delta):
if Input.is_action_just_pressed("animate"):
state_machine.travel("Animate")
var current_root_motion_scale_accumulator: Vector3 = animation_tree.get_root_motion_scale_accumulator()
var difference: Vector3 = 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)
Однак, якщо анімація зациклена, може статися ненавмисна дискретна зміна, тому це корисно лише для деяких простих випадків використання.
.. 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>`
Повертає ``true``, якщо **AnimationMixer** зберігає :ref:`Animation<class_Animation>` із ключем ``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>`
Повертає ``true``, якщо **AnimationMixer** зберігає :ref:`Animation<class_Animation>` із ключем ``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>`
Видаляє :ref:`AnimationLibrary<class_AnimationLibrary>`, пов'язану з ключем ``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>`
Переміщує :ref:`AnimationLibrary<class_AnimationLibrary>`, пов'язану з ключем ``name``, до ключа ``newname``.
.. |virtual| replace:: :abbr:`virtual (Зазвичай, цей метод перевизначається користувачем, щоб він мав вплив.)`
.. |required| replace:: :abbr:`required (This method is required to be overridden when extending its base class.)`
.. |const| replace:: :abbr:`const (Цей метод не має побічних ефектів. Не змінює ніяку змінну екземпляра об'єкта.)`
.. |vararg| replace:: :abbr:`vararg (Цей метод приймає будь-яке число аргументів після описаних тут.)`
.. |constructor| replace:: :abbr:`constructor (Цей метод використовується для побудови типів.)`
.. |static| replace:: :abbr:`static (Цей метод не потребує екземпляра для виклику, його можна викликати безпосередньо за допомогою назви класу.)`
.. |operator| replace:: :abbr:`operator (Цей метод описує дійсний оператор для взаємодії з цим типом як з лівим операндом.)`
.. |bitfield| replace:: :abbr:`BitField (Це значення є цілим числом, складеним у вигляді бітової маски з наступних прапорів.)`
.. |void| replace:: :abbr:`void (Значення не повертається.)`
Reference in New Issue View Git Blame Copy Permalink