mirror of
https://github.com/godotengine/godot-docs-l10n.git
synced 2025-12-31 09:49:22 +03:00
1030 lines
70 KiB
ReStructuredText
1030 lines
70 KiB
ReStructuredText
:github_url: hide
|
||
|
||
.. _class_Vector4:
|
||
|
||
Vector4
|
||
=======
|
||
|
||
Четырехмерный вектор, использующий координаты с плавающей точкой.
|
||
|
||
.. rst-class:: classref-introduction-group
|
||
|
||
Описание
|
||
----------------
|
||
|
||
Структура из 4 элементов, которая может использоваться для представления 4D-координат или любой другой четверки числовых значений.
|
||
|
||
Она использует координаты с плавающей точкой. По умолчанию эти значения с плавающей точкой используют 32-битную точность, в отличие от :ref:`float<class_float>`, который всегда 64-битный. Если требуется двойная точность, скомпилируйте движок с опцией ``precision=double``.
|
||
|
||
См. :ref:`Vector4i<class_Vector4i>` для его целочисленного аналога.
|
||
|
||
\ **Примечание:** В булевом контексте Vector4 будет оцениваться как ``false``, если он равен ``Vector4(0, 0, 0, 0)``. В противном случае Vector4 всегда будет оцениваться как ``true``.
|
||
|
||
.. rst-class:: classref-reftable-group
|
||
|
||
Свойства
|
||
----------------
|
||
|
||
.. table::
|
||
:widths: auto
|
||
|
||
+---------------------------+------------------------------------+---------+
|
||
| :ref:`float<class_float>` | :ref:`w<class_Vector4_property_w>` | ``0.0`` |
|
||
+---------------------------+------------------------------------+---------+
|
||
| :ref:`float<class_float>` | :ref:`x<class_Vector4_property_x>` | ``0.0`` |
|
||
+---------------------------+------------------------------------+---------+
|
||
| :ref:`float<class_float>` | :ref:`y<class_Vector4_property_y>` | ``0.0`` |
|
||
+---------------------------+------------------------------------+---------+
|
||
| :ref:`float<class_float>` | :ref:`z<class_Vector4_property_z>` | ``0.0`` |
|
||
+---------------------------+------------------------------------+---------+
|
||
|
||
.. rst-class:: classref-reftable-group
|
||
|
||
Конструкторы
|
||
------------------------
|
||
|
||
.. table::
|
||
:widths: auto
|
||
|
||
+-------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Vector4<class_Vector4>` | :ref:`Vector4<class_Vector4_constructor_Vector4>`\ (\ ) |
|
||
+-------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Vector4<class_Vector4>` | :ref:`Vector4<class_Vector4_constructor_Vector4>`\ (\ from\: :ref:`Vector4<class_Vector4>`\ ) |
|
||
+-------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Vector4<class_Vector4>` | :ref:`Vector4<class_Vector4_constructor_Vector4>`\ (\ from\: :ref:`Vector4i<class_Vector4i>`\ ) |
|
||
+-------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Vector4<class_Vector4>` | :ref:`Vector4<class_Vector4_constructor_Vector4>`\ (\ x\: :ref:`float<class_float>`, y\: :ref:`float<class_float>`, z\: :ref:`float<class_float>`, w\: :ref:`float<class_float>`\ ) |
|
||
+-------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
|
||
.. rst-class:: classref-reftable-group
|
||
|
||
Методы
|
||
------------
|
||
|
||
.. table::
|
||
:widths: auto
|
||
|
||
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Vector4<class_Vector4>` | :ref:`abs<class_Vector4_method_abs>`\ (\ ) |const| |
|
||
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Vector4<class_Vector4>` | :ref:`ceil<class_Vector4_method_ceil>`\ (\ ) |const| |
|
||
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Vector4<class_Vector4>` | :ref:`clamp<class_Vector4_method_clamp>`\ (\ min\: :ref:`Vector4<class_Vector4>`, max\: :ref:`Vector4<class_Vector4>`\ ) |const| |
|
||
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Vector4<class_Vector4>` | :ref:`clampf<class_Vector4_method_clampf>`\ (\ min\: :ref:`float<class_float>`, max\: :ref:`float<class_float>`\ ) |const| |
|
||
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Vector4<class_Vector4>` | :ref:`cubic_interpolate<class_Vector4_method_cubic_interpolate>`\ (\ b\: :ref:`Vector4<class_Vector4>`, pre_a\: :ref:`Vector4<class_Vector4>`, post_b\: :ref:`Vector4<class_Vector4>`, weight\: :ref:`float<class_float>`\ ) |const| |
|
||
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Vector4<class_Vector4>` | :ref:`cubic_interpolate_in_time<class_Vector4_method_cubic_interpolate_in_time>`\ (\ b\: :ref:`Vector4<class_Vector4>`, pre_a\: :ref:`Vector4<class_Vector4>`, post_b\: :ref:`Vector4<class_Vector4>`, 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:`Vector4<class_Vector4>` | :ref:`direction_to<class_Vector4_method_direction_to>`\ (\ to\: :ref:`Vector4<class_Vector4>`\ ) |const| |
|
||
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`float<class_float>` | :ref:`distance_squared_to<class_Vector4_method_distance_squared_to>`\ (\ to\: :ref:`Vector4<class_Vector4>`\ ) |const| |
|
||
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`float<class_float>` | :ref:`distance_to<class_Vector4_method_distance_to>`\ (\ to\: :ref:`Vector4<class_Vector4>`\ ) |const| |
|
||
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`float<class_float>` | :ref:`dot<class_Vector4_method_dot>`\ (\ with\: :ref:`Vector4<class_Vector4>`\ ) |const| |
|
||
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Vector4<class_Vector4>` | :ref:`floor<class_Vector4_method_floor>`\ (\ ) |const| |
|
||
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Vector4<class_Vector4>` | :ref:`inverse<class_Vector4_method_inverse>`\ (\ ) |const| |
|
||
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`is_equal_approx<class_Vector4_method_is_equal_approx>`\ (\ to\: :ref:`Vector4<class_Vector4>`\ ) |const| |
|
||
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`is_finite<class_Vector4_method_is_finite>`\ (\ ) |const| |
|
||
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`is_normalized<class_Vector4_method_is_normalized>`\ (\ ) |const| |
|
||
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`is_zero_approx<class_Vector4_method_is_zero_approx>`\ (\ ) |const| |
|
||
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`float<class_float>` | :ref:`length<class_Vector4_method_length>`\ (\ ) |const| |
|
||
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`float<class_float>` | :ref:`length_squared<class_Vector4_method_length_squared>`\ (\ ) |const| |
|
||
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Vector4<class_Vector4>` | :ref:`lerp<class_Vector4_method_lerp>`\ (\ to\: :ref:`Vector4<class_Vector4>`, weight\: :ref:`float<class_float>`\ ) |const| |
|
||
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Vector4<class_Vector4>` | :ref:`max<class_Vector4_method_max>`\ (\ with\: :ref:`Vector4<class_Vector4>`\ ) |const| |
|
||
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`int<class_int>` | :ref:`max_axis_index<class_Vector4_method_max_axis_index>`\ (\ ) |const| |
|
||
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Vector4<class_Vector4>` | :ref:`maxf<class_Vector4_method_maxf>`\ (\ with\: :ref:`float<class_float>`\ ) |const| |
|
||
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Vector4<class_Vector4>` | :ref:`min<class_Vector4_method_min>`\ (\ with\: :ref:`Vector4<class_Vector4>`\ ) |const| |
|
||
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`int<class_int>` | :ref:`min_axis_index<class_Vector4_method_min_axis_index>`\ (\ ) |const| |
|
||
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Vector4<class_Vector4>` | :ref:`minf<class_Vector4_method_minf>`\ (\ with\: :ref:`float<class_float>`\ ) |const| |
|
||
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Vector4<class_Vector4>` | :ref:`normalized<class_Vector4_method_normalized>`\ (\ ) |const| |
|
||
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Vector4<class_Vector4>` | :ref:`posmod<class_Vector4_method_posmod>`\ (\ mod\: :ref:`float<class_float>`\ ) |const| |
|
||
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Vector4<class_Vector4>` | :ref:`posmodv<class_Vector4_method_posmodv>`\ (\ modv\: :ref:`Vector4<class_Vector4>`\ ) |const| |
|
||
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Vector4<class_Vector4>` | :ref:`round<class_Vector4_method_round>`\ (\ ) |const| |
|
||
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Vector4<class_Vector4>` | :ref:`sign<class_Vector4_method_sign>`\ (\ ) |const| |
|
||
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Vector4<class_Vector4>` | :ref:`snapped<class_Vector4_method_snapped>`\ (\ step\: :ref:`Vector4<class_Vector4>`\ ) |const| |
|
||
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Vector4<class_Vector4>` | :ref:`snappedf<class_Vector4_method_snappedf>`\ (\ step\: :ref:`float<class_float>`\ ) |const| |
|
||
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
|
||
.. rst-class:: classref-reftable-group
|
||
|
||
Операторы
|
||
------------------
|
||
|
||
.. table::
|
||
:widths: auto
|
||
|
||
+-------------------------------+-------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`operator !=<class_Vector4_operator_neq_Vector4>`\ (\ right\: :ref:`Vector4<class_Vector4>`\ ) |
|
||
+-------------------------------+-------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Vector4<class_Vector4>` | :ref:`operator *<class_Vector4_operator_mul_Projection>`\ (\ right\: :ref:`Projection<class_Projection>`\ ) |
|
||
+-------------------------------+-------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Vector4<class_Vector4>` | :ref:`operator *<class_Vector4_operator_mul_Vector4>`\ (\ right\: :ref:`Vector4<class_Vector4>`\ ) |
|
||
+-------------------------------+-------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Vector4<class_Vector4>` | :ref:`operator *<class_Vector4_operator_mul_float>`\ (\ right\: :ref:`float<class_float>`\ ) |
|
||
+-------------------------------+-------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Vector4<class_Vector4>` | :ref:`operator *<class_Vector4_operator_mul_int>`\ (\ right\: :ref:`int<class_int>`\ ) |
|
||
+-------------------------------+-------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Vector4<class_Vector4>` | :ref:`operator +<class_Vector4_operator_sum_Vector4>`\ (\ right\: :ref:`Vector4<class_Vector4>`\ ) |
|
||
+-------------------------------+-------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Vector4<class_Vector4>` | :ref:`operator -<class_Vector4_operator_dif_Vector4>`\ (\ right\: :ref:`Vector4<class_Vector4>`\ ) |
|
||
+-------------------------------+-------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Vector4<class_Vector4>` | :ref:`operator /<class_Vector4_operator_div_Vector4>`\ (\ right\: :ref:`Vector4<class_Vector4>`\ ) |
|
||
+-------------------------------+-------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Vector4<class_Vector4>` | :ref:`operator /<class_Vector4_operator_div_float>`\ (\ right\: :ref:`float<class_float>`\ ) |
|
||
+-------------------------------+-------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Vector4<class_Vector4>` | :ref:`operator /<class_Vector4_operator_div_int>`\ (\ right\: :ref:`int<class_int>`\ ) |
|
||
+-------------------------------+-------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`operator \<<class_Vector4_operator_lt_Vector4>`\ (\ right\: :ref:`Vector4<class_Vector4>`\ ) |
|
||
+-------------------------------+-------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`operator \<=<class_Vector4_operator_lte_Vector4>`\ (\ right\: :ref:`Vector4<class_Vector4>`\ ) |
|
||
+-------------------------------+-------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`operator ==<class_Vector4_operator_eq_Vector4>`\ (\ right\: :ref:`Vector4<class_Vector4>`\ ) |
|
||
+-------------------------------+-------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`operator ><class_Vector4_operator_gt_Vector4>`\ (\ right\: :ref:`Vector4<class_Vector4>`\ ) |
|
||
+-------------------------------+-------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`operator >=<class_Vector4_operator_gte_Vector4>`\ (\ right\: :ref:`Vector4<class_Vector4>`\ ) |
|
||
+-------------------------------+-------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`float<class_float>` | :ref:`operator []<class_Vector4_operator_idx_int>`\ (\ index\: :ref:`int<class_int>`\ ) |
|
||
+-------------------------------+-------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Vector4<class_Vector4>` | :ref:`operator unary+<class_Vector4_operator_unplus>`\ (\ ) |
|
||
+-------------------------------+-------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Vector4<class_Vector4>` | :ref:`operator unary-<class_Vector4_operator_unminus>`\ (\ ) |
|
||
+-------------------------------+-------------------------------------------------------------------------------------------------------------+
|
||
|
||
.. rst-class:: classref-section-separator
|
||
|
||
----
|
||
|
||
.. rst-class:: classref-descriptions-group
|
||
|
||
Перечисления
|
||
------------------------
|
||
|
||
.. _enum_Vector4_Axis:
|
||
|
||
.. rst-class:: classref-enumeration
|
||
|
||
enum **Axis**: :ref:`🔗<enum_Vector4_Axis>`
|
||
|
||
.. _class_Vector4_constant_AXIS_X:
|
||
|
||
.. rst-class:: classref-enumeration-constant
|
||
|
||
:ref:`Axis<enum_Vector4_Axis>` **AXIS_X** = ``0``
|
||
|
||
Перечисленное значение для оси X. Возвращается :ref:`max_axis_index()<class_Vector4_method_max_axis_index>` и :ref:`min_axis_index()<class_Vector4_method_min_axis_index>`.
|
||
|
||
.. _class_Vector4_constant_AXIS_Y:
|
||
|
||
.. rst-class:: classref-enumeration-constant
|
||
|
||
:ref:`Axis<enum_Vector4_Axis>` **AXIS_Y** = ``1``
|
||
|
||
Перечисленное значение для оси Y. Возвращается :ref:`max_axis_index()<class_Vector4_method_max_axis_index>` и :ref:`min_axis_index()<class_Vector4_method_min_axis_index>`.
|
||
|
||
.. _class_Vector4_constant_AXIS_Z:
|
||
|
||
.. rst-class:: classref-enumeration-constant
|
||
|
||
:ref:`Axis<enum_Vector4_Axis>` **AXIS_Z** = ``2``
|
||
|
||
Перечисленное значение для оси Z. Возвращается :ref:`max_axis_index()<class_Vector4_method_max_axis_index>` и :ref:`min_axis_index()<class_Vector4_method_min_axis_index>`.
|
||
|
||
.. _class_Vector4_constant_AXIS_W:
|
||
|
||
.. rst-class:: classref-enumeration-constant
|
||
|
||
:ref:`Axis<enum_Vector4_Axis>` **AXIS_W** = ``3``
|
||
|
||
Перечисленное значение для оси W. Возвращается :ref:`max_axis_index()<class_Vector4_method_max_axis_index>` и :ref:`min_axis_index()<class_Vector4_method_min_axis_index>`.
|
||
|
||
.. rst-class:: classref-section-separator
|
||
|
||
----
|
||
|
||
.. rst-class:: classref-descriptions-group
|
||
|
||
Константы
|
||
------------------
|
||
|
||
.. _class_Vector4_constant_ZERO:
|
||
|
||
.. rst-class:: classref-constant
|
||
|
||
**ZERO** = ``Vector4(0, 0, 0, 0)`` :ref:`🔗<class_Vector4_constant_ZERO>`
|
||
|
||
Нулевой вектор — вектор у которого все координаты равны ``0``.
|
||
|
||
.. _class_Vector4_constant_ONE:
|
||
|
||
.. rst-class:: classref-constant
|
||
|
||
**ONE** = ``Vector4(1, 1, 1, 1)`` :ref:`🔗<class_Vector4_constant_ONE>`
|
||
|
||
Вектор-единица — вектор у которого все координаты равны ``1``.
|
||
|
||
.. _class_Vector4_constant_INF:
|
||
|
||
.. rst-class:: classref-constant
|
||
|
||
**INF** = ``Vector4(inf, inf, inf, inf)`` :ref:`🔗<class_Vector4_constant_INF>`
|
||
|
||
Вектор бесконечности, вектор, все компоненты которого установлены в :ref:`@GDScript.INF<class_@GDScript_constant_INF>`.
|
||
|
||
.. rst-class:: classref-section-separator
|
||
|
||
----
|
||
|
||
.. rst-class:: classref-descriptions-group
|
||
|
||
Описания свойств
|
||
--------------------------------
|
||
|
||
.. _class_Vector4_property_w:
|
||
|
||
.. rst-class:: classref-property
|
||
|
||
:ref:`float<class_float>` **w** = ``0.0`` :ref:`🔗<class_Vector4_property_w>`
|
||
|
||
Компонент вектора W. Также доступен с помощью индексной позиции ``[3]``.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Vector4_property_x:
|
||
|
||
.. rst-class:: classref-property
|
||
|
||
:ref:`float<class_float>` **x** = ``0.0`` :ref:`🔗<class_Vector4_property_x>`
|
||
|
||
X компонент вектора. Может быть доступен через индекс ``[0]``.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Vector4_property_y:
|
||
|
||
.. rst-class:: classref-property
|
||
|
||
:ref:`float<class_float>` **y** = ``0.0`` :ref:`🔗<class_Vector4_property_y>`
|
||
|
||
Y компонент вектора. Может быть доступен через индекс ``[1]``.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Vector4_property_z:
|
||
|
||
.. rst-class:: classref-property
|
||
|
||
:ref:`float<class_float>` **z** = ``0.0`` :ref:`🔗<class_Vector4_property_z>`
|
||
|
||
Z компонент вектора. Также может быть доступен по индексу ``[2]``.
|
||
|
||
.. rst-class:: classref-section-separator
|
||
|
||
----
|
||
|
||
.. rst-class:: classref-descriptions-group
|
||
|
||
Описания конструктора
|
||
------------------------------------------
|
||
|
||
.. _class_Vector4_constructor_Vector4:
|
||
|
||
.. rst-class:: classref-constructor
|
||
|
||
:ref:`Vector4<class_Vector4>` **Vector4**\ (\ ) :ref:`🔗<class_Vector4_constructor_Vector4>`
|
||
|
||
Создает инициализированный по умолчанию **Vector4**, где все компоненты установлены в ``0``.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. rst-class:: classref-constructor
|
||
|
||
:ref:`Vector4<class_Vector4>` **Vector4**\ (\ from\: :ref:`Vector4<class_Vector4>`\ )
|
||
|
||
Создает **Vector4** как копию заданного **Vector4**.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. rst-class:: classref-constructor
|
||
|
||
:ref:`Vector4<class_Vector4>` **Vector4**\ (\ from\: :ref:`Vector4i<class_Vector4i>`\ )
|
||
|
||
Создает новый **Vector4** из заданного :ref:`Vector4i<class_Vector4i>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. rst-class:: classref-constructor
|
||
|
||
:ref:`Vector4<class_Vector4>` **Vector4**\ (\ x\: :ref:`float<class_float>`, y\: :ref:`float<class_float>`, z\: :ref:`float<class_float>`, w\: :ref:`float<class_float>`\ )
|
||
|
||
Возвращает **Vector4** с заданными компонентами.
|
||
|
||
.. rst-class:: classref-section-separator
|
||
|
||
----
|
||
|
||
.. rst-class:: classref-descriptions-group
|
||
|
||
Описания метода
|
||
------------------------------
|
||
|
||
.. _class_Vector4_method_abs:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`Vector4<class_Vector4>` **abs**\ (\ ) |const| :ref:`🔗<class_Vector4_method_abs>`
|
||
|
||
Возвращает новый вектор в котором все компоненты будут абсолютными значениями (т.е положительными).
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Vector4_method_ceil:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`Vector4<class_Vector4>` **ceil**\ (\ ) |const| :ref:`🔗<class_Vector4_method_ceil>`
|
||
|
||
Возвращает новый вектор, все компоненты которого округлены в большую сторону (в сторону положительной бесконечности).
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Vector4_method_clamp:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`Vector4<class_Vector4>` **clamp**\ (\ min\: :ref:`Vector4<class_Vector4>`, max\: :ref:`Vector4<class_Vector4>`\ ) |const| :ref:`🔗<class_Vector4_method_clamp>`
|
||
|
||
Возвращает новый вектор со всеми компонентами, зажатыми между компонентами ``min`` и ``max``, путем запуска :ref:`@GlobalScope.clamp()<class_@GlobalScope_method_clamp>` для каждого компонента.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Vector4_method_clampf:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`Vector4<class_Vector4>` **clampf**\ (\ min\: :ref:`float<class_float>`, max\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector4_method_clampf>`
|
||
|
||
Возвращает новый вектор со всеми компонентами, зажатыми между ``min`` и ``max``, путем запуска :ref:`@GlobalScope.clamp()<class_@GlobalScope_method_clamp>` для каждого компонента.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Vector4_method_cubic_interpolate:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`Vector4<class_Vector4>` **cubic_interpolate**\ (\ b\: :ref:`Vector4<class_Vector4>`, pre_a\: :ref:`Vector4<class_Vector4>`, post_b\: :ref:`Vector4<class_Vector4>`, weight\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector4_method_cubic_interpolate>`
|
||
|
||
Выполняет кубическую интерполяцию между этим вектором и ``b``, используя ``pre_a`` и ``post_b`` в качестве дескрипторов, и возвращает результат в позиции ``weight``. ``weight`` находится в диапазоне от 0,0 до 1,0, представляя величину интерполяции.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Vector4_method_cubic_interpolate_in_time:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`Vector4<class_Vector4>` **cubic_interpolate_in_time**\ (\ b\: :ref:`Vector4<class_Vector4>`, pre_a\: :ref:`Vector4<class_Vector4>`, post_b\: :ref:`Vector4<class_Vector4>`, 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_Vector4_method_cubic_interpolate_in_time>`
|
||
|
||
Выполняет кубическую интерполяцию между этим вектором и ``b``, используя ``pre_a`` и ``post_b`` в качестве дескрипторов, и возвращает результат в позиции ``weight``. ``weight`` находится в диапазоне от 0,0 до 1,0, представляя величину интерполяции.
|
||
|
||
Он может выполнять более плавную интерполяцию, чем :ref:`cubic_interpolate()<class_Vector4_method_cubic_interpolate>` по значениям времени.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Vector4_method_direction_to:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`Vector4<class_Vector4>` **direction_to**\ (\ to\: :ref:`Vector4<class_Vector4>`\ ) |const| :ref:`🔗<class_Vector4_method_direction_to>`
|
||
|
||
Возвращает нормализованный вектор, указывающий из этого вектора на ``to``. Это эквивалентно использованию ``(b - a).normalized()``.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Vector4_method_distance_squared_to:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`float<class_float>` **distance_squared_to**\ (\ to\: :ref:`Vector4<class_Vector4>`\ ) |const| :ref:`🔗<class_Vector4_method_distance_squared_to>`
|
||
|
||
Возвращает квадрат расстояния между этим вектором и ``to``.
|
||
|
||
Этот метод работает быстрее, чем :ref:`distance_to()<class_Vector4_method_distance_to>`, поэтому предпочитайте его, если вам нужно сравнить векторы или вам нужен квадрат расстояния для какой-то формулы.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Vector4_method_distance_to:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`float<class_float>` **distance_to**\ (\ to\: :ref:`Vector4<class_Vector4>`\ ) |const| :ref:`🔗<class_Vector4_method_distance_to>`
|
||
|
||
Возвращает расстояние между данным вектором и ``to``.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Vector4_method_dot:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`float<class_float>` **dot**\ (\ with\: :ref:`Vector4<class_Vector4>`\ ) |const| :ref:`🔗<class_Vector4_method_dot>`
|
||
|
||
Возвращает скалярное произведение данного вектора и ``with``.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Vector4_method_floor:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`Vector4<class_Vector4>` **floor**\ (\ ) |const| :ref:`🔗<class_Vector4_method_floor>`
|
||
|
||
Возвращает новый вектор, все компоненты которого округлены в меньшую сторону (в сторону отрицательной бесконечности).
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Vector4_method_inverse:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`Vector4<class_Vector4>` **inverse**\ (\ ) |const| :ref:`🔗<class_Vector4_method_inverse>`
|
||
|
||
Возвращает обратный вектор. Это то же самое, что ``Vector4(1.0 / v.x, 1.0 / v.y, 1.0 / v.z, 1.0 / v.w)``.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Vector4_method_is_equal_approx:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`bool<class_bool>` **is_equal_approx**\ (\ to\: :ref:`Vector4<class_Vector4>`\ ) |const| :ref:`🔗<class_Vector4_method_is_equal_approx>`
|
||
|
||
Возвращает ``true``, если этот вектор и ``to`` приблизительно равны, путем запуска :ref:`@GlobalScope.is_equal_approx()<class_@GlobalScope_method_is_equal_approx>` для каждого компонента.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Vector4_method_is_finite:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`bool<class_bool>` **is_finite**\ (\ ) |const| :ref:`🔗<class_Vector4_method_is_finite>`
|
||
|
||
Возвращает ``true``, если этот вектор конечен, вызывая :ref:`@GlobalScope.is_finite()<class_@GlobalScope_method_is_finite>` для каждого компонента.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Vector4_method_is_normalized:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`bool<class_bool>` **is_normalized**\ (\ ) |const| :ref:`🔗<class_Vector4_method_is_normalized>`
|
||
|
||
Возвращает ``true``, если вектор нормализован, т.е. его длина приблизительно равна 1.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Vector4_method_is_zero_approx:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`bool<class_bool>` **is_zero_approx**\ (\ ) |const| :ref:`🔗<class_Vector4_method_is_zero_approx>`
|
||
|
||
Возвращает ``true``, если значения этого вектора приблизительно равны нулю, выполняя :ref:`@GlobalScope.is_zero_approx()<class_@GlobalScope_method_is_zero_approx>` для каждого компонента.
|
||
|
||
Этот метод быстрее, чем использование :ref:`is_equal_approx()<class_Vector4_method_is_equal_approx>` с одним значением в качестве нулевого вектора.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Vector4_method_length:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`float<class_float>` **length**\ (\ ) |const| :ref:`🔗<class_Vector4_method_length>`
|
||
|
||
Возвращает длину (величину) данного вектора.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Vector4_method_length_squared:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`float<class_float>` **length_squared**\ (\ ) |const| :ref:`🔗<class_Vector4_method_length_squared>`
|
||
|
||
Возвращает длину данного вектора в квадрате.
|
||
|
||
Этот метод выполняется быстрее, чем :ref:`length()<class_Vector4_method_length>`, поэтому он предпочтительнее если вам нужно сравнить векторы или нужно расстояние в квадрате для какой-либо формулы.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Vector4_method_lerp:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`Vector4<class_Vector4>` **lerp**\ (\ to\: :ref:`Vector4<class_Vector4>`, weight\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector4_method_lerp>`
|
||
|
||
Возвращает результат линейной интерполяции между данным вектором и ``to`` на величину ``weight``. ``weight`` находится в диапазоне от ``0.0`` до ``1.0``, что представляет собой величину интерполяции.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Vector4_method_max:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`Vector4<class_Vector4>` **max**\ (\ with\: :ref:`Vector4<class_Vector4>`\ ) |const| :ref:`🔗<class_Vector4_method_max>`
|
||
|
||
Возвращает покомпонентный максимум этого и ``with``, что эквивалентно ``Vector4(maxf(x, with.x), maxf(y, with.y), maxf(z, with.z), maxf(w, with.w))``.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Vector4_method_max_axis_index:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`int<class_int>` **max_axis_index**\ (\ ) |const| :ref:`🔗<class_Vector4_method_max_axis_index>`
|
||
|
||
Возвращает ось наибольшего значения вектора. См. константы ``AXIS_*``. Если все компоненты равны, этот метод возвращает :ref:`AXIS_X<class_Vector4_constant_AXIS_X>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Vector4_method_maxf:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`Vector4<class_Vector4>` **maxf**\ (\ with\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector4_method_maxf>`
|
||
|
||
Возвращает покомпонентный максимум этого и ``with``, что эквивалентно ``Vector4(maxf(x, with), maxf(y, with), maxf(z, with), maxf(w, with))``.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Vector4_method_min:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`Vector4<class_Vector4>` **min**\ (\ with\: :ref:`Vector4<class_Vector4>`\ ) |const| :ref:`🔗<class_Vector4_method_min>`
|
||
|
||
Возвращает покомпонентный минимум этого и ``with``, эквивалентный ``Vector4(minf(x, with.x), minf(y, with.y), minf(z, with.z), minf(w, with.w))``.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Vector4_method_min_axis_index:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`int<class_int>` **min_axis_index**\ (\ ) |const| :ref:`🔗<class_Vector4_method_min_axis_index>`
|
||
|
||
Возвращает ось наименьшего значения вектора. См. константы ``AXIS_*``. Если все компоненты равны, этот метод возвращает :ref:`AXIS_W<class_Vector4_constant_AXIS_W>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Vector4_method_minf:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`Vector4<class_Vector4>` **minf**\ (\ with\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector4_method_minf>`
|
||
|
||
Возвращает покомпонентный минимум этого и ``with``, эквивалентно ``Vector4(minf(x, with), minf(y, with), minf(z, with), minf(w, with))``.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Vector4_method_normalized:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`Vector4<class_Vector4>` **normalized**\ (\ ) |const| :ref:`🔗<class_Vector4_method_normalized>`
|
||
|
||
Возвращает результат масштабирования вектора до единичной длины. Эквивалентно ``v / v.length()``. Возвращает ``(0, 0, 0, 0)``, если ``v.length() == 0``. См. также :ref:`is_normalized()<class_Vector4_method_is_normalized>`.
|
||
|
||
\ **Примечание:** Эта функция может возвращать неверные значения, если длина входного вектора близка к нулю.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Vector4_method_posmod:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`Vector4<class_Vector4>` **posmod**\ (\ mod\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector4_method_posmod>`
|
||
|
||
Возвращает вектор, состоящий из :ref:`@GlobalScope.fposmod()<class_@GlobalScope_method_fposmod>` компонентов этого вектора и ``mod``.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Vector4_method_posmodv:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`Vector4<class_Vector4>` **posmodv**\ (\ modv\: :ref:`Vector4<class_Vector4>`\ ) |const| :ref:`🔗<class_Vector4_method_posmodv>`
|
||
|
||
Возвращает вектор, состоящий из :ref:`@GlobalScope.fposmod()<class_@GlobalScope_method_fposmod>` компонентов этого вектора и компонентов ``modv``.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Vector4_method_round:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`Vector4<class_Vector4>` **round**\ (\ ) |const| :ref:`🔗<class_Vector4_method_round>`
|
||
|
||
Возвращает новый вектор, все компоненты которого округлены до ближайшего целого числа, а половинные значения округлены от нуля.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Vector4_method_sign:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`Vector4<class_Vector4>` **sign**\ (\ ) |const| :ref:`🔗<class_Vector4_method_sign>`
|
||
|
||
Возвращает новый вектор, в котором каждый компонент установлен на ``1.0``, если он положительный, ``-1.0``, если он отрицательный, и ``0.0``, если он равен нулю. Результат идентичен вызову :ref:`@GlobalScope.sign()<class_@GlobalScope_method_sign>` для каждого компонента.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Vector4_method_snapped:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`Vector4<class_Vector4>` **snapped**\ (\ step\: :ref:`Vector4<class_Vector4>`\ ) |const| :ref:`🔗<class_Vector4_method_snapped>`
|
||
|
||
Возвращает новый вектор, в котором каждый компонент привязан к ближайшему кратному соответствующего компонента в ``step``. Это также можно использовать для округления компонентов до произвольного числа десятичных знаков.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Vector4_method_snappedf:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`Vector4<class_Vector4>` **snappedf**\ (\ step\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector4_method_snappedf>`
|
||
|
||
Возвращает новый вектор, в котором каждый компонент привязан к ближайшему кратному ``step``. Это также можно использовать для округления компонентов до произвольного числа десятичных знаков.
|
||
|
||
.. rst-class:: classref-section-separator
|
||
|
||
----
|
||
|
||
.. rst-class:: classref-descriptions-group
|
||
|
||
Описания оператора
|
||
------------------------------------
|
||
|
||
.. _class_Vector4_operator_neq_Vector4:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`bool<class_bool>` **operator !=**\ (\ right\: :ref:`Vector4<class_Vector4>`\ ) :ref:`🔗<class_Vector4_operator_neq_Vector4>`
|
||
|
||
Возвращает ``true``, если векторы не равны.
|
||
|
||
\ **Примечание:** Из-за ошибок точности с плавающей точкой рассмотрите возможность использования :ref:`is_equal_approx()<class_Vector4_method_is_equal_approx>` вместо этого, что более надежно.
|
||
|
||
\ **Примечание:** Векторы с элементами :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>` ведут себя не так, как другие векторы. Поэтому результаты этого оператора могут быть неточными, если включены NaN-ы.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Vector4_operator_mul_Projection:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`Vector4<class_Vector4>` **operator ***\ (\ right\: :ref:`Projection<class_Projection>`\ ) :ref:`🔗<class_Vector4_operator_mul_Projection>`
|
||
|
||
Преобразует (умножает) **Vector4** на транспонированную заданную матрицу :ref:`Projection<class_Projection>`.
|
||
|
||
Для преобразования путем инверсии проекции ``projection.inverse() * vector`` можно использовать вместо этого. См. :ref:`Projection.inverse()<class_Projection_method_inverse>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Vector4_operator_mul_Vector4:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`Vector4<class_Vector4>` **operator ***\ (\ right\: :ref:`Vector4<class_Vector4>`\ ) :ref:`🔗<class_Vector4_operator_mul_Vector4>`
|
||
|
||
Умножает каждый компонент **Vector4** на компоненты заданного **Vector4**.
|
||
|
||
::
|
||
|
||
print(Vector4(10, 20, 30, 40) * Vector4(3, 4, 5, 6)) # Выводит (30.0, 80.0, 150.0, 240.0)
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Vector4_operator_mul_float:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`Vector4<class_Vector4>` **operator ***\ (\ right\: :ref:`float<class_float>`\ ) :ref:`🔗<class_Vector4_operator_mul_float>`
|
||
|
||
Умножает каждый компонент **Vector4** на заданное :ref:`float<class_float>`.
|
||
|
||
::
|
||
|
||
print(Vector4(10, 20, 30, 40) * 2) # Выводит (20.0, 40.0, 60.0, 80.0)
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Vector4_operator_mul_int:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`Vector4<class_Vector4>` **operator ***\ (\ right\: :ref:`int<class_int>`\ ) :ref:`🔗<class_Vector4_operator_mul_int>`
|
||
|
||
Умножает каждый компонент **Vector4** на заданное :ref:`int<class_int>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Vector4_operator_sum_Vector4:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`Vector4<class_Vector4>` **operator +**\ (\ right\: :ref:`Vector4<class_Vector4>`\ ) :ref:`🔗<class_Vector4_operator_sum_Vector4>`
|
||
|
||
Добавляет каждый компонент **Vector4** к компонентам указанного **Vector4**.
|
||
|
||
::
|
||
|
||
print(Vector4(10, 20, 30, 40) + Vector4(3, 4, 5, 6)) # Prints (13.0, 24.0, 35.0, 46.0)
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Vector4_operator_dif_Vector4:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`Vector4<class_Vector4>` **operator -**\ (\ right\: :ref:`Vector4<class_Vector4>`\ ) :ref:`🔗<class_Vector4_operator_dif_Vector4>`
|
||
|
||
Вычитает каждый компонент **Vector4** из компонентов заданного **Vector4**.
|
||
|
||
::
|
||
|
||
print(Vector4(10, 20, 30, 40) - Vector4(3, 4, 5, 6)) # Prints (7.0, 16.0, 25.0, 34.0)
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Vector4_operator_div_Vector4:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`Vector4<class_Vector4>` **operator /**\ (\ right\: :ref:`Vector4<class_Vector4>`\ ) :ref:`🔗<class_Vector4_operator_div_Vector4>`
|
||
|
||
Делит каждый компонент **Vector4** на компоненты заданного **Vector4**.
|
||
|
||
::
|
||
|
||
print(Vector4(10, 20, 30, 40) / Vector4(2, 5, 3, 4)) # Prints (5.0, 4.0, 10.0, 10.0)
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Vector4_operator_div_float:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`Vector4<class_Vector4>` **operator /**\ (\ right\: :ref:`float<class_float>`\ ) :ref:`🔗<class_Vector4_operator_div_float>`
|
||
|
||
Делит каждый компонент **Vector4** на заданное :ref:`float<class_float>`.
|
||
|
||
::
|
||
|
||
print(Vector4(10, 20, 30, 40) / 2) # Prints (5.0, 10.0, 15.0, 20.0)
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Vector4_operator_div_int:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`Vector4<class_Vector4>` **operator /**\ (\ right\: :ref:`int<class_int>`\ ) :ref:`🔗<class_Vector4_operator_div_int>`
|
||
|
||
Делит каждый компонент **Vector4** на заданное :ref:`int<class_int>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Vector4_operator_lt_Vector4:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`bool<class_bool>` **operator <**\ (\ right\: :ref:`Vector4<class_Vector4>`\ ) :ref:`🔗<class_Vector4_operator_lt_Vector4>`
|
||
|
||
Сравнивает два вектора **Vector4**, сначала проверяя, меньше ли значение X левого вектора, чем значение X вектора ``right``. Если значения X в точности равны, то он повторяет эту проверку со значениями Y двух векторов, значениями Z двух векторов, а затем со значениями W. Этот оператор полезен для сортировки векторов.
|
||
|
||
\ **Примечание:** Векторы с элементами :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>` ведут себя не так, как другие векторы. Поэтому результаты этого оператора могут быть неточными, если включены NaN-ы.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Vector4_operator_lte_Vector4:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`bool<class_bool>` **operator <=**\ (\ right\: :ref:`Vector4<class_Vector4>`\ ) :ref:`🔗<class_Vector4_operator_lte_Vector4>`
|
||
|
||
Сравнивает два вектора **Vector4**, сначала проверяя, меньше ли значение X левого вектора или равно ли ему значение X вектора ``right``. Если значения X в точности равны, то он повторяет эту проверку со значениями Y двух векторов, значениями Z двух векторов, а затем со значениями W. Этот оператор полезен для сортировки векторов.
|
||
|
||
\ **Примечание:** Векторы с элементами :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>` ведут себя не так, как другие векторы. Поэтому результаты этого оператора могут быть неточными, если включены NaN.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Vector4_operator_eq_Vector4:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`bool<class_bool>` **operator ==**\ (\ right\: :ref:`Vector4<class_Vector4>`\ ) :ref:`🔗<class_Vector4_operator_eq_Vector4>`
|
||
|
||
Возвращает ``true``, если векторы точно равны.
|
||
|
||
\ **Примечание:** Из-за ошибок точности с плавающей точкой рассмотрите возможность использования :ref:`is_equal_approx()<class_Vector4_method_is_equal_approx>` вместо этого, что более надежно.
|
||
|
||
\ **Примечание:** Векторы с элементами :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>` ведут себя не так, как другие векторы. Поэтому результаты этого оператора могут быть неточными, если включены NaN.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Vector4_operator_gt_Vector4:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`bool<class_bool>` **operator >**\ (\ right\: :ref:`Vector4<class_Vector4>`\ ) :ref:`🔗<class_Vector4_operator_gt_Vector4>`
|
||
|
||
Сравнивает два вектора **Vector4**, сначала проверяя, больше ли значение X левого вектора, чем значение X вектора ``right``. Если значения X в точности равны, то он повторяет эту проверку со значениями Y двух векторов, значениями Z двух векторов, а затем со значениями W. Этот оператор полезен для сортировки векторов.
|
||
|
||
\ **Примечание:** Векторы с элементами :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>` ведут себя не так, как другие векторы. Поэтому результаты этого оператора могут быть неточными, если включены NaN.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Vector4_operator_gte_Vector4:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`bool<class_bool>` **operator >=**\ (\ right\: :ref:`Vector4<class_Vector4>`\ ) :ref:`🔗<class_Vector4_operator_gte_Vector4>`
|
||
|
||
Сравнивает два вектора **Vector4**, сначала проверяя, больше ли значение X левого вектора или равно ли ему значение X вектора ``right``. Если значения X в точности равны, то он повторяет эту проверку со значениями Y двух векторов, значениями Z двух векторов, а затем со значениями W. Этот оператор полезен для сортировки векторов.
|
||
|
||
\ **Примечание:** Векторы с элементами :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>` ведут себя не так, как другие векторы. Поэтому результаты этого оператора могут быть неточными, если включены NaN.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Vector4_operator_idx_int:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`float<class_float>` **operator []**\ (\ index\: :ref:`int<class_int>`\ ) :ref:`🔗<class_Vector4_operator_idx_int>`
|
||
|
||
Доступ к компонентам вектора осуществляется с помощью их ``index``. ``v[0]`` эквивалентно ``v.x``, ``v[1]`` эквивалентно ``v.y``, ``v[2]`` эквивалентно ``v.z``, а ``v[3]`` эквивалентно ``v.w``.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Vector4_operator_unplus:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`Vector4<class_Vector4>` **operator unary+**\ (\ ) :ref:`🔗<class_Vector4_operator_unplus>`
|
||
|
||
Возвращает то же значение, как если бы ``+`` не было. Унарный ``+`` ничего не делает, но иногда он может сделать ваш код более читаемым.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Vector4_operator_unminus:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`Vector4<class_Vector4>` **operator unary-**\ (\ ) :ref:`🔗<class_Vector4_operator_unminus>`
|
||
|
||
Возвращает отрицательное значение **Vector4**. Это то же самое, что и запись ``Vector4(-v.x, -v.y, -v.z, -v.w)``. Эта операция меняет направление вектора, сохраняя ту же величину. С плавающей точкой число ноль может быть как положительным, так и отрицательным.
|
||
|
||
.. |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 (Нет возвращаемого значения.)`
|