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/ru/class_vector3.rst
Rémi Verschelde 369fd84a4f Sync classref with 4.5 branch
2025-12-19 14:34:07 +01:00

1395 lines
101 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
=======
Трехмерный вектор, использующий координаты с плавающей точкой.
.. 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>`
Единичный вектор, направленный к верхней стороне (up) импортированных 3D-ресурсов.
.. _class_Vector3_constant_MODEL_BOTTOM:
.. rst-class:: classref-constant
**MODEL_BOTTOM** = ``Vector3(0, -1, 0)`` :ref:`🔗<class_Vector3_constant_MODEL_BOTTOM>`
Единичный вектор, направленный к нижней стороне (down) импортированных 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>`
Единичный вектор, направленный к задней стороне (back) импортированных 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://en.wikipedia.org/wiki/B%C3%A9zier_curve>`__, определенной этим вектором и заданными точками ``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://en.wikipedia.org/wiki/B%C3%A9zier_curve>`__, определенной этим вектором и заданными точками ``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>`
Возвращает расстояние между данным вектором и ``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>` векторов. :ref:`octahedron_encode()<class_Vector3_method_octahedron_encode>` *не* проверяет, нормализован ли этот **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>`
Возвращает результат вращения этого вектора вокруг заданной оси на ``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)) # Prints (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)) # Prints (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)) # Prints (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 левого вектора, чем значение 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 левого вектора или равно ли ему значение 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 левого вектора, чем значение 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 левого вектора или равно ли ему значение 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[1]`` эквивалентно ``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