mirror of
https://github.com/godotengine/godot-docs-l10n.git
synced 2026-01-04 10:09:56 +03:00
756 lines
54 KiB
ReStructuredText
756 lines
54 KiB
ReStructuredText
:github_url: hide
|
||
|
||
.. _class_Quaternion:
|
||
|
||
Quaternion
|
||
==========
|
||
|
||
Призначений для представлення 3D поворотів.
|
||
|
||
.. rst-class:: classref-introduction-group
|
||
|
||
Опис
|
||
--------
|
||
|
||
Вбудований тип :ref:`Variant<class_Variant>` **Quaternion** — це 4D структура даних, яка представляє обертання у формі кватерніона конвенції Гамільтона `кватерніона Гамільтона <https://en.wikipedia.org/wiki/Quaternions_and_spatial_rotation>`__. Порівняно з типом :ref:`Basis<class_Basis>`, який може зберігати як обертання, так і масштаб, кватерніони можуть зберігати *тільки* обертання.
|
||
|
||
\ **Quaternion** складається з 4 компонентів з плаваючою комою: :ref:`w<class_Quaternion_property_w>`, :ref:`x<class_Quaternion_property_x>`, :ref:`y<class_Quaternion_property_y>` та :ref:`z<class_Quaternion_property_z>`. Ці компоненти дуже компактні в пам'яті, і завдяки цьому деякі операції є ефективнішими та менш схильними до помилок з плаваючою комою. Такі методи, як :ref:`get_angle()<class_Quaternion_method_get_angle>`, :ref:`get_axis()<class_Quaternion_method_get_axis>` та :ref:`slerp()<class_Quaternion_method_slerp>`, швидші, ніж їхні аналоги :ref:`Basis<class_Basis>`.
|
||
|
||
Для чудового знайомства з кватерніонами перегляньте `це відео від 3Blue1Brown <https://www.youtube.com/watch?v=d4EgbgTm0Bg>`__. Вам не потрібно знати математику, що лежить в основі кватерніонів, оскільки Godot надає кілька допоміжних методів, які обробляють її за вас. До них належать :ref:`slerp()<class_Quaternion_method_slerp>` та :ref:`spherical_cubic_interpolate()<class_Quaternion_method_spherical_cubic_interpolate>`, а також оператор ``*``.
|
||
|
||
\ **Примітка:** Кватерніони мають бути нормалізовані перед використанням для обертання (див. :ref:`normalized()<class_Quaternion_method_normalized>`).
|
||
|
||
\ **Примітка:** Подібно до :ref:`Vector2<class_Vector2>` та :ref:`Vector3<class_Vector3>`, компоненти кватерніона за замовчуванням використовують 32-бітну точність, на відміну від :ref:`float<class_float>`, який завжди має 64-бітну точність. Якщо потрібна подвійна точність, скомпілюйте рушій з опцією ``precision=double``.
|
||
|
||
.. note::
|
||
|
||
Існують значні відмінності при використанні цього API із С#. Більше інформації: ref:`doc_c_sharp_differences`.
|
||
|
||
.. rst-class:: classref-introduction-group
|
||
|
||
Посібники
|
||
------------------
|
||
|
||
- `3Blue1Brown відео на Quaternions <https://www.youtube.com/watch?v=d4EgbgTm0Bg>`__
|
||
|
||
- `Онлайн Кватерн Візуалізація <https://quaternions.online/>`__
|
||
|
||
- `Використання 3D трансформацій <../tutorials/3d/using_transforms.html#interpolating-with-quaternions>`__
|
||
|
||
- `Демо-версія шутера від третьої особи (TPS) <https://godotengine.org/asset-library/asset/2710>`__
|
||
|
||
- `Розширена візуалізація запитів <https://iwatake2222.github.io/rotation_master/rotation_master.html>`__
|
||
|
||
.. rst-class:: classref-reftable-group
|
||
|
||
Властивості
|
||
----------------------
|
||
|
||
.. table::
|
||
:widths: auto
|
||
|
||
+---------------------------+---------------------------------------+---------+
|
||
| :ref:`float<class_float>` | :ref:`w<class_Quaternion_property_w>` | ``1.0`` |
|
||
+---------------------------+---------------------------------------+---------+
|
||
| :ref:`float<class_float>` | :ref:`x<class_Quaternion_property_x>` | ``0.0`` |
|
||
+---------------------------+---------------------------------------+---------+
|
||
| :ref:`float<class_float>` | :ref:`y<class_Quaternion_property_y>` | ``0.0`` |
|
||
+---------------------------+---------------------------------------+---------+
|
||
| :ref:`float<class_float>` | :ref:`z<class_Quaternion_property_z>` | ``0.0`` |
|
||
+---------------------------+---------------------------------------+---------+
|
||
|
||
.. rst-class:: classref-reftable-group
|
||
|
||
Конструктори
|
||
------------------------
|
||
|
||
.. table::
|
||
:widths: auto
|
||
|
||
+-------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Quaternion<class_Quaternion>` | :ref:`Quaternion<class_Quaternion_constructor_Quaternion>`\ (\ ) |
|
||
+-------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Quaternion<class_Quaternion>` | :ref:`Quaternion<class_Quaternion_constructor_Quaternion>`\ (\ from\: :ref:`Quaternion<class_Quaternion>`\ ) |
|
||
+-------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Quaternion<class_Quaternion>` | :ref:`Quaternion<class_Quaternion_constructor_Quaternion>`\ (\ arc_from\: :ref:`Vector3<class_Vector3>`, arc_to\: :ref:`Vector3<class_Vector3>`\ ) |
|
||
+-------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Quaternion<class_Quaternion>` | :ref:`Quaternion<class_Quaternion_constructor_Quaternion>`\ (\ axis\: :ref:`Vector3<class_Vector3>`, angle\: :ref:`float<class_float>`\ ) |
|
||
+-------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Quaternion<class_Quaternion>` | :ref:`Quaternion<class_Quaternion_constructor_Quaternion>`\ (\ from\: :ref:`Basis<class_Basis>`\ ) |
|
||
+-------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Quaternion<class_Quaternion>` | :ref:`Quaternion<class_Quaternion_constructor_Quaternion>`\ (\ x\: :ref:`float<class_float>`, y\: :ref:`float<class_float>`, z\: :ref:`float<class_float>`, w\: :ref:`float<class_float>`\ ) |
|
||
+-------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
|
||
.. rst-class:: classref-reftable-group
|
||
|
||
Методи
|
||
------------
|
||
|
||
.. table::
|
||
:widths: auto
|
||
|
||
+-------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`float<class_float>` | :ref:`angle_to<class_Quaternion_method_angle_to>`\ (\ to\: :ref:`Quaternion<class_Quaternion>`\ ) |const| |
|
||
+-------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`float<class_float>` | :ref:`dot<class_Quaternion_method_dot>`\ (\ with\: :ref:`Quaternion<class_Quaternion>`\ ) |const| |
|
||
+-------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Quaternion<class_Quaternion>` | :ref:`exp<class_Quaternion_method_exp>`\ (\ ) |const| |
|
||
+-------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Quaternion<class_Quaternion>` | :ref:`from_euler<class_Quaternion_method_from_euler>`\ (\ euler\: :ref:`Vector3<class_Vector3>`\ ) |static| |
|
||
+-------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`float<class_float>` | :ref:`get_angle<class_Quaternion_method_get_angle>`\ (\ ) |const| |
|
||
+-------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Vector3<class_Vector3>` | :ref:`get_axis<class_Quaternion_method_get_axis>`\ (\ ) |const| |
|
||
+-------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Vector3<class_Vector3>` | :ref:`get_euler<class_Quaternion_method_get_euler>`\ (\ order\: :ref:`int<class_int>` = 2\ ) |const| |
|
||
+-------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Quaternion<class_Quaternion>` | :ref:`inverse<class_Quaternion_method_inverse>`\ (\ ) |const| |
|
||
+-------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`is_equal_approx<class_Quaternion_method_is_equal_approx>`\ (\ to\: :ref:`Quaternion<class_Quaternion>`\ ) |const| |
|
||
+-------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`is_finite<class_Quaternion_method_is_finite>`\ (\ ) |const| |
|
||
+-------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`is_normalized<class_Quaternion_method_is_normalized>`\ (\ ) |const| |
|
||
+-------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`float<class_float>` | :ref:`length<class_Quaternion_method_length>`\ (\ ) |const| |
|
||
+-------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`float<class_float>` | :ref:`length_squared<class_Quaternion_method_length_squared>`\ (\ ) |const| |
|
||
+-------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Quaternion<class_Quaternion>` | :ref:`log<class_Quaternion_method_log>`\ (\ ) |const| |
|
||
+-------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Quaternion<class_Quaternion>` | :ref:`normalized<class_Quaternion_method_normalized>`\ (\ ) |const| |
|
||
+-------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Quaternion<class_Quaternion>` | :ref:`slerp<class_Quaternion_method_slerp>`\ (\ to\: :ref:`Quaternion<class_Quaternion>`, weight\: :ref:`float<class_float>`\ ) |const| |
|
||
+-------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Quaternion<class_Quaternion>` | :ref:`slerpni<class_Quaternion_method_slerpni>`\ (\ to\: :ref:`Quaternion<class_Quaternion>`, weight\: :ref:`float<class_float>`\ ) |const| |
|
||
+-------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Quaternion<class_Quaternion>` | :ref:`spherical_cubic_interpolate<class_Quaternion_method_spherical_cubic_interpolate>`\ (\ b\: :ref:`Quaternion<class_Quaternion>`, pre_a\: :ref:`Quaternion<class_Quaternion>`, post_b\: :ref:`Quaternion<class_Quaternion>`, weight\: :ref:`float<class_float>`\ ) |const| |
|
||
+-------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Quaternion<class_Quaternion>` | :ref:`spherical_cubic_interpolate_in_time<class_Quaternion_method_spherical_cubic_interpolate_in_time>`\ (\ b\: :ref:`Quaternion<class_Quaternion>`, pre_a\: :ref:`Quaternion<class_Quaternion>`, post_b\: :ref:`Quaternion<class_Quaternion>`, weight\: :ref:`float<class_float>`, b_t\: :ref:`float<class_float>`, pre_a_t\: :ref:`float<class_float>`, post_b_t\: :ref:`float<class_float>`\ ) |const| |
|
||
+-------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
|
||
.. rst-class:: classref-reftable-group
|
||
|
||
Оператори
|
||
------------------
|
||
|
||
.. table::
|
||
:widths: auto
|
||
|
||
+-------------------------------------+-----------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`operator !=<class_Quaternion_operator_neq_Quaternion>`\ (\ right\: :ref:`Quaternion<class_Quaternion>`\ ) |
|
||
+-------------------------------------+-----------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Quaternion<class_Quaternion>` | :ref:`operator *<class_Quaternion_operator_mul_Quaternion>`\ (\ right\: :ref:`Quaternion<class_Quaternion>`\ ) |
|
||
+-------------------------------------+-----------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Vector3<class_Vector3>` | :ref:`operator *<class_Quaternion_operator_mul_Vector3>`\ (\ right\: :ref:`Vector3<class_Vector3>`\ ) |
|
||
+-------------------------------------+-----------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Quaternion<class_Quaternion>` | :ref:`operator *<class_Quaternion_operator_mul_float>`\ (\ right\: :ref:`float<class_float>`\ ) |
|
||
+-------------------------------------+-----------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Quaternion<class_Quaternion>` | :ref:`operator *<class_Quaternion_operator_mul_int>`\ (\ right\: :ref:`int<class_int>`\ ) |
|
||
+-------------------------------------+-----------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Quaternion<class_Quaternion>` | :ref:`operator +<class_Quaternion_operator_sum_Quaternion>`\ (\ right\: :ref:`Quaternion<class_Quaternion>`\ ) |
|
||
+-------------------------------------+-----------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Quaternion<class_Quaternion>` | :ref:`operator -<class_Quaternion_operator_dif_Quaternion>`\ (\ right\: :ref:`Quaternion<class_Quaternion>`\ ) |
|
||
+-------------------------------------+-----------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Quaternion<class_Quaternion>` | :ref:`operator /<class_Quaternion_operator_div_float>`\ (\ right\: :ref:`float<class_float>`\ ) |
|
||
+-------------------------------------+-----------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Quaternion<class_Quaternion>` | :ref:`operator /<class_Quaternion_operator_div_int>`\ (\ right\: :ref:`int<class_int>`\ ) |
|
||
+-------------------------------------+-----------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`operator ==<class_Quaternion_operator_eq_Quaternion>`\ (\ right\: :ref:`Quaternion<class_Quaternion>`\ ) |
|
||
+-------------------------------------+-----------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`float<class_float>` | :ref:`operator []<class_Quaternion_operator_idx_int>`\ (\ index\: :ref:`int<class_int>`\ ) |
|
||
+-------------------------------------+-----------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Quaternion<class_Quaternion>` | :ref:`operator unary+<class_Quaternion_operator_unplus>`\ (\ ) |
|
||
+-------------------------------------+-----------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Quaternion<class_Quaternion>` | :ref:`operator unary-<class_Quaternion_operator_unminus>`\ (\ ) |
|
||
+-------------------------------------+-----------------------------------------------------------------------------------------------------------------+
|
||
|
||
.. rst-class:: classref-section-separator
|
||
|
||
----
|
||
|
||
.. rst-class:: classref-descriptions-group
|
||
|
||
Константи
|
||
------------------
|
||
|
||
.. _class_Quaternion_constant_IDENTITY:
|
||
|
||
.. rst-class:: classref-constant
|
||
|
||
**IDENTITY** = ``Quaternion(0, 0, 0, 1)`` :ref:`🔗<class_Quaternion_constant_IDENTITY>`
|
||
|
||
Кватерніон одиниці, що представляє відсутність обертання. Він має таке ж обертання, як і :ref:`Basis.IDENTITY<class_Basis_constant_IDENTITY>`.
|
||
|
||
Якщо :ref:`Vector3<class_Vector3>` обертається (множиться) на цей кватерніон, він не змінюється.
|
||
|
||
\ **Примітка:** У GDScript ця константа еквівалентна створенню :ref:`Quaternion<class_Quaternion_constructor_Quaternion>` без будь-яких аргументів. Її можна використовувати для покращення коду та для узгодженості з C#.
|
||
|
||
.. rst-class:: classref-section-separator
|
||
|
||
----
|
||
|
||
.. rst-class:: classref-descriptions-group
|
||
|
||
Описи властивостей
|
||
------------------------------------
|
||
|
||
.. _class_Quaternion_property_w:
|
||
|
||
.. rst-class:: classref-property
|
||
|
||
:ref:`float<class_float>` **w** = ``1.0`` :ref:`🔗<class_Quaternion_property_w>`
|
||
|
||
W компонент кватерніона. Це "реальна" частина.
|
||
|
||
\ **Примітка:** Компоненти кватерніона зазвичай не треба змінювати напряму.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Quaternion_property_x:
|
||
|
||
.. rst-class:: classref-property
|
||
|
||
:ref:`float<class_float>` **x** = ``0.0`` :ref:`🔗<class_Quaternion_property_x>`
|
||
|
||
X компонент картернатури. Це значення вздовж осі "імагінар" ``i``.
|
||
|
||
\ **Примітка:** Компоненти Quaternion зазвичай не повинні маніпулювати безпосередньо.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Quaternion_property_y:
|
||
|
||
.. rst-class:: classref-property
|
||
|
||
:ref:`float<class_float>` **y** = ``0.0`` :ref:`🔗<class_Quaternion_property_y>`
|
||
|
||
Y компонент картернатури. Це значення вздовж осі "імаляр" ``j``.
|
||
|
||
\ **Примітка:** Компоненти Quaternion зазвичай не повинні маніпулювати безпосередньо.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Quaternion_property_z:
|
||
|
||
.. rst-class:: classref-property
|
||
|
||
:ref:`float<class_float>` **z** = ``0.0`` :ref:`🔗<class_Quaternion_property_z>`
|
||
|
||
Z компонент картернію. Це значення вздовж осі "імаляр" ``k``.
|
||
|
||
\ **Примітка:** Компоненти Quaternion зазвичай не повинні маніпулювати безпосередньо.
|
||
|
||
.. rst-class:: classref-section-separator
|
||
|
||
----
|
||
|
||
.. rst-class:: classref-descriptions-group
|
||
|
||
Описи конструкторів
|
||
--------------------------------------
|
||
|
||
.. _class_Quaternion_constructor_Quaternion:
|
||
|
||
.. rst-class:: classref-constructor
|
||
|
||
:ref:`Quaternion<class_Quaternion>` **Quaternion**\ (\ ) :ref:`🔗<class_Quaternion_constructor_Quaternion>`
|
||
|
||
Створює **Quaternion**, ідентичний :ref:`IDENTITY<class_Quaternion_constant_IDENTITY>`.
|
||
|
||
\ **Примітка:** У C# це створює ``кватерніон`` з усіма його компонентами, встановленими на ``0.0``.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. rst-class:: classref-constructor
|
||
|
||
:ref:`Quaternion<class_Quaternion>` **Quaternion**\ (\ from\: :ref:`Quaternion<class_Quaternion>`\ )
|
||
|
||
Constructs a **Quaternion** як копія даної **Quaternion**.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. rst-class:: classref-constructor
|
||
|
||
:ref:`Quaternion<class_Quaternion>` **Quaternion**\ (\ arc_from\: :ref:`Vector3<class_Vector3>`, arc_to\: :ref:`Vector3<class_Vector3>`\ )
|
||
|
||
Constructs **Quaternion**, що представляє найбільшу дугу між ``arc_from`` і ``arc_to``. Це можна уявити як дві точки, що перетинають поверхню сфери, з радіусом ``1.0``.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. rst-class:: classref-constructor
|
||
|
||
:ref:`Quaternion<class_Quaternion>` **Quaternion**\ (\ axis\: :ref:`Vector3<class_Vector3>`, angle\: :ref:`float<class_float>`\ )
|
||
|
||
Constructs a **Quaternion**, що представляє обертання навколо ``осі`` заданим ``кут``, в радианах. Ось повинна бути нормалізований вектор.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. rst-class:: classref-constructor
|
||
|
||
:ref:`Quaternion<class_Quaternion>` **Quaternion**\ (\ from\: :ref:`Basis<class_Basis>`\ )
|
||
|
||
Constructs a **Quaternion** з даної обертання :ref:`Basis<class_Basis>`.
|
||
|
||
Цей конструктор швидше, ніж :ref:`Basis.get_rotation_quaternion()<class_Basis_method_get_rotation_quaternion>`, але надана основа повинна бути *orthonormalized* (див. :ref:`Basis.orthonormalized()<class_Basis_method_orthonormalized>`). В іншому випадку конструктор не вдається і повертає ``константність``.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. rst-class:: classref-constructor
|
||
|
||
:ref:`Quaternion<class_Quaternion>` **Quaternion**\ (\ x\: :ref:`float<class_float>`, y\: :ref:`float<class_float>`, z\: :ref:`float<class_float>`, w\: :ref:`float<class_float>`\ )
|
||
|
||
Constructs **Quaternion**, визначений заданими значеннями.
|
||
|
||
\ **Примітка:** Тільки нормалізовані кватерніони представляють обертання; якщо ці значення не нормалізуються, новий **Quaternion** не буде дійсним обертанням.
|
||
|
||
.. rst-class:: classref-section-separator
|
||
|
||
----
|
||
|
||
.. rst-class:: classref-descriptions-group
|
||
|
||
Описи методів
|
||
--------------------------
|
||
|
||
.. _class_Quaternion_method_angle_to:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`float<class_float>` **angle_to**\ (\ to\: :ref:`Quaternion<class_Quaternion>`\ ) |const| :ref:`🔗<class_Quaternion_method_angle_to>`
|
||
|
||
Повертає кут між цим картероном і ``паром до``. Це величина кута, вам потрібно буде обертати, щоб отримати від одного до іншого.
|
||
|
||
\ **Note:** Температурна похибка точки плавлення для цього методу є аномально високими, тому методи, такі як ``is_zero_приблизно`` не буде працювати надійно.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Quaternion_method_dot:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`float<class_float>` **dot**\ (\ with\: :ref:`Quaternion<class_Quaternion>`\ ) |const| :ref:`🔗<class_Quaternion_method_dot>`
|
||
|
||
Повертає продукт точки між цим кварталом та ``паром``.
|
||
|
||
Це еквівалентно ``(quat.x * з.x) + (quat.y * з.y) + (quat.z * з.z) + (quat.w * з.w)``.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Quaternion_method_exp:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`Quaternion<class_Quaternion>` **exp**\ (\ ) |const| :ref:`🔗<class_Quaternion_method_exp>`
|
||
|
||
Повертає доцільність цього кватернату. Вісь обертання результату - нормалізована вісь обертання цієї кватернції, кут результату - довжина векторної частини цієї кватернції.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Quaternion_method_from_euler:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`Quaternion<class_Quaternion>` **from_euler**\ (\ euler\: :ref:`Vector3<class_Vector3>`\ ) |static| :ref:`🔗<class_Quaternion_method_from_euler>`
|
||
|
||
:ref:`Vector3<class_Vector3>` ` Кути евлера <https://en.wikipedia.org/wiki/Euler_angles>`__, в радіях. Цей метод завжди використовує конвенцію YXZ (:ref:`@GlobalScope.EULER_ORDER_YXZ<class_@GlobalScope_constant_EULER_ORDER_YXZ>`).
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Quaternion_method_get_angle:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`float<class_float>` **get_angle**\ (\ ) |const| :ref:`🔗<class_Quaternion_method_get_angle>`
|
||
|
||
Повертає кут повороту, представлений цим кватерном.
|
||
|
||
\ **Примітка:** Вода повинна бути нормалізована.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Quaternion_method_get_axis:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`Vector3<class_Vector3>` **get_axis**\ (\ ) |const| :ref:`🔗<class_Quaternion_method_get_axis>`
|
||
|
||
Повертаємо вісь обертання, представлене цим кватерном.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Quaternion_method_get_euler:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`Vector3<class_Vector3>` **get_euler**\ (\ order\: :ref:`int<class_int>` = 2\ ) |const| :ref:`🔗<class_Quaternion_method_get_euler>`
|
||
|
||
Повертає обертання цього кватерніона як :ref:`Vector3<class_Vector3>` кутів Ейлера [url=https://en.wikipedia.org/wiki/Euler_angles]у радіанах.
|
||
|
||
Порядок кожного послідовного обертання можна змінити за допомогою [param order] (див. константи [enum EulerOrder]). За замовчуванням використовується конвенція YXZ ([constant EULER_ORDER_YXZ]): спочатку обчислюється Z (крен), потім X (тангаж) і, нарешті, Y (рискання). При використанні протилежного методу [method from_euler] цей порядок змінюється на протилежний.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Quaternion_method_inverse:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`Quaternion<class_Quaternion>` **inverse**\ (\ ) |const| :ref:`🔗<class_Quaternion_method_inverse>`
|
||
|
||
Повертає несвоєчасну версію цієї кватернції, що інвертує ознаку кожного компонента, крім :ref:`w<class_Quaternion_property_w>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Quaternion_method_is_equal_approx:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`bool<class_bool>` **is_equal_approx**\ (\ to\: :ref:`Quaternion<class_Quaternion>`\ ) |const| :ref:`🔗<class_Quaternion_method_is_equal_approx>`
|
||
|
||
Повертає ``true``, якщо цей кватерніон і ``to`` приблизно рівні, шляхом виклику :ref:`@GlobalScope.is_equal_approx()<class_@GlobalScope_method_is_equal_approx>` для кожного компонента.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Quaternion_method_is_finite:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`bool<class_bool>` **is_finite**\ (\ ) |const| :ref:`🔗<class_Quaternion_method_is_finite>`
|
||
|
||
Повертає ``true``, якщо це картерніон скінчив, викликаючи :ref:`@GlobalScope.is_finite()<class_@GlobalScope_method_is_finite>` на кожному компоненті.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Quaternion_method_is_normalized:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`bool<class_bool>` **is_normalized**\ (\ ) |const| :ref:`🔗<class_Quaternion_method_is_normalized>`
|
||
|
||
Повернення ``true``, якщо це нормалізовано. Дивись також :ref:`normalized()<class_Quaternion_method_normalized>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Quaternion_method_length:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`float<class_float>` **length**\ (\ ) |const| :ref:`🔗<class_Quaternion_method_length>`
|
||
|
||
Повертаємо цю довжину картерніонів, також називається величиною.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Quaternion_method_length_squared:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`float<class_float>` **length_squared**\ (\ ) |const| :ref:`🔗<class_Quaternion_method_length_squared>`
|
||
|
||
Повертаємо цю довжину кватерна, квадрат.
|
||
|
||
\ **Примітка:** Цей метод швидше, ніж :ref:`довжини()<class_Quaternion_method_довжини>`, тому воліє його, якщо потрібно тільки порівняти довжини кватернції.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Quaternion_method_log:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`Quaternion<class_Quaternion>` **log**\ (\ ) |const| :ref:`🔗<class_Quaternion_method_log>`
|
||
|
||
Повертає логарифм цього кватерніона. Множить вісь обертання цього кватерніона на його кут повороту та зберігає результат у векторній частині повернутого кватерніона (:ref:`x<class_Quaternion_property_x>`, :ref:`y<class_Quaternion_property_y>` та :ref:`z<class_Quaternion_property_z>`). Дійсна частина повернутого кватерніона (:ref:`w<class_Quaternion_property_w>`) завжди дорівнює ``0.0``.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Quaternion_method_normalized:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`Quaternion<class_Quaternion>` **normalized**\ (\ ) |const| :ref:`🔗<class_Quaternion_method_normalized>`
|
||
|
||
Повертає копію цього кватерніона, нормалізовану таким чином, що її довжина дорівнює ``1.0``. Див. також :ref:`is_normalized()<class_Quaternion_method_is_normalized>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Quaternion_method_slerp:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`Quaternion<class_Quaternion>` **slerp**\ (\ to\: :ref:`Quaternion<class_Quaternion>`, weight\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Quaternion_method_slerp>`
|
||
|
||
Виконує сферично-лінійну інтерполяцію з кватерніоном ``to``, маючи вагу ``weight``, та повертає результат. Як цей кватерніон, так і ``to`` мають бути нормалізовані.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Quaternion_method_slerpni:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`Quaternion<class_Quaternion>` **slerpni**\ (\ to\: :ref:`Quaternion<class_Quaternion>`, weight\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Quaternion_method_slerpni>`
|
||
|
||
Виконує сферично-лінійну інтерполяцію з кватерніоном ``to``, маючи значення ``weight``, та повертає результат. На відміну від методу :ref:`slerp()<class_Quaternion_method_slerp>`, цей метод не перевіряє, чи шлях обертання менший за 90 градусів. Як цей кватерніон, так і ``to`` мають бути нормалізовані.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Quaternion_method_spherical_cubic_interpolate:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`Quaternion<class_Quaternion>` **spherical_cubic_interpolate**\ (\ b\: :ref:`Quaternion<class_Quaternion>`, pre_a\: :ref:`Quaternion<class_Quaternion>`, post_b\: :ref:`Quaternion<class_Quaternion>`, weight\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Quaternion_method_spherical_cubic_interpolate>`
|
||
|
||
Виконує сферичне переполування кубічних між картерніями ``pre_a``, цей вектор, ``b``, а ``post_b``, за вказаною кількістю ``вага``.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Quaternion_method_spherical_cubic_interpolate_in_time:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`Quaternion<class_Quaternion>` **spherical_cubic_interpolate_in_time**\ (\ b\: :ref:`Quaternion<class_Quaternion>`, pre_a\: :ref:`Quaternion<class_Quaternion>`, post_b\: :ref:`Quaternion<class_Quaternion>`, weight\: :ref:`float<class_float>`, b_t\: :ref:`float<class_float>`, pre_a_t\: :ref:`float<class_float>`, post_b_t\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Quaternion_method_spherical_cubic_interpolate_in_time>`
|
||
|
||
Виконує сферичне переполування кубічних між картерніями ``pre_a``, цей вектор, ``b``, а ``post_b``, за вказаною кількістю ``weight``.
|
||
|
||
Він може виконувати плавлення інтерполяції, ніж :ref:`spherical_cubic_interpolate()<class_Quaternion_method_spherical_cubic_interpolate>` за цінностями часу..
|
||
|
||
.. rst-class:: classref-section-separator
|
||
|
||
----
|
||
|
||
.. rst-class:: classref-descriptions-group
|
||
|
||
Описи операторів
|
||
--------------------------------
|
||
|
||
.. _class_Quaternion_operator_neq_Quaternion:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`bool<class_bool>` **operator !=**\ (\ right\: :ref:`Quaternion<class_Quaternion>`\ ) :ref:`🔗<class_Quaternion_operator_neq_Quaternion>`
|
||
|
||
Повертає ``true``, якщо компоненти обох кватерніонів не є абсолютно рівними.
|
||
|
||
\ **Примітка:** Через помилки точності чисел з плаваючою комою, розгляньте можливість використання :ref:`is_equal_approx()<class_Quaternion_method_is_equal_approx>`, що є надійнішим.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Quaternion_operator_mul_Quaternion:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`Quaternion<class_Quaternion>` **operator ***\ (\ right\: :ref:`Quaternion<class_Quaternion>`\ ) :ref:`🔗<class_Quaternion_operator_mul_Quaternion>`
|
||
|
||
Складає (множить) два кватерніони. Це обертає кватерніон ``right`` (дочірній елемент) на цей кватерніон (батьківський елемент).
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Quaternion_operator_mul_Vector3:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`Vector3<class_Vector3>` **operator ***\ (\ right\: :ref:`Vector3<class_Vector3>`\ ) :ref:`🔗<class_Quaternion_operator_mul_Vector3>`
|
||
|
||
Обертає (множить) вектор ``right`` на цей кватерніон, повертаючи :ref:`Vector3<class_Vector3>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Quaternion_operator_mul_float:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`Quaternion<class_Quaternion>` **operator ***\ (\ right\: :ref:`float<class_float>`\ ) :ref:`🔗<class_Quaternion_operator_mul_float>`
|
||
|
||
Багатомовність кожного компонента **Quaternion** за правою :ref:`float<class_float>` значення.
|
||
|
||
Ця операція не має значення самостійно, але її можна використовувати в складі більшого виразу.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Quaternion_operator_mul_int:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`Quaternion<class_Quaternion>` **operator ***\ (\ right\: :ref:`int<class_int>`\ ) :ref:`🔗<class_Quaternion_operator_mul_int>`
|
||
|
||
Багатомовність кожного компонента **Quaternion** за правою :ref:`int<class_int>` значення.
|
||
|
||
Ця операція не має значення самостійно, але її можна використовувати в складі більшого виразу.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Quaternion_operator_sum_Quaternion:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`Quaternion<class_Quaternion>` **operator +**\ (\ right\: :ref:`Quaternion<class_Quaternion>`\ ) :ref:`🔗<class_Quaternion_operator_sum_Quaternion>`
|
||
|
||
Додає кожному компоненту зліва **Quaternion** праворуч **Quaternion**.
|
||
|
||
Ця операція не має значення на власній, але її можна використовувати в складі більшого виразу, наприклад, приблизуючи проміжне обертання між двома сусідніми поворотами.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Quaternion_operator_dif_Quaternion:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`Quaternion<class_Quaternion>` **operator -**\ (\ right\: :ref:`Quaternion<class_Quaternion>`\ ) :ref:`🔗<class_Quaternion_operator_dif_Quaternion>`
|
||
|
||
Відстеження кожного компонента зліва **Quaternion** праворуч **Quaternion**.
|
||
|
||
Ця операція не має значення самостійно, але її можна використовувати в складі більшого виразу.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Quaternion_operator_div_float:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`Quaternion<class_Quaternion>` **operator /**\ (\ right\: :ref:`float<class_float>`\ ) :ref:`🔗<class_Quaternion_operator_div_float>`
|
||
|
||
Дивиди кожного компонента **Quaternion** праворуч :ref:`float<class_float>` значення.
|
||
|
||
Ця операція не має значення самостійно, але її можна використовувати в складі більшого виразу.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Quaternion_operator_div_int:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`Quaternion<class_Quaternion>` **operator /**\ (\ right\: :ref:`int<class_int>`\ ) :ref:`🔗<class_Quaternion_operator_div_int>`
|
||
|
||
Дивиди кожного компонента **Quaternion** праворуч :ref:`int<class_int>` значення.
|
||
|
||
Ця операція не має значення самостійно, але її можна використовувати в складі більшого виразу.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Quaternion_operator_eq_Quaternion:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`bool<class_bool>` **operator ==**\ (\ right\: :ref:`Quaternion<class_Quaternion>`\ ) :ref:`🔗<class_Quaternion_operator_eq_Quaternion>`
|
||
|
||
Повертаємо ``true``, якщо компоненти обох кватерій рівно рівні.
|
||
|
||
\ **Примітка:** У зв'язку з похибками точності точки, розглянути використання :ref:`is_equal_approx()<class_Quaternion_method_is_equal_approx>` замість того, що є більш надійним.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Quaternion_operator_idx_int:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`float<class_float>` **operator []**\ (\ index\: :ref:`int<class_int>`\ ) :ref:`🔗<class_Quaternion_operator_idx_int>`
|
||
|
||
Доступ до кожного компонента цього кватерніона за його індексом.
|
||
|
||
Індекс ``0`` такий самий, як :ref:`x<class_Quaternion_property_x>`, індекс ``1`` такий самий, як :ref:`y<class_Quaternion_property_y>`, індекс ``2`` такий самий, як :ref:`z<class_Quaternion_property_z>`, а індекс ``3`` такий самий, як :ref:`w<class_Quaternion_property_w>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Quaternion_operator_unplus:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`Quaternion<class_Quaternion>` **operator unary+**\ (\ ) :ref:`🔗<class_Quaternion_operator_unplus>`
|
||
|
||
Повертає однакову вартість, якщо ``+`` не було. `` +`` нічого не робить, але іноді це може зробити ваш код більш читабельним.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Quaternion_operator_unminus:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`Quaternion<class_Quaternion>` **operator unary-**\ (\ ) :ref:`🔗<class_Quaternion_operator_unminus>`
|
||
|
||
Повернення негативного значення **Quaternion**. Це так само, як і множення всіх компонентів ``-1``. Це результат операції в квертику, що відображає однакове обертання.
|
||
|
||
.. |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 (Значення не повертається.)`
|