godotengine/godot-docs-l10n
1
0
Fork 0
mirror of https://github.com/godotengine/godot-docs-l10n.git synced 2026-01-04 10:09:56 +03:00
Code Issues Packages Projects Releases Wiki Activity
Files
4.x
godot-docs-l10n/classes/ru/class_vector2.rst
Rémi Verschelde c3f2364c10 Sync classref with 4.6 branch 
Lots of translations invalidated (fuzzied) as we just synced Weblate.
2025-12-19 16:39:51 +01:00

1295 lines
94 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_Vector2:
Vector2
=======
Двумерный 2D вектор, использующий координаты с плавающей точкой.
.. rst-class:: classref-introduction-group
Описание
----------------
Структура из 2 элементов, которая может использоваться для представления 2D-координат или любой другой пары числовых значений.
Она использует координаты с плавающей точкой. По умолчанию эти значения с плавающей точкой используют 32-битную точность, в отличие от :ref:`float<class_float>`, который всегда 64-битный. Если требуется двойная точность, скомпилируйте движок с опцией ``precision=double``.
См. :ref:`Vector2i<class_Vector2i>` для его целочисленного аналога.
\ **Примечание:** В логическом контексте Vector2 будет оцениваться как ``false``, если он равен ``Vector2(0, 0)``. В противном случае Vector2 всегда будет оцениваться как ``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>`__
- `Все демоверсии 2D <https://github.com/godotengine/godot-demo-projects/tree/master/2d>`__
.. rst-class:: classref-reftable-group
Свойства
----------------
.. table::
:widths: auto
+---------------------------+------------------------------------+---------+
| :ref:`float<class_float>` | :ref:`x<class_Vector2_property_x>` | ``0.0`` |
+---------------------------+------------------------------------+---------+
| :ref:`float<class_float>` | :ref:`y<class_Vector2_property_y>` | ``0.0`` |
+---------------------------+------------------------------------+---------+
.. rst-class:: classref-reftable-group
Конструкторы
------------------------
.. table::
:widths: auto
+-------------------------------+-----------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`Vector2<class_Vector2_constructor_Vector2>`\ (\ ) |
+-------------------------------+-----------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`Vector2<class_Vector2_constructor_Vector2>`\ (\ from\: :ref:`Vector2<class_Vector2>`\ ) |
+-------------------------------+-----------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`Vector2<class_Vector2_constructor_Vector2>`\ (\ from\: :ref:`Vector2i<class_Vector2i>`\ ) |
+-------------------------------+-----------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`Vector2<class_Vector2_constructor_Vector2>`\ (\ x\: :ref:`float<class_float>`, y\: :ref:`float<class_float>`\ ) |
+-------------------------------+-----------------------------------------------------------------------------------------------------------------------+
.. rst-class:: classref-reftable-group
Методы
------------
.. table::
:widths: auto
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`abs<class_Vector2_method_abs>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`angle<class_Vector2_method_angle>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`angle_to<class_Vector2_method_angle_to>`\ (\ to\: :ref:`Vector2<class_Vector2>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`angle_to_point<class_Vector2_method_angle_to_point>`\ (\ to\: :ref:`Vector2<class_Vector2>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`aspect<class_Vector2_method_aspect>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`bezier_derivative<class_Vector2_method_bezier_derivative>`\ (\ control_1\: :ref:`Vector2<class_Vector2>`, control_2\: :ref:`Vector2<class_Vector2>`, end\: :ref:`Vector2<class_Vector2>`, t\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`bezier_interpolate<class_Vector2_method_bezier_interpolate>`\ (\ control_1\: :ref:`Vector2<class_Vector2>`, control_2\: :ref:`Vector2<class_Vector2>`, end\: :ref:`Vector2<class_Vector2>`, t\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`bounce<class_Vector2_method_bounce>`\ (\ n\: :ref:`Vector2<class_Vector2>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`ceil<class_Vector2_method_ceil>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`clamp<class_Vector2_method_clamp>`\ (\ min\: :ref:`Vector2<class_Vector2>`, max\: :ref:`Vector2<class_Vector2>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`clampf<class_Vector2_method_clampf>`\ (\ min\: :ref:`float<class_float>`, max\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`cross<class_Vector2_method_cross>`\ (\ with\: :ref:`Vector2<class_Vector2>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`cubic_interpolate<class_Vector2_method_cubic_interpolate>`\ (\ b\: :ref:`Vector2<class_Vector2>`, pre_a\: :ref:`Vector2<class_Vector2>`, post_b\: :ref:`Vector2<class_Vector2>`, weight\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`cubic_interpolate_in_time<class_Vector2_method_cubic_interpolate_in_time>`\ (\ b\: :ref:`Vector2<class_Vector2>`, pre_a\: :ref:`Vector2<class_Vector2>`, post_b\: :ref:`Vector2<class_Vector2>`, 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:`Vector2<class_Vector2>` | :ref:`direction_to<class_Vector2_method_direction_to>`\ (\ to\: :ref:`Vector2<class_Vector2>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`distance_squared_to<class_Vector2_method_distance_squared_to>`\ (\ to\: :ref:`Vector2<class_Vector2>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`distance_to<class_Vector2_method_distance_to>`\ (\ to\: :ref:`Vector2<class_Vector2>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`dot<class_Vector2_method_dot>`\ (\ with\: :ref:`Vector2<class_Vector2>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`floor<class_Vector2_method_floor>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`from_angle<class_Vector2_method_from_angle>`\ (\ angle\: :ref:`float<class_float>`\ ) |static| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_equal_approx<class_Vector2_method_is_equal_approx>`\ (\ to\: :ref:`Vector2<class_Vector2>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_finite<class_Vector2_method_is_finite>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_normalized<class_Vector2_method_is_normalized>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_zero_approx<class_Vector2_method_is_zero_approx>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`length<class_Vector2_method_length>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`length_squared<class_Vector2_method_length_squared>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`lerp<class_Vector2_method_lerp>`\ (\ to\: :ref:`Vector2<class_Vector2>`, weight\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`limit_length<class_Vector2_method_limit_length>`\ (\ length\: :ref:`float<class_float>` = 1.0\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`max<class_Vector2_method_max>`\ (\ with\: :ref:`Vector2<class_Vector2>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`max_axis_index<class_Vector2_method_max_axis_index>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`maxf<class_Vector2_method_maxf>`\ (\ with\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`min<class_Vector2_method_min>`\ (\ with\: :ref:`Vector2<class_Vector2>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`min_axis_index<class_Vector2_method_min_axis_index>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`minf<class_Vector2_method_minf>`\ (\ with\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`move_toward<class_Vector2_method_move_toward>`\ (\ to\: :ref:`Vector2<class_Vector2>`, delta\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`normalized<class_Vector2_method_normalized>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`orthogonal<class_Vector2_method_orthogonal>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`posmod<class_Vector2_method_posmod>`\ (\ mod\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`posmodv<class_Vector2_method_posmodv>`\ (\ modv\: :ref:`Vector2<class_Vector2>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`project<class_Vector2_method_project>`\ (\ b\: :ref:`Vector2<class_Vector2>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`reflect<class_Vector2_method_reflect>`\ (\ line\: :ref:`Vector2<class_Vector2>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`rotated<class_Vector2_method_rotated>`\ (\ angle\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`round<class_Vector2_method_round>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`sign<class_Vector2_method_sign>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`slerp<class_Vector2_method_slerp>`\ (\ to\: :ref:`Vector2<class_Vector2>`, weight\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`slide<class_Vector2_method_slide>`\ (\ n\: :ref:`Vector2<class_Vector2>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`snapped<class_Vector2_method_snapped>`\ (\ step\: :ref:`Vector2<class_Vector2>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`snappedf<class_Vector2_method_snappedf>`\ (\ step\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
.. rst-class:: classref-reftable-group
Операторы
------------------
.. table::
:widths: auto
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator !=<class_Vector2_operator_neq_Vector2>`\ (\ right\: :ref:`Vector2<class_Vector2>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`operator *<class_Vector2_operator_mul_Transform2D>`\ (\ right\: :ref:`Transform2D<class_Transform2D>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`operator *<class_Vector2_operator_mul_Vector2>`\ (\ right\: :ref:`Vector2<class_Vector2>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`operator *<class_Vector2_operator_mul_float>`\ (\ right\: :ref:`float<class_float>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`operator *<class_Vector2_operator_mul_int>`\ (\ right\: :ref:`int<class_int>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`operator +<class_Vector2_operator_sum_Vector2>`\ (\ right\: :ref:`Vector2<class_Vector2>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`operator -<class_Vector2_operator_dif_Vector2>`\ (\ right\: :ref:`Vector2<class_Vector2>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`operator /<class_Vector2_operator_div_Vector2>`\ (\ right\: :ref:`Vector2<class_Vector2>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`operator /<class_Vector2_operator_div_float>`\ (\ right\: :ref:`float<class_float>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`operator /<class_Vector2_operator_div_int>`\ (\ right\: :ref:`int<class_int>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator \<<class_Vector2_operator_lt_Vector2>`\ (\ right\: :ref:`Vector2<class_Vector2>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator \<=<class_Vector2_operator_lte_Vector2>`\ (\ right\: :ref:`Vector2<class_Vector2>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator ==<class_Vector2_operator_eq_Vector2>`\ (\ right\: :ref:`Vector2<class_Vector2>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator ><class_Vector2_operator_gt_Vector2>`\ (\ right\: :ref:`Vector2<class_Vector2>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator >=<class_Vector2_operator_gte_Vector2>`\ (\ right\: :ref:`Vector2<class_Vector2>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`operator []<class_Vector2_operator_idx_int>`\ (\ index\: :ref:`int<class_int>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`operator unary+<class_Vector2_operator_unplus>`\ (\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`operator unary-<class_Vector2_operator_unminus>`\ (\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Перечисления
------------------------
.. _enum_Vector2_Axis:
.. rst-class:: classref-enumeration
enum **Axis**: :ref:`🔗<enum_Vector2_Axis>`
.. _class_Vector2_constant_AXIS_X:
.. rst-class:: classref-enumeration-constant
:ref:`Axis<enum_Vector2_Axis>` **AXIS_X** = ``0``
Перечисленное значение для оси X. Возвращается :ref:`max_axis_index()<class_Vector2_method_max_axis_index>` и :ref:`min_axis_index()<class_Vector2_method_min_axis_index>`.
.. _class_Vector2_constant_AXIS_Y:
.. rst-class:: classref-enumeration-constant
:ref:`Axis<enum_Vector2_Axis>` **AXIS_Y** = ``1``
Перечисленное значение для оси Y. Возвращается :ref:`max_axis_index()<class_Vector2_method_max_axis_index>` и :ref:`min_axis_index()<class_Vector2_method_min_axis_index>`.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Константы
------------------
.. _class_Vector2_constant_ZERO:
.. rst-class:: classref-constant
**ZERO** = ``Vector2(0, 0)`` :ref:`🔗<class_Vector2_constant_ZERO>`
Нулевой вектор — вектор у которого все координаты равны ``0``.
.. _class_Vector2_constant_ONE:
.. rst-class:: classref-constant
**ONE** = ``Vector2(1, 1)`` :ref:`🔗<class_Vector2_constant_ONE>`
Вектор-единица — вектор у которого все координаты равны ``1``.
.. _class_Vector2_constant_INF:
.. rst-class:: classref-constant
**INF** = ``Vector2(inf, inf)`` :ref:`🔗<class_Vector2_constant_INF>`
Вектор бесконечности, вектор, все компоненты которого установлены в :ref:`@GDScript.INF<class_@GDScript_constant_INF>`.
.. _class_Vector2_constant_LEFT:
.. rst-class:: classref-constant
**LEFT** = ``Vector2(-1, 0)`` :ref:`🔗<class_Vector2_constant_LEFT>`
Левый единичный вектор. Представляет направление влево.
.. _class_Vector2_constant_RIGHT:
.. rst-class:: classref-constant
**RIGHT** = ``Vector2(1, 0)`` :ref:`🔗<class_Vector2_constant_RIGHT>`
Правый единичный вектор. Представляет направление вправо.
.. _class_Vector2_constant_UP:
.. rst-class:: classref-constant
**UP** = ``Vector2(0, -1)`` :ref:`🔗<class_Vector2_constant_UP>`
Up единичный вектор вверх. Y направлен вниз в 2D, поэтому этот вектор указывает на -Y.
.. _class_Vector2_constant_DOWN:
.. rst-class:: classref-constant
**DOWN** = ``Vector2(0, 1)`` :ref:`🔗<class_Vector2_constant_DOWN>`
Down - единичный вектор вниз. Y направлен вниз в 2D, поэтому этот вектор указывает на +Y.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Описания свойств
--------------------------------
.. _class_Vector2_property_x:
.. rst-class:: classref-property
:ref:`float<class_float>` **x** = ``0.0`` :ref:`🔗<class_Vector2_property_x>`
X компонент вектора. Может быть доступен через индекс ``[0]``.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_property_y:
.. rst-class:: classref-property
:ref:`float<class_float>` **y** = ``0.0`` :ref:`🔗<class_Vector2_property_y>`
Y компонент вектора. Может быть доступен через индекс ``[1]``.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Описания конструктора
------------------------------------------
.. _class_Vector2_constructor_Vector2:
.. rst-class:: classref-constructor
:ref:`Vector2<class_Vector2>` **Vector2**\ (\ ) :ref:`🔗<class_Vector2_constructor_Vector2>`
Создает инициализированный по умолчанию **Vector2**, где все компоненты установлены в ``0``.
.. rst-class:: classref-item-separator
----
.. rst-class:: classref-constructor
:ref:`Vector2<class_Vector2>` **Vector2**\ (\ from\: :ref:`Vector2<class_Vector2>`\ )
Создает **Vector2** как копию заданного **Vector2**.
.. rst-class:: classref-item-separator
----
.. rst-class:: classref-constructor
:ref:`Vector2<class_Vector2>` **Vector2**\ (\ from\: :ref:`Vector2i<class_Vector2i>`\ )
Создает новый **Vector2** из :ref:`Vector2i<class_Vector2i>`.
.. rst-class:: classref-item-separator
----
.. rst-class:: classref-constructor
:ref:`Vector2<class_Vector2>` **Vector2**\ (\ x\: :ref:`float<class_float>`, y\: :ref:`float<class_float>`\ )
Создает новый **Vector2** из заданных ``x`` и ``y``.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Описания метода
------------------------------
.. _class_Vector2_method_abs:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **abs**\ (\ ) |const| :ref:`🔗<class_Vector2_method_abs>`
Возвращает новый вектор в котором все компоненты будут абсолютными значениями (т.е положительными).
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_angle:
.. rst-class:: classref-method
:ref:`float<class_float>` **angle**\ (\ ) |const| :ref:`🔗<class_Vector2_method_angle>`
Returns this vector's angle with respect to the positive X axis, or ``(1, 0)`` vector, in radians.
For example, ``Vector2.RIGHT.angle()`` will return zero, ``Vector2.DOWN.angle()`` will return ``PI / 2`` (a quarter turn, or 90 degrees), and ``Vector2(1, -1).angle()`` will return ``-PI / 4`` (a negative eighth turn, or -45 degrees).
This is equivalent to calling :ref:`@GlobalScope.atan2()<class_@GlobalScope_method_atan2>` with :ref:`y<class_Vector2_property_y>` and :ref:`x<class_Vector2_property_x>`.
\ `Illustration of the returned angle. <https://raw.githubusercontent.com/godotengine/godot-docs/master/img/vector2_angle.png>`__
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_angle_to:
.. rst-class:: classref-method
:ref:`float<class_float>` **angle_to**\ (\ to\: :ref:`Vector2<class_Vector2>`\ ) |const| :ref:`🔗<class_Vector2_method_angle_to>`
Returns the signed angle to the given vector, in radians. The result ranges from ``-PI`` to ``PI`` (inclusive).
\ `Illustration of the returned angle. <https://raw.githubusercontent.com/godotengine/godot-docs/master/img/vector2_angle_to.png>`__
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_angle_to_point:
.. rst-class:: classref-method
:ref:`float<class_float>` **angle_to_point**\ (\ to\: :ref:`Vector2<class_Vector2>`\ ) |const| :ref:`🔗<class_Vector2_method_angle_to_point>`
Returns the signed angle between the X axis and the line from this vector to point ``to``, in radians. The result ranges from ``-PI`` to ``PI`` (inclusive).
\ ``a.angle_to_point(b)`` is equivalent to ``(b - a).angle()``. See also :ref:`angle()<class_Vector2_method_angle>`.
\ `Illustration of the returned angle. <https://raw.githubusercontent.com/godotengine/godot-docs/master/img/vector2_angle_to_point.png>`__
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_aspect:
.. rst-class:: classref-method
:ref:`float<class_float>` **aspect**\ (\ ) |const| :ref:`🔗<class_Vector2_method_aspect>`
Returns this vector's aspect ratio, which is :ref:`x<class_Vector2_property_x>` divided by :ref:`y<class_Vector2_property_y>`.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_bezier_derivative:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **bezier_derivative**\ (\ control_1\: :ref:`Vector2<class_Vector2>`, control_2\: :ref:`Vector2<class_Vector2>`, end\: :ref:`Vector2<class_Vector2>`, t\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector2_method_bezier_derivative>`
Возвращает производную по заданному ``t`` на `кривой Безье <https://en.wikipedia.org/wiki/B%C3%A9zier_curve>`__, определенной этим вектором и заданными точками ``control_1``, ``control_2`` и ``end``.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_bezier_interpolate:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **bezier_interpolate**\ (\ control_1\: :ref:`Vector2<class_Vector2>`, control_2\: :ref:`Vector2<class_Vector2>`, end\: :ref:`Vector2<class_Vector2>`, t\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector2_method_bezier_interpolate>`
Возвращает точку с заданным ``t`` на `кривой Безье <https://en.wikipedia.org/wiki/B%C3%A9zier_curve>`__, определенной этим вектором и заданными точками ``control_1``, ``control_2`` и ``end``.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_bounce:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **bounce**\ (\ n\: :ref:`Vector2<class_Vector2>`\ ) |const| :ref:`🔗<class_Vector2_method_bounce>`
Возвращает вектор, «отскочивший» от линии, определенной заданной нормалью ``n``, перпендикулярной линии.
\ **Примечание:** :ref:`bounce()<class_Vector2_method_bounce>` выполняет операцию, которую большинство движков и фреймворков называют ``reflect()``.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_ceil:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **ceil**\ (\ ) |const| :ref:`🔗<class_Vector2_method_ceil>`
Возвращает новый вектор, все компоненты которого округлены в большую сторону (в сторону положительной бесконечности).
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_clamp:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **clamp**\ (\ min\: :ref:`Vector2<class_Vector2>`, max\: :ref:`Vector2<class_Vector2>`\ ) |const| :ref:`🔗<class_Vector2_method_clamp>`
Возвращает новый вектор со всеми компонентами, зажатыми между компонентами ``min`` и ``max``, путем запуска :ref:`@GlobalScope.clamp()<class_@GlobalScope_method_clamp>` для каждого компонента.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_clampf:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **clampf**\ (\ min\: :ref:`float<class_float>`, max\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector2_method_clampf>`
Возвращает новый вектор со всеми компонентами, зажатыми между ``min`` и ``max``, путем запуска :ref:`@GlobalScope.clamp()<class_@GlobalScope_method_clamp>` для каждого компонента.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_cross:
.. rst-class:: classref-method
:ref:`float<class_float>` **cross**\ (\ with\: :ref:`Vector2<class_Vector2>`\ ) |const| :ref:`🔗<class_Vector2_method_cross>`
Возвращает 2D-аналог векторного произведения для этого вектора и ``with``.
Это знаковая площадь параллелограмма, образованного двумя векторами. Если второй вектор отстоит по часовой стрелке от первого вектора, то векторное произведение будет положительной площадью. Если против часовой стрелки, то векторное произведение будет отрицательной площадью. Если два вектора параллельны, это возвращает ноль, что делает его полезным для проверки параллельности двух векторов.
\ **Примечание:** Взаимное произведение не определено в 2D математически. Этот метод встраивает 2D-векторы в плоскость XY 3D-пространства и использует компонент Z их векторного произведения в качестве аналога.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_cubic_interpolate:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **cubic_interpolate**\ (\ b\: :ref:`Vector2<class_Vector2>`, pre_a\: :ref:`Vector2<class_Vector2>`, post_b\: :ref:`Vector2<class_Vector2>`, weight\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector2_method_cubic_interpolate>`
Выполняет кубическую интерполяцию между этим вектором и ``b``, используя ``pre_a`` и ``post_b`` в качестве дескрипторов, и возвращает результат в позиции ``weight``. ``weight`` находится в диапазоне от 0,0 до 1,0, представляя величину интерполяции.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_cubic_interpolate_in_time:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **cubic_interpolate_in_time**\ (\ b\: :ref:`Vector2<class_Vector2>`, pre_a\: :ref:`Vector2<class_Vector2>`, post_b\: :ref:`Vector2<class_Vector2>`, 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_Vector2_method_cubic_interpolate_in_time>`
Выполняет кубическую интерполяцию между этим вектором и ``b``, используя ``pre_a`` и ``post_b`` в качестве дескрипторов, и возвращает результат в позиции ``weight``. ``weight`` находится в диапазоне от 0,0 до 1,0, представляя величину интерполяции.
Он может выполнять более плавную интерполяцию, чем :ref:`cubic_interpolate()<class_Vector2_method_cubic_interpolate>` по значениям времени.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_direction_to:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **direction_to**\ (\ to\: :ref:`Vector2<class_Vector2>`\ ) |const| :ref:`🔗<class_Vector2_method_direction_to>`
Returns the normalized vector pointing from this vector to ``to``.
\ ``a.direction_to(b)`` is equivalent to ``(b - a).normalized()``. See also :ref:`normalized()<class_Vector2_method_normalized>`.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_distance_squared_to:
.. rst-class:: classref-method
:ref:`float<class_float>` **distance_squared_to**\ (\ to\: :ref:`Vector2<class_Vector2>`\ ) |const| :ref:`🔗<class_Vector2_method_distance_squared_to>`
Возвращает квадрат расстояния между этим вектором и ``to``.
Этот метод работает быстрее, чем :ref:`distance_to()<class_Vector2_method_distance_to>`, поэтому предпочитайте его, если вам нужно сравнить векторы или вам нужен квадрат расстояния для какой-то формулы.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_distance_to:
.. rst-class:: classref-method
:ref:`float<class_float>` **distance_to**\ (\ to\: :ref:`Vector2<class_Vector2>`\ ) |const| :ref:`🔗<class_Vector2_method_distance_to>`
Возвращает расстояние между данным вектором и ``to``.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_dot:
.. rst-class:: classref-method
:ref:`float<class_float>` **dot**\ (\ with\: :ref:`Vector2<class_Vector2>`\ ) |const| :ref:`🔗<class_Vector2_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_Vector2_method_floor:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **floor**\ (\ ) |const| :ref:`🔗<class_Vector2_method_floor>`
Возвращает новый вектор, все компоненты которого округлены в меньшую сторону (в сторону отрицательной бесконечности).
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_from_angle:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **from_angle**\ (\ angle\: :ref:`float<class_float>`\ ) |static| :ref:`🔗<class_Vector2_method_from_angle>`
Создает **Vector2**, повернутый на заданный ``angle`` в радианах. Это эквивалентно выполнению ``Vector2(cos(angle), sin(angle))`` или ``Vector2.RIGHT.rotated(angle)``.
::
print(Vector2.from_angle(0)) # Выводит (1.0, 0.0)
print(Vector2(1, 0).angle()) # Выводит 0.0, что является углом, использованным выше.
print(Vector2.from_angle(PI / 2)) # Выводит (0.0, 1.0)
\ **Примечание:** Длина возвращаемого **Vector2** составляет *приблизительно* ``1.0``, но не гарантируется, что она будет равна точно ``1.0`` из-за проблем с точностью чисел с плавающей точкой. Вызовите :ref:`normalized()<class_Vector2_method_normalized>` для возвращенного **Vector2**, если вам требуется единичный вектор.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_is_equal_approx:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_equal_approx**\ (\ to\: :ref:`Vector2<class_Vector2>`\ ) |const| :ref:`🔗<class_Vector2_method_is_equal_approx>`
Возвращает ``true``, если этот вектор и ``to`` приблизительно равны, путем запуска :ref:`@GlobalScope.is_equal_approx()<class_@GlobalScope_method_is_equal_approx>` для каждого компонента.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_is_finite:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_finite**\ (\ ) |const| :ref:`🔗<class_Vector2_method_is_finite>`
Возвращает ``true``, если этот вектор конечен, вызывая :ref:`@GlobalScope.is_finite()<class_@GlobalScope_method_is_finite>` для каждого компонента.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_is_normalized:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_normalized**\ (\ ) |const| :ref:`🔗<class_Vector2_method_is_normalized>`
Возвращает ``true``, если вектор нормализован, т.е. его длина приблизительно равна 1.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_is_zero_approx:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_zero_approx**\ (\ ) |const| :ref:`🔗<class_Vector2_method_is_zero_approx>`
Возвращает ``true``, если значения этого вектора приблизительно равны нулю, выполняя :ref:`@GlobalScope.is_zero_approx()<class_@GlobalScope_method_is_zero_approx>` для каждого компонента.
Этот метод быстрее, чем использование :ref:`is_equal_approx()<class_Vector2_method_is_equal_approx>` с одним значением в качестве нулевого вектора.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_length:
.. rst-class:: classref-method
:ref:`float<class_float>` **length**\ (\ ) |const| :ref:`🔗<class_Vector2_method_length>`
Возвращает длину (величину) данного вектора.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_length_squared:
.. rst-class:: classref-method
:ref:`float<class_float>` **length_squared**\ (\ ) |const| :ref:`🔗<class_Vector2_method_length_squared>`
Возвращает длину данного вектора в квадрате.
Этот метод выполняется быстрее, чем :ref:`length()<class_Vector2_method_length>`, поэтому он предпочтительнее если вам нужно сравнить векторы или нужно расстояние в квадрате для какой-либо формулы.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_lerp:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **lerp**\ (\ to\: :ref:`Vector2<class_Vector2>`, weight\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector2_method_lerp>`
Возвращает результат линейной интерполяции между данным вектором и ``to`` на величину ``weight``. ``weight`` находится в диапазоне от ``0.0`` до ``1.0``, что представляет собой величину интерполяции.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_limit_length:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **limit_length**\ (\ length\: :ref:`float<class_float>` = 1.0\ ) |const| :ref:`🔗<class_Vector2_method_limit_length>`
Возвращает вектор с максимальной длиной, ограничивая его длину до ``length``. Если вектор не конечен, результат не определен.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_max:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **max**\ (\ with\: :ref:`Vector2<class_Vector2>`\ ) |const| :ref:`🔗<class_Vector2_method_max>`
Возвращает покомпонентный максимум этого и ``with``, что эквивалентно ``Vector2(maxf(x, with.x), maxf(y, with.y))``.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_max_axis_index:
.. rst-class:: classref-method
:ref:`int<class_int>` **max_axis_index**\ (\ ) |const| :ref:`🔗<class_Vector2_method_max_axis_index>`
Возвращает ось наибольшего значения вектора. См. константы ``AXIS_*``. Если все компоненты равны, этот метод возвращает :ref:`AXIS_X<class_Vector2_constant_AXIS_X>`.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_maxf:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **maxf**\ (\ with\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector2_method_maxf>`
Возвращает покомпонентный максимум этого и ``with``, что эквивалентно ``Vector2(maxf(x, with), maxf(y, with))``.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_min:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **min**\ (\ with\: :ref:`Vector2<class_Vector2>`\ ) |const| :ref:`🔗<class_Vector2_method_min>`
Возвращает покомпонентный минимум этого и ``with``, эквивалентно ``Vector2(minf(x, with.x), minf(y, with.y))``.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_min_axis_index:
.. rst-class:: classref-method
:ref:`int<class_int>` **min_axis_index**\ (\ ) |const| :ref:`🔗<class_Vector2_method_min_axis_index>`
Возвращает ось наименьшего значения вектора. См. константы ``AXIS_*``. Если все компоненты равны, этот метод возвращает :ref:`AXIS_Y<class_Vector2_constant_AXIS_Y>`.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_minf:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **minf**\ (\ with\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector2_method_minf>`
Возвращает покомпонентный минимум этого и ``with``, эквивалентно ``Vector2(minf(x, with), minf(y, with))``.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_move_toward:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **move_toward**\ (\ to\: :ref:`Vector2<class_Vector2>`, delta\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector2_method_move_toward>`
Возвращает новый вектор, смещенный к ``to`` на фиксированную величину ``delta``. Не выйдет за пределы конечного значения.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_normalized:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **normalized**\ (\ ) |const| :ref:`🔗<class_Vector2_method_normalized>`
Возвращает результат масштабирования вектора до единичной длины. Эквивалентно ``v / v.length()``. Возвращает ``(0, 0)``, если ``v.length() == 0``. См. также :ref:`is_normalized()<class_Vector2_method_is_normalized>`.
\ **Примечание:** Эта функция может возвращать неверные значения, если длина входного вектора близка к нулю.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_orthogonal:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **orthogonal**\ (\ ) |const| :ref:`🔗<class_Vector2_method_orthogonal>`
Возвращает перпендикулярный вектор, повернутый на 90 градусов против часовой стрелки по сравнению с исходным, с той же длиной.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_posmod:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **posmod**\ (\ mod\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector2_method_posmod>`
Возвращает вектор, состоящий из :ref:`@GlobalScope.fposmod()<class_@GlobalScope_method_fposmod>` компонентов этого вектора и ``mod``.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_posmodv:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **posmodv**\ (\ modv\: :ref:`Vector2<class_Vector2>`\ ) |const| :ref:`🔗<class_Vector2_method_posmodv>`
Возвращает вектор, состоящий из :ref:`@GlobalScope.fposmod()<class_@GlobalScope_method_fposmod>` компонентов этого вектора и компонентов ``modv``.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_project:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **project**\ (\ b\: :ref:`Vector2<class_Vector2>`\ ) |const| :ref:`🔗<class_Vector2_method_project>`
Возвращает новый вектор, полученный в результате проецирования этого вектора на заданный вектор ``b``. Результирующий новый вектор параллелен ``b``. См. также :ref:`slide()<class_Vector2_method_slide>`.
\ **Примечание:** Если вектор ``b`` является нулевым вектором, компоненты результирующего нового вектора будут :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>`.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_reflect:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **reflect**\ (\ line\: :ref:`Vector2<class_Vector2>`\ ) |const| :ref:`🔗<class_Vector2_method_reflect>`
Возвращает результат отражения вектора от линии, заданной заданным вектором направления ``line``.
\ **Примечание:** :ref:`reflect()<class_Vector2_method_reflect>` отличается от того, что другие движки и фреймворки называют ``reflect()``. В других движках ``reflect()`` принимает нормальное направление, которое является направлением, перпендикулярным линии. В Godot вы указываете направление линии напрямую. См. также :ref:`bounce()<class_Vector2_method_bounce>`, который делает то, что большинство движков называют ``reflect()``.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_rotated:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **rotated**\ (\ angle\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector2_method_rotated>`
Возвращает результат поворота этого вектора на ``angle`` (в радианах). См. также :ref:`@GlobalScope.deg_to_rad()<class_@GlobalScope_method_deg_to_rad>`.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_round:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **round**\ (\ ) |const| :ref:`🔗<class_Vector2_method_round>`
Возвращает новый вектор, все компоненты которого округлены до ближайшего целого числа, а половинные значения округлены от нуля.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_sign:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **sign**\ (\ ) |const| :ref:`🔗<class_Vector2_method_sign>`
Возвращает новый вектор, в котором каждый компонент установлен на ``1.0``, если он положительный, ``-1.0``, если он отрицательный, и ``0.0``, если он равен нулю. Результат идентичен вызову :ref:`@GlobalScope.sign()<class_@GlobalScope_method_sign>` для каждого компонента.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_slerp:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **slerp**\ (\ to\: :ref:`Vector2<class_Vector2>`, weight\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector2_method_slerp>`
Возвращает результат сферической линейной интерполяции между этим вектором и ``to`` на величину ``weight``. ``weight`` находится в диапазоне от 0,0 до 1,0, представляя величину интерполяции.
Этот метод также обрабатывает интерполяцию длин, если входные векторы имеют разную длину. Для особого случая, когда один или оба входных вектора имеют нулевую длину, этот метод ведет себя как :ref:`lerp()<class_Vector2_method_lerp>`.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_slide:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **slide**\ (\ n\: :ref:`Vector2<class_Vector2>`\ ) |const| :ref:`🔗<class_Vector2_method_slide>`
Возвращает новый вектор, полученный в результате скольжения этого вектора вдоль линии с нормалью ``n``. Результирующий новый вектор перпендикулярен ``n`` и эквивалентен этому вектору за вычетом его проекции на ``n``. См. также :ref:`project()<class_Vector2_method_project>`.
\ **Примечание:** Вектор ``n`` должен быть нормализован. См. также :ref:`normalized()<class_Vector2_method_normalized>`.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_snapped:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **snapped**\ (\ step\: :ref:`Vector2<class_Vector2>`\ ) |const| :ref:`🔗<class_Vector2_method_snapped>`
Возвращает новый вектор, в котором каждый компонент привязан к ближайшему кратному соответствующего компонента в ``step``. Это также можно использовать для округления компонентов до произвольного числа десятичных знаков.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_snappedf:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **snappedf**\ (\ step\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector2_method_snappedf>`
Возвращает новый вектор, в котором каждый компонент привязан к ближайшему кратному ``step``. Это также можно использовать для округления компонентов до произвольного числа десятичных знаков.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Описания оператора
------------------------------------
.. _class_Vector2_operator_neq_Vector2:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator !=**\ (\ right\: :ref:`Vector2<class_Vector2>`\ ) :ref:`🔗<class_Vector2_operator_neq_Vector2>`
Возвращает ``true``, если векторы не равны.
\ **Примечание:** Из-за ошибок точности с плавающей точкой рассмотрите возможность использования :ref:`is_equal_approx()<class_Vector2_method_is_equal_approx>` вместо этого, что более надежно.
\ **Примечание:** Векторы с элементами :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>` ведут себя не так, как другие векторы. Поэтому результаты этого оператора могут быть неточными, если включены NaN-ы.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_operator_mul_Transform2D:
.. rst-class:: classref-operator
:ref:`Vector2<class_Vector2>` **operator ***\ (\ right\: :ref:`Transform2D<class_Transform2D>`\ ) :ref:`🔗<class_Vector2_operator_mul_Transform2D>`
Обратно преобразует (умножает) **Vector2** на заданную матрицу преобразования :ref:`Transform2D<class_Transform2D>`, при условии, что базис преобразования ортонормален (т. е. поворот/отражение хороши, масштабирование/перекос — нет).
\ ``vector * transform`` эквивалентно ``transform.inverse() * vector``. См. :ref:`Transform2D.inverse()<class_Transform2D_method_inverse>`.
Для преобразования с помощью обратного аффинного преобразования (например, с масштабированием) вместо него можно использовать ``transform.affine_inverse() * vector``. См. :ref:`Transform2D.affine_inverse()<class_Transform2D_method_affine_inverse>`.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_operator_mul_Vector2:
.. rst-class:: classref-operator
:ref:`Vector2<class_Vector2>` **operator ***\ (\ right\: :ref:`Vector2<class_Vector2>`\ ) :ref:`🔗<class_Vector2_operator_mul_Vector2>`
Умножает каждый компонент **Vector2** на компоненты заданного **Vector2**.
::
print(Vector2(10, 20) * Vector2(3, 4)) # Выводит (30.0, 80.0)
.. rst-class:: classref-item-separator
----
.. _class_Vector2_operator_mul_float:
.. rst-class:: classref-operator
:ref:`Vector2<class_Vector2>` **operator ***\ (\ right\: :ref:`float<class_float>`\ ) :ref:`🔗<class_Vector2_operator_mul_float>`
Умножает каждый компонент **Vector2** на заданное :ref:`float<class_float>`.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_operator_mul_int:
.. rst-class:: classref-operator
:ref:`Vector2<class_Vector2>` **operator ***\ (\ right\: :ref:`int<class_int>`\ ) :ref:`🔗<class_Vector2_operator_mul_int>`
Умножает каждый компонент **Vector2** на заданное :ref:`int<class_int>`.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_operator_sum_Vector2:
.. rst-class:: classref-operator
:ref:`Vector2<class_Vector2>` **operator +**\ (\ right\: :ref:`Vector2<class_Vector2>`\ ) :ref:`🔗<class_Vector2_operator_sum_Vector2>`
Добавляет каждый компонент **Vector2** к компонентам указанного **Vector2**.
::
print(Vector2(10, 20) + Vector2(3, 4)) # Prints (13.0, 24.0)
.. rst-class:: classref-item-separator
----
.. _class_Vector2_operator_dif_Vector2:
.. rst-class:: classref-operator
:ref:`Vector2<class_Vector2>` **operator -**\ (\ right\: :ref:`Vector2<class_Vector2>`\ ) :ref:`🔗<class_Vector2_operator_dif_Vector2>`
Вычитает каждый компонент **Vector2** из компонентов заданного **Vector2**.
::
print(Vector2(10, 20) - Vector2(3, 4)) # Print (7.0, 16.0)
.. rst-class:: classref-item-separator
----
.. _class_Vector2_operator_div_Vector2:
.. rst-class:: classref-operator
:ref:`Vector2<class_Vector2>` **operator /**\ (\ right\: :ref:`Vector2<class_Vector2>`\ ) :ref:`🔗<class_Vector2_operator_div_Vector2>`
Делит каждый компонент **Vector2** на компоненты заданного **Vector2**.
::
print(Vector2(10, 20) / Vector2(2, 5)) # Prints (5.0, 4.0)
.. rst-class:: classref-item-separator
----
.. _class_Vector2_operator_div_float:
.. rst-class:: classref-operator
:ref:`Vector2<class_Vector2>` **operator /**\ (\ right\: :ref:`float<class_float>`\ ) :ref:`🔗<class_Vector2_operator_div_float>`
Делит каждый компонент **Vector2** на заданное :ref:`float<class_float>`.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_operator_div_int:
.. rst-class:: classref-operator
:ref:`Vector2<class_Vector2>` **operator /**\ (\ right\: :ref:`int<class_int>`\ ) :ref:`🔗<class_Vector2_operator_div_int>`
Делит каждый компонент **Vector2** на заданное :ref:`int<class_int>`.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_operator_lt_Vector2:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator <**\ (\ right\: :ref:`Vector2<class_Vector2>`\ ) :ref:`🔗<class_Vector2_operator_lt_Vector2>`
Сравнивает два вектора **Vector2**, сначала проверяя, меньше ли значение X левого вектора, чем значение X вектора ``right``. Если значения X в точности равны, то он повторяет эту проверку со значениями Y двух векторов. Этот оператор полезен для сортировки векторов.
\ **Примечание:** Векторы с элементами :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>` ведут себя не так, как другие векторы. Поэтому результаты этого оператора могут быть неточными, если включены NaN-ы.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_operator_lte_Vector2:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator <=**\ (\ right\: :ref:`Vector2<class_Vector2>`\ ) :ref:`🔗<class_Vector2_operator_lte_Vector2>`
Сравнивает два вектора **Vector2**, сначала проверяя, меньше ли значение X левого вектора или равно ли ему значение X вектора ``right``. Если значения X в точности равны, то он повторяет эту проверку со значениями Y двух векторов. Этот оператор полезен для сортировки векторов.
\ **Примечание:** Векторы с элементами :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>` ведут себя не так, как другие векторы. Поэтому результаты этого оператора могут быть неточными, если включены NaN-ы.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_operator_eq_Vector2:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator ==**\ (\ right\: :ref:`Vector2<class_Vector2>`\ ) :ref:`🔗<class_Vector2_operator_eq_Vector2>`
Возвращает ``true``, если векторы точно равны.
\ **Примечание:** Из-за ошибок точности с плавающей точкой рассмотрите возможность использования :ref:`is_equal_approx()<class_Vector2_method_is_equal_approx>` вместо этого, что более надежно.
\ **Примечание:** Векторы с элементами :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>` ведут себя не так, как другие векторы. Поэтому результаты этого оператора могут быть неточными, если включены NaN.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_operator_gt_Vector2:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator >**\ (\ right\: :ref:`Vector2<class_Vector2>`\ ) :ref:`🔗<class_Vector2_operator_gt_Vector2>`
Сравнивает два вектора **Vector2**, сначала проверяя, больше ли значение X левого вектора, чем значение X вектора ``right``. Если значения X в точности равны, то он повторяет эту проверку со значениями Y двух векторов. Этот оператор полезен для сортировки векторов.
\ **Примечание:** Векторы с элементами :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>` ведут себя не так, как другие векторы. Поэтому результаты этого оператора могут быть неточными, если включены NaN-ы.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_operator_gte_Vector2:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator >=**\ (\ right\: :ref:`Vector2<class_Vector2>`\ ) :ref:`🔗<class_Vector2_operator_gte_Vector2>`
Сравнивает два вектора **Vector2**, сначала проверяя, больше ли значение X левого вектора или равно ли ему значение X вектора ``right``. Если значения X в точности равны, то он повторяет эту проверку со значениями Y двух векторов. Этот оператор полезен для сортировки векторов.
\ **Примечание:** Векторы с элементами :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>` ведут себя не так, как другие векторы. Поэтому результаты этого оператора могут быть неточными, если включены NaN.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_operator_idx_int:
.. rst-class:: classref-operator
:ref:`float<class_float>` **operator []**\ (\ index\: :ref:`int<class_int>`\ ) :ref:`🔗<class_Vector2_operator_idx_int>`
Доступ к компонентам вектора осуществляется с помощью их ``index``. ``v[0]`` эквивалентно ``v.x``, а ``v[1]`` эквивалентно ``v.y``.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_operator_unplus:
.. rst-class:: classref-operator
:ref:`Vector2<class_Vector2>` **operator unary+**\ (\ ) :ref:`🔗<class_Vector2_operator_unplus>`
Возвращает то же значение, как если бы ``+`` не было. Унарный ``+`` ничего не делает, но иногда он может сделать ваш код более читаемым.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_operator_unminus:
.. rst-class:: classref-operator
:ref:`Vector2<class_Vector2>` **operator unary-**\ (\ ) :ref:`🔗<class_Vector2_operator_unminus>`
Возвращает отрицательное значение **Vector2**. Это то же самое, что и запись ``Vector2(-v.x, -v.y)``. Эта операция меняет направление вектора, сохраняя ту же величину. С плавающей точкой число ноль может быть как положительным, так и отрицательным.
.. |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