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_vector3.rst

1395 lines
100 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_Vector3:
Vector3
=======
3D-вектор, що використовує координати з рухомою комою.
.. rst-class:: classref-introduction-group
Опис
--------
3-елементна структура, яка може використовуватися для представлення 3D-координат або будь-якої іншої трійки числових значень.
Вона використовує координати з рухомою комою. За замовчуванням ці значення мають 32-бітну точність, на відміну від :ref:`float<class_float>`, який завжди має 64-бітну точність. Якщо потрібна подвійна точність, скомпілюйте рушій з опцією ``precision=double``.
Див. також :ref:`Vector3i<class_Vector3i>` для цілочисельного аналога.
\ **Примітка:** У булевому контексті **Vector3** буде оцінюватися як ``false``, якщо дорівнює ``Vector3(0, 0, 0)``. В інших випадках **Vector3** завжди буде оцінюватися як ``true``.
.. rst-class:: classref-introduction-group
Посібники
------------------
- :doc:`Покажчик математичної документації <../tutorials/math/index>`
- :doc:`Векторна математика <../tutorials/math/vector_math>`
- :doc:`Поглиблена векторна математика <../tutorials/math/vectors_advanced>`
- `3Blue1Brown Сутність лінійної алгебри <https://www.youtube.com/playlist?list=PLZHQObOWTQDPD3MizzM2xVFitgF8hE_ab>`__
- `Демонстраційне перетворення матриці <https://godotengine.org/asset-library/asset/2787>`__
- `Всі 3D демо <https://github.com/godotengine/godot-demo-projects/tree/master/3d>`__
.. rst-class:: classref-reftable-group
Властивості
----------------------
.. table::
:widths: auto
+---------------------------+------------------------------------+---------+
| :ref:`float<class_float>` | :ref:`x<class_Vector3_property_x>` | ``0.0`` |
+---------------------------+------------------------------------+---------+
| :ref:`float<class_float>` | :ref:`y<class_Vector3_property_y>` | ``0.0`` |
+---------------------------+------------------------------------+---------+
| :ref:`float<class_float>` | :ref:`z<class_Vector3_property_z>` | ``0.0`` |
+---------------------------+------------------------------------+---------+
.. rst-class:: classref-reftable-group
Конструктори
------------------------
.. table::
:widths: auto
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`Vector3<class_Vector3_constructor_Vector3>`\ (\ ) |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`Vector3<class_Vector3_constructor_Vector3>`\ (\ from\: :ref:`Vector3<class_Vector3>`\ ) |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`Vector3<class_Vector3_constructor_Vector3>`\ (\ from\: :ref:`Vector3i<class_Vector3i>`\ ) |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`Vector3<class_Vector3_constructor_Vector3>`\ (\ x\: :ref:`float<class_float>`, y\: :ref:`float<class_float>`, z\: :ref:`float<class_float>`\ ) |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------+
.. rst-class:: classref-reftable-group
Методи
------------
.. table::
:widths: auto
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`abs<class_Vector3_method_abs>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`angle_to<class_Vector3_method_angle_to>`\ (\ to\: :ref:`Vector3<class_Vector3>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`bezier_derivative<class_Vector3_method_bezier_derivative>`\ (\ control_1\: :ref:`Vector3<class_Vector3>`, control_2\: :ref:`Vector3<class_Vector3>`, end\: :ref:`Vector3<class_Vector3>`, t\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`bezier_interpolate<class_Vector3_method_bezier_interpolate>`\ (\ control_1\: :ref:`Vector3<class_Vector3>`, control_2\: :ref:`Vector3<class_Vector3>`, end\: :ref:`Vector3<class_Vector3>`, t\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`bounce<class_Vector3_method_bounce>`\ (\ n\: :ref:`Vector3<class_Vector3>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`ceil<class_Vector3_method_ceil>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`clamp<class_Vector3_method_clamp>`\ (\ min\: :ref:`Vector3<class_Vector3>`, max\: :ref:`Vector3<class_Vector3>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`clampf<class_Vector3_method_clampf>`\ (\ min\: :ref:`float<class_float>`, max\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`cross<class_Vector3_method_cross>`\ (\ with\: :ref:`Vector3<class_Vector3>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`cubic_interpolate<class_Vector3_method_cubic_interpolate>`\ (\ b\: :ref:`Vector3<class_Vector3>`, pre_a\: :ref:`Vector3<class_Vector3>`, post_b\: :ref:`Vector3<class_Vector3>`, weight\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`cubic_interpolate_in_time<class_Vector3_method_cubic_interpolate_in_time>`\ (\ b\: :ref:`Vector3<class_Vector3>`, pre_a\: :ref:`Vector3<class_Vector3>`, post_b\: :ref:`Vector3<class_Vector3>`, 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:`Vector3<class_Vector3>` | :ref:`direction_to<class_Vector3_method_direction_to>`\ (\ to\: :ref:`Vector3<class_Vector3>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`distance_squared_to<class_Vector3_method_distance_squared_to>`\ (\ to\: :ref:`Vector3<class_Vector3>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`distance_to<class_Vector3_method_distance_to>`\ (\ to\: :ref:`Vector3<class_Vector3>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`dot<class_Vector3_method_dot>`\ (\ with\: :ref:`Vector3<class_Vector3>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`floor<class_Vector3_method_floor>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`inverse<class_Vector3_method_inverse>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_equal_approx<class_Vector3_method_is_equal_approx>`\ (\ to\: :ref:`Vector3<class_Vector3>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_finite<class_Vector3_method_is_finite>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_normalized<class_Vector3_method_is_normalized>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_zero_approx<class_Vector3_method_is_zero_approx>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`length<class_Vector3_method_length>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`length_squared<class_Vector3_method_length_squared>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`lerp<class_Vector3_method_lerp>`\ (\ to\: :ref:`Vector3<class_Vector3>`, weight\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`limit_length<class_Vector3_method_limit_length>`\ (\ length\: :ref:`float<class_float>` = 1.0\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`max<class_Vector3_method_max>`\ (\ with\: :ref:`Vector3<class_Vector3>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`max_axis_index<class_Vector3_method_max_axis_index>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`maxf<class_Vector3_method_maxf>`\ (\ with\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`min<class_Vector3_method_min>`\ (\ with\: :ref:`Vector3<class_Vector3>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`min_axis_index<class_Vector3_method_min_axis_index>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`minf<class_Vector3_method_minf>`\ (\ with\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`move_toward<class_Vector3_method_move_toward>`\ (\ to\: :ref:`Vector3<class_Vector3>`, delta\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`normalized<class_Vector3_method_normalized>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`octahedron_decode<class_Vector3_method_octahedron_decode>`\ (\ uv\: :ref:`Vector2<class_Vector2>`\ ) |static| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`octahedron_encode<class_Vector3_method_octahedron_encode>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Basis<class_Basis>` | :ref:`outer<class_Vector3_method_outer>`\ (\ with\: :ref:`Vector3<class_Vector3>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`posmod<class_Vector3_method_posmod>`\ (\ mod\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`posmodv<class_Vector3_method_posmodv>`\ (\ modv\: :ref:`Vector3<class_Vector3>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`project<class_Vector3_method_project>`\ (\ b\: :ref:`Vector3<class_Vector3>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`reflect<class_Vector3_method_reflect>`\ (\ n\: :ref:`Vector3<class_Vector3>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`rotated<class_Vector3_method_rotated>`\ (\ axis\: :ref:`Vector3<class_Vector3>`, angle\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`round<class_Vector3_method_round>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`sign<class_Vector3_method_sign>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`signed_angle_to<class_Vector3_method_signed_angle_to>`\ (\ to\: :ref:`Vector3<class_Vector3>`, axis\: :ref:`Vector3<class_Vector3>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`slerp<class_Vector3_method_slerp>`\ (\ to\: :ref:`Vector3<class_Vector3>`, weight\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`slide<class_Vector3_method_slide>`\ (\ n\: :ref:`Vector3<class_Vector3>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`snapped<class_Vector3_method_snapped>`\ (\ step\: :ref:`Vector3<class_Vector3>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`snappedf<class_Vector3_method_snappedf>`\ (\ step\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
.. rst-class:: classref-reftable-group
Оператори
------------------
.. table::
:widths: auto
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator !=<class_Vector3_operator_neq_Vector3>`\ (\ right\: :ref:`Vector3<class_Vector3>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`operator *<class_Vector3_operator_mul_Basis>`\ (\ right\: :ref:`Basis<class_Basis>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`operator *<class_Vector3_operator_mul_Quaternion>`\ (\ right\: :ref:`Quaternion<class_Quaternion>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`operator *<class_Vector3_operator_mul_Transform3D>`\ (\ right\: :ref:`Transform3D<class_Transform3D>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`operator *<class_Vector3_operator_mul_Vector3>`\ (\ right\: :ref:`Vector3<class_Vector3>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`operator *<class_Vector3_operator_mul_float>`\ (\ right\: :ref:`float<class_float>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`operator *<class_Vector3_operator_mul_int>`\ (\ right\: :ref:`int<class_int>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`operator +<class_Vector3_operator_sum_Vector3>`\ (\ right\: :ref:`Vector3<class_Vector3>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`operator -<class_Vector3_operator_dif_Vector3>`\ (\ right\: :ref:`Vector3<class_Vector3>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`operator /<class_Vector3_operator_div_Vector3>`\ (\ right\: :ref:`Vector3<class_Vector3>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`operator /<class_Vector3_operator_div_float>`\ (\ right\: :ref:`float<class_float>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`operator /<class_Vector3_operator_div_int>`\ (\ right\: :ref:`int<class_int>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator \<<class_Vector3_operator_lt_Vector3>`\ (\ right\: :ref:`Vector3<class_Vector3>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator \<=<class_Vector3_operator_lte_Vector3>`\ (\ right\: :ref:`Vector3<class_Vector3>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator ==<class_Vector3_operator_eq_Vector3>`\ (\ right\: :ref:`Vector3<class_Vector3>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator ><class_Vector3_operator_gt_Vector3>`\ (\ right\: :ref:`Vector3<class_Vector3>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator >=<class_Vector3_operator_gte_Vector3>`\ (\ right\: :ref:`Vector3<class_Vector3>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`operator []<class_Vector3_operator_idx_int>`\ (\ index\: :ref:`int<class_int>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`operator unary+<class_Vector3_operator_unplus>`\ (\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`operator unary-<class_Vector3_operator_unminus>`\ (\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Переліки
----------------
.. _enum_Vector3_Axis:
.. rst-class:: classref-enumeration
enum **Axis**: :ref:`🔗<enum_Vector3_Axis>`
.. _class_Vector3_constant_AXIS_X:
.. rst-class:: classref-enumeration-constant
:ref:`Axis<enum_Vector3_Axis>` **AXIS_X** = ``0``
Значення переліку для осі X. Повертається методами :ref:`max_axis_index()<class_Vector3_method_max_axis_index>` і :ref:`min_axis_index()<class_Vector3_method_min_axis_index>`.
.. _class_Vector3_constant_AXIS_Y:
.. rst-class:: classref-enumeration-constant
:ref:`Axis<enum_Vector3_Axis>` **AXIS_Y** = ``1``
Значення переліку для осі Y. Повертається методами :ref:`max_axis_index()<class_Vector3_method_max_axis_index>` і :ref:`min_axis_index()<class_Vector3_method_min_axis_index>`.
.. _class_Vector3_constant_AXIS_Z:
.. rst-class:: classref-enumeration-constant
:ref:`Axis<enum_Vector3_Axis>` **AXIS_Z** = ``2``
Значення переліку для осі Z. Повертається методами :ref:`max_axis_index()<class_Vector3_method_max_axis_index>` і :ref:`min_axis_index()<class_Vector3_method_min_axis_index>`.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Константи
------------------
.. _class_Vector3_constant_ZERO:
.. rst-class:: classref-constant
**ZERO** = ``Vector3(0, 0, 0)`` :ref:`🔗<class_Vector3_constant_ZERO>`
Нульовий вектор — вектор, у якого всі компоненти встановлені в ``0``.
.. _class_Vector3_constant_ONE:
.. rst-class:: classref-constant
**ONE** = ``Vector3(1, 1, 1)`` :ref:`🔗<class_Vector3_constant_ONE>`
Одиничний вектор — вектор, у якого всі компоненти встановлені в ``1``.
.. _class_Vector3_constant_INF:
.. rst-class:: classref-constant
**INF** = ``Vector3(inf, inf, inf)`` :ref:`🔗<class_Vector3_constant_INF>`
Вектор нескінченності — вектор, у якого всі компоненти встановлені в :ref:`@GDScript.INF<class_@GDScript_constant_INF>`.
.. _class_Vector3_constant_LEFT:
.. rst-class:: classref-constant
**LEFT** = ``Vector3(-1, 0, 0)`` :ref:`🔗<class_Vector3_constant_LEFT>`
Вектор лівої одиниці. Представляє місцевий напрямок зліва, а також глобальний напрямок заходу.
.. _class_Vector3_constant_RIGHT:
.. rst-class:: classref-constant
**RIGHT** = ``Vector3(1, 0, 0)`` :ref:`🔗<class_Vector3_constant_RIGHT>`
Вектор правого блоку. Представляє місцевий напрямок права, а також глобальний напрямок на схід.
.. _class_Vector3_constant_UP:
.. rst-class:: classref-constant
**UP** = ``Vector3(0, 1, 0)`` :ref:`🔗<class_Vector3_constant_UP>`
Одиничний вектор вверх.
.. _class_Vector3_constant_DOWN:
.. rst-class:: classref-constant
**DOWN** = ``Vector3(0, -1, 0)`` :ref:`🔗<class_Vector3_constant_DOWN>`
Одиничний вектор вниз.
.. _class_Vector3_constant_FORWARD:
.. rst-class:: classref-constant
**FORWARD** = ``Vector3(0, 0, -1)`` :ref:`🔗<class_Vector3_constant_FORWARD>`
Одиничний вектор вперед. Представляє локальний напрямок вперед і глобальний напрямок на північ. Майте на увазі, що напрямок вперед для світла, камер тощо відрізняється від 3D-ресурсів, таких як персонажі, які за домовленістю обернені до камери. Використовуйте константи :ref:`MODEL_FRONT<class_Vector3_constant_MODEL_FRONT>` та подібні під час роботи в просторі 3D-ресурсів.
.. _class_Vector3_constant_BACK:
.. rst-class:: classref-constant
**BACK** = ``Vector3(0, 0, 1)`` :ref:`🔗<class_Vector3_constant_BACK>`
Одиничний вектор назад. Представляє локальний напрямок назад і глобальний напрямок на південь.
.. _class_Vector3_constant_MODEL_LEFT:
.. rst-class:: classref-constant
**MODEL_LEFT** = ``Vector3(1, 0, 0)`` :ref:`🔗<class_Vector3_constant_MODEL_LEFT>`
Одиничний вектор, спрямований у лівий бік імпортованих 3D-ресурсів.
.. _class_Vector3_constant_MODEL_RIGHT:
.. rst-class:: classref-constant
**MODEL_RIGHT** = ``Vector3(-1, 0, 0)`` :ref:`🔗<class_Vector3_constant_MODEL_RIGHT>`
Одиничний вектор, спрямований у правий бік імпортованих 3D-ресурсів.
.. _class_Vector3_constant_MODEL_TOP:
.. rst-class:: classref-constant
**MODEL_TOP** = ``Vector3(0, 1, 0)`` :ref:`🔗<class_Vector3_constant_MODEL_TOP>`
Одиничний вектор, спрямований у верхній бік (вгору) імпортованих 3D-ресурсів.
.. _class_Vector3_constant_MODEL_BOTTOM:
.. rst-class:: classref-constant
**MODEL_BOTTOM** = ``Vector3(0, -1, 0)`` :ref:`🔗<class_Vector3_constant_MODEL_BOTTOM>`
Одиничний вектор, спрямований у нижній бік (вниз) імпортованих 3D-ресурсів.
.. _class_Vector3_constant_MODEL_FRONT:
.. rst-class:: classref-constant
**MODEL_FRONT** = ``Vector3(0, 0, 1)`` :ref:`🔗<class_Vector3_constant_MODEL_FRONT>`
Одиничний вектор, спрямований у передній бік (обличчям вперед) імпортованих 3D-ресурсів.
.. _class_Vector3_constant_MODEL_REAR:
.. rst-class:: classref-constant
**MODEL_REAR** = ``Vector3(0, 0, -1)`` :ref:`🔗<class_Vector3_constant_MODEL_REAR>`
Одиничний вектор, спрямований у задній бік (назад) імпортованих 3D-ресурсів.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Описи властивостей
------------------------------------
.. _class_Vector3_property_x:
.. rst-class:: classref-property
:ref:`float<class_float>` **x** = ``0.0`` :ref:`🔗<class_Vector3_property_x>`
Векторний компонент X. Також доступний за допомогою індексної позиції ``[0]``.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_property_y:
.. rst-class:: classref-property
:ref:`float<class_float>` **y** = ``0.0`` :ref:`🔗<class_Vector3_property_y>`
Векторний компонент Y. Також доступний за допомогою індексної позиції ``[1]``.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_property_z:
.. rst-class:: classref-property
:ref:`float<class_float>` **z** = ``0.0`` :ref:`🔗<class_Vector3_property_z>`
Векторний компонент Z. Також доступний за допомогою індексної позиції ``[2]``.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Описи конструкторів
--------------------------------------
.. _class_Vector3_constructor_Vector3:
.. rst-class:: classref-constructor
:ref:`Vector3<class_Vector3>` **Vector3**\ (\ ) :ref:`🔗<class_Vector3_constructor_Vector3>`
Створює стандартну ініціалізацію **Vector3** з усіма компонентами, встановленими на ``0``.
.. rst-class:: classref-item-separator
----
.. rst-class:: classref-constructor
:ref:`Vector3<class_Vector3>` **Vector3**\ (\ from\: :ref:`Vector3<class_Vector3>`\ )
Створює **Vector3** як копію заданого **Vector3**.
.. rst-class:: classref-item-separator
----
.. rst-class:: classref-constructor
:ref:`Vector3<class_Vector3>` **Vector3**\ (\ from\: :ref:`Vector3i<class_Vector3i>`\ )
Створює новий **Vector3** з :ref:`Vector3i<class_Vector3i>`.
.. rst-class:: classref-item-separator
----
.. rst-class:: classref-constructor
:ref:`Vector3<class_Vector3>` **Vector3**\ (\ x\: :ref:`float<class_float>`, y\: :ref:`float<class_float>`, z\: :ref:`float<class_float>`\ )
Повертає **Vector3** з заданими компонентами.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Описи методів
--------------------------
.. _class_Vector3_method_abs:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **abs**\ (\ ) |const| :ref:`🔗<class_Vector3_method_abs>`
Повертає новий вектор з усіма компонентами в абсолютних значеннях (тобто позитиву).
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_angle_to:
.. rst-class:: classref-method
:ref:`float<class_float>` **angle_to**\ (\ to\: :ref:`Vector3<class_Vector3>`\ ) |const| :ref:`🔗<class_Vector3_method_angle_to>`
Повертає невід’ємний мінімальний кут до заданого вектора, в радіанах.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_bezier_derivative:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **bezier_derivative**\ (\ control_1\: :ref:`Vector3<class_Vector3>`, control_2\: :ref:`Vector3<class_Vector3>`, end\: :ref:`Vector3<class_Vector3>`, t\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector3_method_bezier_derivative>`
Повертає похідну в заданій точці ``t`` на `Кривій Безьє <https://uk.wikipedia.org/wiki/%D0%9A%D1%80%D0%B8%D0%B2%D0%B0_%D0%91%D0%B5%D0%B7%D1%8C%D1%94>`__, визначеній цим вектором і заданими точками ``control_1``, ``control_2``, та ``end``.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_bezier_interpolate:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **bezier_interpolate**\ (\ control_1\: :ref:`Vector3<class_Vector3>`, control_2\: :ref:`Vector3<class_Vector3>`, end\: :ref:`Vector3<class_Vector3>`, t\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector3_method_bezier_interpolate>`
Повертає точку в заданій точці ``t`` на `Кривій Безьє <https://uk.wikipedia.org/wiki/%D0%9A%D1%80%D0%B8%D0%B2%D0%B0_%D0%91%D0%B5%D0%B7%D1%8C%D1%94>`__, визначеній цим вектором і заданими точками ``control_1``, ``control_2``, та ``end``.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_bounce:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **bounce**\ (\ n\: :ref:`Vector3<class_Vector3>`\ ) |const| :ref:`🔗<class_Vector3_method_bounce>`
Повертає вектор, «відбитий» від площини, визначеної заданою нормаллю ``n``.
\ **Примітка:** :ref:`bounce()<class_Vector3_method_bounce>` виконує операцію, яку більшість рушіїв і фреймворків називають ``reflect()``.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_ceil:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **ceil**\ (\ ) |const| :ref:`🔗<class_Vector3_method_ceil>`
Повертає новий вектор, у якого всі компоненти округлені до більшого цілого (до додатної нескінченності).
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_clamp:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **clamp**\ (\ min\: :ref:`Vector3<class_Vector3>`, max\: :ref:`Vector3<class_Vector3>`\ ) |const| :ref:`🔗<class_Vector3_method_clamp>`
Повертає новий вектор, у якого всі компоненти обмежені між відповідними компонентами ``min`` і ``max``, викликаючи :ref:`@GlobalScope.clamp()<class_@GlobalScope_method_clamp>` для кожного компоненту.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_clampf:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **clampf**\ (\ min\: :ref:`float<class_float>`, max\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector3_method_clampf>`
Повертає новий вектор, у якого всі компоненти обмежені між ``min`` і ``max``, викликаючи :ref:`@GlobalScope.clamp()<class_@GlobalScope_method_clamp>` для кожного компоненту.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_cross:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **cross**\ (\ with\: :ref:`Vector3<class_Vector3>`\ ) |const| :ref:`🔗<class_Vector3_method_cross>`
Повертає векторний добуток цього вектора і ``with``.
Це повертає вектор, перпендикулярний до обох векторів (цього і ``with``), що відповідає вектору нормалі площини, визначеної цими двома векторами. Оскільки існує два таких вектори в протилежних напрямках, цей метод повертає той, що визначається правилом правої руки. Якщо два вектори паралельні, метод повертає нульовий вектор, що корисно для перевірки паралельності векторів.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_cubic_interpolate:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **cubic_interpolate**\ (\ b\: :ref:`Vector3<class_Vector3>`, pre_a\: :ref:`Vector3<class_Vector3>`, post_b\: :ref:`Vector3<class_Vector3>`, weight\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector3_method_cubic_interpolate>`
Виконує кубічну інтерполяцію між цим вектором і ``b``, використовуючи ``pre_a`` і ``post_b`` як контрольні точки, та повертає результат у позиції ``weight``. ``weight`` знаходиться в діапазоні від 0.0 до 1.0 і визначає ступінь інтерполяції.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_cubic_interpolate_in_time:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **cubic_interpolate_in_time**\ (\ b\: :ref:`Vector3<class_Vector3>`, pre_a\: :ref:`Vector3<class_Vector3>`, post_b\: :ref:`Vector3<class_Vector3>`, 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_Vector3_method_cubic_interpolate_in_time>`
Виконує кубічну інтерполяцію між цим вектором і ``b``, використовуючи ``pre_a`` і ``post_b`` як контрольні точки, та повертає результат у позиції ``weight``. ``weight`` знаходиться в діапазоні від 0.0 до 1.0 і визначає ступінь інтерполяції.
Може виконувати плавнішу інтерполяцію, ніж :ref:`cubic_interpolate()<class_Vector3_method_cubic_interpolate>`), завдяки використанню значень часу.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_direction_to:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **direction_to**\ (\ to\: :ref:`Vector3<class_Vector3>`\ ) |const| :ref:`🔗<class_Vector3_method_direction_to>`
Повертає нормалізований вектор, що вказує від цього вектора до ``to``. Це еквівалентно виразу ``(b - a).normalized()``.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_distance_squared_to:
.. rst-class:: classref-method
:ref:`float<class_float>` **distance_squared_to**\ (\ to\: :ref:`Vector3<class_Vector3>`\ ) |const| :ref:`🔗<class_Vector3_method_distance_squared_to>`
Повертає квадрат відстані між цим вектором і ``to``.
Цей метод працює швидше, ніж :ref:`distance_to()<class_Vector3_method_distance_to>`, тому надавайте йому перевагу, якщо потрібно порівнювати вектори або використовувати квадрат відстані у формулі.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_distance_to:
.. rst-class:: classref-method
:ref:`float<class_float>` **distance_to**\ (\ to\: :ref:`Vector3<class_Vector3>`\ ) |const| :ref:`🔗<class_Vector3_method_distance_to>`
Повертає відстань між цим вектором і ``до``.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_dot:
.. rst-class:: classref-method
:ref:`float<class_float>` **dot**\ (\ with\: :ref:`Vector3<class_Vector3>`\ ) |const| :ref:`🔗<class_Vector3_method_dot>`
Повертає скалярний добуток цього вектора і ``with``. Це можна використовувати для порівняння кута між двома векторами. Наприклад, цей метод можна застосувати, щоб визначити, чи ворог дивиться на гравця.
Скалярний добуток буде ``0`` для прямого кута (90 градусів), більший за 0, якщо кут менший за 90 градусів і менший за 0, якщо кут більший за 90 градусів.
При використанні одиничних (нормалізованих) векторів результат завжди буде між ``-1.0`` (кут 180 градусів), коли вектори спрямовані в протилежних напрямках, та ``1.0`` (кут 0 градусів), коли вектори співнаправлені.
\ **Примітка:** ``a.dot(b)`` еквівалентно ``b.dot(a)``.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_floor:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **floor**\ (\ ) |const| :ref:`🔗<class_Vector3_method_floor>`
Повертає новий вектор, у якого всі компоненти округлені вниз (до від'ємної нескінченності).
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_inverse:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **inverse**\ (\ ) |const| :ref:`🔗<class_Vector3_method_inverse>`
Повертає обернений вектор. Це те саме, що ``Vector3(1.0 / v.x, 1.0 / v.y, 1.0 / v.z)``.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_is_equal_approx:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_equal_approx**\ (\ to\: :ref:`Vector3<class_Vector3>`\ ) |const| :ref:`🔗<class_Vector3_method_is_equal_approx>`
Повертає ``true``, якщо цей вектор і ``to`` є приблизно рівними, викликаючи :ref:`@GlobalScope.is_equal_approx()<class_@GlobalScope_method_is_equal_approx>` для кожного компоненту.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_is_finite:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_finite**\ (\ ) |const| :ref:`🔗<class_Vector3_method_is_finite>`
Повертає ``true``, якщо цей вектор є скінченним, викликаючи :ref:`@GlobalScope.is_finite()<class_@GlobalScope_method_is_finite>` на кожному компоненту.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_is_normalized:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_normalized**\ (\ ) |const| :ref:`🔗<class_Vector3_method_is_normalized>`
Повертає ``true``, якщо вектор нормалізований, тобто його довжина приблизно дорівнює 1.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_is_zero_approx:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_zero_approx**\ (\ ) |const| :ref:`🔗<class_Vector3_method_is_zero_approx>`
Повертає ``true``, якщо значення цього вектора приблизно дорівнюють нулю, викликаючи :ref:`@GlobalScope.is_zero_approx()<class_@GlobalScope_method_is_zero_approx>` на кожному компоненті.
Цей метод працює швидше, ніж використання :ref:`is_equal_approx()<class_Vector3_method_is_equal_approx>`, із одним значенням як нульовий вектор.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_length:
.. rst-class:: classref-method
:ref:`float<class_float>` **length**\ (\ ) |const| :ref:`🔗<class_Vector3_method_length>`
Повертає довжину (величину) цього вектору.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_length_squared:
.. rst-class:: classref-method
:ref:`float<class_float>` **length_squared**\ (\ ) |const| :ref:`🔗<class_Vector3_method_length_squared>`
Повертає квадрат довжини (квадрат величини) цього вектора.
Цей метод працює швидше, ніж :ref:`length()<class_Vector3_method_length>`, тому віддавайте йому перевагу, якщо вам потрібно порівняти вектори або потрібен квадрат відстані для якоїсь формули.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_lerp:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **lerp**\ (\ to\: :ref:`Vector3<class_Vector3>`, weight\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector3_method_lerp>`
Повертає результат лінійної інтерполяції між цим вектором та ``to`` на величину ``weight``. Значення ``weight`` повинно знаходитися в діапазоні від ``0.0`` до ``1.0`` і представляє ступінь інтерполяції.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_limit_length:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **limit_length**\ (\ length\: :ref:`float<class_float>` = 1.0\ ) |const| :ref:`🔗<class_Vector3_method_limit_length>`
Повертає вектор із максимальною довжиною, обмежуючи його довжину до ``length``. Якщо вектор нескінченний, результат не визначений.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_max:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **max**\ (\ with\: :ref:`Vector3<class_Vector3>`\ ) |const| :ref:`🔗<class_Vector3_method_max>`
Повертає вектор, кожен компонент якого є максимальним серед відповідних компонентів цього вектора та вектора ``with``. Еквівалентно ``Vector3(maxf(x, with.x), maxf(y, with.y), maxf(z, with.z))``.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_max_axis_index:
.. rst-class:: classref-method
:ref:`int<class_int>` **max_axis_index**\ (\ ) |const| :ref:`🔗<class_Vector3_method_max_axis_index>`
Повертає вісь найвищого значення вектора. ``AXIS_*`` константи. Якщо всі компоненти рівні, цей метод повертає :ref:`AXIS_X<class_Vector3_constant_AXIS_X>`.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_maxf:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **maxf**\ (\ with\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector3_method_maxf>`
Повертає компонентний максимум цього вектора і ``with``, еквівалентно ``Vector3(maxf(x, with), maxf(y, with), maxf(z, with))``.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_min:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **min**\ (\ with\: :ref:`Vector3<class_Vector3>`\ ) |const| :ref:`🔗<class_Vector3_method_min>`
Повертає вектор, кожен компонент якого є мінімальним серед відповідного компонента цього вектора та вектора ``with``. Еквівалентно ``Vector3(minf(x, with.x), minf(y, with.y), minf(z, with.z))``.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_min_axis_index:
.. rst-class:: classref-method
:ref:`int<class_int>` **min_axis_index**\ (\ ) |const| :ref:`🔗<class_Vector3_method_min_axis_index>`
Повертає вісь найнижчого значення вектора. ``AXIS_*`` константи. Якщо всі компоненти рівні, цей метод повертає :ref:`AXIS_Z<class_Vector3_constant_AXIS_Z>`.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_minf:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **minf**\ (\ with\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector3_method_minf>`
Повертає компонентний мінімум цього вектора та ``with``. Еквівалентно ``Vector3(minf(x, with), minf(y, with), minf(z, with))``.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_move_toward:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **move_toward**\ (\ to\: :ref:`Vector3<class_Vector3>`, delta\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector3_method_move_toward>`
Повертає новий вектор, зміщений у напрямку ``to`` на фіксовану величину ``delta``. Не виходить за межі кінцевого значення.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_normalized:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **normalized**\ (\ ) |const| :ref:`🔗<class_Vector3_method_normalized>`
Повертає результат масштабування вектора до одиничної довжини. Еквівалентно ``v / v.length()``. Повертає ``(0, 0, 0)``, якщо ``v.length() == 0``. Див. також :ref:`is_normalized()<class_Vector3_method_is_normalized>`.
\ **Примітка:** Ця функція може повертати некоректні значення, якщо довжина вхідного вектора наближена до нуля.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_octahedron_decode:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **octahedron_decode**\ (\ uv\: :ref:`Vector2<class_Vector2>`\ ) |static| :ref:`🔗<class_Vector3_method_octahedron_decode>`
Повертає **Vector3** із октаедрично стиснутої форми, створеної за допомогою :ref:`octahedron_encode()<class_Vector3_method_octahedron_encode>` (збереженої як :ref:`Vector2<class_Vector2>`).
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_octahedron_encode:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **octahedron_encode**\ (\ ) |const| :ref:`🔗<class_Vector3_method_octahedron_encode>`
Повертає октаедрично закодовану (oct32) форму цього **Vector3** у вигляді :ref:`Vector2<class_Vector2>`. Оскільки :ref:`Vector2<class_Vector2>` займає на 1/3 менше пам’яті порівняно з **Vector3**, цей метод стиснення дозволяє передавати більшу кількість нормалізованих (:ref:`normalized()<class_Vector3_method_normalized>`) векторів **Vector3** без збільшення вимог до пам’яті чи сховища. Див. також :ref:`octahedron_decode()<class_Vector3_method_octahedron_decode>`.
\ **Примітка:** :ref:`octahedron_encode()<class_Vector3_method_octahedron_encode>` можна застосовувати лише до нормалізованих (:ref:`normalized()<class_Vector3_method_normalized>`) векторів. Функція *не* перевіряє, чи є **Vector3** нормалізованим, і поверне значення, яке не декодується у вихідний вектор, якщо вхідний **Vector3** не нормалізований.
\ **Примітка:** Октаедричне стиснення є *з втратами*, хоча візуальні відмінності зазвичай непомітні в реальних сценаріях.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_outer:
.. rst-class:: classref-method
:ref:`Basis<class_Basis>` **outer**\ (\ with\: :ref:`Vector3<class_Vector3>`\ ) |const| :ref:`🔗<class_Vector3_method_outer>`
Повертає зовнішній добуток із ``with``.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_posmod:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **posmod**\ (\ mod\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector3_method_posmod>`
Повертає вектор, який складається з :ref:`@GlobalScope.fposmod()<class_@GlobalScope_method_fposmod>` компонентів цього вектора та ``mod``.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_posmodv:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **posmodv**\ (\ modv\: :ref:`Vector3<class_Vector3>`\ ) |const| :ref:`🔗<class_Vector3_method_posmodv>`
Повертає вектор, який складається з :ref:`@GlobalScope.fposmod()<class_@GlobalScope_method_fposmod>` компонентів цього вектора та компонентів ``modv``.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_project:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **project**\ (\ b\: :ref:`Vector3<class_Vector3>`\ ) |const| :ref:`🔗<class_Vector3_method_project>`
Повертає новий вектор, отриманий проєкцією цього вектора на заданий вектор ``b``. Отриманий вектор буде паралельним до ``b``. Див. також :ref:`slide()<class_Vector3_method_slide>`.
\ **Примітка:** Якщо ``b`` є нульовим вектором, компоненти отриманого вектора будуть рівні :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>`.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_reflect:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **reflect**\ (\ n\: :ref:`Vector3<class_Vector3>`\ ) |const| :ref:`🔗<class_Vector3_method_reflect>`
Повертає результат відбиття вектора через площину, визначену заданим вектором нормалі ``n``.
\ **Примітка:** :ref:`reflect()<class_Vector3_method_reflect>` відрізняється від того, що інші рушії та фреймворки називають ``reflect()``. В інших рушіях ``reflect()`` повертає результат вектора, відбитого заданою площиною. Таким чином, відбиття проходить через заданий вектор нормалі. Тоді як у Godot відбиття проходить через площину і може розглядатися як відскок від нормалі. Див. також :ref:`bounce()<class_Vector3_method_bounce>`, який робить те, що більшість рушіїв називають ``reflect()``.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_rotated:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **rotated**\ (\ axis\: :ref:`Vector3<class_Vector3>`, angle\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector3_method_rotated>`
Повертає результат обертання цього вектора навколо заданої осі ``axis`` на кут ``angle`` (у радіанах). Ось має бути нормалізованим вектором. Див. також :ref:`@GlobalScope.deg_to_rad()<class_@GlobalScope_method_deg_to_rad>`.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_round:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **round**\ (\ ) |const| :ref:`🔗<class_Vector3_method_round>`
Повертає новий вектор, у якому всі компоненти округлені до найближчого цілого числа.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_sign:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **sign**\ (\ ) |const| :ref:`🔗<class_Vector3_method_sign>`
Повертає новий вектор, у якому кожен компонент приймає значення ``1.0``, якщо він додатний, ``-1.0``, якщо від'ємний, і ``0.0``, якщо нульовий. Результат ідентичний виклику :ref:`@GlobalScope.sign()<class_@GlobalScope_method_sign>` для кожного компонента.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_signed_angle_to:
.. rst-class:: classref-method
:ref:`float<class_float>` **signed_angle_to**\ (\ to\: :ref:`Vector3<class_Vector3>`, axis\: :ref:`Vector3<class_Vector3>`\ ) |const| :ref:`🔗<class_Vector3_method_signed_angle_to>`
Повертає кут зі знаком до заданого вектора, в радіанах. Знак кута є додатнім при обертанні проти годинникової стрілки та від'ємним — за годинниковою стрілкою, якщо дивитися зі сторони, вказаної віссю ``axis``.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_slerp:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **slerp**\ (\ to\: :ref:`Vector3<class_Vector3>`, weight\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector3_method_slerp>`
Повертає результат сферичної лінійної інтерполяції між цим вектором та ``to``, на величину ``weight``. ``weight`` знаходиться в діапазоні від 0,0 до 1,0, що представляє величину інтерполяції.
Цей метод також обробляє інтерполяцію довжин, якщо вхідні вектори мають різну довжину. Для окремого випадку, коли один або обидва вхідні вектори мають нульову довжину, цей метод поводиться як :ref:`lerp()<class_Vector3_method_lerp>`.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_slide:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **slide**\ (\ n\: :ref:`Vector3<class_Vector3>`\ ) |const| :ref:`🔗<class_Vector3_method_slide>`
Повертає новий вектор, отриманий в результаті ковзання цього вектора вздовж площини з нормаллю ``n``. Отриманий новий вектор є перпендикулярним до ``n`` і еквівалентний цьому вектору мінус його проєкція на ``n``. Дивіться також :ref:`project()<class_Vector3_method_project>`.
\ **Примітка:** Вектор ``n`` має бути нормалізованим. Дивіться також :ref:`normalized()<class_Vector3_method_normalized>`.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_snapped:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **snapped**\ (\ step\: :ref:`Vector3<class_Vector3>`\ ) |const| :ref:`🔗<class_Vector3_method_snapped>`
Повертає новий вектор, кожна компонента якого прив'язана до найближчого кратного відповідної компоненти у векторі ``step``. Це також можна використовувати для заокруглення компонент до довільної кількості знаків після коми.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_snappedf:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **snappedf**\ (\ step\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector3_method_snappedf>`
Повертає новий вектор, кожна компонента якого прив'язана до найближчого кратного значення ``step``. Це також можна використовувати для заокруглення компонент до довільної кількості знаків після коми.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Описи операторів
--------------------------------
.. _class_Vector3_operator_neq_Vector3:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator !=**\ (\ right\: :ref:`Vector3<class_Vector3>`\ ) :ref:`🔗<class_Vector3_operator_neq_Vector3>`
Повертає ``true``, якщо вектори не рівні.
\ **Примітка:** Через помилки точності з плаваючою комою, краще використати :ref:`is_equal_approx()<class_Vector3_method_is_equal_approx>`, який є більш надійним.
\ **Примітка:** Вектори з елементами :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>` не поводяться так само, як інші вектори. Тому результати цього оператора можуть бути неточними, якщо включено NaN.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_operator_mul_Basis:
.. rst-class:: classref-operator
:ref:`Vector3<class_Vector3>` **operator ***\ (\ right\: :ref:`Basis<class_Basis>`\ ) :ref:`🔗<class_Vector3_operator_mul_Basis>`
Обернено трансформує (множить) вектор **Vector3** на задану матрицю :ref:`Basis<class_Basis>` за умови, що базис є ортонормованим (тобто обертання/віддзеркалення припустимі, а масштабування/зкіс — ні).
Вираз ``vector * basis`` еквівалентний до ``basis.transposed() * vector``. Дивіться :ref:`Basis.transposed()<class_Basis_method_transposed>`.
Для трансформації за допомогою оберненого неортонормованого базису (наприклад, з масштабуванням) можна натомість використовувати ``basis.inverse() * vector``. Дивіться :ref:`Basis.inverse()<class_Basis_method_inverse>`.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_operator_mul_Quaternion:
.. rst-class:: classref-operator
:ref:`Vector3<class_Vector3>` **operator ***\ (\ right\: :ref:`Quaternion<class_Quaternion>`\ ) :ref:`🔗<class_Vector3_operator_mul_Quaternion>`
Обернено трансформує (множить) вектор **Vector3** на заданий кватерніон :ref:`Quaternion<class_Quaternion>`.
Вираз ``vector * quaternion`` еквівалентний до ``quaternion.inverse() * vector``. Дивіться :ref:`Quaternion.inverse()<class_Quaternion_method_inverse>`.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_operator_mul_Transform3D:
.. rst-class:: classref-operator
:ref:`Vector3<class_Vector3>` **operator ***\ (\ right\: :ref:`Transform3D<class_Transform3D>`\ ) :ref:`🔗<class_Vector3_operator_mul_Transform3D>`
Обернено трансформує (множить) вектор **Vector3** на задану матрицю трансформації :ref:`Transform3D<class_Transform3D>` за умови, що базис трансформації є ортонормованим (тобто обертання/віддзеркалення припустимі, а масштабування/зкіс — ні).
Вираз ``vector * transform`` еквівалентний до ``transform.inverse() * vector``. Дивіться :ref:`Transform3D.inverse()<class_Transform3D_method_inverse>`.
Для трансформації за допомогою оберненої афінної трансформації (наприклад, з масштабуванням) можна натомість використовувати ``transform.affine_inverse() * vector``. Дивіться :ref:`Transform3D.affine_inverse()<class_Transform3D_method_affine_inverse>`.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_operator_mul_Vector3:
.. rst-class:: classref-operator
:ref:`Vector3<class_Vector3>` **operator ***\ (\ right\: :ref:`Vector3<class_Vector3>`\ ) :ref:`🔗<class_Vector3_operator_mul_Vector3>`
Множить кожну компоненту **Vector3** на компоненти заданого **Vector3**.
::
print(Vector3(10, 20, 30) * Vector3(3, 4, 5)) # Виводить (30.0, 80.0, 150.0)
.. rst-class:: classref-item-separator
----
.. _class_Vector3_operator_mul_float:
.. rst-class:: classref-operator
:ref:`Vector3<class_Vector3>` **operator ***\ (\ right\: :ref:`float<class_float>`\ ) :ref:`🔗<class_Vector3_operator_mul_float>`
Множення кожного компонента **Vector3** заданими :ref:`float<class_float>`.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_operator_mul_int:
.. rst-class:: classref-operator
:ref:`Vector3<class_Vector3>` **operator ***\ (\ right\: :ref:`int<class_int>`\ ) :ref:`🔗<class_Vector3_operator_mul_int>`
Множення кожного компонента **Vector3** заданим :ref:`int<class_int>`.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_operator_sum_Vector3:
.. rst-class:: classref-operator
:ref:`Vector3<class_Vector3>` **operator +**\ (\ right\: :ref:`Vector3<class_Vector3>`\ ) :ref:`🔗<class_Vector3_operator_sum_Vector3>`
Додає кожен компонент **Vector3** до компонентів заданого **Vector3**.
::
print(Vector3(10, 20, 30) + Vector3(3, 4, 5)) # Виводить (13.0, 24.0, 35.0)
.. rst-class:: classref-item-separator
----
.. _class_Vector3_operator_dif_Vector3:
.. rst-class:: classref-operator
:ref:`Vector3<class_Vector3>` **operator -**\ (\ right\: :ref:`Vector3<class_Vector3>`\ ) :ref:`🔗<class_Vector3_operator_dif_Vector3>`
Віднімає кожну компоненту **Vector3** від компонентів заданого **Vector3**.
::
print(Vector3(10, 20, 30) - Vector3(3, 4, 5)) # Виводить (7.0, 16.0, 25.0)
.. rst-class:: classref-item-separator
----
.. _class_Vector3_operator_div_Vector3:
.. rst-class:: classref-operator
:ref:`Vector3<class_Vector3>` **operator /**\ (\ right\: :ref:`Vector3<class_Vector3>`\ ) :ref:`🔗<class_Vector3_operator_div_Vector3>`
Ділить кожну компоненту **Vector3** на компоненти заданого **Vector3**.
::
print(Vector3(10, 20, 30) / Vector3(2, 5, 3)) # Виводить (5.0, 4.0, 10.0)
.. rst-class:: classref-item-separator
----
.. _class_Vector3_operator_div_float:
.. rst-class:: classref-operator
:ref:`Vector3<class_Vector3>` **operator /**\ (\ right\: :ref:`float<class_float>`\ ) :ref:`🔗<class_Vector3_operator_div_float>`
Дивиди кожний компонент **Vector3** відданий :ref:`float<class_float>`.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_operator_div_int:
.. rst-class:: classref-operator
:ref:`Vector3<class_Vector3>` **operator /**\ (\ right\: :ref:`int<class_int>`\ ) :ref:`🔗<class_Vector3_operator_div_int>`
Дивиди кожного компонента **Vector3** за умови :ref:`int<class_int>`.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_operator_lt_Vector3:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator <**\ (\ right\: :ref:`Vector3<class_Vector3>`\ ) :ref:`🔗<class_Vector3_operator_lt_Vector3>`
Порівнює два вектори **Vector3**, спочатку перевіряючи чи значення X у лівого вектора менше за значення ``right`` вектора, і, за рівності X, повторює перевірку для значень Y, а потім Z. Корисно для сортування.
\ **Примітка:** Поведінка векторів з :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>` відрізняється від інших. Через це результати цього методу можуть бути неточними за наявності NaN-ів.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_operator_lte_Vector3:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator <=**\ (\ right\: :ref:`Vector3<class_Vector3>`\ ) :ref:`🔗<class_Vector3_operator_lte_Vector3>`
Порівнює два вектори **Vector3**, спочатку перевіряючи чи значення X у лівого вектора менше чи рівне до ``right`` вектора, і, за рівності X, повторює перевірку для значень Y, а потім Z. Корисно для сортування.
\ **Примітка:** Поведінка векторів з :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>` відрізняється від інших. Через це результати цього методу можуть бути неточними за наявності NaN-ів.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_operator_eq_Vector3:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator ==**\ (\ right\: :ref:`Vector3<class_Vector3>`\ ) :ref:`🔗<class_Vector3_operator_eq_Vector3>`
Повертає ``true``, якщо вектори абсолютно рівні.
\ **Примітка:** Через помилки точності з плаваючою комою, краще використати :ref:`is_equal_approx()<class_Vector3_method_is_equal_approx>`, який є більш надійним.
\ **Примітка:** Вектори з елементами :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>` не поводяться так само, як інші вектори. Тому результати цього оператора можуть бути неточними, якщо включено NaN.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_operator_gt_Vector3:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator >**\ (\ right\: :ref:`Vector3<class_Vector3>`\ ) :ref:`🔗<class_Vector3_operator_gt_Vector3>`
Порівнює два вектори **Vector3**, спочатку перевіряючи чи значення X у лівого вектора більше за значення ``right`` вектора, і, за рівності X, повторює перевірку для значень Y, а потім Z. Корисно для сортування.
\ **Примітка:** Поведінка векторів з :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>` відрізняється від інших. Через це результати цього методу можуть бути неточними за наявності NaN-ів.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_operator_gte_Vector3:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator >=**\ (\ right\: :ref:`Vector3<class_Vector3>`\ ) :ref:`🔗<class_Vector3_operator_gte_Vector3>`
Порівнює два вектори **Vector3**, спочатку перевіряючи чи значення X у лівого вектора більше чи рівне до ``right`` вектора, і, за рівності X, повторює перевірку для значень Y, а потім Z. Корисно для сортування.
\ **Примітка:** Поведінка векторів з :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>` відрізняється від інших. Через це результати цього методу можуть бути неточними за наявності NaN-ів.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_operator_idx_int:
.. rst-class:: classref-operator
:ref:`float<class_float>` **operator []**\ (\ index\: :ref:`int<class_int>`\ ) :ref:`🔗<class_Vector3_operator_idx_int>`
Доступ до векторних компонентів за допомогою їх ``index``. ``v[0]`` еквівалент ``v.x``, ``v`` еквівалент ``v.y``, і ``v[2]`` еквівалент ``v.z``.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_operator_unplus:
.. rst-class:: classref-operator
:ref:`Vector3<class_Vector3>` **operator unary+**\ (\ ) :ref:`🔗<class_Vector3_operator_unplus>`
Повертає однакову вартість, якщо ``+`` не було. `` +`` нічого не робить, але іноді це може зробити ваш код більш читабельним.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_operator_unminus:
.. rst-class:: classref-operator
:ref:`Vector3<class_Vector3>` **operator unary-**\ (\ ) :ref:`🔗<class_Vector3_operator_unminus>`
Повертає негативне значення **Vector3**. Це так само, як написано ``Vector3(-v.x, -v.y, -v.z)``. Ця операція закріплює напрямок вектора, зберігаючи однакову величину. З поплавками число нуль може бути або позитивним або негативним.
.. |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