godotengine/godot-docs-l10n
1
0
Fork 0
mirror of https://github.com/godotengine/godot-docs-l10n.git synced 2026-01-06 22:09:55 +03:00
Code Issues Packages Projects Releases Wiki Activity
Files
4.x
godot-docs-l10n/classes/fr/class_vector3.rst
Rémi Verschelde 369fd84a4f Sync classref with 4.5 branch
2025-12-19 14:34:07 +01:00

1395 lines
90 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_Vector3:
Vector3
=======
Un vecteur 3D utilisant des coordonnées flottantes.
.. rst-class:: classref-introduction-group
Description
-----------
Une structure de 3 éléments qui peut être utilisée pour représenter des coordonnées 3D ou tout autre triplet de valeurs numériques.
Elle utilise des coordonnées flottantes. Par défaut, ces valeurs flottantes utilisent une précision 32 bits, contrairement à :ref:`float<class_float>` qui est toujours en 64 bits. Si une précision double est nécessaire, compilez le moteur avec l'option ``precision=double``.
Voir :ref:`Vector3i<class_Vector3i>` pour l'équivalent entier.
\ **Note :** Avec des booléens, un Vector3 sera évalué à ``false`` s'il est égal à ``Vector3(0, 0, 0)``. Sinon, un Vector4 sera toujours évalué à ``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 3D <https://github.com/godotengine/godot-demo-projects/tree/master/3d>`__
.. rst-class:: classref-reftable-group
Propriétés
--------------------
.. table::
:widths: auto
+---------------------------+------------------------------------+---------+
| :ref:`float<class_float>` | :ref:`x<class_Vector3_property_x>` | ``0.0`` |
+---------------------------+------------------------------------+---------+
| :ref:`float<class_float>` | :ref:`y<class_Vector3_property_y>` | ``0.0`` |
+---------------------------+------------------------------------+---------+
| :ref:`float<class_float>` | :ref:`z<class_Vector3_property_z>` | ``0.0`` |
+---------------------------+------------------------------------+---------+
.. rst-class:: classref-reftable-group
Constructeurs
--------------------------
.. table::
:widths: auto
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`Vector3<class_Vector3_constructor_Vector3>`\ (\ ) |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`Vector3<class_Vector3_constructor_Vector3>`\ (\ from\: :ref:`Vector3<class_Vector3>`\ ) |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`Vector3<class_Vector3_constructor_Vector3>`\ (\ from\: :ref:`Vector3i<class_Vector3i>`\ ) |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`Vector3<class_Vector3_constructor_Vector3>`\ (\ x\: :ref:`float<class_float>`, y\: :ref:`float<class_float>`, z\: :ref:`float<class_float>`\ ) |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------+
.. rst-class:: classref-reftable-group
Méthodes
----------------
.. table::
:widths: auto
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`abs<class_Vector3_method_abs>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`angle_to<class_Vector3_method_angle_to>`\ (\ to\: :ref:`Vector3<class_Vector3>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`bezier_derivative<class_Vector3_method_bezier_derivative>`\ (\ control_1\: :ref:`Vector3<class_Vector3>`, control_2\: :ref:`Vector3<class_Vector3>`, end\: :ref:`Vector3<class_Vector3>`, t\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`bezier_interpolate<class_Vector3_method_bezier_interpolate>`\ (\ control_1\: :ref:`Vector3<class_Vector3>`, control_2\: :ref:`Vector3<class_Vector3>`, end\: :ref:`Vector3<class_Vector3>`, t\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`bounce<class_Vector3_method_bounce>`\ (\ n\: :ref:`Vector3<class_Vector3>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`ceil<class_Vector3_method_ceil>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`clamp<class_Vector3_method_clamp>`\ (\ min\: :ref:`Vector3<class_Vector3>`, max\: :ref:`Vector3<class_Vector3>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`clampf<class_Vector3_method_clampf>`\ (\ min\: :ref:`float<class_float>`, max\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`cross<class_Vector3_method_cross>`\ (\ with\: :ref:`Vector3<class_Vector3>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`cubic_interpolate<class_Vector3_method_cubic_interpolate>`\ (\ b\: :ref:`Vector3<class_Vector3>`, pre_a\: :ref:`Vector3<class_Vector3>`, post_b\: :ref:`Vector3<class_Vector3>`, weight\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`cubic_interpolate_in_time<class_Vector3_method_cubic_interpolate_in_time>`\ (\ b\: :ref:`Vector3<class_Vector3>`, pre_a\: :ref:`Vector3<class_Vector3>`, post_b\: :ref:`Vector3<class_Vector3>`, weight\: :ref:`float<class_float>`, b_t\: :ref:`float<class_float>`, pre_a_t\: :ref:`float<class_float>`, post_b_t\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`direction_to<class_Vector3_method_direction_to>`\ (\ to\: :ref:`Vector3<class_Vector3>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`distance_squared_to<class_Vector3_method_distance_squared_to>`\ (\ to\: :ref:`Vector3<class_Vector3>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`distance_to<class_Vector3_method_distance_to>`\ (\ to\: :ref:`Vector3<class_Vector3>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`dot<class_Vector3_method_dot>`\ (\ with\: :ref:`Vector3<class_Vector3>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`floor<class_Vector3_method_floor>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`inverse<class_Vector3_method_inverse>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_equal_approx<class_Vector3_method_is_equal_approx>`\ (\ to\: :ref:`Vector3<class_Vector3>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_finite<class_Vector3_method_is_finite>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_normalized<class_Vector3_method_is_normalized>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_zero_approx<class_Vector3_method_is_zero_approx>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`length<class_Vector3_method_length>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`length_squared<class_Vector3_method_length_squared>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`lerp<class_Vector3_method_lerp>`\ (\ to\: :ref:`Vector3<class_Vector3>`, weight\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`limit_length<class_Vector3_method_limit_length>`\ (\ length\: :ref:`float<class_float>` = 1.0\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`max<class_Vector3_method_max>`\ (\ with\: :ref:`Vector3<class_Vector3>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`max_axis_index<class_Vector3_method_max_axis_index>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`maxf<class_Vector3_method_maxf>`\ (\ with\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`min<class_Vector3_method_min>`\ (\ with\: :ref:`Vector3<class_Vector3>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`min_axis_index<class_Vector3_method_min_axis_index>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`minf<class_Vector3_method_minf>`\ (\ with\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`move_toward<class_Vector3_method_move_toward>`\ (\ to\: :ref:`Vector3<class_Vector3>`, delta\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`normalized<class_Vector3_method_normalized>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`octahedron_decode<class_Vector3_method_octahedron_decode>`\ (\ uv\: :ref:`Vector2<class_Vector2>`\ ) |static| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`octahedron_encode<class_Vector3_method_octahedron_encode>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Basis<class_Basis>` | :ref:`outer<class_Vector3_method_outer>`\ (\ with\: :ref:`Vector3<class_Vector3>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`posmod<class_Vector3_method_posmod>`\ (\ mod\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`posmodv<class_Vector3_method_posmodv>`\ (\ modv\: :ref:`Vector3<class_Vector3>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`project<class_Vector3_method_project>`\ (\ b\: :ref:`Vector3<class_Vector3>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`reflect<class_Vector3_method_reflect>`\ (\ n\: :ref:`Vector3<class_Vector3>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`rotated<class_Vector3_method_rotated>`\ (\ axis\: :ref:`Vector3<class_Vector3>`, angle\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`round<class_Vector3_method_round>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`sign<class_Vector3_method_sign>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`signed_angle_to<class_Vector3_method_signed_angle_to>`\ (\ to\: :ref:`Vector3<class_Vector3>`, axis\: :ref:`Vector3<class_Vector3>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`slerp<class_Vector3_method_slerp>`\ (\ to\: :ref:`Vector3<class_Vector3>`, weight\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`slide<class_Vector3_method_slide>`\ (\ n\: :ref:`Vector3<class_Vector3>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`snapped<class_Vector3_method_snapped>`\ (\ step\: :ref:`Vector3<class_Vector3>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`snappedf<class_Vector3_method_snappedf>`\ (\ step\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
.. rst-class:: classref-reftable-group
Opérateurs
--------------------
.. table::
:widths: auto
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator !=<class_Vector3_operator_neq_Vector3>`\ (\ right\: :ref:`Vector3<class_Vector3>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`operator *<class_Vector3_operator_mul_Basis>`\ (\ right\: :ref:`Basis<class_Basis>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`operator *<class_Vector3_operator_mul_Quaternion>`\ (\ right\: :ref:`Quaternion<class_Quaternion>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`operator *<class_Vector3_operator_mul_Transform3D>`\ (\ right\: :ref:`Transform3D<class_Transform3D>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`operator *<class_Vector3_operator_mul_Vector3>`\ (\ right\: :ref:`Vector3<class_Vector3>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`operator *<class_Vector3_operator_mul_float>`\ (\ right\: :ref:`float<class_float>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`operator *<class_Vector3_operator_mul_int>`\ (\ right\: :ref:`int<class_int>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`operator +<class_Vector3_operator_sum_Vector3>`\ (\ right\: :ref:`Vector3<class_Vector3>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`operator -<class_Vector3_operator_dif_Vector3>`\ (\ right\: :ref:`Vector3<class_Vector3>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`operator /<class_Vector3_operator_div_Vector3>`\ (\ right\: :ref:`Vector3<class_Vector3>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`operator /<class_Vector3_operator_div_float>`\ (\ right\: :ref:`float<class_float>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`operator /<class_Vector3_operator_div_int>`\ (\ right\: :ref:`int<class_int>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator \<<class_Vector3_operator_lt_Vector3>`\ (\ right\: :ref:`Vector3<class_Vector3>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator \<=<class_Vector3_operator_lte_Vector3>`\ (\ right\: :ref:`Vector3<class_Vector3>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator ==<class_Vector3_operator_eq_Vector3>`\ (\ right\: :ref:`Vector3<class_Vector3>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator ><class_Vector3_operator_gt_Vector3>`\ (\ right\: :ref:`Vector3<class_Vector3>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator >=<class_Vector3_operator_gte_Vector3>`\ (\ right\: :ref:`Vector3<class_Vector3>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`operator []<class_Vector3_operator_idx_int>`\ (\ index\: :ref:`int<class_int>`\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`operator unary+<class_Vector3_operator_unplus>`\ (\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`operator unary-<class_Vector3_operator_unminus>`\ (\ ) |
+-------------------------------+----------------------------------------------------------------------------------------------------------------+
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Énumérations
------------------------
.. _enum_Vector3_Axis:
.. rst-class:: classref-enumeration
enum **Axis**: :ref:`🔗<enum_Vector3_Axis>`
.. _class_Vector3_constant_AXIS_X:
.. rst-class:: classref-enumeration-constant
:ref:`Axis<enum_Vector3_Axis>` **AXIS_X** = ``0``
La valeur de l'énumération pour l'axe X. Renvoyé par :ref:`max_axis_index()<class_Vector3_method_max_axis_index>` et :ref:`min_axis_index()<class_Vector3_method_min_axis_index>`.
.. _class_Vector3_constant_AXIS_Y:
.. rst-class:: classref-enumeration-constant
:ref:`Axis<enum_Vector3_Axis>` **AXIS_Y** = ``1``
La valeur de l'énumération pour l'axe Y. Retourné par :ref:`max_axis_index()<class_Vector3_method_max_axis_index>` et :ref:`min_axis_index()<class_Vector3_method_min_axis_index>`.
.. _class_Vector3_constant_AXIS_Z:
.. rst-class:: classref-enumeration-constant
:ref:`Axis<enum_Vector3_Axis>` **AXIS_Z** = ``2``
La valeur de l'énumération pour l'axe Z. Renvoyé par :ref:`max_axis_index()<class_Vector3_method_max_axis_index>` et :ref:`min_axis_index()<class_Vector3_method_min_axis_index>`.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Constantes
--------------------
.. _class_Vector3_constant_ZERO:
.. rst-class:: classref-constant
**ZERO** = ``Vector3(0, 0, 0)`` :ref:`🔗<class_Vector3_constant_ZERO>`
Le vecteur zéro, un vecteur avec tous ses composants définis ``0``.
.. _class_Vector3_constant_ONE:
.. rst-class:: classref-constant
**ONE** = ``Vector3(1, 1, 1)`` :ref:`🔗<class_Vector3_constant_ONE>`
Le vecteur unitaire, un vecteur avec tous ses composants définis à ``1``.
.. _class_Vector3_constant_INF:
.. rst-class:: classref-constant
**INF** = ``Vector3(inf, inf, inf)`` :ref:`🔗<class_Vector3_constant_INF>`
Le vecteur infini, un vecteur avec tous ses composants définit à :ref:`@GDScript.INF<class_@GDScript_constant_INF>`.
.. _class_Vector3_constant_LEFT:
.. rst-class:: classref-constant
**LEFT** = ``Vector3(-1, 0, 0)`` :ref:`🔗<class_Vector3_constant_LEFT>`
Le vecteur unitaire gauche. Représente la direction locale à gauche, et la direction globale vers l'ouest.
.. _class_Vector3_constant_RIGHT:
.. rst-class:: classref-constant
**RIGHT** = ``Vector3(1, 0, 0)`` :ref:`🔗<class_Vector3_constant_RIGHT>`
Le vecteur unitaire vers la droite. Représente la direction locale à droite, et la direction globale vers l'est.
.. _class_Vector3_constant_UP:
.. rst-class:: classref-constant
**UP** = ``Vector3(0, 1, 0)`` :ref:`🔗<class_Vector3_constant_UP>`
Vecteur unitaire vers le haut.
.. _class_Vector3_constant_DOWN:
.. rst-class:: classref-constant
**DOWN** = ``Vector3(0, -1, 0)`` :ref:`🔗<class_Vector3_constant_DOWN>`
Vecteur unitaire vers le bas.
.. _class_Vector3_constant_FORWARD:
.. rst-class:: classref-constant
**FORWARD** = ``Vector3(0, 0, -1)`` :ref:`🔗<class_Vector3_constant_FORWARD>`
Un vecteur avant unité. Représente la direction locale de l'avant et la direction globale du nord. Gardez à l'esprit que la direction vers l'avant pour les lumières, les caméras, etc est différente des ressources 3D comme les personnages, qui se tournent vers la caméra par convention. Utilisez :ref:`MODEL_FRONT<class_Vector3_constant_MODEL_FRONT>` et les constantes similaires quand vous travaillez dans l'espace de ressource 3D.
.. _class_Vector3_constant_BACK:
.. rst-class:: classref-constant
**BACK** = ``Vector3(0, 0, 1)`` :ref:`🔗<class_Vector3_constant_BACK>`
Vecteur unitaire vers l'arrière. Représente la direction locale vers l'arrière, et la direction globale vers le sud.
.. _class_Vector3_constant_MODEL_LEFT:
.. rst-class:: classref-constant
**MODEL_LEFT** = ``Vector3(1, 0, 0)`` :ref:`🔗<class_Vector3_constant_MODEL_LEFT>`
Vecteur unité pointant vers le côté gauche des ressources 3D importées.
.. _class_Vector3_constant_MODEL_RIGHT:
.. rst-class:: classref-constant
**MODEL_RIGHT** = ``Vector3(-1, 0, 0)`` :ref:`🔗<class_Vector3_constant_MODEL_RIGHT>`
Vecteur unité pointant vers le côté droit des ressources 3D importées.
.. _class_Vector3_constant_MODEL_TOP:
.. rst-class:: classref-constant
**MODEL_TOP** = ``Vector3(0, 1, 0)`` :ref:`🔗<class_Vector3_constant_MODEL_TOP>`
Vecteur unité pointant vers le haut des ressources 3D importées.
.. _class_Vector3_constant_MODEL_BOTTOM:
.. rst-class:: classref-constant
**MODEL_BOTTOM** = ``Vector3(0, -1, 0)`` :ref:`🔗<class_Vector3_constant_MODEL_BOTTOM>`
Vecteur unité pointant vers le bas des ressources 3D importées.
.. _class_Vector3_constant_MODEL_FRONT:
.. rst-class:: classref-constant
**MODEL_FRONT** = ``Vector3(0, 0, 1)`` :ref:`🔗<class_Vector3_constant_MODEL_FRONT>`
Vecteur unité pointant vers l'avant des ressources 3D importées.
.. _class_Vector3_constant_MODEL_REAR:
.. rst-class:: classref-constant
**MODEL_REAR** = ``Vector3(0, 0, -1)`` :ref:`🔗<class_Vector3_constant_MODEL_REAR>`
Vecteur unité pointant vers l'arrière des ressources 3D importées.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descriptions des propriétés
------------------------------------------------------
.. _class_Vector3_property_x:
.. rst-class:: classref-property
:ref:`float<class_float>` **x** = ``0.0`` :ref:`🔗<class_Vector3_property_x>`
La composante vectorielle X. Également accessible en utilisant le code de position index ``[0]``.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_property_y:
.. rst-class:: classref-property
:ref:`float<class_float>` **y** = ``0.0`` :ref:`🔗<class_Vector3_property_y>`
La composante vectorielle X. Également accessible en utilisant le code de position index ``[1]``.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_property_z:
.. rst-class:: classref-property
:ref:`float<class_float>` **z** = ``0.0`` :ref:`🔗<class_Vector3_property_z>`
Le composant vectoriel Z. Également accessible en utilisant l'index ``[2]``.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descriptions des constructeurs
------------------------------------------------------------
.. _class_Vector3_constructor_Vector3:
.. rst-class:: classref-constructor
:ref:`Vector3<class_Vector3>` **Vector3**\ (\ ) :ref:`🔗<class_Vector3_constructor_Vector3>`
Construit un **Vector3** initialisé par défaut, avec toutes ses composantes définies à ``0``.
.. rst-class:: classref-item-separator
----
.. rst-class:: classref-constructor
:ref:`Vector3<class_Vector3>` **Vector3**\ (\ from\: :ref:`Vector3<class_Vector3>`\ )
Construit un **Vector3** comme copie du **Vector3** donné.
.. rst-class:: classref-item-separator
----
.. rst-class:: classref-constructor
:ref:`Vector3<class_Vector3>` **Vector3**\ (\ from\: :ref:`Vector3i<class_Vector3i>`\ )
Construit un nouveau **Vector3** à partir d'un :ref:`Vector3i<class_Vector3i>`.
.. rst-class:: classref-item-separator
----
.. rst-class:: classref-constructor
:ref:`Vector3<class_Vector3>` **Vector3**\ (\ x\: :ref:`float<class_float>`, y\: :ref:`float<class_float>`, z\: :ref:`float<class_float>`\ )
Renvoie un **Vector3** avec les coordonnées spécifiées.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descriptions des méthodes
--------------------------------------------------
.. _class_Vector3_method_abs:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **abs**\ (\ ) |const| :ref:`🔗<class_Vector3_method_abs>`
Renvoie un nouveau vecteur avec tous ses composantes en valeurs absolues (c'est-à-dire toujours positives).
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_angle_to:
.. rst-class:: classref-method
:ref:`float<class_float>` **angle_to**\ (\ to\: :ref:`Vector3<class_Vector3>`\ ) |const| :ref:`🔗<class_Vector3_method_angle_to>`
Renvoie l'angle non signé minimum avec le vecteur donné, en radians.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_bezier_derivative:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **bezier_derivative**\ (\ control_1\: :ref:`Vector3<class_Vector3>`, control_2\: :ref:`Vector3<class_Vector3>`, end\: :ref:`Vector3<class_Vector3>`, t\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector3_method_bezier_derivative>`
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_Vector3_method_bezier_interpolate:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **bezier_interpolate**\ (\ control_1\: :ref:`Vector3<class_Vector3>`, control_2\: :ref:`Vector3<class_Vector3>`, end\: :ref:`Vector3<class_Vector3>`, t\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector3_method_bezier_interpolate>`
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_Vector3_method_bounce:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **bounce**\ (\ n\: :ref:`Vector3<class_Vector3>`\ ) |const| :ref:`🔗<class_Vector3_method_bounce>`
Renvoie le vecteur "réfléchi" d'un plan défini par la normale ``n`` donnée.
\ **Note:** :ref:`bounce()<class_Vector3_method_bounce>` effectue l'opération que la plupart des moteurs et des frameworks appellent ``reflect()``.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_ceil:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **ceil**\ (\ ) |const| :ref:`🔗<class_Vector3_method_ceil>`
Renvoie un nouveau vecteur avec tous les composantes arrondies vers le haut (vers +infini).
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_clamp:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **clamp**\ (\ min\: :ref:`Vector3<class_Vector3>`, max\: :ref:`Vector3<class_Vector3>`\ ) |const| :ref:`🔗<class_Vector3_method_clamp>`
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_Vector3_method_clampf:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **clampf**\ (\ min\: :ref:`float<class_float>`, max\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector3_method_clampf>`
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_Vector3_method_cross:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **cross**\ (\ with\: :ref:`Vector3<class_Vector3>`\ ) |const| :ref:`🔗<class_Vector3_method_cross>`
Renvoie le produit vectoriel de ce vecteur et ``with``.
Cela renvoie un vecteur perpendiculaire à ceci et ``with``, ce qui serait le vecteur normal au plan défini par les deux vecteurs. Comme il y a deux vecteurs possibles, dans des directions opposées, cette méthode renvoie le vecteur défini par un système de coordonnées main droite. Si les deux vecteurs sont parallèles, cette méthode renvoie un vecteur vide, ce qui la rend utile pour tester si deux vecteurs sont parallèles.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_cubic_interpolate:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **cubic_interpolate**\ (\ b\: :ref:`Vector3<class_Vector3>`, pre_a\: :ref:`Vector3<class_Vector3>`, post_b\: :ref:`Vector3<class_Vector3>`, weight\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector3_method_cubic_interpolate>`
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_Vector3_method_cubic_interpolate_in_time:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **cubic_interpolate_in_time**\ (\ b\: :ref:`Vector3<class_Vector3>`, pre_a\: :ref:`Vector3<class_Vector3>`, post_b\: :ref:`Vector3<class_Vector3>`, weight\: :ref:`float<class_float>`, b_t\: :ref:`float<class_float>`, pre_a_t\: :ref:`float<class_float>`, post_b_t\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector3_method_cubic_interpolate_in_time>`
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_Vector3_method_cubic_interpolate>` pour les valeurs temporelles.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_direction_to:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **direction_to**\ (\ to\: :ref:`Vector3<class_Vector3>`\ ) |const| :ref:`🔗<class_Vector3_method_direction_to>`
Renvoie le vecteur normalisé pointant de ce vecteur en direction de ``to``. Ceci est équivalent à l'utilisation de ``(b - a).normalized()``.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_distance_squared_to:
.. rst-class:: classref-method
:ref:`float<class_float>` **distance_squared_to**\ (\ to\: :ref:`Vector3<class_Vector3>`\ ) |const| :ref:`🔗<class_Vector3_method_distance_squared_to>`
Renvoie la distance au carré entre ce vecteur et ``to``.
Cette méthode est plus rapide que :ref:`distance_to()<class_Vector3_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_Vector3_method_distance_to:
.. rst-class:: classref-method
:ref:`float<class_float>` **distance_to**\ (\ to\: :ref:`Vector3<class_Vector3>`\ ) |const| :ref:`🔗<class_Vector3_method_distance_to>`
Renvoie la distance entre ce vecteur et ``to``.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_dot:
.. rst-class:: classref-method
:ref:`float<class_float>` **dot**\ (\ with\: :ref:`Vector3<class_Vector3>`\ ) |const| :ref:`🔗<class_Vector3_method_dot>`
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_Vector3_method_floor:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **floor**\ (\ ) |const| :ref:`🔗<class_Vector3_method_floor>`
Renvoie un nouveau vecteur avec tous les composantes arrondies vers le bas (vers -infini).
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_inverse:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **inverse**\ (\ ) |const| :ref:`🔗<class_Vector3_method_inverse>`
Renvoie l'inverse du vecteur. Cela est identique à ``Vector3( 1.0 / v.x, 1.0 / v.y, 1.0 / v.z )``.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_is_equal_approx:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_equal_approx**\ (\ to\: :ref:`Vector3<class_Vector3>`\ ) |const| :ref:`🔗<class_Vector3_method_is_equal_approx>`
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_Vector3_method_is_finite:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_finite**\ (\ ) |const| :ref:`🔗<class_Vector3_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_Vector3_method_is_normalized:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_normalized**\ (\ ) |const| :ref:`🔗<class_Vector3_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_Vector3_method_is_zero_approx:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_zero_approx**\ (\ ) |const| :ref:`🔗<class_Vector3_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_Vector3_method_is_equal_approx>` avec un vecteur nul comme valeur.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_length:
.. rst-class:: classref-method
:ref:`float<class_float>` **length**\ (\ ) |const| :ref:`🔗<class_Vector3_method_length>`
Renvoie la longueur (magnitude) de ce vecteur.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_length_squared:
.. rst-class:: classref-method
:ref:`float<class_float>` **length_squared**\ (\ ) |const| :ref:`🔗<class_Vector3_method_length_squared>`
Renvoie la longeur (magnitude) au carré de ce vecteur.
Cette méthode est plus rapide que :ref:`length()<class_Vector3_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_Vector3_method_lerp:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **lerp**\ (\ to\: :ref:`Vector3<class_Vector3>`, weight\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector3_method_lerp>`
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_Vector3_method_limit_length:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **limit_length**\ (\ length\: :ref:`float<class_float>` = 1.0\ ) |const| :ref:`🔗<class_Vector3_method_limit_length>`
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_Vector3_method_max:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **max**\ (\ with\: :ref:`Vector3<class_Vector3>`\ ) |const| :ref:`🔗<class_Vector3_method_max>`
Renvoie le maximum par composante de ceci et ``with``, équivalent à ``Vector3(maxf(x, with.x), maxf(y, with.y), maxf(z, with.z))``.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_max_axis_index:
.. rst-class:: classref-method
:ref:`int<class_int>` **max_axis_index**\ (\ ) |const| :ref:`🔗<class_Vector3_method_max_axis_index>`
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_Vector3_constant_AXIS_X>`.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_maxf:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **maxf**\ (\ with\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector3_method_maxf>`
Renvoie le maximum par composante de ceci et ``with``, équivalent à ``Vector3(maxf(x, with), maxf(y, with), maxf(z, with))``.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_min:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **min**\ (\ with\: :ref:`Vector3<class_Vector3>`\ ) |const| :ref:`🔗<class_Vector3_method_min>`
Renvoie le minimum par composante de ceci et ``with``, équivalent à ``Vector3(minf(x, with.x), minf(y, with.y), minf(z, with.z))``.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_min_axis_index:
.. rst-class:: classref-method
:ref:`int<class_int>` **min_axis_index**\ (\ ) |const| :ref:`🔗<class_Vector3_method_min_axis_index>`
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_Z<class_Vector3_constant_AXIS_Z>`.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_minf:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **minf**\ (\ with\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector3_method_minf>`
Renvoie le minimum par composante de ceci et ``with``, équivalent à ``Vector3(minf(x, with), minf(y, with), minf(z, with))``.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_move_toward:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **move_toward**\ (\ to\: :ref:`Vector3<class_Vector3>`, delta\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector3_method_move_toward>`
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_Vector3_method_normalized:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **normalized**\ (\ ) |const| :ref:`🔗<class_Vector3_method_normalized>`
Renvoie le résultat de la mise à l'échelle du vecteur à la longueur unité. Équivalent à ``v / v.length()``. Renvoie ``(0, 0, 0)`` si ``v.length() == 0``. Voir aussi :ref:`is_normalized()<class_Vector3_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_Vector3_method_octahedron_decode:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **octahedron_decode**\ (\ uv\: :ref:`Vector2<class_Vector2>`\ ) |static| :ref:`🔗<class_Vector3_method_octahedron_decode>`
Renvoie le **Vector3** depuis une forme compressé octaédrique créée en utilisant :ref:`octahedron_encode()<class_Vector3_method_octahedron_encode>` (stocké comme un :ref:`Vector2<class_Vector2>`).
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_octahedron_encode:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **octahedron_encode**\ (\ ) |const| :ref:`🔗<class_Vector3_method_octahedron_encode>`
Renvoie la forme encodée octaédrique de ce **Vector3** en tant que :ref:`Vector2<class_Vector2>`. Comme un :ref:`Vector2<class_Vector2>` occupe 1/3 moins de mémoire comparé à **Vector3**, cette forme de compression peut être utilisée pour passer de plus grandes quantités de **Vector3**\ s normalisés (:ref:`normalized()<class_Vector3_method_normalized>`) sans augmenter la nécessité de mémoire et de stockage. Voir aussi :ref:`octahedron_decode()<class_Vector3_method_octahedron_decode>`.
\ **Note :** :ref:`octahedron_encode()<class_Vector3_method_octahedron_encode>` peut seulement être utilisée pour des vecteurs normalisés (:ref:`normalized()<class_Vector3_method_normalized>`). :ref:`octahedron_encode()<class_Vector3_method_octahedron_encode>` ne vérifie *pas* si ce **Vector3** est normalisé, et va renvoyer une valeur qui ne se décompresse pas en la valeur originale si le **Vector3** n'est pas normalisée.
\ **Note :** La compression octaédrique a des *pertes*, même si les différences visuels sont rarement perceptibles dans des scénarios réels.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_outer:
.. rst-class:: classref-method
:ref:`Basis<class_Basis>` **outer**\ (\ with\: :ref:`Vector3<class_Vector3>`\ ) |const| :ref:`🔗<class_Vector3_method_outer>`
Renvoie le produit extérieur avec ``with``.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_posmod:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **posmod**\ (\ mod\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector3_method_posmod>`
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_Vector3_method_posmodv:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **posmodv**\ (\ modv\: :ref:`Vector3<class_Vector3>`\ ) |const| :ref:`🔗<class_Vector3_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_Vector3_method_project:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **project**\ (\ b\: :ref:`Vector3<class_Vector3>`\ ) |const| :ref:`🔗<class_Vector3_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_Vector3_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_Vector3_method_reflect:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **reflect**\ (\ n\: :ref:`Vector3<class_Vector3>`\ ) |const| :ref:`🔗<class_Vector3_method_reflect>`
Renvoie le résultat de la réflexion du vecteur à travers un plan défini par le vecteur normal ``n`` donné.
\ **Note :** :ref:`reflect()<class_Vector3_method_reflect>` diffère de ce que les autres moteurs et frameworks appellent ``reflect()``. Dans d'autres moteurs, ``reflect()`` renvoie le résultat du vecteur réfléchi par le plan donné. La réflexion passe donc par la normale donnée. Tandis que dans Godot, la réflexion passe par le plan et peut être pensé comme rebondissant de la normale. Voir aussi :ref:`bounce()<class_Vector3_method_bounce>` qui fait ce que la plupart des moteurs appellent ``reflect()``.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_rotated:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **rotated**\ (\ axis\: :ref:`Vector3<class_Vector3>`, angle\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector3_method_rotated>`
Renvoie le résultat de la rotation de ce vecteur autour d'un axe donné, d'un ``angle`` donné (en radians). L'axe doit être un vecteur normalisé. Voir aussi :ref:`@GlobalScope.deg_to_rad()<class_@GlobalScope_method_deg_to_rad>`.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_round:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **round**\ (\ ) |const| :ref:`🔗<class_Vector3_method_round>`
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_Vector3_method_sign:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **sign**\ (\ ) |const| :ref:`🔗<class_Vector3_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_Vector3_method_signed_angle_to:
.. rst-class:: classref-method
:ref:`float<class_float>` **signed_angle_to**\ (\ to\: :ref:`Vector3<class_Vector3>`, axis\: :ref:`Vector3<class_Vector3>`\ ) |const| :ref:`🔗<class_Vector3_method_signed_angle_to>`
Renvoie l'angle signé du vecteur donné, en radians. Le signe de l'angle est positif dans le sens inverse des aiguilles d'une montre et négatif dans l'autre direction lorsqu'il est vu du côté spécifié par l'axe ``axis``.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_slerp:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **slerp**\ (\ to\: :ref:`Vector3<class_Vector3>`, weight\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector3_method_slerp>`
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_Vector3_method_lerp>`.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_slide:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **slide**\ (\ n\: :ref:`Vector3<class_Vector3>`\ ) |const| :ref:`🔗<class_Vector3_method_slide>`
Returns a new vector resulting from sliding this vector along a plane 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_Vector3_method_project>`.
\ **Note:** The vector ``n`` must be normalized. See also :ref:`normalized()<class_Vector3_method_normalized>`.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_method_snapped:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **snapped**\ (\ step\: :ref:`Vector3<class_Vector3>`\ ) |const| :ref:`🔗<class_Vector3_method_snapped>`
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_Vector3_method_snappedf:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **snappedf**\ (\ step\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector3_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_Vector3_operator_neq_Vector3:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator !=**\ (\ right\: :ref:`Vector3<class_Vector3>`\ ) :ref:`🔗<class_Vector3_operator_neq_Vector3>`
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_Vector3_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_Vector3_operator_mul_Basis:
.. rst-class:: classref-operator
:ref:`Vector3<class_Vector3>` **operator ***\ (\ right\: :ref:`Basis<class_Basis>`\ ) :ref:`🔗<class_Vector3_operator_mul_Basis>`
Transforme (multiplie) de manière inverse le **Vector3** par la matrice de base :ref:`Basis<class_Basis>` donnée, avec la supposition que la base est orthonormée (c.a.d. une rotation/réflexion est OK, une échelle/un cisaillement ne l'est pas).
\ ``vector * basis`` est équivalent à ``basis.transposed() * vector``. Voir :ref:`Basis.transposed()<class_Basis_method_transposed>`.
Pour transformer par l'inverse d'une base non-orthonormée (par ex. avec une mise à l'échelle), ``basis.inverse() * vector`` peut être utilisé à la place. Voir :ref:`Basis.inverse()<class_Basis_method_inverse>`.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_operator_mul_Quaternion:
.. rst-class:: classref-operator
:ref:`Vector3<class_Vector3>` **operator ***\ (\ right\: :ref:`Quaternion<class_Quaternion>`\ ) :ref:`🔗<class_Vector3_operator_mul_Quaternion>`
Transforme (multiplie) de manière inverse le **Vector3** par le :ref:`Quaternion<class_Quaternion>` donné.
\ ``vector * quaternion`` est équivalent à ``quaternion.inverse() * vector``. Voir :ref:`Quaternion.inverse()<class_Quaternion_method_inverse>`.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_operator_mul_Transform3D:
.. rst-class:: classref-operator
:ref:`Vector3<class_Vector3>` **operator ***\ (\ right\: :ref:`Transform3D<class_Transform3D>`\ ) :ref:`🔗<class_Vector3_operator_mul_Transform3D>`
Transforme (multiplie) de manière inverse le **Vector3** par la matrice de transformation :ref:`Transform3D<class_Transform3D>` 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:`Transform3D.inverse()<class_Transform3D_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:`Transform3D.affine_inverse()<class_Transform3D_method_affine_inverse>`.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_operator_mul_Vector3:
.. rst-class:: classref-operator
:ref:`Vector3<class_Vector3>` **operator ***\ (\ right\: :ref:`Vector3<class_Vector3>`\ ) :ref:`🔗<class_Vector3_operator_mul_Vector3>`
Multiplie chaque composante du **Vector3** par les composantes du **Vector3** donné.
::
print(Vector3(10, 20, 30) * Vector3(3, 4, 5)) # Affiche (30.0, 80.0, 150.0)
.. rst-class:: classref-item-separator
----
.. _class_Vector3_operator_mul_float:
.. rst-class:: classref-operator
:ref:`Vector3<class_Vector3>` **operator ***\ (\ right\: :ref:`float<class_float>`\ ) :ref:`🔗<class_Vector3_operator_mul_float>`
Multiplie chaque composante du **Vector3** par le flottant :ref:`float<class_float>` donné.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_operator_mul_int:
.. rst-class:: classref-operator
:ref:`Vector3<class_Vector3>` **operator ***\ (\ right\: :ref:`int<class_int>`\ ) :ref:`🔗<class_Vector3_operator_mul_int>`
Multiplie chaque composante du **Vector3** par l'entier :ref:`int<class_int>` donné.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_operator_sum_Vector3:
.. rst-class:: classref-operator
:ref:`Vector3<class_Vector3>` **operator +**\ (\ right\: :ref:`Vector3<class_Vector3>`\ ) :ref:`🔗<class_Vector3_operator_sum_Vector3>`
Ajoute chaque composante du **Vector3** aux composantes du **Vector3** donné.
::
print(Vector3(10, 20, 30) + Vector3(3, 4, 5)) # Affiche (13.0, 24.0, 35.0)
.. rst-class:: classref-item-separator
----
.. _class_Vector3_operator_dif_Vector3:
.. rst-class:: classref-operator
:ref:`Vector3<class_Vector3>` **operator -**\ (\ right\: :ref:`Vector3<class_Vector3>`\ ) :ref:`🔗<class_Vector3_operator_dif_Vector3>`
Soustrait chaque composante du **Vector3** par les composantes du **Vector3** donné.
::
print(Vector3(10, 20, 30) - Vector3(3, 4, 5)) # Affiche (7.0, 16.0, 25.0)
.. rst-class:: classref-item-separator
----
.. _class_Vector3_operator_div_Vector3:
.. rst-class:: classref-operator
:ref:`Vector3<class_Vector3>` **operator /**\ (\ right\: :ref:`Vector3<class_Vector3>`\ ) :ref:`🔗<class_Vector3_operator_div_Vector3>`
Divise chaque composante du **Vector3** par les composantes du **Vector3** donné.
::
print(Vector3(10, 20, 30) / Vector3(2, 5, 3)) # Affiche (5.0, 4.0, 10.0)
.. rst-class:: classref-item-separator
----
.. _class_Vector3_operator_div_float:
.. rst-class:: classref-operator
:ref:`Vector3<class_Vector3>` **operator /**\ (\ right\: :ref:`float<class_float>`\ ) :ref:`🔗<class_Vector3_operator_div_float>`
Divise chaque composante du **Vector3** par le flottant :ref:`float<class_float>` donné.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_operator_div_int:
.. rst-class:: classref-operator
:ref:`Vector3<class_Vector3>` **operator /**\ (\ right\: :ref:`int<class_int>`\ ) :ref:`🔗<class_Vector3_operator_div_int>`
Divise chaque composante du **Vector3** par l'entier :ref:`int<class_int>` donné.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_operator_lt_Vector3:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator <**\ (\ right\: :ref:`Vector3<class_Vector3>`\ ) :ref:`🔗<class_Vector3_operator_lt_Vector3>`
Compare deux **Vector3** 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, puis sur les valeurs en Z. 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 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_Vector3_operator_lte_Vector3:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator <=**\ (\ right\: :ref:`Vector3<class_Vector3>`\ ) :ref:`🔗<class_Vector3_operator_lte_Vector3>`
Compare deux **Vector3** 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, puis sur les valeurs en Z. 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 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_Vector3_operator_eq_Vector3:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator ==**\ (\ right\: :ref:`Vector3<class_Vector3>`\ ) :ref:`🔗<class_Vector3_operator_eq_Vector3>`
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_Vector3_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_Vector3_operator_gt_Vector3:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator >**\ (\ right\: :ref:`Vector3<class_Vector3>`\ ) :ref:`🔗<class_Vector3_operator_gt_Vector3>`
Compare deux **Vector3** 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, puis sur les valeurs en Z. 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 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_Vector3_operator_gte_Vector3:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator >=**\ (\ right\: :ref:`Vector3<class_Vector3>`\ ) :ref:`🔗<class_Vector3_operator_gte_Vector3>`
Compare deux **Vector3** 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, puis sur les valeurs en Z. 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 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_Vector3_operator_idx_int:
.. rst-class:: classref-operator
:ref:`float<class_float>` **operator []**\ (\ index\: :ref:`int<class_int>`\ ) :ref:`🔗<class_Vector3_operator_idx_int>`
Accède aux composantes du vecteur par leur ``index``. ``v[0]`` est équivalent à ``v.x``, ``v[1]`` est équivalent à ``v.y``, et ``v[2]`` est équivalent à ``v.z``.
.. rst-class:: classref-item-separator
----
.. _class_Vector3_operator_unplus:
.. rst-class:: classref-operator
:ref:`Vector3<class_Vector3>` **operator unary+**\ (\ ) :ref:`🔗<class_Vector3_operator_unplus>`
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_Vector3_operator_unminus:
.. rst-class:: classref-operator
:ref:`Vector3<class_Vector3>` **operator unary-**\ (\ ) :ref:`🔗<class_Vector3_operator_unminus>`
Renvoie la valeur négative du **Vector3**. Revient à écrire ``Vector3(-v.x, -v.y,-v.z)``. 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