mirror of
https://github.com/godotengine/godot-docs-l10n.git
synced 2025-12-31 09:49:22 +03:00
1395 lines
90 KiB
ReStructuredText
1395 lines
90 KiB
ReStructuredText
:github_url: hide
|
|
|
|
.. _class_Vector3:
|
|
|
|
Vector3
|
|
=======
|
|
|
|
Un vettore 3D che utilizza coordinate in virgola mobile.
|
|
|
|
.. rst-class:: classref-introduction-group
|
|
|
|
Descrizione
|
|
----------------------
|
|
|
|
Una struttura a 3 elementi che può essere utilizzata per rappresentare coordinate 3D o qualsiasi altra tripletta di valori numerici.
|
|
|
|
Utilizza coordinate in virgola mobile. Per impostazione predefinita, questi valori in virgola mobile usano una precisione a 32 bit, a differenza di :ref:`float<class_float>` che è sempre a 64 bit. Se è necessaria una precisione doppia, compila il motore con l'opzione ``precision=double``.
|
|
|
|
Vedi :ref:`Vector3i<class_Vector3i>` per la sua controparte con numeri interi.
|
|
|
|
\ **Nota:** In un contesto booleano, un Vector3 sarà valutato come ``false`` se è uguale a ``Vector3(0, 0, 0)``. Altrimenti, un Vector3 sarà sempre valutato come ``true``.
|
|
|
|
.. rst-class:: classref-introduction-group
|
|
|
|
Tutorial
|
|
----------------
|
|
|
|
- :doc:`Indice della documentazione di matematica <../tutorials/math/index>`
|
|
|
|
- :doc:`Matematica dei vettori <../tutorials/math/vector_math>`
|
|
|
|
- :doc:`Matematica avanzata dei vettori <../tutorials/math/vectors_advanced>`
|
|
|
|
- `3Blue1Brown Essence of Linear Algebra <https://www.youtube.com/playlist?list=PLZHQObOWTQDPD3MizzM2xVFitgF8hE_ab>`__
|
|
|
|
- `Demo di trasformazione di matrice <https://godotengine.org/asset-library/asset/2787>`__
|
|
|
|
- `Tutte le demo 3D <https://github.com/godotengine/godot-demo-projects/tree/master/3d>`__
|
|
|
|
.. rst-class:: classref-reftable-group
|
|
|
|
Proprietà
|
|
------------------
|
|
|
|
.. 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
|
|
|
|
Costruttori
|
|
----------------------
|
|
|
|
.. 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
|
|
|
|
Metodi
|
|
------------
|
|
|
|
.. 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
|
|
|
|
Operatori
|
|
------------------
|
|
|
|
.. 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
|
|
|
|
Enumerazioni
|
|
------------------------
|
|
|
|
.. _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``
|
|
|
|
Valore enumerato per l'asse X. Restituito da :ref:`max_axis_index()<class_Vector3_method_max_axis_index>` e :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``
|
|
|
|
Valore enumerato per l'asse Y. Restituito da :ref:`max_axis_index()<class_Vector3_method_max_axis_index>` e :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``
|
|
|
|
Valore enumerato per l'asse Z. Restituito da :ref:`max_axis_index()<class_Vector3_method_max_axis_index>` e :ref:`min_axis_index()<class_Vector3_method_min_axis_index>`.
|
|
|
|
.. rst-class:: classref-section-separator
|
|
|
|
----
|
|
|
|
.. rst-class:: classref-descriptions-group
|
|
|
|
Costanti
|
|
----------------
|
|
|
|
.. _class_Vector3_constant_ZERO:
|
|
|
|
.. rst-class:: classref-constant
|
|
|
|
**ZERO** = ``Vector3(0, 0, 0)`` :ref:`🔗<class_Vector3_constant_ZERO>`
|
|
|
|
Il vettore zero, un vettore con tutti i suoi componenti impostati su ``0``.
|
|
|
|
.. _class_Vector3_constant_ONE:
|
|
|
|
.. rst-class:: classref-constant
|
|
|
|
**ONE** = ``Vector3(1, 1, 1)`` :ref:`🔗<class_Vector3_constant_ONE>`
|
|
|
|
Il vettore unitario, un vettore con tutti i suoi componenti impostati su ``1``.
|
|
|
|
.. _class_Vector3_constant_INF:
|
|
|
|
.. rst-class:: classref-constant
|
|
|
|
**INF** = ``Vector3(inf, inf, inf)`` :ref:`🔗<class_Vector3_constant_INF>`
|
|
|
|
Il vettore infinito, un vettore con tutti i suoi componenti impostati su :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>`
|
|
|
|
Il vettore unitario sinistro. Rappresenta la direzione locale di sinistra e la direzione globale dell'ovest.
|
|
|
|
.. _class_Vector3_constant_RIGHT:
|
|
|
|
.. rst-class:: classref-constant
|
|
|
|
**RIGHT** = ``Vector3(1, 0, 0)`` :ref:`🔗<class_Vector3_constant_RIGHT>`
|
|
|
|
Il vettore unitario destro. Rappresenta la direzione locale di destra e la direzione globale dell'est.
|
|
|
|
.. _class_Vector3_constant_UP:
|
|
|
|
.. rst-class:: classref-constant
|
|
|
|
**UP** = ``Vector3(0, 1, 0)`` :ref:`🔗<class_Vector3_constant_UP>`
|
|
|
|
Il vettore unitario verso l'alto.
|
|
|
|
.. _class_Vector3_constant_DOWN:
|
|
|
|
.. rst-class:: classref-constant
|
|
|
|
**DOWN** = ``Vector3(0, -1, 0)`` :ref:`🔗<class_Vector3_constant_DOWN>`
|
|
|
|
Il vettore unitario verso il basso.
|
|
|
|
.. _class_Vector3_constant_FORWARD:
|
|
|
|
.. rst-class:: classref-constant
|
|
|
|
**FORWARD** = ``Vector3(0, 0, -1)`` :ref:`🔗<class_Vector3_constant_FORWARD>`
|
|
|
|
Il vettore unitario anteriore. Rappresenta la direzione locale in avanti e la direzione globale del nord. Tieni presente che la direzione in avanti di luci, telecamere, ecc. è diversa dalle risorse 3D come i personaggi, che per convenzione sono rivolti verso la telecamera. Usa :ref:`MODEL_FRONT<class_Vector3_constant_MODEL_FRONT>` e costanti simili quando lavori nello spazio delle risorse 3D.
|
|
|
|
.. _class_Vector3_constant_BACK:
|
|
|
|
.. rst-class:: classref-constant
|
|
|
|
**BACK** = ``Vector3(0, 0, 1)`` :ref:`🔗<class_Vector3_constant_BACK>`
|
|
|
|
Il vettore unitario posteriore. Rappresenta la direzione locale del retro e la direzione globale del sud.
|
|
|
|
.. _class_Vector3_constant_MODEL_LEFT:
|
|
|
|
.. rst-class:: classref-constant
|
|
|
|
**MODEL_LEFT** = ``Vector3(1, 0, 0)`` :ref:`🔗<class_Vector3_constant_MODEL_LEFT>`
|
|
|
|
Vettore unitario che punta verso il lato sinistro delle risorse 3D importate.
|
|
|
|
.. _class_Vector3_constant_MODEL_RIGHT:
|
|
|
|
.. rst-class:: classref-constant
|
|
|
|
**MODEL_RIGHT** = ``Vector3(-1, 0, 0)`` :ref:`🔗<class_Vector3_constant_MODEL_RIGHT>`
|
|
|
|
Vettore unitario che punta verso il lato destro delle risorse 3D importate.
|
|
|
|
.. _class_Vector3_constant_MODEL_TOP:
|
|
|
|
.. rst-class:: classref-constant
|
|
|
|
**MODEL_TOP** = ``Vector3(0, 1, 0)`` :ref:`🔗<class_Vector3_constant_MODEL_TOP>`
|
|
|
|
Vettore unitario che punta verso il lato superiore (su) delle risorse 3D importate.
|
|
|
|
.. _class_Vector3_constant_MODEL_BOTTOM:
|
|
|
|
.. rst-class:: classref-constant
|
|
|
|
**MODEL_BOTTOM** = ``Vector3(0, -1, 0)`` :ref:`🔗<class_Vector3_constant_MODEL_BOTTOM>`
|
|
|
|
Vettore unitario che punta verso il lato inferiore (giù) delle risorse 3D importate.
|
|
|
|
.. _class_Vector3_constant_MODEL_FRONT:
|
|
|
|
.. rst-class:: classref-constant
|
|
|
|
**MODEL_FRONT** = ``Vector3(0, 0, 1)`` :ref:`🔗<class_Vector3_constant_MODEL_FRONT>`
|
|
|
|
Vettore unitario che punta verso il lato anteriore (rivolto in avanti) delle risorse 3D importate.
|
|
|
|
.. _class_Vector3_constant_MODEL_REAR:
|
|
|
|
.. rst-class:: classref-constant
|
|
|
|
**MODEL_REAR** = ``Vector3(0, 0, -1)`` :ref:`🔗<class_Vector3_constant_MODEL_REAR>`
|
|
|
|
Vettore unitario che punta verso il lato posteriore (retro) delle risorse 3D importate.
|
|
|
|
.. rst-class:: classref-section-separator
|
|
|
|
----
|
|
|
|
.. rst-class:: classref-descriptions-group
|
|
|
|
Descrizioni delle proprietà
|
|
------------------------------------------------------
|
|
|
|
.. _class_Vector3_property_x:
|
|
|
|
.. rst-class:: classref-property
|
|
|
|
:ref:`float<class_float>` **x** = ``0.0`` :ref:`🔗<class_Vector3_property_x>`
|
|
|
|
Il componente X del vettore. Accessibile anche tramite la posizione di indice ``[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>`
|
|
|
|
Il componente Y del vettore. Accessibile anche tramite la posizione di indice ``[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>`
|
|
|
|
Il componente Z del vettore. Accessibile anche tramite la posizione di indice ``[2]``.
|
|
|
|
.. rst-class:: classref-section-separator
|
|
|
|
----
|
|
|
|
.. rst-class:: classref-descriptions-group
|
|
|
|
Descrizioni dei costruttori
|
|
------------------------------------------------------
|
|
|
|
.. _class_Vector3_constructor_Vector3:
|
|
|
|
.. rst-class:: classref-constructor
|
|
|
|
:ref:`Vector3<class_Vector3>` **Vector3**\ (\ ) :ref:`🔗<class_Vector3_constructor_Vector3>`
|
|
|
|
Costruisce un **Vector3** predefinito con tutti i componenti impostati su ``0``.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. rst-class:: classref-constructor
|
|
|
|
:ref:`Vector3<class_Vector3>` **Vector3**\ (\ from\: :ref:`Vector3<class_Vector3>`\ )
|
|
|
|
Costruisce un **Vector3** come copia del **Vector3** specificato.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. rst-class:: classref-constructor
|
|
|
|
:ref:`Vector3<class_Vector3>` **Vector3**\ (\ from\: :ref:`Vector3i<class_Vector3i>`\ )
|
|
|
|
Costruisce un nuovo **Vector3** da :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>`\ )
|
|
|
|
Restituisce un **Vector3** con i componenti forniti.
|
|
|
|
.. rst-class:: classref-section-separator
|
|
|
|
----
|
|
|
|
.. rst-class:: classref-descriptions-group
|
|
|
|
Descrizioni dei metodi
|
|
--------------------------------------------
|
|
|
|
.. _class_Vector3_method_abs:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`Vector3<class_Vector3>` **abs**\ (\ ) |const| :ref:`🔗<class_Vector3_method_abs>`
|
|
|
|
Restituisce un nuovo vettore con tutti i componenti in valori assoluti (ovvero positivi).
|
|
|
|
.. 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>`
|
|
|
|
Restituisce l'angolo minimo senza segno verso il vettore fornito, in radianti.
|
|
|
|
.. 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>`
|
|
|
|
Restituisce la derivata in ``t`` sulla `curva di Bézier <https://it.wikipedia.org/wiki/Curva_di_B%C3%A9zier>`__ definita da questo vettore e dai punti ``control_1``, ``control_2`` e ``end`` specificati.
|
|
|
|
.. 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>`
|
|
|
|
Restituisce il in ``t`` sulla `curva di Bézier <https://it.wikipedia.org/wiki/Curva_di_B%C3%A9zier>`__ definita da questo vettore e dai punti ``control_1``, ``control_2`` e ``end`` specificati.
|
|
|
|
.. 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>`
|
|
|
|
Restituisce il vettore "rimbalzato" da un piano definito dalla normale ``n``.
|
|
|
|
\ **Nota:** :ref:`bounce()<class_Vector3_method_bounce>` esegue l'operazione che la maggior parte dei motori e framework chiamano ``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>`
|
|
|
|
Restituisce un nuovo vettore con tutti i componenti arrotondati per eccesso (verso l'infinito positivo).
|
|
|
|
.. 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>`
|
|
|
|
Restituisce un nuovo vettore con tutti i suoi componenti limitati tra i componenti di ``min`` e ``max``, eseguendo :ref:`@GlobalScope.clamp()<class_@GlobalScope_method_clamp>` su ciascun componente.
|
|
|
|
.. 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>`
|
|
|
|
Restituisce un nuovo vettore con tutti i suoi componenti limitati tra ``min`` e ``max``, eseguendo :ref:`@GlobalScope.clamp()<class_@GlobalScope_method_clamp>` su ciascun componente.
|
|
|
|
.. 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>`
|
|
|
|
Restituisce il prodotto vettoriale di questo vettore e ``with``.
|
|
|
|
Questo restituisce un vettore perpendicolare sia a questo sia a ``with``, che sarebbe il vettore normale del piano definito dai due vettori. Poiché ci sono due vettori di questo tipo, in direzioni opposte, questo metodo restituisce il vettore definito da un sistema di coordinate destrorso. Se i due vettori sono paralleli, questo restituisce un vettore vuoto, il che lo rende utile per testare se due vettori sono paralleli.
|
|
|
|
.. 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>`
|
|
|
|
Esegue un'interpolazione cubica tra questo vettore e ``b`` usando ``pre_a`` e ``post_b`` come manopole e restituisce il risultato nella posizione ``weight``. ``weight`` è compreso tra 0,0 e 1,0, e rappresenta la quantità di interpolazione.
|
|
|
|
.. 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>`
|
|
|
|
Esegue un'interpolazione cubica tra questo vettore e ``b`` usando ``pre_a`` e ``post_b`` come manopole e restituisce il risultato nella posizione ``weight``. ``weight`` è compreso tra 0,0 e 1,0, e rappresenta la quantità di interpolazione.
|
|
|
|
Può eseguire un'interpolazione più fluida rispetto al :ref:`cubic_interpolate()<class_Vector3_method_cubic_interpolate>` in base ai valori temporali.
|
|
|
|
.. 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>`
|
|
|
|
Restituisce il vettore normalizzato che punta da questo vettore a ``to``. Ciò equivale a usare ``(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>`
|
|
|
|
Restituisce la distanza al quadrato tra questo vettore e ``to``.
|
|
|
|
Questo metodo è più veloce di :ref:`distance_to()<class_Vector3_method_distance_to>`, quindi è preferibile se è necessario confrontare vettori o se è necessaria la distanza al quadrato per una formula.
|
|
|
|
.. 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>`
|
|
|
|
Restituisce la distanza tra questo vettore e ``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>`
|
|
|
|
Restituisce il prodotto scalare di questo vettore e ``with``. Può essere utilizzato per confrontare l'angolo tra due vettori. Ad esempio, può essere utilizzato per determinare se un nemico è rivolto verso il giocatore.
|
|
|
|
Il prodotto scalare sarà ``0`` per un angolo retto (90 gradi), maggiore di 0 per angoli più stretti di 90 gradi e minore di 0 per angoli più larghi di 90 gradi.
|
|
|
|
Quando si utilizzano vettori unitari (normalizzati), il risultato sarà sempre compreso tra ``-1.0`` (angolo di 180 gradi) quando i vettori sono rivolti in direzioni opposte e ``1.0`` (angolo di 0 gradi) quando i vettori sono allineati.
|
|
|
|
\ **Nota:** ``a.dot(b)`` è equivalente a ``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>`
|
|
|
|
Restituisce un nuovo vettore con tutti i componenti arrotondati per difetto (verso l'infinito negativo).
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_Vector3_method_inverse:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`Vector3<class_Vector3>` **inverse**\ (\ ) |const| :ref:`🔗<class_Vector3_method_inverse>`
|
|
|
|
Restituisce l'inverso del vettore. È lo stesso di ``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>`
|
|
|
|
Restituisce ``true`` se questo vettore e ``to`` sono approssimativamente uguali, eseguendo :ref:`@GlobalScope.is_equal_approx()<class_@GlobalScope_method_is_equal_approx>` su ciascun componente.
|
|
|
|
.. 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>`
|
|
|
|
Restituisce ``true`` se questo vettore è finito, eseguendo :ref:`@GlobalScope.is_finite()<class_@GlobalScope_method_is_finite>` su ciascun componente.
|
|
|
|
.. 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>`
|
|
|
|
Restituisce ``true`` se il vettore è normalizzato, ovvero la sua lunghezza è approssimativamente uguale a 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>`
|
|
|
|
Restituisce ``true`` se i valori di questo vettore sono approssimativamente zero, eseguendo :ref:`@GlobalScope.is_zero_approx()<class_@GlobalScope_method_is_zero_approx>` su ciascun componente.
|
|
|
|
Questo metodo è più veloce di :ref:`is_equal_approx()<class_Vector3_method_is_equal_approx>` con un valore come vettore zero.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_Vector3_method_length:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`float<class_float>` **length**\ (\ ) |const| :ref:`🔗<class_Vector3_method_length>`
|
|
|
|
Restituisce la lunghezza (magnitudine) di questo vettore.
|
|
|
|
.. 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>`
|
|
|
|
Restituisce la lunghezza (magnitudine) al quadrato di questo vettore.
|
|
|
|
Questo metodo è più veloce di :ref:`length()<class_Vector3_method_length>`, quindi è preferibile se è necessario confrontare vettori o se è necessaria la distanza al quadrato per una formula.
|
|
|
|
.. 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>`
|
|
|
|
Restituisce il risultato dell'interpolazione lineare tra questo vettore e ``to`` per la quantità ``weight``. ``weight`` è compreso tra ``0.0`` e ``1.0``, che rappresenta la quantità di interpolazione.
|
|
|
|
.. 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>`
|
|
|
|
Restituisce il vettore con una lunghezza massima limitandone la lunghezza a ``length``. Se il vettore non è finito, il risultato è indefinito.
|
|
|
|
.. 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>`
|
|
|
|
Restituisce il massimo, componente per componente, di questo vettore e ``with``, equivalente a ``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>`
|
|
|
|
Restituisce l'asse del valore più alto del vettore. Vedi le costanti ``AXIS_*``. Se tutti i componenti sono uguali, questo metodo restituisce :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>`
|
|
|
|
Restituisce il massimo, componente per componente, di questo vettore e ``with``, equivalente a ``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>`
|
|
|
|
Restituisce il minimo, componente per componente, di questo vettore e ``with``, equivalente a ``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>`
|
|
|
|
Restituisce l'asse del valore più basso del vettore. Vedi le costanti ``AXIS_*``. Se tutti i componenti sono uguali, questo metodo restituisce :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>`
|
|
|
|
Restituisce il minimo, componente per componente, di questo vettore e ``with``, equivalente a ``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>`
|
|
|
|
Restituisce un nuovo vettore spostato verso ``to`` per la quantità ``delta``. Non andrà oltre il valore 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>`
|
|
|
|
Restituisce il risultato della scalatura del vettore a lunghezza unitaria. Equivalente a ``v / v.length()``. Restituisce ``(0, 0, 0)`` se ``v.length() == 0``. Vedi anche :ref:`is_normalized()<class_Vector3_method_is_normalized>`.
|
|
|
|
\ **Nota:** Questa funzione potrebbe restituire valori non corretti se la lunghezza del vettore passato è vicina a zero.
|
|
|
|
.. 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>`
|
|
|
|
Restituisce **Vector3** da una forma compressa ottaedrica creata attraverso :ref:`octahedron_encode()<class_Vector3_method_octahedron_encode>` (memorizzata come :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>`
|
|
|
|
Restituisce la forma codificata ottaedrica (oct32) di questo **Vector3** come :ref:`Vector2<class_Vector2>`. Poiché un :ref:`Vector2<class_Vector2>` occupa 1/3 di memoria in meno rispetto a **Vector3**, questa forma di compressione può essere utilizzata per passare quantità maggiori di **Vector3** normalizzati (vedi :ref:`normalized()<class_Vector3_method_normalized>`) senza aumentare i requisiti di archiviazione o memoria. Vedi anche :ref:`octahedron_decode()<class_Vector3_method_octahedron_decode>`.
|
|
|
|
\ **Nota:** :ref:`octahedron_encode()<class_Vector3_method_octahedron_encode>` può essere utilizzato solo per vettori da :ref:`normalized()<class_Vector3_method_normalized>`. :ref:`octahedron_encode()<class_Vector3_method_octahedron_encode>` *non* verifica se questo **Vector3** è normalizzato e restituirà un valore che non si decomprime al valore originale se **Vector3** non è normalizzato.
|
|
|
|
\ **Nota:** La compressione ottaedrica è *con perdita di dati*, sebbene le differenze visive siano raramente percepibili in scenari del mondo reale.
|
|
|
|
.. 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>`
|
|
|
|
Restituisce il prodotto esterno con il vettore ``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>`
|
|
|
|
Restituisce un vettore composto dal risultato di :ref:`@GlobalScope.fposmod()<class_@GlobalScope_method_fposmod>` dai componenti di questo vettore e ``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>`
|
|
|
|
Restituisce un vettore composto dal risultato di :ref:`@GlobalScope.fposmod()<class_@GlobalScope_method_fposmod>` dai componenti di questo vettore e i componenti di ``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>`
|
|
|
|
Restituisce un nuovo vettore risultante dalla proiezione di questo vettore sul vettore ``b``. Il nuovo vettore risultante è parallelo a ``b``. Vedi anche :ref:`slide()<class_Vector3_method_slide>`.
|
|
|
|
\ **Nota:** Se il vettore ``b`` è un vettore zero, i componenti del nuovo vettore risultante saranno :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>`
|
|
|
|
Restituisce il risultato della riflessione del vettore attraverso un piano definito dal vettore normale ``n``.
|
|
|
|
\ **Nota:** :ref:`reflect()<class_Vector3_method_reflect>` differisce da ciò che altri motori e framework chiamano ``reflect()``. In altri motori, ``reflect()`` restituisce il risultato del vettore riflesso dal piano specificato. La riflessione passa quindi attraverso la normale specificata. Mentre in Godot la riflessione passa attraverso il piano e può essere pensata come un rimbalzo sulla normale. Vedi anche :ref:`bounce()<class_Vector3_method_bounce>` che fa ciò che la maggior parte dei motori chiama ``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>`
|
|
|
|
Restituisce il risultato della rotazione di questo vettore attorno a un determinato asse di ``angle`` (in radianti). L'asse deve essere un vettore normalizzato. Vedi anche :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>`
|
|
|
|
Restituisce un nuovo vettore con tutti i componenti arrotondati all'intero più vicino, con i casi a metà arrotondati lontani da zero.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_Vector3_method_sign:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`Vector3<class_Vector3>` **sign**\ (\ ) |const| :ref:`🔗<class_Vector3_method_sign>`
|
|
|
|
Restituisce un nuovo vettore con ogni componente impostato su ``1.0`` se è positivo, ``-1.0`` se è negativo e ``0.0`` se è zero. Il risultato è identico alla chiamata di :ref:`@GlobalScope.sign()<class_@GlobalScope_method_sign>` su ciascun componente.
|
|
|
|
.. 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>`
|
|
|
|
Restituisce l'angolo con segno al vettore specificato, in radianti. Il segno dell'angolo è positivo in senso antiorario e negativo in senso orario se visto dal lato specificato dall'asse ``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>`
|
|
|
|
Restituisce il risultato dell'interpolazione lineare sferica tra questo vettore e ``to``, per la quantità ``weight``. ``weight`` è compreso tra 0,0 e 1,0, e rappresenta la quantità di interpolazione.
|
|
|
|
Questo metodo gestisce anche l'interpolazione delle lunghezze se i vettori passati hanno lunghezze diverse. Per il caso speciale di uno o entrambi i vettori passati con lunghezza zero, questo metodo si comporta come :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>`
|
|
|
|
Restituisce un nuovo vettore risultante dallo scorrimento di questo vettore lungo un piano con la normale ``n``. Il nuovo vettore risultante è perpendicolare a ``n`` ed è equivalente a questo vettore meno la sua proiezione su ``n``. Vedi anche :ref:`project()<class_Vector3_method_project>`.
|
|
|
|
\ **Nota:** Il vettore ``n`` deve essere normalizzato. Vedi anche :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>`
|
|
|
|
Restituisce un nuovo vettore con ciascun componente arrotondato al multiplo più vicino del componente corrispondente in ``step``. Può anche essere utilizzato per arrotondare i componenti a un numero arbitrario di decimali.
|
|
|
|
.. 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>`
|
|
|
|
Restituisce un nuovo vettore con ogni componente arrotondato al multiplo più vicino di ``step``. Può anche essere utilizzato per arrotondare i componenti a un numero arbitrario di decimali.
|
|
|
|
.. rst-class:: classref-section-separator
|
|
|
|
----
|
|
|
|
.. rst-class:: classref-descriptions-group
|
|
|
|
Descrizioni degli operatori
|
|
------------------------------------------------------
|
|
|
|
.. _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>`
|
|
|
|
Restituisce ``true`` se i vettori non sono uguali.
|
|
|
|
\ **Nota:** A causa di errori di precisione per virgola mobile, considera invece utilizzare :ref:`is_equal_approx()<class_Vector3_method_is_equal_approx>`, che è più affidabile.
|
|
|
|
\ **Nota:** I vettori con componenti :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>` non si comportano allo stesso modo di altri vettori. Perciò, i risultati di questa operazione potrebbero non essere accurati se valori NaN sono inclusi.
|
|
|
|
.. 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>`
|
|
|
|
Trasforma inversamente (moltiplica) il **Vector3** per la matrice :ref:`Basis<class_Basis>` fornita, presupponendo che la base sia ortonormale (ovvero rotazione/riflessione vanno bene, ma scala/inclinazione no).
|
|
|
|
\ ``vector * transform`` è equivalente a ``transform.inverse() * vector``. Vedi\ :ref:`Transform2D.inverse()<class_Transform2D_method_inverse>`.
|
|
|
|
Per trasformare per inverso una trasformazione affine (ad esempio con scala) può essere utilizzato ``transform.affine_inverse() * vector``. Vedi :ref:`Transform2D.affine_inverse()<class_Transform2D_method_affine_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>`
|
|
|
|
Trasforma inversamente (moltiplica) il **Vector3** per il :ref:`Quaternion<class_Quaternion>` fornito.
|
|
|
|
\ ``vector * quaternion`` è equivalente a ``quaternion.inverse() * vector``. Vedi :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>`
|
|
|
|
Trasforma inversamente (moltiplica) il **Vector3** per la matrice di trasformazione :ref:`Transform3D<class_Transform3D>` fornita, presupponendo che la base di trasformazione sia ortonormale (ovvero rotazione/riflessione vanno bene, ma scala/inclinazione no).
|
|
|
|
\ ``vector * transform`` è equivalente a ``transform.inverse() * vector``. Vedi\ :ref:`Transform2D.inverse()<class_Transform2D_method_inverse>`.
|
|
|
|
Per trasformare per inverso una trasformazione affine (ad esempio con scala) può essere utilizzato ``transform.affine_inverse() * vector``. Vedi :ref:`Transform2D.affine_inverse()<class_Transform2D_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>`
|
|
|
|
Moltiplica ogni componente del **Vector3** per i componenti del **Vector3** fornito.
|
|
|
|
::
|
|
|
|
print(Vector3(10, 20, 30) * Vector3(3, 4, 5)) # Stampa (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>`
|
|
|
|
Moltiplica ogni componente del **Vector3** per il :ref:`float<class_float>` fornito.
|
|
|
|
.. 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>`
|
|
|
|
Moltiplica ogni componente del **Vector3** per l':ref:`int<class_int>` fornito.
|
|
|
|
.. 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>`
|
|
|
|
Aggiunge ogni componente del **Vector3** con i componenti del **Vector3** fornito.
|
|
|
|
::
|
|
|
|
print(Vector3(10, 20, 30) + Vector3(3, 4, 5)) # Stampa (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>`
|
|
|
|
Sottrae ogni componente del **Vector3** dai componenti del **Vector3** fornito.
|
|
|
|
::
|
|
|
|
print(Vector3(10, 20, 30) - Vector3(3, 4, 5)) # Stampa (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>`
|
|
|
|
Divide ogni componente del **Vector3** per i componenti del **Vector3** fornito.
|
|
|
|
::
|
|
|
|
print(Vector3(10, 20, 30) / Vector3(2, 5, 3)) # Stampa (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>`
|
|
|
|
Divide ogni componente del **Vector3** per il :ref:`float<class_float>` fornito.
|
|
|
|
.. 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>`
|
|
|
|
Divide ogni componente del **Vector3** per l':ref:`float<class_float>` fornito.
|
|
|
|
.. 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>`
|
|
|
|
Confronta due vettori **Vector3** verificando prima se il valore X del vettore di sinistra è minore del valore X del vettore ``right``. Se i valori X sono esattamente uguali, ripete questa verifica con i valori Y dei due vettori e poi con i valori Z. Questo operatore è utile per ordinare i vettori.
|
|
|
|
\ **Nota:** I vettori con componenti :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>` non si comportano come altri vettori. Pertanto, i risultati di questo operatore potrebbero non essere accurati se valori NAN sono inclusi.
|
|
|
|
.. 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>`
|
|
|
|
Confronta due vettori **Vector3** verificando prima se il valore X del vettore di sinistra è minore o uguale al valore X del vettore ``right``. Se i valori X sono esattamente uguali, ripete questa verifica con i valori Y dei due vettori e poi con i valori Z. Questo operatore è utile per ordinare i vettori.
|
|
|
|
\ **Nota:** I vettori con componenti :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>` non si comportano come altri vettori. Pertanto, i risultati di questo operatore potrebbero non essere accurati se valori NAN sono inclusi.
|
|
|
|
.. 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>`
|
|
|
|
Restituisce ``true`` se i vettori sono esattamente uguali.
|
|
|
|
\ **Nota:** A causa di errori di precisione per virgola mobile, considera invece utilizzare :ref:`is_equal_approx()<class_Vector3_method_is_equal_approx>`, che è più affidabile.
|
|
|
|
\ **Nota:** I vettori con componenti :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>` non si comportano come altri vettori. Pertanto, i risultati di questo operatore potrebbero non essere accurati se valori NAN sono inclusi.
|
|
|
|
.. 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>`
|
|
|
|
Confronta due vettori **Vector3** verificando prima se il valore X del vettore di sinistra è maggiore del valore X del vettore ``right``. Se i valori X sono esattamente uguali, ripete questa verifica con i valori Y dei due vettori e poi con i valori Z. Questo operatore è utile per ordinare i vettori.
|
|
|
|
\ **Nota:** I vettori con componenti :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>` non si comportano come altri vettori. Pertanto, i risultati di questo operatore potrebbero non essere accurati se valori NAN sono inclusi.
|
|
|
|
.. 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>`
|
|
|
|
Confronta due vettori **Vector3** verificando prima se il valore X del vettore di sinistra è maggiore o uguale al valore X del vettore ``right``. Se i valori X sono esattamente uguali, ripete questa verifica con i valori Y dei due vettori e poi con i valori Z. Questo operatore è utile per ordinare i vettori.
|
|
|
|
\ **Nota:** I vettori con componenti :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>` non si comportano come altri vettori. Pertanto, i risultati di questo operatore potrebbero non essere accurati se valori NAN sono inclusi.
|
|
|
|
.. 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>`
|
|
|
|
Accede ai componenti del vettore attraverso il loro indice (``index``). ``v[0]`` è equivalente a ``v.x``, ``v[1]`` è equivalente a ``v.y``, e ``v[2]`` è equivalente a ``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>`
|
|
|
|
Restituisce lo stesso valore come se ``+`` non ci fosse. Il ``+`` unario non fa nulla, ma a volte può rendere il tuo codice più leggibile.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_Vector3_operator_unminus:
|
|
|
|
.. rst-class:: classref-operator
|
|
|
|
:ref:`Vector3<class_Vector3>` **operator unary-**\ (\ ) :ref:`🔗<class_Vector3_operator_unminus>`
|
|
|
|
Restituisce il valore negativo del **Vector3**. Equivale a scrivere ``Vector3(-v.x, -v.y, -v.z)``. Questa operazione inverte la direzione del vettore mantenendo la stessa magnitudine. Con i float, il numero zero può essere sia positivo sia negativo.
|
|
|
|
.. |virtual| replace:: :abbr:`virtual (Questo metodo dovrebbe solitamente essere sovrascritto dall'utente per aver un effetto.)`
|
|
.. |required| replace:: :abbr:`required (This method is required to be overridden when extending its base class.)`
|
|
.. |const| replace:: :abbr:`const (Questo metodo non ha effetti collaterali. Non modifica alcuna variabile appartenente all'istanza.)`
|
|
.. |vararg| replace:: :abbr:`vararg (Questo metodo accetta qualsiasi numero di argomenti oltre a quelli descritti qui.)`
|
|
.. |constructor| replace:: :abbr:`constructor (Questo metodo è utilizzato per creare un tipo.)`
|
|
.. |static| replace:: :abbr:`static (Questo metodo non necessita di alcun'istanza per essere chiamato, quindi può essere chiamato direttamente usando il nome della classe.)`
|
|
.. |operator| replace:: :abbr:`operator (Questo metodo descrive un operatore valido da usare con questo tipo come operando di sinistra.)`
|
|
.. |bitfield| replace:: :abbr:`BitField (Questo valore è un intero composto da una maschera di bit dei seguenti flag.)`
|
|
.. |void| replace:: :abbr:`void (Nessun valore restituito.)`
|