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
57781dc0bc3ff665ce77f07d04c053cbb254ac37
godot-docs-l10n/classes/uk/class_vector4.rst

1030 lines
69 KiB
ReStructuredText
Raw 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_Vector4:
Vector4
=======
Вектор 4D з використанням плавно-точкових координат.
.. rst-class:: classref-introduction-group
Опис
--------
4-оелементна структура, яка може бути використана для представлення координат 4D або будь-яких інших квадроциклів числових значень.
Використовується плаваючі координати точки. За замовчуванням ці значення плаваючі точки використовують 32-бітну точність, на відміну від :ref:`float<class_float>`, яка завжди 64-біт. Якщо потрібна подвійна точність, зніміть двигун за допомогою параметра ``, оцінивши=double``.
Переглянути :ref:`Vector4i<class_Vector4i>` для свого цілого аналога.
\ **Примітка:** У булевому контексті Vector4 оцінюватиме ``false``, якщо це дорівнює ``Vector4(0, 0, 0)``. Вектор4 завжди оцінюється ``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>`
Повертає відстань між цим вектором і ``до``.
.. 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() * вектор`` можна використовувати замість. Див. :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)) # Виводить (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)) # Виводить (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)) # Виводить (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** на задане число з плаваючою комою.
::
print(Vector4(10, 20, 30, 40) / 2) # Виводить (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 у лівого вектора менше за значення ``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 у лівого вектора менше чи рівне до ``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 у лівого вектора більше за значення ``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 у лівого вектора більше чи рівне до ``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>`
Доступ до векторних компонентів за допомогою їх ``параметр``. ``v[0]`` еквівалент ``v.x``, ``v`` еквівалент ``v.y``, ``v`` еквівалент ``v.z``, і ``v128`` еквівалент ``v.w``.w[/code].
.. 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 (Значення не повертається.)`
Reference in New Issue View Git Blame Copy Permalink