mirror of
https://github.com/godotengine/godot-docs-l10n.git
synced 2026-01-04 10:09:56 +03:00
1400 lines
90 KiB
ReStructuredText
1400 lines
90 KiB
ReStructuredText
:github_url: hide
|
|
|
|
.. DO NOT EDIT THIS FILE!!!
|
|
.. Generated automatically from Godot engine sources.
|
|
.. Generator: https://github.com/godotengine/godot/tree/master/doc/tools/make_rst.py.
|
|
.. XML source: https://github.com/godotengine/godot/tree/master/doc/classes/Vector3.xml.
|
|
|
|
.. _class_Vector3:
|
|
|
|
Vector3
|
|
=======
|
|
|
|
Un vector 3D que utiliza coordenadas de punto flotante.
|
|
|
|
.. rst-class:: classref-introduction-group
|
|
|
|
Descripción
|
|
----------------------
|
|
|
|
Estructura de 3 elementos que puede ser usada para representar coordenadas 3D o cualquier otro trío de valores numéricos.
|
|
|
|
Utiliza coordenadas de punto flotante. De forma predeterminada, estos valores de punto flotante utilizan una precisión de 32 bits, a diferencia de :ref:`float<class_float>` que siempre es de 64 bits. Si se necesita una precisión doble, compila el motor con la opción ``precision=double``.
|
|
|
|
Ver :ref:`Vector3i<class_Vector3i>` para su contraparte entera.
|
|
|
|
\ **Nota:** En un contexto booleano, un Vector3 se evaluará como ``false`` si es igual a ``Vector3(0, 0, 0)``. De lo contrario, un Vector3 siempre se evaluará como ``true``.
|
|
|
|
.. rst-class:: classref-introduction-group
|
|
|
|
Tutoriales
|
|
--------------------
|
|
|
|
- :doc:`Índice de documentación matemática <../tutorials/math/index>`
|
|
|
|
- :doc:`Matemáticas vectoriales <../tutorials/math/vector_math>`
|
|
|
|
- :doc:`Matemática vectorial avanzada <../tutorials/math/vectors_advanced>`
|
|
|
|
- `Esencia del álgebra lineal de 3Blue1Brown <https://www.youtube.com/playlist?list=PLZHQObOWTQDPD3MizzM2xVFitgF8hE_ab>`__
|
|
|
|
- `Demo de Transformación de Matriz <https://godotengine.org/asset-library/asset/2787>`__
|
|
|
|
- `Todos los Demos en 3D <https://github.com/godotengine/godot-demo-projects/tree/master/3d>`__
|
|
|
|
.. rst-class:: classref-reftable-group
|
|
|
|
Propiedades
|
|
----------------------
|
|
|
|
.. 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
|
|
|
|
Constructores
|
|
--------------------------
|
|
|
|
.. 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étodos
|
|
--------------
|
|
|
|
.. 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
|
|
|
|
Operadores
|
|
--------------------
|
|
|
|
.. 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
|
|
|
|
Enumeraciones
|
|
--------------------------
|
|
|
|
.. _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``
|
|
|
|
Valor enumerado para el eje X. Devuelto por :ref:`max_axis_index()<class_Vector3_method_max_axis_index>` y :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``
|
|
|
|
Valor enumerado para el eje Y. Devuelto por :ref:`max_axis_index()<class_Vector3_method_max_axis_index>` y :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``
|
|
|
|
Valor enumerado para el eje Z. Devuelto por :ref:`max_axis_index()<class_Vector3_method_max_axis_index>` y :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>`
|
|
|
|
Vector cero, un vector con todos los componentes ajustados a ``0``.
|
|
|
|
.. _class_Vector3_constant_ONE:
|
|
|
|
.. rst-class:: classref-constant
|
|
|
|
**ONE** = ``Vector3(1, 1, 1)`` :ref:`🔗<class_Vector3_constant_ONE>`
|
|
|
|
Un vector, un vector con todos los componentes ajustados a ``1``.
|
|
|
|
.. _class_Vector3_constant_INF:
|
|
|
|
.. rst-class:: classref-constant
|
|
|
|
**INF** = ``Vector3(inf, inf, inf)`` :ref:`🔗<class_Vector3_constant_INF>`
|
|
|
|
Vector infinito, un vector con todos los componentes ajustados a :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>`
|
|
|
|
Vector de la unidad izquierda. Representa la dirección local de la izquierda y la dirección global del oeste.
|
|
|
|
.. _class_Vector3_constant_RIGHT:
|
|
|
|
.. rst-class:: classref-constant
|
|
|
|
**RIGHT** = ``Vector3(1, 0, 0)`` :ref:`🔗<class_Vector3_constant_RIGHT>`
|
|
|
|
Vector de la unidad derecha. Representa la dirección local de la derecha, y la dirección global del este.
|
|
|
|
.. _class_Vector3_constant_UP:
|
|
|
|
.. rst-class:: classref-constant
|
|
|
|
**UP** = ``Vector3(0, 1, 0)`` :ref:`🔗<class_Vector3_constant_UP>`
|
|
|
|
Vector de la unidad superior.
|
|
|
|
.. _class_Vector3_constant_DOWN:
|
|
|
|
.. rst-class:: classref-constant
|
|
|
|
**DOWN** = ``Vector3(0, -1, 0)`` :ref:`🔗<class_Vector3_constant_DOWN>`
|
|
|
|
Vector de la unidad inferior.
|
|
|
|
.. _class_Vector3_constant_FORWARD:
|
|
|
|
.. rst-class:: classref-constant
|
|
|
|
**FORWARD** = ``Vector3(0, 0, -1)`` :ref:`🔗<class_Vector3_constant_FORWARD>`
|
|
|
|
Vector unitario hacia adelante. Representa la dirección local de avance y la dirección global del norte. Tenga en cuenta que la dirección de avance para las luces, las cámaras, etc. es diferente de los activos 3D como los personajes, que miran hacia la cámara por convención. Utilice :ref:`MODEL_FRONT<class_Vector3_constant_MODEL_FRONT>` y constantes similares cuando trabaje en el espacio de activos 3D.
|
|
|
|
.. _class_Vector3_constant_BACK:
|
|
|
|
.. rst-class:: classref-constant
|
|
|
|
**BACK** = ``Vector3(0, 0, 1)`` :ref:`🔗<class_Vector3_constant_BACK>`
|
|
|
|
Vector de la unidad trasera. Representa la dirección local de la espalda, y la dirección global del sur.
|
|
|
|
.. _class_Vector3_constant_MODEL_LEFT:
|
|
|
|
.. rst-class:: classref-constant
|
|
|
|
**MODEL_LEFT** = ``Vector3(1, 0, 0)`` :ref:`🔗<class_Vector3_constant_MODEL_LEFT>`
|
|
|
|
Vector unitario que apunta hacia el lado izquierdo de los activos 3D importados.
|
|
|
|
.. _class_Vector3_constant_MODEL_RIGHT:
|
|
|
|
.. rst-class:: classref-constant
|
|
|
|
**MODEL_RIGHT** = ``Vector3(-1, 0, 0)`` :ref:`🔗<class_Vector3_constant_MODEL_RIGHT>`
|
|
|
|
Vector unitario que apunta hacia el lado derecho de los activos 3D importados.
|
|
|
|
.. _class_Vector3_constant_MODEL_TOP:
|
|
|
|
.. rst-class:: classref-constant
|
|
|
|
**MODEL_TOP** = ``Vector3(0, 1, 0)`` :ref:`🔗<class_Vector3_constant_MODEL_TOP>`
|
|
|
|
Vector unitario que apunta hacia el lado superior (arriba) de los activos 3D importados.
|
|
|
|
.. _class_Vector3_constant_MODEL_BOTTOM:
|
|
|
|
.. rst-class:: classref-constant
|
|
|
|
**MODEL_BOTTOM** = ``Vector3(0, -1, 0)`` :ref:`🔗<class_Vector3_constant_MODEL_BOTTOM>`
|
|
|
|
Vector unitario que apunta hacia el lado inferior (abajo) de los activos 3D importados.
|
|
|
|
.. _class_Vector3_constant_MODEL_FRONT:
|
|
|
|
.. rst-class:: classref-constant
|
|
|
|
**MODEL_FRONT** = ``Vector3(0, 0, 1)`` :ref:`🔗<class_Vector3_constant_MODEL_FRONT>`
|
|
|
|
Vector unitario que apunta hacia el lado frontal (mirando hacia adelante) de los activos 3D importados.
|
|
|
|
.. _class_Vector3_constant_MODEL_REAR:
|
|
|
|
.. rst-class:: classref-constant
|
|
|
|
**MODEL_REAR** = ``Vector3(0, 0, -1)`` :ref:`🔗<class_Vector3_constant_MODEL_REAR>`
|
|
|
|
Vector unitario que apunta hacia el lado trasero (parte posterior) de los activos 3D importados.
|
|
|
|
.. rst-class:: classref-section-separator
|
|
|
|
----
|
|
|
|
.. rst-class:: classref-descriptions-group
|
|
|
|
Descripciones de Propiedades
|
|
--------------------------------------------------------
|
|
|
|
.. _class_Vector3_property_x:
|
|
|
|
.. rst-class:: classref-property
|
|
|
|
:ref:`float<class_float>` **x** = ``0.0`` :ref:`🔗<class_Vector3_property_x>`
|
|
|
|
El componente X del vector. También se puede acceder utilizando la posición del índice ``[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>`
|
|
|
|
El componente Y del vector. También se puede acceder usando la posición del índice ``[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>`
|
|
|
|
El componente Z del vector. También se puede acceder usando la posición del índice ``[2]``.
|
|
|
|
.. rst-class:: classref-section-separator
|
|
|
|
----
|
|
|
|
.. rst-class:: classref-descriptions-group
|
|
|
|
Descripciones de Constructores
|
|
------------------------------------------------------------
|
|
|
|
.. _class_Vector3_constructor_Vector3:
|
|
|
|
.. rst-class:: classref-constructor
|
|
|
|
:ref:`Vector3<class_Vector3>` **Vector3**\ (\ ) :ref:`🔗<class_Vector3_constructor_Vector3>`
|
|
|
|
Construye un **Vector3** inicializado por defecto con todos los componentes establecidos en ``0``.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. rst-class:: classref-constructor
|
|
|
|
:ref:`Vector3<class_Vector3>` **Vector3**\ (\ from\: :ref:`Vector3<class_Vector3>`\ )
|
|
|
|
Construye un **Vector3** como una copia del **Vector3** dado.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. rst-class:: classref-constructor
|
|
|
|
:ref:`Vector3<class_Vector3>` **Vector3**\ (\ from\: :ref:`Vector3i<class_Vector3i>`\ )
|
|
|
|
Construye un nuevo **Vector3** a partir de 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>`\ )
|
|
|
|
Devuelve un **Vector3** con los componentes dados.
|
|
|
|
.. rst-class:: classref-section-separator
|
|
|
|
----
|
|
|
|
.. rst-class:: classref-descriptions-group
|
|
|
|
Descripciones de Métodos
|
|
------------------------------------------------
|
|
|
|
.. _class_Vector3_method_abs:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`Vector3<class_Vector3>` **abs**\ (\ ) |const| :ref:`🔗<class_Vector3_method_abs>`
|
|
|
|
Devuelve un nuevo vector con todos los componentes en valores absolutos (es decir, positivos).
|
|
|
|
.. 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>`
|
|
|
|
Devuelve el ángulo mínimo sin signo del vector dado, en radianes.
|
|
|
|
.. 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>`
|
|
|
|
Devuelve la derivada en el ``t`` dado en la `curva de Bézier <https://en.wikipedia.org/wiki/B%C3%A9zier_curve>`__ definida por este vector y los puntos ``control_1``, ``control_2`` y ``end`` dados.
|
|
|
|
.. 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>`
|
|
|
|
Devuelve el punto en el ``t`` dado en la `curva de Bézier <https://en.wikipedia.org/wiki/B%C3%A9zier_curve>`__ definida por este vector y los puntos ``control_1``, ``control_2`` y ``end`` dados.
|
|
|
|
.. 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>`
|
|
|
|
Devuelve el vector "rebotado" de un plano definido por la normal dada ``n``.
|
|
|
|
\ **Nota:** :ref:`bounce()<class_Vector3_method_bounce>` realiza la operación que la mayoría de los motores y frameworks llaman ``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>`
|
|
|
|
Devuelve un nuevo vector con todos los componentes redondeados hacia arriba (hacia el 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>`
|
|
|
|
Devuelve un nuevo vector con todos los componentes limitados entre los componentes de ``min`` y ``max``, ejecutando :ref:`@GlobalScope.clamp()<class_@GlobalScope_method_clamp>` en cada 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>`
|
|
|
|
Devuelve un nuevo vector con todos los componentes restringidos entre ``min`` y ``max``, ejecutando :ref:`@GlobalScope.clamp()<class_@GlobalScope_method_clamp>` en cada 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>`
|
|
|
|
Devuelve el producto vectorial de este vector y ``with``.
|
|
|
|
Esto devuelve un vector perpendicular tanto a este como a ``with``, que sería el vector normal del plano definido por los dos vectores. Como hay dos de estos vectores, en direcciones opuestas, este método devuelve el vector definido por un sistema de coordenadas a derechas. Si los dos vectores son paralelos, esto devuelve un vector vacío, lo que lo hace útil para probar si dos vectores son paralelos.
|
|
|
|
.. 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>`
|
|
|
|
Realiza una interpolación cúbica entre este vector y ``b`` usando ``pre_a`` y ``post_b`` como manejadores, y devuelve el resultado en la posición ``weight``. ``weight`` está en el rango de 0.0 a 1.0, representando la cantidad de interpolación.
|
|
|
|
.. 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>`
|
|
|
|
Realiza una interpolación cúbica entre este vector y ``b`` usando ``pre_a`` y ``post_b`` como manejadores, y devuelve el resultado en la posición ``weight``. ``weight`` está en el rango de 0.0 a 1.0, representando la cantidad de interpolación.
|
|
|
|
Puede realizar una interpolación más suave que :ref:`cubic_interpolate()<class_Vector3_method_cubic_interpolate>` por los valores de tiempo.
|
|
|
|
.. 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>`
|
|
|
|
Devuelve el vector normalizado que apunta desde este vector a ``to``. Esto es equivalente a usar ``(to - self).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>`
|
|
|
|
Devuelve la distancia al cuadrado entre este vector y ``to``.
|
|
|
|
Este método se ejecuta más rápido que :ref:`distance_to()<class_Vector3_method_distance_to>`, así que es preferible si necesitas comparar vectores o necesitas la distancia al cuadrado para alguna fórmula.
|
|
|
|
.. 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>`
|
|
|
|
Devuelve la distancia entre este vector y ``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>`
|
|
|
|
Devuelve el producto escalar de este vector y ``with``. Esto puede ser usado para comparar el ángulo entre dos vectores. Por ejemplo, esto puede ser usado para determinar si un enemigo está de cara al jugador.
|
|
|
|
El producto escalar será ``0`` para un ángulo recto (90 grados), mayor que 0 para ángulos más estrechos que 90 grados y menor que 0 para ángulos más anchos que 90 grados.
|
|
|
|
Cuando se utilizan vectores unitarios (normalizados), el resultado siempre estará entre ``-1.0`` (ángulo de 180 grados) cuando los vectores estén orientados en direcciones opuestas, y ``1.0`` (ángulo de 0 grados) cuando los vectores estén alineados.
|
|
|
|
\ **Nota:** ``a.dot(b)`` es 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>`
|
|
|
|
Devuelve un nuevo vector con todos los componentes redondeados hacia abajo (hacia el 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>`
|
|
|
|
Devuelve la inversa del vector. Es lo mismo que ``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>`
|
|
|
|
Devuelve ``true`` si este vector y ``to`` son aproximadamente iguales, ejecutando :ref:`@GlobalScope.is_equal_approx()<class_@GlobalScope_method_is_equal_approx>` en cada 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>`
|
|
|
|
Devuelve ``true`` si este vector es finito, llamando a :ref:`@GlobalScope.is_finite()<class_@GlobalScope_method_is_finite>` en cada 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>`
|
|
|
|
Devuelve ``true`` si el vector está normalizado, es decir, si su longitud es aproximadamente igual 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>`
|
|
|
|
Devuelve ``true`` si los valores de este vector son aproximadamente cero, ejecutando :ref:`@GlobalScope.is_zero_approx()<class_@GlobalScope_method_is_zero_approx>` en cada componente.
|
|
|
|
Este método es más rápido que usar :ref:`is_equal_approx()<class_Vector3_method_is_equal_approx>` con un valor como un vector cero.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_Vector3_method_length:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`float<class_float>` **length**\ (\ ) |const| :ref:`🔗<class_Vector3_method_length>`
|
|
|
|
Devuelve la longitud (magnitud) de este vector.
|
|
|
|
.. 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>`
|
|
|
|
Devuelve la longitud cuadrada (magnitud cuadrada) de este vector.
|
|
|
|
Este método funciona más rápido que el :ref:`length()<class_Vector3_method_length>`, por lo que es preferible si necesitas comparar vectores o necesitas la distancia al cuadrado para alguna fórmula.
|
|
|
|
.. 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>`
|
|
|
|
Devuelve el resultado de la interpolación lineal entre este vector y ``to`` por la cantidad ``weight``. ``weight`` está en el rango de ``0.0`` a ``1.0``, representando la cantidad de interpolación.
|
|
|
|
.. 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>`
|
|
|
|
Devuelve el vector con una longitud máxima limitando su longitud a ``length``. Si el vector no es finito, el resultado no está definido.
|
|
|
|
.. 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>`
|
|
|
|
Devuelve el máximo componente a componente de este y ``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>`
|
|
|
|
Devuelve el eje del valor más alto del vector. Consulta las constantes ``AXIS_*``. Si todos los componentes son iguales, este método devuelve :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>`
|
|
|
|
Devuelve el máximo componente a componente de este y ``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>`
|
|
|
|
Devuelve el mínimo componente a componente de este y ``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>`
|
|
|
|
Devuelve el eje del valor más bajo del vector. Consulta las constantes ``AXIS_*``. Si todos los componentes son iguales, este método devuelve la constante ``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>`
|
|
|
|
Devuelve el mínimo componente a componente de este y ``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>`
|
|
|
|
Devuelve un nuevo vector movido hacia ``to`` por la cantidad fija de ``delta``. No pasará del valor final.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_Vector3_method_normalized:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`Vector3<class_Vector3>` **normalized**\ (\ ) |const| :ref:`🔗<class_Vector3_method_normalized>`
|
|
|
|
Devuelve el resultado de escalar el vector a la longitud unitaria. Equivalente a ``v / v.length()``. Devuelve ``(0, 0, 0)`` si ``v.length() == 0``. Véase también :ref:`is_normalized()<class_Vector3_method_is_normalized>`.
|
|
|
|
\ **Nota:** Esta función puede devolver valores incorrectos si la longitud del vector de entrada es cercana a cero.
|
|
|
|
.. 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>`
|
|
|
|
Devuelve el **Vector3** de una forma comprimida octaédrica creada usando :ref:`octahedron_encode()<class_Vector3_method_octahedron_encode>` (almacenado como 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>`
|
|
|
|
Devuelve la forma codificada en octaedro (oct32) de este **Vector3** como un :ref:`Vector2<class_Vector2>`. Dado que un :ref:`Vector2<class_Vector2>` ocupa 1/3 menos de memoria en comparación con **Vector3**, esta forma de compresión se puede utilizar para pasar mayores cantidades de :ref:`normalized()<class_Vector3_method_normalized>` **Vector3**\ s sin aumentar los requisitos de almacenamiento o memoria. Véase también :ref:`octahedron_decode()<class_Vector3_method_octahedron_decode>`.
|
|
|
|
\ **Nota:** :ref:`octahedron_encode()<class_Vector3_method_octahedron_encode>` sólo se puede utilizar para vectores :ref:`normalized()<class_Vector3_method_normalized>`. :ref:`octahedron_encode()<class_Vector3_method_octahedron_encode>` *no* comprueba si este **Vector3** está normalizado y devolverá un valor que no se descomprime al valor original si el **Vector3** no está normalizado.
|
|
|
|
\ **Nota:** La compresión octaédrica es *pérdida*, aunque las diferencias visuales rara vez son perceptibles en escenarios del mundo real.
|
|
|
|
.. 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>`
|
|
|
|
Devuelve el producto exterior con ``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>`
|
|
|
|
Devuelve un vector compuesto por el :ref:`@GlobalScope.fposmod()<class_@GlobalScope_method_fposmod>` de los componentes de este vector y ``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>`
|
|
|
|
Devuelve un vector compuesto por el :ref:`@GlobalScope.fposmod()<class_@GlobalScope_method_fposmod>` de los componentes de este vector y los componentes 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>`
|
|
|
|
Devuelve un nuevo vector resultante de proyectar este vector sobre el vector ``b`` dado. El nuevo vector resultante es paralelo a ``b``. Ver también :ref:`slide()<class_Vector3_method_slide>`.
|
|
|
|
\ **Nota:** Si el vector ``b`` es un vector cero, los componentes del nuevo vector resultante serán :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>`
|
|
|
|
Devuelve el resultado de reflejar el vector a través de un plano definido por el vector normal dado ``n``.
|
|
|
|
\ **Nota:** :ref:`reflect()<class_Vector3_method_reflect>` difiere de lo que otros motores y frameworks llaman ``reflect()``. En otros motores, ``reflect()`` devuelve el resultado del vector reflejado por el plano dado. La reflexión, por tanto, pasa a través de la normal dada. Mientras que en Godot la reflexión pasa a través del plano y se puede pensar como un rebote en la normal. Véase también :ref:`bounce()<class_Vector3_method_bounce>` que hace lo que la mayoría de los motores llaman ``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>`
|
|
|
|
Devuelve el resultado de rotar este vector alrededor de un eje dado por ``angle`` (en radianes). El eje debe ser un vector normalizado. Véase también :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>`
|
|
|
|
Devuelve un nuevo vector con todos los componentes redondeados al entero más cercano, con los casos intermedios redondeados desde cero.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_Vector3_method_sign:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`Vector3<class_Vector3>` **sign**\ (\ ) |const| :ref:`🔗<class_Vector3_method_sign>`
|
|
|
|
Devuelve un nuevo vector con cada componente establecido a ``1.0`` si es positivo, ``-1.0`` si es negativo y ``0.0`` si es cero. El resultado es idéntico a llamar a :ref:`@GlobalScope.sign()<class_@GlobalScope_method_sign>` en cada 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>`
|
|
|
|
Devuelve el ángulo con signo al vector dado, en radianes. El signo del ángulo es positivo en el sentido contrario a las agujas del reloj y negativo en el sentido de las agujas del reloj cuando se ve desde el lado especificado por el ``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>`
|
|
|
|
Devuelve el resultado de la interpolación lineal esférica entre este vector y ``to``, por la cantidad ``weight``. ``weight`` está en el rango de 0.0 a 1.0, representando la cantidad de interpolación.
|
|
|
|
Este método también gestiona la interpolación de las longitudes si los vectores de entrada tienen longitudes diferentes. Para el caso especial de que uno o ambos vectores de entrada tengan longitud cero, este método se comporta como :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>`
|
|
|
|
Devuelve un nuevo vector resultante de deslizar este vector a lo largo de un plano con normal ``n``. El nuevo vector resultante es perpendicular a ``n``, y es equivalente a este vector menos su proyección sobre ``n``. Véase también :ref:`project()<class_Vector3_method_project>`.
|
|
|
|
\ **Nota:** El vector ``n`` debe ser normalizado. Véase también :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>`
|
|
|
|
Devuelve un nuevo vector con cada componente ajustado al múltiplo más cercano del componente correspondiente en ``step``. Esto también se puede usar para redondear los componentes a un número arbitrario de decimales.
|
|
|
|
.. 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>`
|
|
|
|
Devuelve un nuevo vector con cada componente ajustado al múltiplo más cercano de ``step``. Esto también se puede usar para redondear los componentes a un número arbitrario de decimales.
|
|
|
|
.. rst-class:: classref-section-separator
|
|
|
|
----
|
|
|
|
.. rst-class:: classref-descriptions-group
|
|
|
|
Descripciones de Operadores
|
|
------------------------------------------------------
|
|
|
|
.. _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>`
|
|
|
|
Devuelve ``true`` si los vectores no son iguales.
|
|
|
|
\ **Nota:** Debido a errores de precisión en punto flotante, considera usar :ref:`is_equal_approx()<class_Vector3_method_is_equal_approx>` en su lugar, ya que es más fiable.
|
|
|
|
\ **Nota:** Los vectores con elementos :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>` no se comportan igual que otros vectores. Por lo tanto, los resultados de este operador podrían no ser precisos si se incluyen NaN.
|
|
|
|
.. 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>`
|
|
|
|
Transforma inversamente (multiplica) el **Vector3** por la matriz :ref:`Basis<class_Basis>` dada, bajo el supuesto de que la base es ortonormal (es decir, la rotación/reflexión está bien, la escala/sesgo no lo está).
|
|
|
|
\ ``vector * basis`` es equivalente a ``basis.transposed() * vector``. Ver :ref:`Basis.transposed()<class_Basis_method_transposed>`.
|
|
|
|
Para transformar por la inversa de una base no ortonormal (por ejemplo, con escalado) se puede utilizar ``basis.inverse() * vector`` en su lugar. Véase :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>`
|
|
|
|
Transforma inversamente (multiplica) el **Vector3** por el :ref:`Quaternion<class_Quaternion>` dado.
|
|
|
|
\ ``vector * quaternion`` es equivalente a ``quaternion.inverse() * vector``. Véase :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>`
|
|
|
|
Transforma inversamente (multiplica) el **Vector3** por la matriz de transformación :ref:`Transform3D<class_Transform3D>` dada, bajo el supuesto de que la base de transformación es ortonormal (es decir, la rotación/reflexión está bien, la escala/sesgo no lo está).
|
|
|
|
\ ``vector * transform`` es equivalente a ``transform.inverse() * vector``. Véase :ref:`Transform3D.inverse()<class_Transform3D_method_inverse>`.
|
|
|
|
Para transformar por la inversa de una transformación afín (por ejemplo, con escalado) se puede utilizar ``transform.affine_inverse() * vector`` en su lugar. Véase :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>`
|
|
|
|
Multiplica cada componente de **Vector3** por los componentes del **Vector3** dado.
|
|
|
|
::
|
|
|
|
print(Vector3(10, 20, 30) * Vector3(3, 4, 5)) # Imprime (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>`
|
|
|
|
Multiplies each component of the **Vector3** by the given :ref:`float<class_float>`.
|
|
|
|
.. 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>`
|
|
|
|
Multiplica cada componente del **Vector3** por el :ref:`int<class_int>` dado.
|
|
|
|
.. 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>`
|
|
|
|
Suma cada componente de **Vector3** con los componentes del **Vector3** dado.
|
|
|
|
::
|
|
|
|
print(Vector3(10, 20, 30) + Vector3(3, 4, 5)) # Imprime (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>`
|
|
|
|
Resta cada componente de **Vector3** por los componentes del **Vector3** dado.
|
|
|
|
::
|
|
|
|
print(Vector3(10, 20, 30) - Vector3(3, 4, 5)) # Imprime (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 cada componente de **Vector3** entre los componentes del **Vector3** dado.
|
|
|
|
::
|
|
|
|
print(Vector3(10, 20, 30) / Vector3(2, 5, 3)) # Imprime (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 cada componente del **Vector3** por el :ref:`float<class_float>` dado.
|
|
|
|
.. 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 cada componente del **Vector3** por el :ref:`int<class_int>` dado.
|
|
|
|
.. 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>`
|
|
|
|
Compara dos vectores **Vector3** comprobando primero si el valor X del vector de la izquierda es menor que el valor X del vector ``right``. Si los valores X son exactamente iguales, entonces repite esta comprobación con los valores Y de los dos vectores, y luego con los valores Z. Este operador es útil para ordenar vectores.
|
|
|
|
\ **Nota:** Los vectores con elementos :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>` no se comportan igual que otros vectores. Por lo tanto, los resultados de este operador pueden no ser precisos si se incluyen NaN.
|
|
|
|
.. 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>`
|
|
|
|
Compara dos vectores **Vector3** comprobando primero si el valor X del vector de la izquierda es menor o igual que el valor X del vector ``right``. Si los valores X son exactamente iguales, entonces repite esta comprobación con los valores Y de los dos vectores, y luego con los valores Z. Este operador es útil para ordenar vectores.
|
|
|
|
\ **Nota:** Los vectores con elementos :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>` no se comportan igual que otros vectores. Por lo tanto, los resultados de este operador pueden no ser precisos si se incluyen NaN.
|
|
|
|
.. 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>`
|
|
|
|
Devuelve ``true`` si los vectores son exactamente iguales.
|
|
|
|
\ **Nota:** Debido a errores de precisión en punto flotante, considera usar :ref:`is_equal_approx()<class_Vector3_method_is_equal_approx>` en su lugar, ya que es más fiable.
|
|
|
|
\ **Nota:** Los vectores con elementos :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>` no se comportan igual que otros vectores. Por lo tanto, los resultados de este operador podrían no ser precisos si se incluyen NaN.
|
|
|
|
.. 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>`
|
|
|
|
Compara dos vectores **Vector3** comprobando primero si el valor X del vector de la izquierda es mayor que el valor X del vector ``right``. Si los valores X son exactamente iguales, entonces repite esta comprobación con los valores Y de los dos vectores, y luego con los valores Z. Este operador es útil para ordenar vectores.
|
|
|
|
\ **Nota:** Los vectores con elementos :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>` no se comportan igual que otros vectores. Por lo tanto, los resultados de este operador pueden no ser precisos si se incluyen NaN.
|
|
|
|
.. 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>`
|
|
|
|
Compara dos vectores **Vector3** comprobando primero si el valor X del vector de la izquierda es mayor o igual que el valor X del vector ``right``. Si los valores X son exactamente iguales, entonces repite esta comprobación con los valores Y de los dos vectores, y luego con los valores Z. Este operador es útil para ordenar vectores.
|
|
|
|
\ **Nota:** Los vectores con elementos :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>` no se comportan igual que otros vectores. Por lo tanto, los resultados de este operador pueden no ser precisos si se incluyen NaN.
|
|
|
|
.. 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 a los componentes del vector utilizando su ``index``. ``v[0]`` es equivalente a ``v.x``, ``v[1]`` es equivalente a ``v.y``, y ``v[2]`` es 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>`
|
|
|
|
Returns the same value as if the ``+`` was not there. Unary ``+`` does nothing, but sometimes it can make your code more readable.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_Vector3_operator_unminus:
|
|
|
|
.. rst-class:: classref-operator
|
|
|
|
:ref:`Vector3<class_Vector3>` **operator unary-**\ (\ ) :ref:`🔗<class_Vector3_operator_unminus>`
|
|
|
|
Devuelve el valor negativo del **Vector3**. Esto es lo mismo que escribir ``Vector3(-v.x, -v.y, -v.z)``. Esta operación invierte la dirección del vector manteniendo la misma magnitud. Con floats, el número cero puede ser positivo o negativo.
|
|
|
|
.. |virtual| replace:: :abbr:`virtual (Normalmente, este método debería ser sobreescrito por el usuario para que tenga algún efecto.)`
|
|
.. |required| replace:: :abbr:`required (This method is required to be overridden when extending its base class.)`
|
|
.. |const| replace:: :abbr:`const (Este método no tiene efectos secundarios. No modifica ninguna de las variables miembro de la instancia.)`
|
|
.. |vararg| replace:: :abbr:`vararg (Este método permite agregar cualquier número de argumentos después de los descritos aquí.)`
|
|
.. |constructor| replace:: :abbr:`constructor (Este método se utiliza para construir un tipo.)`
|
|
.. |static| replace:: :abbr:`static (Este método no necesita una instancia para ser llamado, por lo que puede llamarse directamente utilizando el nombre de la clase.)`
|
|
.. |operator| replace:: :abbr:`operator (Este método describe un operador válido para usar con este tipo como operando izquierdo.)`
|
|
.. |bitfield| replace:: :abbr:`BitField (Este valor es un entero compuesto como una máscara de bits de las siguientes banderas.)`
|
|
.. |void| replace:: :abbr:`void (Sin valor de retorno.)`
|