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

1295 lines
85 KiB
ReStructuredText
Raw Permalink Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

:github_url: hide
.. _class_Vector2:
Vector2
=======
Un vecteur 2D utilisant des coordonnées flottantes.
.. rst-class:: classref-introduction-group
Description
-----------
Une structure de 2 éléments qui peut être utilisée pour représenter les coordonnées 2D ou toute autre paire de valeurs numériques.
Il utilise des coordonnées flottantes. Par défaut, ces valeurs flottantes utilisent une précision de 32 bits, contrairement à :ref:`float<class_float>` qui est toujours de 64 bits. Si une double précision est nécessaire, compilez le moteur avec l'option ``précision=double``.
Voir :ref:`Vector2i<class_Vector2i>` pour son homologue entier.
\ **Note :** Dans un contexte booléen, un Vector2 évaluera ``false`` s'il est égal à ``Vector2(0, 0)``. Sinon, un Vector2 évaluera toujours ``true``.
.. rst-class:: classref-introduction-group
Tutoriels
------------------
- :doc:`Index de la documentation sur les mathématiques <../tutorials/math/index>`
- :doc:`Mathématiques des vecteurs <../tutorials/math/vector_math>`
- :doc:`Mathématiques avancées des vecteurs <../tutorials/math/vectors_advanced>`
- `3Blue1Brown Essence of Linear Algebra <https://www.youtube.com/playlist?list=PLZHQObOWTQDPD3MizzM2xVFitgF8hE_ab>`__
- `Démo de transformation matricielle <https://godotengine.org/asset-library/asset/2787>`__
- `Toutes les démos 2D <https://github.com/godotengine/godot-demo-projects/tree/master/2d>`__
.. rst-class:: classref-reftable-group
Propriétés
--------------------
.. table::
:widths: auto
+---------------------------+------------------------------------+---------+
| :ref:`float<class_float>` | :ref:`x<class_Vector2_property_x>` | ``0.0`` |
+---------------------------+------------------------------------+---------+
| :ref:`float<class_float>` | :ref:`y<class_Vector2_property_y>` | ``0.0`` |
+---------------------------+------------------------------------+---------+
.. rst-class:: classref-reftable-group
Constructeurs
--------------------------
.. table::
:widths: auto
+-------------------------------+-----------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`Vector2<class_Vector2_constructor_Vector2>`\ (\ ) |
+-------------------------------+-----------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`Vector2<class_Vector2_constructor_Vector2>`\ (\ from\: :ref:`Vector2<class_Vector2>`\ ) |
+-------------------------------+-----------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`Vector2<class_Vector2_constructor_Vector2>`\ (\ from\: :ref:`Vector2i<class_Vector2i>`\ ) |
+-------------------------------+-----------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`Vector2<class_Vector2_constructor_Vector2>`\ (\ x\: :ref:`float<class_float>`, y\: :ref:`float<class_float>`\ ) |
+-------------------------------+-----------------------------------------------------------------------------------------------------------------------+
.. rst-class:: classref-reftable-group
Méthodes
----------------
.. table::
:widths: auto
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`abs<class_Vector2_method_abs>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`angle<class_Vector2_method_angle>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`angle_to<class_Vector2_method_angle_to>`\ (\ to\: :ref:`Vector2<class_Vector2>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`angle_to_point<class_Vector2_method_angle_to_point>`\ (\ to\: :ref:`Vector2<class_Vector2>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`aspect<class_Vector2_method_aspect>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`bezier_derivative<class_Vector2_method_bezier_derivative>`\ (\ control_1\: :ref:`Vector2<class_Vector2>`, control_2\: :ref:`Vector2<class_Vector2>`, end\: :ref:`Vector2<class_Vector2>`, t\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`bezier_interpolate<class_Vector2_method_bezier_interpolate>`\ (\ control_1\: :ref:`Vector2<class_Vector2>`, control_2\: :ref:`Vector2<class_Vector2>`, end\: :ref:`Vector2<class_Vector2>`, t\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`bounce<class_Vector2_method_bounce>`\ (\ n\: :ref:`Vector2<class_Vector2>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`ceil<class_Vector2_method_ceil>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`clamp<class_Vector2_method_clamp>`\ (\ min\: :ref:`Vector2<class_Vector2>`, max\: :ref:`Vector2<class_Vector2>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`clampf<class_Vector2_method_clampf>`\ (\ min\: :ref:`float<class_float>`, max\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`cross<class_Vector2_method_cross>`\ (\ with\: :ref:`Vector2<class_Vector2>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`cubic_interpolate<class_Vector2_method_cubic_interpolate>`\ (\ b\: :ref:`Vector2<class_Vector2>`, pre_a\: :ref:`Vector2<class_Vector2>`, post_b\: :ref:`Vector2<class_Vector2>`, weight\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`cubic_interpolate_in_time<class_Vector2_method_cubic_interpolate_in_time>`\ (\ b\: :ref:`Vector2<class_Vector2>`, pre_a\: :ref:`Vector2<class_Vector2>`, post_b\: :ref:`Vector2<class_Vector2>`, weight\: :ref:`float<class_float>`, b_t\: :ref:`float<class_float>`, pre_a_t\: :ref:`float<class_float>`, post_b_t\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`direction_to<class_Vector2_method_direction_to>`\ (\ to\: :ref:`Vector2<class_Vector2>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`distance_squared_to<class_Vector2_method_distance_squared_to>`\ (\ to\: :ref:`Vector2<class_Vector2>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`distance_to<class_Vector2_method_distance_to>`\ (\ to\: :ref:`Vector2<class_Vector2>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`dot<class_Vector2_method_dot>`\ (\ with\: :ref:`Vector2<class_Vector2>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`floor<class_Vector2_method_floor>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`from_angle<class_Vector2_method_from_angle>`\ (\ angle\: :ref:`float<class_float>`\ ) |static| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_equal_approx<class_Vector2_method_is_equal_approx>`\ (\ to\: :ref:`Vector2<class_Vector2>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_finite<class_Vector2_method_is_finite>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_normalized<class_Vector2_method_is_normalized>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_zero_approx<class_Vector2_method_is_zero_approx>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`length<class_Vector2_method_length>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`length_squared<class_Vector2_method_length_squared>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`lerp<class_Vector2_method_lerp>`\ (\ to\: :ref:`Vector2<class_Vector2>`, weight\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`limit_length<class_Vector2_method_limit_length>`\ (\ length\: :ref:`float<class_float>` = 1.0\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`max<class_Vector2_method_max>`\ (\ with\: :ref:`Vector2<class_Vector2>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`max_axis_index<class_Vector2_method_max_axis_index>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`maxf<class_Vector2_method_maxf>`\ (\ with\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`min<class_Vector2_method_min>`\ (\ with\: :ref:`Vector2<class_Vector2>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`min_axis_index<class_Vector2_method_min_axis_index>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`minf<class_Vector2_method_minf>`\ (\ with\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`move_toward<class_Vector2_method_move_toward>`\ (\ to\: :ref:`Vector2<class_Vector2>`, delta\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`normalized<class_Vector2_method_normalized>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`orthogonal<class_Vector2_method_orthogonal>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`posmod<class_Vector2_method_posmod>`\ (\ mod\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`posmodv<class_Vector2_method_posmodv>`\ (\ modv\: :ref:`Vector2<class_Vector2>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`project<class_Vector2_method_project>`\ (\ b\: :ref:`Vector2<class_Vector2>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`reflect<class_Vector2_method_reflect>`\ (\ line\: :ref:`Vector2<class_Vector2>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`rotated<class_Vector2_method_rotated>`\ (\ angle\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`round<class_Vector2_method_round>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`sign<class_Vector2_method_sign>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`slerp<class_Vector2_method_slerp>`\ (\ to\: :ref:`Vector2<class_Vector2>`, weight\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`slide<class_Vector2_method_slide>`\ (\ n\: :ref:`Vector2<class_Vector2>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`snapped<class_Vector2_method_snapped>`\ (\ step\: :ref:`Vector2<class_Vector2>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`snappedf<class_Vector2_method_snappedf>`\ (\ step\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
.. rst-class:: classref-reftable-group
Opérateurs
--------------------
.. table::
:widths: auto
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator !=<class_Vector2_operator_neq_Vector2>`\ (\ right\: :ref:`Vector2<class_Vector2>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`operator *<class_Vector2_operator_mul_Transform2D>`\ (\ right\: :ref:`Transform2D<class_Transform2D>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`operator *<class_Vector2_operator_mul_Vector2>`\ (\ right\: :ref:`Vector2<class_Vector2>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`operator *<class_Vector2_operator_mul_float>`\ (\ right\: :ref:`float<class_float>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`operator *<class_Vector2_operator_mul_int>`\ (\ right\: :ref:`int<class_int>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`operator +<class_Vector2_operator_sum_Vector2>`\ (\ right\: :ref:`Vector2<class_Vector2>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`operator -<class_Vector2_operator_dif_Vector2>`\ (\ right\: :ref:`Vector2<class_Vector2>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`operator /<class_Vector2_operator_div_Vector2>`\ (\ right\: :ref:`Vector2<class_Vector2>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`operator /<class_Vector2_operator_div_float>`\ (\ right\: :ref:`float<class_float>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`operator /<class_Vector2_operator_div_int>`\ (\ right\: :ref:`int<class_int>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator \<<class_Vector2_operator_lt_Vector2>`\ (\ right\: :ref:`Vector2<class_Vector2>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator \<=<class_Vector2_operator_lte_Vector2>`\ (\ right\: :ref:`Vector2<class_Vector2>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator ==<class_Vector2_operator_eq_Vector2>`\ (\ right\: :ref:`Vector2<class_Vector2>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator ><class_Vector2_operator_gt_Vector2>`\ (\ right\: :ref:`Vector2<class_Vector2>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator >=<class_Vector2_operator_gte_Vector2>`\ (\ right\: :ref:`Vector2<class_Vector2>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`operator []<class_Vector2_operator_idx_int>`\ (\ index\: :ref:`int<class_int>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`operator unary+<class_Vector2_operator_unplus>`\ (\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`operator unary-<class_Vector2_operator_unminus>`\ (\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Énumérations
------------------------
.. _enum_Vector2_Axis:
.. rst-class:: classref-enumeration
enum **Axis**: :ref:`🔗<enum_Vector2_Axis>`
.. _class_Vector2_constant_AXIS_X:
.. rst-class:: classref-enumeration-constant
:ref:`Axis<enum_Vector2_Axis>` **AXIS_X** = ``0``
La valeur de l'énumération pour l'axe X. Renvoyé par :ref:`max_axis_index()<class_Vector2_method_max_axis_index>` et :ref:`min_axis_index()<class_Vector2_method_min_axis_index>`.
.. _class_Vector2_constant_AXIS_Y:
.. rst-class:: classref-enumeration-constant
:ref:`Axis<enum_Vector2_Axis>` **AXIS_Y** = ``1``
La valeur de l'énumération pour l'axe Y. Retourné par :ref:`max_axis_index()<class_Vector2_method_max_axis_index>` et :ref:`min_axis_index()<class_Vector2_method_min_axis_index>`.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Constantes
--------------------
.. _class_Vector2_constant_ZERO:
.. rst-class:: classref-constant
**ZERO** = ``Vector2(0, 0)`` :ref:`🔗<class_Vector2_constant_ZERO>`
Le vecteur zéro, un vecteur avec tous ses composants définis ``0``.
.. _class_Vector2_constant_ONE:
.. rst-class:: classref-constant
**ONE** = ``Vector2(1, 1)`` :ref:`🔗<class_Vector2_constant_ONE>`
Le vecteur unitaire, un vecteur avec tous ses composants définis à ``1``.
.. _class_Vector2_constant_INF:
.. rst-class:: classref-constant
**INF** = ``Vector2(inf, inf)`` :ref:`🔗<class_Vector2_constant_INF>`
Le vecteur infini, un vecteur avec tous ses composants définit à :ref:`@GDScript.INF<class_@GDScript_constant_INF>`.
.. _class_Vector2_constant_LEFT:
.. rst-class:: classref-constant
**LEFT** = ``Vector2(-1, 0)`` :ref:`🔗<class_Vector2_constant_LEFT>`
Le vecteur unitaire gauche. Représente la direction vers la gauche.
.. _class_Vector2_constant_RIGHT:
.. rst-class:: classref-constant
**RIGHT** = ``Vector2(1, 0)`` :ref:`🔗<class_Vector2_constant_RIGHT>`
Le vecteur unitaire droit. Représente la direction vers la droite.
.. _class_Vector2_constant_UP:
.. rst-class:: classref-constant
**UP** = ``Vector2(0, -1)`` :ref:`🔗<class_Vector2_constant_UP>`
Le vecteur unitaire vers le haut. Y représente le bas en 2D, donc ce vecteur pointe vers -Y.
.. _class_Vector2_constant_DOWN:
.. rst-class:: classref-constant
**DOWN** = ``Vector2(0, 1)`` :ref:`🔗<class_Vector2_constant_DOWN>`
Le vecteur unitaire vers le bas. Y représente le bas en 2D, donc ce vecteur pointe vers +Y.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descriptions des propriétés
------------------------------------------------------
.. _class_Vector2_property_x:
.. rst-class:: classref-property
:ref:`float<class_float>` **x** = ``0.0`` :ref:`🔗<class_Vector2_property_x>`
La composante vectorielle X. Également accessible en utilisant le code de position index ``[0]``.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_property_y:
.. rst-class:: classref-property
:ref:`float<class_float>` **y** = ``0.0`` :ref:`🔗<class_Vector2_property_y>`
La composante vectorielle X. Également accessible en utilisant le code de position index ``[1]``.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descriptions des constructeurs
------------------------------------------------------------
.. _class_Vector2_constructor_Vector2:
.. rst-class:: classref-constructor
:ref:`Vector2<class_Vector2>` **Vector2**\ (\ ) :ref:`🔗<class_Vector2_constructor_Vector2>`
Construit un **Vector2** initialisé par défaut avec toutes les composantes définies à ``0``.
.. rst-class:: classref-item-separator
----
.. rst-class:: classref-constructor
:ref:`Vector2<class_Vector2>` **Vector2**\ (\ from\: :ref:`Vector2<class_Vector2>`\ )
Construit un **Vector2** comme copie du **Vector2** donné.
.. rst-class:: classref-item-separator
----
.. rst-class:: classref-constructor
:ref:`Vector2<class_Vector2>` **Vector2**\ (\ from\: :ref:`Vector2i<class_Vector2i>`\ )
Construit un nouveau **Vector2** depuis un :ref:`Vector2i<class_Vector2i>`.
.. rst-class:: classref-item-separator
----
.. rst-class:: classref-constructor
:ref:`Vector2<class_Vector2>` **Vector2**\ (\ x\: :ref:`float<class_float>`, y\: :ref:`float<class_float>`\ )
Construit un nouveau **Vector2** depuis les ``x`` et ``y`` donnés.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descriptions des méthodes
--------------------------------------------------
.. _class_Vector2_method_abs:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **abs**\ (\ ) |const| :ref:`🔗<class_Vector2_method_abs>`
Renvoie un nouveau vecteur avec tous ses composantes en valeurs absolues (c'est-à-dire toujours positives).
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_angle:
.. rst-class:: classref-method
:ref:`float<class_float>` **angle**\ (\ ) |const| :ref:`🔗<class_Vector2_method_angle>`
Returns this vector's angle with respect to the positive X axis, or ``(1, 0)`` vector, in radians.
For example, ``Vector2.RIGHT.angle()`` will return zero, ``Vector2.DOWN.angle()`` will return ``PI / 2`` (a quarter turn, or 90 degrees), and ``Vector2(1, -1).angle()`` will return ``-PI / 4`` (a negative eighth turn, or -45 degrees).
This is equivalent to calling :ref:`@GlobalScope.atan2()<class_@GlobalScope_method_atan2>` with :ref:`y<class_Vector2_property_y>` and :ref:`x<class_Vector2_property_x>`.
\ `Illustration of the returned angle. <https://raw.githubusercontent.com/godotengine/godot-docs/master/img/vector2_angle.png>`__
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_angle_to:
.. rst-class:: classref-method
:ref:`float<class_float>` **angle_to**\ (\ to\: :ref:`Vector2<class_Vector2>`\ ) |const| :ref:`🔗<class_Vector2_method_angle_to>`
Returns the signed angle to the given vector, in radians. The result ranges from ``-PI`` to ``PI`` (inclusive).
\ `Illustration of the returned angle. <https://raw.githubusercontent.com/godotengine/godot-docs/master/img/vector2_angle_to.png>`__
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_angle_to_point:
.. rst-class:: classref-method
:ref:`float<class_float>` **angle_to_point**\ (\ to\: :ref:`Vector2<class_Vector2>`\ ) |const| :ref:`🔗<class_Vector2_method_angle_to_point>`
Returns the signed angle between the X axis and the line from this vector to point ``to``, in radians. The result ranges from ``-PI`` to ``PI`` (inclusive).
\ ``a.angle_to_point(b)`` is equivalent to ``(b - a).angle()``. See also :ref:`angle()<class_Vector2_method_angle>`.
\ `Illustration of the returned angle. <https://raw.githubusercontent.com/godotengine/godot-docs/master/img/vector2_angle_to_point.png>`__
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_aspect:
.. rst-class:: classref-method
:ref:`float<class_float>` **aspect**\ (\ ) |const| :ref:`🔗<class_Vector2_method_aspect>`
Returns this vector's aspect ratio, which is :ref:`x<class_Vector2_property_x>` divided by :ref:`y<class_Vector2_property_y>`.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_bezier_derivative:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **bezier_derivative**\ (\ control_1\: :ref:`Vector2<class_Vector2>`, control_2\: :ref:`Vector2<class_Vector2>`, end\: :ref:`Vector2<class_Vector2>`, t\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector2_method_bezier_derivative>`
Renvoie la dérivée au ``t`` donné sur la `courbe de Bézier <https://fr.wikipedia.org/wiki/Courbe_de_B%C3%A9zier>`__ définie par ce vecteur et les points ``control_1``, ``control_2``, et ``end`` donnés.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_bezier_interpolate:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **bezier_interpolate**\ (\ control_1\: :ref:`Vector2<class_Vector2>`, control_2\: :ref:`Vector2<class_Vector2>`, end\: :ref:`Vector2<class_Vector2>`, t\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector2_method_bezier_interpolate>`
Renvoie le point au ``t`` donné sur la `courbe de Bézier <https://fr.wikipedia.org/wiki/Courbe_de_B%C3%A9zier>`__ définie par ce vecteur et les points ``control_1``, ``control_2``, et ``end`` donnés.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_bounce:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **bounce**\ (\ n\: :ref:`Vector2<class_Vector2>`\ ) |const| :ref:`🔗<class_Vector2_method_bounce>`
Renvoie le vecteur "réfléchi" d'une ligne définie par la normale ``n`` donnée perpendiculaire à la ligne.
\ **Note:** :ref:`bounce()<class_Vector2_method_bounce>` effectue l'opération que la plupart des moteurs et des frameworks appellent ``reflect()``.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_ceil:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **ceil**\ (\ ) |const| :ref:`🔗<class_Vector2_method_ceil>`
Renvoie un nouveau vecteur avec tous les composantes arrondies vers le haut (vers +infini).
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_clamp:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **clamp**\ (\ min\: :ref:`Vector2<class_Vector2>`, max\: :ref:`Vector2<class_Vector2>`\ ) |const| :ref:`🔗<class_Vector2_method_clamp>`
Renvoie un nouveau vecteur avec toutes les composantes bornées entre les composantes de ``min`` et ``max``, en exécutant :ref:`@GlobalScope.clamp()<class_@GlobalScope_method_clamp>` sur chaque composante.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_clampf:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **clampf**\ (\ min\: :ref:`float<class_float>`, max\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector2_method_clampf>`
Renvoie un nouveau vecteur avec toutes les composantes bornées entre ``min`` et ``max``, en exécutant :ref:`@GlobalScope.clamp()<class_@GlobalScope_method_clamp>` sur chaque composante.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_cross:
.. rst-class:: classref-method
:ref:`float<class_float>` **cross**\ (\ with\: :ref:`Vector2<class_Vector2>`\ ) |const| :ref:`🔗<class_Vector2_method_cross>`
Renvoie l'analogue 2D produit vectoriel de ce vecteur et ``with``.
C'est l'aire signée du parallélogramme formé par les deux vecteurs. Si le second vecteur est dans le sens des aiguilles d'une montre depuis le premier vecteur, le produit vectoriel est l'aire positive. S'il est dans le sens inverse, le produit vectoriel est l'aire négative. Si les deux vecteurs sont parallèle, ceci renvoie zéro, ce qui la rend utile pour tester si deux vecteurs sont parallèles.
\ **Note :** Le produit vectoriel n'est pas défini en 2D mathématiquement. Cette méthode intègre les vecteurs 2D dans le plan XY de l'espace 3D et utilise la composante Z du produit vectoriel comme l'analogue.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_cubic_interpolate:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **cubic_interpolate**\ (\ b\: :ref:`Vector2<class_Vector2>`, pre_a\: :ref:`Vector2<class_Vector2>`, post_b\: :ref:`Vector2<class_Vector2>`, weight\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector2_method_cubic_interpolate>`
Effectue une interpolation cubique entre ce vecteur et ``b`` en utilisant ``pre_a`` et ``post_b`` comme poignées, et renvoie le résultat à la position ``weight``. ``weight`` est dans l'intervalle de 0,0 à 1,0, représentant le montant d'interpolation.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_cubic_interpolate_in_time:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **cubic_interpolate_in_time**\ (\ b\: :ref:`Vector2<class_Vector2>`, pre_a\: :ref:`Vector2<class_Vector2>`, post_b\: :ref:`Vector2<class_Vector2>`, weight\: :ref:`float<class_float>`, b_t\: :ref:`float<class_float>`, pre_a_t\: :ref:`float<class_float>`, post_b_t\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector2_method_cubic_interpolate_in_time>`
Effectue une interpolation cubique entre ce vecteur et ``b`` en utilisant ``pre_a`` et ``post_b`` comme poignées, et renvoie le résultat à la position ``weight``. ``weight`` est dans l'intervalle de 0,0 à 1,0, représentant la quantité d'interpolation.
Elle peut effectuer une interpolation plus lisse que :ref:`cubic_interpolate()<class_Vector2_method_cubic_interpolate>` pour les valeurs temporelles.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_direction_to:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **direction_to**\ (\ to\: :ref:`Vector2<class_Vector2>`\ ) |const| :ref:`🔗<class_Vector2_method_direction_to>`
Returns the normalized vector pointing from this vector to ``to``.
\ ``a.direction_to(b)`` is equivalent to ``(b - a).normalized()``. See also :ref:`normalized()<class_Vector2_method_normalized>`.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_distance_squared_to:
.. rst-class:: classref-method
:ref:`float<class_float>` **distance_squared_to**\ (\ to\: :ref:`Vector2<class_Vector2>`\ ) |const| :ref:`🔗<class_Vector2_method_distance_squared_to>`
Renvoie la distance au carré entre ce vecteur et ``to``.
Cette méthode est plus rapide que :ref:`distance_to()<class_Vector2_method_distance_to>`, alors préfèrez-la si vous avez besoin de comparer des vecteurs ou besoin de la distance carrée pour une formule.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_distance_to:
.. rst-class:: classref-method
:ref:`float<class_float>` **distance_to**\ (\ to\: :ref:`Vector2<class_Vector2>`\ ) |const| :ref:`🔗<class_Vector2_method_distance_to>`
Renvoie la distance entre ce vecteur et ``to``.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_dot:
.. rst-class:: classref-method
:ref:`float<class_float>` **dot**\ (\ with\: :ref:`Vector2<class_Vector2>`\ ) |const| :ref:`🔗<class_Vector2_method_dot>`
Renvoie le produit scalaire de ce vecteur avec ``with``. Ceci peut être utilisé pour comparer l'angle entre deux vecteurs. Par exemple, cela peut être utilisé pour déterminer si un ennemi est face au joueur.
Le produit scalaire sera ``0`` pour un angle droit (90 degrés), supérieur à 0 pour les angles plus étroits que 90 degrés et inférieur à 0 pour les angles plus larges que 90 degrés.
Lors de l'utilisation de vecteurs unitaires (normalisés), le résultat sera toujours compris entre ``-1.0`` (angle de 180 degrés) lorsque les vecteurs font face à des directions opposées, et ``1.0`` (angle de 0 degré) lorsque les vecteurs sont alignés.
\ **Note :** ``a.dot(b)`` est équivalent à ``b.dot(a)``.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_floor:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **floor**\ (\ ) |const| :ref:`🔗<class_Vector2_method_floor>`
Renvoie un nouveau vecteur avec tous les composantes arrondies vers le bas (vers -infini).
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_from_angle:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **from_angle**\ (\ angle\: :ref:`float<class_float>`\ ) |static| :ref:`🔗<class_Vector2_method_from_angle>`
Crée un **Vector2** unitaire tourné de l'``angle`` donné en radians. Ceci équivaut à faire ``Vector2(cos(angle), sin(angle))`` ou ``Vector2.RIGHT.rotated(angle)``.
::
print(Vector2.from_angle(0)) # Affiche (1.0, 0.0)
print(Vector2(1, 0).angle()) # Affiche 0.0, qui est l'angle utilisé ci-dessus.
print(Vector2.from_angle(PI / 2)) # Affiche (0.0, 1.0)
\ **Note :** La longueur du **Vector2** renvoyé est *approximativement* ``1.0``, mais elle n'est pas garantie d'être exactement ``1.0`` en raison de problèmes de précision flottants. Appelez :ref:`normalized()<class_Vector2_method_normalized>` sur le **Vector2** renvoyé si vous avez besoin d'un vecteur unitaire.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_is_equal_approx:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_equal_approx**\ (\ to\: :ref:`Vector2<class_Vector2>`\ ) |const| :ref:`🔗<class_Vector2_method_is_equal_approx>`
Renvoie ``true`` si ce vecteur et ``to`` sont approximativement égaux, en exécutant :ref:`@GlobalScope.is_equal_approx()<class_@GlobalScope_method_is_equal_approx>` sur chaque composante.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_is_finite:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_finite**\ (\ ) |const| :ref:`🔗<class_Vector2_method_is_finite>`
Renvoie ``true`` si ce vecteur est fini, en appelant :ref:`@GlobalScope.is_finite()<class_@GlobalScope_method_is_finite>` sur chaque composante.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_is_normalized:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_normalized**\ (\ ) |const| :ref:`🔗<class_Vector2_method_is_normalized>`
Renvoie ``true`` si le vecteur est normalisé, c.a.d. sa longueur est environ égale à 1.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_is_zero_approx:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_zero_approx**\ (\ ) |const| :ref:`🔗<class_Vector2_method_is_zero_approx>`
Renvoie ``true`` si les valeurs de ce vecteur sont approximativement nulles, en exécutant :ref:`@GlobalScope.is_zero_approx()<class_@GlobalScope_method_is_zero_approx>` sur chaque composante.
Cette méthode est plus rapide qu'utiliser :ref:`is_equal_approx()<class_Vector2_method_is_equal_approx>` avec un vecteur nul comme valeur.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_length:
.. rst-class:: classref-method
:ref:`float<class_float>` **length**\ (\ ) |const| :ref:`🔗<class_Vector2_method_length>`
Renvoie la longueur (magnitude) de ce vecteur.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_length_squared:
.. rst-class:: classref-method
:ref:`float<class_float>` **length_squared**\ (\ ) |const| :ref:`🔗<class_Vector2_method_length_squared>`
Renvoie la longeur (magnitude) au carré de ce vecteur.
Cette méthode est plus rapide que :ref:`length()<class_Vector2_method_length>` donc préférez-le si vous devez comparer des vecteurs ou avoir besoin de la distance carrée pour certaines formules.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_lerp:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **lerp**\ (\ to\: :ref:`Vector2<class_Vector2>`, weight\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector2_method_lerp>`
Renvoie le résultat de l'interpolation linéaire entre ce vecteur et ``to`` par la quantité ``weight``. ``weight`` est compris entre ``0.0`` et ``1.0``, représentant le montant d'interpolation.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_limit_length:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **limit_length**\ (\ length\: :ref:`float<class_float>` = 1.0\ ) |const| :ref:`🔗<class_Vector2_method_limit_length>`
Renvoie le vecteur avec une longueur maximale en limitant sa longueur à ``length``. Si le vecteur n'est pas fini, le résultat est indéfini.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_max:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **max**\ (\ with\: :ref:`Vector2<class_Vector2>`\ ) |const| :ref:`🔗<class_Vector2_method_max>`
Renvoie le maximum par composante de ceci et ``with``, équivalent à ``Vector2(maxf(x, with.x), maxf(y, with.y))``.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_max_axis_index:
.. rst-class:: classref-method
:ref:`int<class_int>` **max_axis_index**\ (\ ) |const| :ref:`🔗<class_Vector2_method_max_axis_index>`
Renvoie l'axe de la valeur la plus importante du vecteur. Voir les constantes\ ``AXIS_*``. Si tous les composants sont égaux, cette méthode renvoie :ref:`AXIS_X<class_Vector2_constant_AXIS_X>`.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_maxf:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **maxf**\ (\ with\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector2_method_maxf>`
Renvoie le maximum par composante de ceci et ``with``, équivalent à ``Vector2(maxf(x, with), maxf(y, with))``.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_min:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **min**\ (\ with\: :ref:`Vector2<class_Vector2>`\ ) |const| :ref:`🔗<class_Vector2_method_min>`
Renvoie le minimum par composante de ceci et ``with``, équivalent à ``Vector2(minf(x, with.x), minf(y, with.y))``.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_min_axis_index:
.. rst-class:: classref-method
:ref:`int<class_int>` **min_axis_index**\ (\ ) |const| :ref:`🔗<class_Vector2_method_min_axis_index>`
Renvoie l'axe de la valeur la moins importante du vecteur. Voir les constantes\ ``AXIS_*``. Si tous les composants sont égaux, cette méthode renvoie :ref:`AXIS_Y<class_Vector2_constant_AXIS_Y>`.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_minf:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **minf**\ (\ with\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector2_method_minf>`
Renvoie le minimum par composante de ceci et ``with``, équivalent à ``Vector2(minf(x, with), minf(y, with))``.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_move_toward:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **move_toward**\ (\ to\: :ref:`Vector2<class_Vector2>`, delta\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector2_method_move_toward>`
Renvoie un nouveau vecteur déplacé en direction de ``to`` par la quantité ``delta``. Ne dépassera pas la valeur finale.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_normalized:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **normalized**\ (\ ) |const| :ref:`🔗<class_Vector2_method_normalized>`
Renvoie le résultat de la mise à l'échelle du vecteur à la longueur unité. Équivalent à ``v / v.length()``. Renvoie ``(0, 0)`` si ``v.length() == 0``. Voir aussi :ref:`is_normalized()<class_Vector2_method_is_normalized>`.
\ **Note :** Cette fonction peut renvoyer des valeurs incorrectes si la longueur du vecteur d'entrée est proche de zéro.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_orthogonal:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **orthogonal**\ (\ ) |const| :ref:`🔗<class_Vector2_method_orthogonal>`
Renvoie un vecteur perpendiculaire, pivoté de 90 degrés dans le sens anti-horaire comparé à l'original, avec la même longueur.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_posmod:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **posmod**\ (\ mod\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector2_method_posmod>`
Renvoie un vecteur composé du :ref:`@GlobalScope.fposmod()<class_@GlobalScope_method_fposmod>` des composantes de ce vecteur et ``mod``.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_posmodv:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **posmodv**\ (\ modv\: :ref:`Vector2<class_Vector2>`\ ) |const| :ref:`🔗<class_Vector2_method_posmodv>`
Renvoie un vecteur composé du :ref:`@GlobalScope.fposmod()<class_@GlobalScope_method_fposmod>` des composantes du vecteur et des composantes de ``modv``.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_project:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **project**\ (\ b\: :ref:`Vector2<class_Vector2>`\ ) |const| :ref:`🔗<class_Vector2_method_project>`
Renvoie un nouveau vecteur résultant de la projection de ce vecteur sur le vecteur ``b`` donné. Le nouveau vecteur résultant sera parallèle à ``b``. Voir aussi :ref:`slide()<class_Vector2_method_slide>`.
\ **Note :** Si le vecteur ``b`` est un vecteur nul, les composantes du nouveau vecteur résultant seront :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>`.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_reflect:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **reflect**\ (\ line\: :ref:`Vector2<class_Vector2>`\ ) |const| :ref:`🔗<class_Vector2_method_reflect>`
Renvoie le résultat de la réflexion du vecteur par rapport à une ligne définie par le vecteur de direction ``line`` donné.
\ **Note :** :ref:`reflect()<class_Vector2_method_reflect>` diffère de ce que les autres moteurs et frameworks appellent ``reflect()``. Dans d'autres moteurs ``reflect()`` prends une direction normale qui est une direction perpendiculaire à la ligne. Dans Godot, vous spécifiez la direction de la ligne directement. Voir aussi :ref:`bounce()<class_Vector2_method_bounce>` qui fait ce que la plupart des moteurs appellent ``reflect()``.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_rotated:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **rotated**\ (\ angle\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector2_method_rotated>`
Renvoie le résultat de la rotation de ce vecteur par ``angle`` (en radians). Voir aussi :ref:`@GlobalScope.deg_to_rad()<class_@GlobalScope_method_deg_to_rad>`.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_round:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **round**\ (\ ) |const| :ref:`🔗<class_Vector2_method_round>`
Renvoie une nouveau vecteur avec tous ses composantes arrondies à l'entier le plus proche, avec les demis arrondis à l'entier supérieur.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_sign:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **sign**\ (\ ) |const| :ref:`🔗<class_Vector2_method_sign>`
Renvoie un nouveau vecteur avec chaque composante définie à ``1.0`` si elle est positive, ``-1.0`` si elle est négative, et ``0.0`` si elle est nulle. Le résultat est identique à celui d'appeler :ref:`@GlobalScope.sign()<class_@GlobalScope_method_sign>` sur chaque composante.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_slerp:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **slerp**\ (\ to\: :ref:`Vector2<class_Vector2>`, weight\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector2_method_slerp>`
Renvoie le résultat de l'interpolation linéaire sphérique entre ce vecteur et ``to``, par la quantité ``weight``. ``weight`` est compris entre 0,0 et 1,0, représentant le montant d'interpolation.
Cette méthode gère également l'interpolation des longueurs si les vecteurs d'entrée ont des longueurs différentes. Pour le cas particulier où un ou deux vecteurs d'entrée ont une longueur nulle, cette méthode se comporte comme :ref:`lerp()<class_Vector2_method_lerp>`.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_slide:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **slide**\ (\ n\: :ref:`Vector2<class_Vector2>`\ ) |const| :ref:`🔗<class_Vector2_method_slide>`
Returns a new vector resulting from sliding this vector along a line with normal ``n``. The resulting new vector is perpendicular to ``n``, and is equivalent to this vector minus its projection on ``n``. See also :ref:`project()<class_Vector2_method_project>`.
\ **Note:** The vector ``n`` must be normalized. See also :ref:`normalized()<class_Vector2_method_normalized>`.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_snapped:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **snapped**\ (\ step\: :ref:`Vector2<class_Vector2>`\ ) |const| :ref:`🔗<class_Vector2_method_snapped>`
Renvoie un nouveau vecteur avec chaque composante arrondie au multiple le plus proche de la composante correspondante dans ``step``. Cela peut également être utilisé pour arrondir les composantes à un nombre arbitraire de décimales.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_method_snappedf:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **snappedf**\ (\ step\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector2_method_snappedf>`
Renvoie un nouveau vecteur avec chaque composante arrondie au multiple le plus proche de ``step``. Cela peut également être utilisé pour arrondir des composantes à un nombre arbitraire de décimales.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descriptions des opérateurs
------------------------------------------------------
.. _class_Vector2_operator_neq_Vector2:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator !=**\ (\ right\: :ref:`Vector2<class_Vector2>`\ ) :ref:`🔗<class_Vector2_operator_neq_Vector2>`
Renvoie ``true`` si les vecteurs ne sont pas égaux.
\ **Note :** À cause des erreurs de précision des flottants, envisagez d'utiliser :ref:`is_equal_approx()<class_Vector2_method_is_equal_approx>` à la place, qui est plus fiable.
\ **Note :** Les vecteurs avec des éléments :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>` ne se comportent pas comme les autres vecteurs. Ainsi, les résultats de cet opérateur peuvent ne pas être précis quand des NaNs sont présents.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_operator_mul_Transform2D:
.. rst-class:: classref-operator
:ref:`Vector2<class_Vector2>` **operator ***\ (\ right\: :ref:`Transform2D<class_Transform2D>`\ ) :ref:`🔗<class_Vector2_operator_mul_Transform2D>`
Transforme (multiplie) de manière inverse le **Vector2** par la matrice de transformation :ref:`Transform2D<class_Transform2D>` donnée, avec la supposition que la base de la transformation est orthonormée (c.a.d. une rotation/réflexion est OK, une échelle/un cisaillement ne l'est pas).
\ ``vector * transform`` est équivalent à ``transform.inverse() * vector``. Voir :ref:`Transform2D.inverse()<class_Transform2D_method_inverse>`.
Pour transformer par l'inverse d'une transformation affine (par ex. avec une mise à l'échelle), ``transform.affine_inverse() * vector`` peut être utilisé à la place. Voir :ref:`Transform2D.affine_inverse()<class_Transform2D_method_affine_inverse>`.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_operator_mul_Vector2:
.. rst-class:: classref-operator
:ref:`Vector2<class_Vector2>` **operator ***\ (\ right\: :ref:`Vector2<class_Vector2>`\ ) :ref:`🔗<class_Vector2_operator_mul_Vector2>`
Multiplie chaque composante du **Vector2** par les composantes du **Vector2** donné.
::
print(Vector2(10, 20) * Vector2(3, 4)) # Affiche (30.0, 80.0)
.. rst-class:: classref-item-separator
----
.. _class_Vector2_operator_mul_float:
.. rst-class:: classref-operator
:ref:`Vector2<class_Vector2>` **operator ***\ (\ right\: :ref:`float<class_float>`\ ) :ref:`🔗<class_Vector2_operator_mul_float>`
Multiplie chaque composante du **Vector2** par le flottant :ref:`float<class_float>` donné.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_operator_mul_int:
.. rst-class:: classref-operator
:ref:`Vector2<class_Vector2>` **operator ***\ (\ right\: :ref:`int<class_int>`\ ) :ref:`🔗<class_Vector2_operator_mul_int>`
Multiplie chaque composante du **Vector2** par l'entier :ref:`int<class_int>` donné.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_operator_sum_Vector2:
.. rst-class:: classref-operator
:ref:`Vector2<class_Vector2>` **operator +**\ (\ right\: :ref:`Vector2<class_Vector2>`\ ) :ref:`🔗<class_Vector2_operator_sum_Vector2>`
Ajoute chaque composante du **Vector2** aux composantes du **Vector2** donné.
::
print(Vector2(10, 20) + Vector2(3, 4)) # Affiche (13.0, 24.0)
.. rst-class:: classref-item-separator
----
.. _class_Vector2_operator_dif_Vector2:
.. rst-class:: classref-operator
:ref:`Vector2<class_Vector2>` **operator -**\ (\ right\: :ref:`Vector2<class_Vector2>`\ ) :ref:`🔗<class_Vector2_operator_dif_Vector2>`
Soustrait chaque composante du **Vector2** par les composantes du **Vector2** donné.
::
print(Vector2(10, 20) - Vector2(3, 4)) # Affiche (7.0, 16.0)
.. rst-class:: classref-item-separator
----
.. _class_Vector2_operator_div_Vector2:
.. rst-class:: classref-operator
:ref:`Vector2<class_Vector2>` **operator /**\ (\ right\: :ref:`Vector2<class_Vector2>`\ ) :ref:`🔗<class_Vector2_operator_div_Vector2>`
Divise chaque composante du **Vector2** par les composantes du **Vector2** donné.
::
print(Vector2(10, 20) / Vector2(2, 5)) # Affiche (5.0, 4.0)
.. rst-class:: classref-item-separator
----
.. _class_Vector2_operator_div_float:
.. rst-class:: classref-operator
:ref:`Vector2<class_Vector2>` **operator /**\ (\ right\: :ref:`float<class_float>`\ ) :ref:`🔗<class_Vector2_operator_div_float>`
Divise chaque composante du **Vector2** par le flottant :ref:`float<class_float>` donné.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_operator_div_int:
.. rst-class:: classref-operator
:ref:`Vector2<class_Vector2>` **operator /**\ (\ right\: :ref:`int<class_int>`\ ) :ref:`🔗<class_Vector2_operator_div_int>`
Divise chaque composante du **Vector2** par l'entier :ref:`int<class_int>` donné.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_operator_lt_Vector2:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator <**\ (\ right\: :ref:`Vector2<class_Vector2>`\ ) :ref:`🔗<class_Vector2_operator_lt_Vector2>`
Compare deux **Vector2** en vérifiant en premier si la valeur en X du vecteur de gauche est inférieure à la valeur en X du vecteur ``right``. Si les deux valeurs en X sont exactement égales, alors il répète la vérification sur les valeurs en Y des deux vecteurs. Cet opérateur est utile pour trier des vecteurs.
\ **Note :** Les vecteurs avec des éléments :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>` ne se comportent pas de la même façon que les autres vecteurs. Ainsi, les résultats de cet opérateur peuvent ne pas être exacts si des NaN sont inclus.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_operator_lte_Vector2:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator <=**\ (\ right\: :ref:`Vector2<class_Vector2>`\ ) :ref:`🔗<class_Vector2_operator_lte_Vector2>`
Compare deux :ref:`Vector2i<class_Vector2i>` en vérifiant en premier si la valeur en X du vecteur de gauche est inférieure ou égale à la valeur en X du vecteur ``right``. Si les deux valeurs en X sont exactement égales, alors il répète la vérification sur les valeurs en Y des deux vecteurs. Cet opérateur est utile pour trier des vecteurs.
\ **Note :** Les vecteurs avec des éléments :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>` ne se comportent pas de la même façon que les autres vecteurs. Ainsi, les résultats de cet opérateur peuvent ne pas être exacts si des NaN sont inclus.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_operator_eq_Vector2:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator ==**\ (\ right\: :ref:`Vector2<class_Vector2>`\ ) :ref:`🔗<class_Vector2_operator_eq_Vector2>`
Renvoie ``true`` si les vecteurs sont exactement égaux.
\ **Note :** À cause des erreurs de précision des flottants, envisagez d'utiliser :ref:`is_equal_approx()<class_Vector2_method_is_equal_approx>` à la place, qui est plus fiable.
\ **Note :** Les vecteurs avec des éléments :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>` ne se comportent pas comme les autres vecteurs. Ainsi, les résultats de cet opérateur peuvent ne pas être précis quand des NaNs sont présents.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_operator_gt_Vector2:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator >**\ (\ right\: :ref:`Vector2<class_Vector2>`\ ) :ref:`🔗<class_Vector2_operator_gt_Vector2>`
Compare deux **Vector2** en vérifiant en premier si la valeur en X du vecteur de gauche est supérieure à la valeur en X du vecteur ``right``. Si les deux valeurs en X sont exactement égales, alors il répète la vérification sur les valeurs en Y des deux vecteurs. Cet opérateur est utile pour trier des vecteurs.
\ **Note :** Les vecteurs avec des éléments :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>` ne se comportent pas de la même façon que les autres vecteurs. Ainsi, les résultats de cet opérateur peuvent ne pas être exacts si des NaN sont inclus.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_operator_gte_Vector2:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator >=**\ (\ right\: :ref:`Vector2<class_Vector2>`\ ) :ref:`🔗<class_Vector2_operator_gte_Vector2>`
Compare deux **Vector2** en vérifiant en premier si la valeur en X du vecteur de gauche est supérieure ou égale à la valeur en X du vecteur ``right``. Si les deux valeurs en X sont exactement égales, alors il répète la vérification sur les valeurs en Y des deux vecteurs. Cet opérateur est utile pour trier des vecteurs.
\ **Note :** Les vecteurs avec des éléments :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>` ne se comportent pas de la même façon que les autres vecteurs. Ainsi, les résultats de cet opérateur peuvent ne pas être exacts si des NaN sont inclus.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_operator_idx_int:
.. rst-class:: classref-operator
:ref:`float<class_float>` **operator []**\ (\ index\: :ref:`int<class_int>`\ ) :ref:`🔗<class_Vector2_operator_idx_int>`
Accède aux composantes du vecteur par leur ``index``. ``v[0]`` est équivalent à ``v.x`` et ``v[1]`` est équivalent à ``v.y``.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_operator_unplus:
.. rst-class:: classref-operator
:ref:`Vector2<class_Vector2>` **operator unary+**\ (\ ) :ref:`🔗<class_Vector2_operator_unplus>`
Renvoie la même valeur comme si ``+`` n'était pas là. Le ``+`` unaire ne fait rien, mais peut parfois rendre votre code plus lisible.
.. rst-class:: classref-item-separator
----
.. _class_Vector2_operator_unminus:
.. rst-class:: classref-operator
:ref:`Vector2<class_Vector2>` **operator unary-**\ (\ ) :ref:`🔗<class_Vector2_operator_unminus>`
Renvoie la valeur négative du **Vector2**. Revient à écrire ``Vector2(-v.x, -v.y)``. Cette opération retourne la direction du vecteur tout en gardant la même magnitude. Avec des flottants, le nombre zéro peut être positif ou négatif.
.. |virtual| replace:: :abbr:`virtual (Cette méthode doit typiquement être redéfinie par l'utilisateur pour avoir un effet.)`
.. |required| replace:: :abbr:`required (This method is required to be overridden when extending its base class.)`
.. |const| replace:: :abbr:`const (Cette méthode n'a pas d'effets de bord. Elle ne modifie aucune des variables membres de l'instance.)`
.. |vararg| replace:: :abbr:`vararg (Cette méthode accepte n'importe quel nombre d'arguments après ceux décris ici.)`
.. |constructor| replace:: :abbr:`constructor (Cette méthode est utilisée pour construire un type.)`
.. |static| replace:: :abbr:`static (Cette méthode n'a pas besoin d'instance pour être appelée, elle peut donc être directement appelée en utilisant le nom de la classe.)`
.. |operator| replace:: :abbr:`operator (Cette méthode décrit un opérateur valide à utiliser avec ce type en tant qu'opérande gauche.)`
.. |bitfield| replace:: :abbr:`BitField (Cette valeur est un nombre entier composé d'un masque de bits des options suivantes.)`
.. |void| replace:: :abbr:`void (Aucune valeur de retour.)`
Reference in New Issue View Git Blame Copy Permalink