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

1030 lines
63 KiB
ReStructuredText
Raw Permalink Blame History

:github_url: hide
.. _class_Vector4:
Vector4
=======
Un vector 4D que utiliza coordenadas de punto flotante.
.. rst-class:: classref-introduction-group
Descripción
----------------------
Una estructura de 4 elementos que se puede usar para representar coordenadas 4D o cualquier otro cuarteto 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 tiene 64 bits. Si se necesita precisión doble, compila el motor con la opción ``precision=double``.
Véase :ref:`Vector4i<class_Vector4i>` para su contraparte entera.
\ **Nota:** En un contexto booleano, un Vector4 se evaluará como ``false`` si es igual a ``Vector4(0, 0, 0, 0)``. De lo contrario, un Vector4 siempre se evaluará como ``true``.
.. rst-class:: classref-reftable-group
Propiedades
----------------------
.. table::
:widths: auto
+---------------------------+------------------------------------+---------+
| :ref:`float<class_float>` | :ref:`w<class_Vector4_property_w>` | ``0.0`` |
+---------------------------+------------------------------------+---------+
| :ref:`float<class_float>` | :ref:`x<class_Vector4_property_x>` | ``0.0`` |
+---------------------------+------------------------------------+---------+
| :ref:`float<class_float>` | :ref:`y<class_Vector4_property_y>` | ``0.0`` |
+---------------------------+------------------------------------+---------+
| :ref:`float<class_float>` | :ref:`z<class_Vector4_property_z>` | ``0.0`` |
+---------------------------+------------------------------------+---------+
.. rst-class:: classref-reftable-group
Constructores
--------------------------
.. table::
:widths: auto
+-------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector4<class_Vector4>` | :ref:`Vector4<class_Vector4_constructor_Vector4>`\ (\ ) |
+-------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector4<class_Vector4>` | :ref:`Vector4<class_Vector4_constructor_Vector4>`\ (\ from\: :ref:`Vector4<class_Vector4>`\ ) |
+-------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector4<class_Vector4>` | :ref:`Vector4<class_Vector4_constructor_Vector4>`\ (\ from\: :ref:`Vector4i<class_Vector4i>`\ ) |
+-------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector4<class_Vector4>` | :ref:`Vector4<class_Vector4_constructor_Vector4>`\ (\ x\: :ref:`float<class_float>`, y\: :ref:`float<class_float>`, z\: :ref:`float<class_float>`, w\: :ref:`float<class_float>`\ ) |
+-------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
.. rst-class:: classref-reftable-group
Métodos
--------------
.. table::
:widths: auto
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector4<class_Vector4>` | :ref:`abs<class_Vector4_method_abs>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector4<class_Vector4>` | :ref:`ceil<class_Vector4_method_ceil>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector4<class_Vector4>` | :ref:`clamp<class_Vector4_method_clamp>`\ (\ min\: :ref:`Vector4<class_Vector4>`, max\: :ref:`Vector4<class_Vector4>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector4<class_Vector4>` | :ref:`clampf<class_Vector4_method_clampf>`\ (\ min\: :ref:`float<class_float>`, max\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector4<class_Vector4>` | :ref:`cubic_interpolate<class_Vector4_method_cubic_interpolate>`\ (\ b\: :ref:`Vector4<class_Vector4>`, pre_a\: :ref:`Vector4<class_Vector4>`, post_b\: :ref:`Vector4<class_Vector4>`, weight\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector4<class_Vector4>` | :ref:`cubic_interpolate_in_time<class_Vector4_method_cubic_interpolate_in_time>`\ (\ b\: :ref:`Vector4<class_Vector4>`, pre_a\: :ref:`Vector4<class_Vector4>`, post_b\: :ref:`Vector4<class_Vector4>`, weight\: :ref:`float<class_float>`, b_t\: :ref:`float<class_float>`, pre_a_t\: :ref:`float<class_float>`, post_b_t\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector4<class_Vector4>` | :ref:`direction_to<class_Vector4_method_direction_to>`\ (\ to\: :ref:`Vector4<class_Vector4>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`distance_squared_to<class_Vector4_method_distance_squared_to>`\ (\ to\: :ref:`Vector4<class_Vector4>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`distance_to<class_Vector4_method_distance_to>`\ (\ to\: :ref:`Vector4<class_Vector4>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`dot<class_Vector4_method_dot>`\ (\ with\: :ref:`Vector4<class_Vector4>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector4<class_Vector4>` | :ref:`floor<class_Vector4_method_floor>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector4<class_Vector4>` | :ref:`inverse<class_Vector4_method_inverse>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_equal_approx<class_Vector4_method_is_equal_approx>`\ (\ to\: :ref:`Vector4<class_Vector4>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_finite<class_Vector4_method_is_finite>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_normalized<class_Vector4_method_is_normalized>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_zero_approx<class_Vector4_method_is_zero_approx>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`length<class_Vector4_method_length>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`length_squared<class_Vector4_method_length_squared>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector4<class_Vector4>` | :ref:`lerp<class_Vector4_method_lerp>`\ (\ to\: :ref:`Vector4<class_Vector4>`, weight\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector4<class_Vector4>` | :ref:`max<class_Vector4_method_max>`\ (\ with\: :ref:`Vector4<class_Vector4>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`max_axis_index<class_Vector4_method_max_axis_index>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector4<class_Vector4>` | :ref:`maxf<class_Vector4_method_maxf>`\ (\ with\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector4<class_Vector4>` | :ref:`min<class_Vector4_method_min>`\ (\ with\: :ref:`Vector4<class_Vector4>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`min_axis_index<class_Vector4_method_min_axis_index>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector4<class_Vector4>` | :ref:`minf<class_Vector4_method_minf>`\ (\ with\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector4<class_Vector4>` | :ref:`normalized<class_Vector4_method_normalized>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector4<class_Vector4>` | :ref:`posmod<class_Vector4_method_posmod>`\ (\ mod\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector4<class_Vector4>` | :ref:`posmodv<class_Vector4_method_posmodv>`\ (\ modv\: :ref:`Vector4<class_Vector4>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector4<class_Vector4>` | :ref:`round<class_Vector4_method_round>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector4<class_Vector4>` | :ref:`sign<class_Vector4_method_sign>`\ (\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector4<class_Vector4>` | :ref:`snapped<class_Vector4_method_snapped>`\ (\ step\: :ref:`Vector4<class_Vector4>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector4<class_Vector4>` | :ref:`snappedf<class_Vector4_method_snappedf>`\ (\ step\: :ref:`float<class_float>`\ ) |const| |
+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
.. rst-class:: classref-reftable-group
Operadores
--------------------
.. table::
:widths: auto
+-------------------------------+-------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator !=<class_Vector4_operator_neq_Vector4>`\ (\ right\: :ref:`Vector4<class_Vector4>`\ ) |
+-------------------------------+-------------------------------------------------------------------------------------------------------------+
| :ref:`Vector4<class_Vector4>` | :ref:`operator *<class_Vector4_operator_mul_Projection>`\ (\ right\: :ref:`Projection<class_Projection>`\ ) |
+-------------------------------+-------------------------------------------------------------------------------------------------------------+
| :ref:`Vector4<class_Vector4>` | :ref:`operator *<class_Vector4_operator_mul_Vector4>`\ (\ right\: :ref:`Vector4<class_Vector4>`\ ) |
+-------------------------------+-------------------------------------------------------------------------------------------------------------+
| :ref:`Vector4<class_Vector4>` | :ref:`operator *<class_Vector4_operator_mul_float>`\ (\ right\: :ref:`float<class_float>`\ ) |
+-------------------------------+-------------------------------------------------------------------------------------------------------------+
| :ref:`Vector4<class_Vector4>` | :ref:`operator *<class_Vector4_operator_mul_int>`\ (\ right\: :ref:`int<class_int>`\ ) |
+-------------------------------+-------------------------------------------------------------------------------------------------------------+
| :ref:`Vector4<class_Vector4>` | :ref:`operator +<class_Vector4_operator_sum_Vector4>`\ (\ right\: :ref:`Vector4<class_Vector4>`\ ) |
+-------------------------------+-------------------------------------------------------------------------------------------------------------+
| :ref:`Vector4<class_Vector4>` | :ref:`operator -<class_Vector4_operator_dif_Vector4>`\ (\ right\: :ref:`Vector4<class_Vector4>`\ ) |
+-------------------------------+-------------------------------------------------------------------------------------------------------------+
| :ref:`Vector4<class_Vector4>` | :ref:`operator /<class_Vector4_operator_div_Vector4>`\ (\ right\: :ref:`Vector4<class_Vector4>`\ ) |
+-------------------------------+-------------------------------------------------------------------------------------------------------------+
| :ref:`Vector4<class_Vector4>` | :ref:`operator /<class_Vector4_operator_div_float>`\ (\ right\: :ref:`float<class_float>`\ ) |
+-------------------------------+-------------------------------------------------------------------------------------------------------------+
| :ref:`Vector4<class_Vector4>` | :ref:`operator /<class_Vector4_operator_div_int>`\ (\ right\: :ref:`int<class_int>`\ ) |
+-------------------------------+-------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator \<<class_Vector4_operator_lt_Vector4>`\ (\ right\: :ref:`Vector4<class_Vector4>`\ ) |
+-------------------------------+-------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator \<=<class_Vector4_operator_lte_Vector4>`\ (\ right\: :ref:`Vector4<class_Vector4>`\ ) |
+-------------------------------+-------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator ==<class_Vector4_operator_eq_Vector4>`\ (\ right\: :ref:`Vector4<class_Vector4>`\ ) |
+-------------------------------+-------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator ><class_Vector4_operator_gt_Vector4>`\ (\ right\: :ref:`Vector4<class_Vector4>`\ ) |
+-------------------------------+-------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator >=<class_Vector4_operator_gte_Vector4>`\ (\ right\: :ref:`Vector4<class_Vector4>`\ ) |
+-------------------------------+-------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`operator []<class_Vector4_operator_idx_int>`\ (\ index\: :ref:`int<class_int>`\ ) |
+-------------------------------+-------------------------------------------------------------------------------------------------------------+
| :ref:`Vector4<class_Vector4>` | :ref:`operator unary+<class_Vector4_operator_unplus>`\ (\ ) |
+-------------------------------+-------------------------------------------------------------------------------------------------------------+
| :ref:`Vector4<class_Vector4>` | :ref:`operator unary-<class_Vector4_operator_unminus>`\ (\ ) |
+-------------------------------+-------------------------------------------------------------------------------------------------------------+
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Enumeraciones
--------------------------
.. _enum_Vector4_Axis:
.. rst-class:: classref-enumeration
enum **Axis**: :ref:`🔗<enum_Vector4_Axis>`
.. _class_Vector4_constant_AXIS_X:
.. rst-class:: classref-enumeration-constant
:ref:`Axis<enum_Vector4_Axis>` **AXIS_X** = ``0``
Valor enumerado para el eje X. Devuelto por :ref:`max_axis_index()<class_Vector4_method_max_axis_index>` y :ref:`min_axis_index()<class_Vector4_method_min_axis_index>`.
.. _class_Vector4_constant_AXIS_Y:
.. rst-class:: classref-enumeration-constant
:ref:`Axis<enum_Vector4_Axis>` **AXIS_Y** = ``1``
Valor enumerado para el eje Y. Devuelto por :ref:`max_axis_index()<class_Vector4_method_max_axis_index>` y :ref:`min_axis_index()<class_Vector4_method_min_axis_index>`.
.. _class_Vector4_constant_AXIS_Z:
.. rst-class:: classref-enumeration-constant
:ref:`Axis<enum_Vector4_Axis>` **AXIS_Z** = ``2``
Valor enumerado para el eje Z. Devuelto por :ref:`max_axis_index()<class_Vector4_method_max_axis_index>` y :ref:`min_axis_index()<class_Vector4_method_min_axis_index>`.
.. _class_Vector4_constant_AXIS_W:
.. rst-class:: classref-enumeration-constant
:ref:`Axis<enum_Vector4_Axis>` **AXIS_W** = ``3``
Valor enumerado para el eje W. Devuelto por :ref:`max_axis_index()<class_Vector4_method_max_axis_index>` y :ref:`min_axis_index()<class_Vector4_method_min_axis_index>`.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Constantes
--------------------
.. _class_Vector4_constant_ZERO:
.. rst-class:: classref-constant
**ZERO** = ``Vector4(0, 0, 0, 0)`` :ref:`🔗<class_Vector4_constant_ZERO>`
Vector cero, un vector con todos los componentes ajustados a ``0``.
.. _class_Vector4_constant_ONE:
.. rst-class:: classref-constant
**ONE** = ``Vector4(1, 1, 1, 1)`` :ref:`🔗<class_Vector4_constant_ONE>`
Un vector, un vector con todos los componentes ajustados a ``1``.
.. _class_Vector4_constant_INF:
.. rst-class:: classref-constant
**INF** = ``Vector4(inf, inf, inf, inf)`` :ref:`🔗<class_Vector4_constant_INF>`
Vector infinito, un vector con todos los componentes ajustados a :ref:`@GDScript.INF<class_@GDScript_constant_INF>`.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descripciones de Propiedades
--------------------------------------------------------
.. _class_Vector4_property_w:
.. rst-class:: classref-property
:ref:`float<class_float>` **w** = ``0.0`` :ref:`🔗<class_Vector4_property_w>`
El componente W del vector. También se puede acceder utilizando la posición del índice ``[3]``.
.. rst-class:: classref-item-separator
----
.. _class_Vector4_property_x:
.. rst-class:: classref-property
:ref:`float<class_float>` **x** = ``0.0`` :ref:`🔗<class_Vector4_property_x>`
El componente X del vector. También se puede acceder utilizando la posición del índice ``[0]``.
.. rst-class:: classref-item-separator
----
.. _class_Vector4_property_y:
.. rst-class:: classref-property
:ref:`float<class_float>` **y** = ``0.0`` :ref:`🔗<class_Vector4_property_y>`
El componente Y del vector. También se puede acceder usando la posición del índice ``[1]``.
.. rst-class:: classref-item-separator
----
.. _class_Vector4_property_z:
.. rst-class:: classref-property
:ref:`float<class_float>` **z** = ``0.0`` :ref:`🔗<class_Vector4_property_z>`
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_Vector4_constructor_Vector4:
.. rst-class:: classref-constructor
:ref:`Vector4<class_Vector4>` **Vector4**\ (\ ) :ref:`🔗<class_Vector4_constructor_Vector4>`
Construye un **Vector4** inicializado por defecto con todos los componentes establecidos a ``0``.
.. rst-class:: classref-item-separator
----
.. rst-class:: classref-constructor
:ref:`Vector4<class_Vector4>` **Vector4**\ (\ from\: :ref:`Vector4<class_Vector4>`\ )
Construye un **Vector4** como copia del **Vector4** dado.
.. rst-class:: classref-item-separator
----
.. rst-class:: classref-constructor
:ref:`Vector4<class_Vector4>` **Vector4**\ (\ from\: :ref:`Vector4i<class_Vector4i>`\ )
Construye un nuevo **Vector4** a partir del :ref:`Vector4i<class_Vector4i>` dado.
.. rst-class:: classref-item-separator
----
.. rst-class:: classref-constructor
:ref:`Vector4<class_Vector4>` **Vector4**\ (\ x\: :ref:`float<class_float>`, y\: :ref:`float<class_float>`, z\: :ref:`float<class_float>`, w\: :ref:`float<class_float>`\ )
Devuelve un **Vector4** con los componentes dados.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descripciones de Métodos
------------------------------------------------
.. _class_Vector4_method_abs:
.. rst-class:: classref-method
:ref:`Vector4<class_Vector4>` **abs**\ (\ ) |const| :ref:`🔗<class_Vector4_method_abs>`
Devuelve un nuevo vector con todos los componentes en valores absolutos (es decir, positivos).
.. rst-class:: classref-item-separator
----
.. _class_Vector4_method_ceil:
.. rst-class:: classref-method
:ref:`Vector4<class_Vector4>` **ceil**\ (\ ) |const| :ref:`🔗<class_Vector4_method_ceil>`
Devuelve un nuevo vector con todos los componentes redondeados hacia arriba (hacia el infinito positivo).
.. rst-class:: classref-item-separator
----
.. _class_Vector4_method_clamp:
.. rst-class:: classref-method
:ref:`Vector4<class_Vector4>` **clamp**\ (\ min\: :ref:`Vector4<class_Vector4>`, max\: :ref:`Vector4<class_Vector4>`\ ) |const| :ref:`🔗<class_Vector4_method_clamp>`
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_Vector4_method_clampf:
.. rst-class:: classref-method
:ref:`Vector4<class_Vector4>` **clampf**\ (\ min\: :ref:`float<class_float>`, max\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector4_method_clampf>`
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_Vector4_method_cubic_interpolate:
.. rst-class:: classref-method
:ref:`Vector4<class_Vector4>` **cubic_interpolate**\ (\ b\: :ref:`Vector4<class_Vector4>`, pre_a\: :ref:`Vector4<class_Vector4>`, post_b\: :ref:`Vector4<class_Vector4>`, weight\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector4_method_cubic_interpolate>`
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_Vector4_method_cubic_interpolate_in_time:
.. rst-class:: classref-method
:ref:`Vector4<class_Vector4>` **cubic_interpolate_in_time**\ (\ b\: :ref:`Vector4<class_Vector4>`, pre_a\: :ref:`Vector4<class_Vector4>`, post_b\: :ref:`Vector4<class_Vector4>`, weight\: :ref:`float<class_float>`, b_t\: :ref:`float<class_float>`, pre_a_t\: :ref:`float<class_float>`, post_b_t\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector4_method_cubic_interpolate_in_time>`
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_Vector4_method_cubic_interpolate>` por los valores de tiempo.
.. rst-class:: classref-item-separator
----
.. _class_Vector4_method_direction_to:
.. rst-class:: classref-method
:ref:`Vector4<class_Vector4>` **direction_to**\ (\ to\: :ref:`Vector4<class_Vector4>`\ ) |const| :ref:`🔗<class_Vector4_method_direction_to>`
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_Vector4_method_distance_squared_to:
.. rst-class:: classref-method
:ref:`float<class_float>` **distance_squared_to**\ (\ to\: :ref:`Vector4<class_Vector4>`\ ) |const| :ref:`🔗<class_Vector4_method_distance_squared_to>`
Devuelve la distancia al cuadrado entre este vector y ``to``.
Este método se ejecuta más rápido que :ref:`distance_to()<class_Vector4_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_Vector4_method_distance_to:
.. rst-class:: classref-method
:ref:`float<class_float>` **distance_to**\ (\ to\: :ref:`Vector4<class_Vector4>`\ ) |const| :ref:`🔗<class_Vector4_method_distance_to>`
Devuelve la distancia entre este vector y ``to``.
.. rst-class:: classref-item-separator
----
.. _class_Vector4_method_dot:
.. rst-class:: classref-method
:ref:`float<class_float>` **dot**\ (\ with\: :ref:`Vector4<class_Vector4>`\ ) |const| :ref:`🔗<class_Vector4_method_dot>`
Devuelve el producto escalar de este vector y ``with``.
.. rst-class:: classref-item-separator
----
.. _class_Vector4_method_floor:
.. rst-class:: classref-method
:ref:`Vector4<class_Vector4>` **floor**\ (\ ) |const| :ref:`🔗<class_Vector4_method_floor>`
Devuelve un nuevo vector con todos los componentes redondeados hacia abajo (hacia el infinito negativo).
.. rst-class:: classref-item-separator
----
.. _class_Vector4_method_inverse:
.. rst-class:: classref-method
:ref:`Vector4<class_Vector4>` **inverse**\ (\ ) |const| :ref:`🔗<class_Vector4_method_inverse>`
Devuelve el inverso del vector. Esto es lo mismo que ``Vector4(1.0 / v.x, 1.0 / v.y, 1.0 / v.z, 1.0 / v.w)``.
.. rst-class:: classref-item-separator
----
.. _class_Vector4_method_is_equal_approx:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_equal_approx**\ (\ to\: :ref:`Vector4<class_Vector4>`\ ) |const| :ref:`🔗<class_Vector4_method_is_equal_approx>`
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_Vector4_method_is_finite:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_finite**\ (\ ) |const| :ref:`🔗<class_Vector4_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_Vector4_method_is_normalized:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_normalized**\ (\ ) |const| :ref:`🔗<class_Vector4_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_Vector4_method_is_zero_approx:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_zero_approx**\ (\ ) |const| :ref:`🔗<class_Vector4_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_Vector4_method_is_equal_approx>` con un valor como un vector cero.
.. rst-class:: classref-item-separator
----
.. _class_Vector4_method_length:
.. rst-class:: classref-method
:ref:`float<class_float>` **length**\ (\ ) |const| :ref:`🔗<class_Vector4_method_length>`
Devuelve la longitud (magnitud) de este vector.
.. rst-class:: classref-item-separator
----
.. _class_Vector4_method_length_squared:
.. rst-class:: classref-method
:ref:`float<class_float>` **length_squared**\ (\ ) |const| :ref:`🔗<class_Vector4_method_length_squared>`
Devuelve la longitud cuadrada (magnitud cuadrada) de este vector.
Este método funciona más rápido que el :ref:`length()<class_Vector4_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_Vector4_method_lerp:
.. rst-class:: classref-method
:ref:`Vector4<class_Vector4>` **lerp**\ (\ to\: :ref:`Vector4<class_Vector4>`, weight\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector4_method_lerp>`
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_Vector4_method_max:
.. rst-class:: classref-method
:ref:`Vector4<class_Vector4>` **max**\ (\ with\: :ref:`Vector4<class_Vector4>`\ ) |const| :ref:`🔗<class_Vector4_method_max>`
Devuelve el máximo componente a componente de este y ``with``, equivalente a ``Vector4(maxf(x, with.x), maxf(y, with.y), maxf(z, with.z), maxf(w, with.w))``.
.. rst-class:: classref-item-separator
----
.. _class_Vector4_method_max_axis_index:
.. rst-class:: classref-method
:ref:`int<class_int>` **max_axis_index**\ (\ ) |const| :ref:`🔗<class_Vector4_method_max_axis_index>`
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_Vector4_constant_AXIS_X>`.
.. rst-class:: classref-item-separator
----
.. _class_Vector4_method_maxf:
.. rst-class:: classref-method
:ref:`Vector4<class_Vector4>` **maxf**\ (\ with\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector4_method_maxf>`
Devuelve el máximo componente a componente de este y ``with``, equivalente a ``Vector4(maxf(x, with), maxf(y, with), maxf(z, with), maxf(w, with))``.
.. rst-class:: classref-item-separator
----
.. _class_Vector4_method_min:
.. rst-class:: classref-method
:ref:`Vector4<class_Vector4>` **min**\ (\ with\: :ref:`Vector4<class_Vector4>`\ ) |const| :ref:`🔗<class_Vector4_method_min>`
Devuelve el mínimo componente a componente de este y ``with``, equivalente a ``Vector4(minf(x, with.x), minf(y, with.y), minf(z, with.z), minf(w, with.w))``.
.. rst-class:: classref-item-separator
----
.. _class_Vector4_method_min_axis_index:
.. rst-class:: classref-method
:ref:`int<class_int>` **min_axis_index**\ (\ ) |const| :ref:`🔗<class_Vector4_method_min_axis_index>`
Devuelve el eje del valor más bajo del vector. Ver las constantes ``AXIS_*``. Si todos los componentes son iguales, este método devuelve :ref:`AXIS_W<class_Vector4_constant_AXIS_W>`.
.. rst-class:: classref-item-separator
----
.. _class_Vector4_method_minf:
.. rst-class:: classref-method
:ref:`Vector4<class_Vector4>` **minf**\ (\ with\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector4_method_minf>`
Devuelve el mínimo componente a componente de este y ``with``, equivalente a ``Vector4(minf(x, with), minf(y, with), minf(z, with), minf(w, with))``.
.. rst-class:: classref-item-separator
----
.. _class_Vector4_method_normalized:
.. rst-class:: classref-method
:ref:`Vector4<class_Vector4>` **normalized**\ (\ ) |const| :ref:`🔗<class_Vector4_method_normalized>`
Devuelve el resultado de escalar el vector a longitud unitaria. Equivalente a ``v / v.length()``. Devuelve ``(0, 0, 0, 0)`` si ``v.length() == 0``. Véase también :ref:`is_normalized()<class_Vector4_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_Vector4_method_posmod:
.. rst-class:: classref-method
:ref:`Vector4<class_Vector4>` **posmod**\ (\ mod\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector4_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_Vector4_method_posmodv:
.. rst-class:: classref-method
:ref:`Vector4<class_Vector4>` **posmodv**\ (\ modv\: :ref:`Vector4<class_Vector4>`\ ) |const| :ref:`🔗<class_Vector4_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_Vector4_method_round:
.. rst-class:: classref-method
:ref:`Vector4<class_Vector4>` **round**\ (\ ) |const| :ref:`🔗<class_Vector4_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_Vector4_method_sign:
.. rst-class:: classref-method
:ref:`Vector4<class_Vector4>` **sign**\ (\ ) |const| :ref:`🔗<class_Vector4_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_Vector4_method_snapped:
.. rst-class:: classref-method
:ref:`Vector4<class_Vector4>` **snapped**\ (\ step\: :ref:`Vector4<class_Vector4>`\ ) |const| :ref:`🔗<class_Vector4_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_Vector4_method_snappedf:
.. rst-class:: classref-method
:ref:`Vector4<class_Vector4>` **snappedf**\ (\ step\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Vector4_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_Vector4_operator_neq_Vector4:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator !=**\ (\ right\: :ref:`Vector4<class_Vector4>`\ ) :ref:`🔗<class_Vector4_operator_neq_Vector4>`
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_Vector4_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_Vector4_operator_mul_Projection:
.. rst-class:: classref-operator
:ref:`Vector4<class_Vector4>` **operator ***\ (\ right\: :ref:`Projection<class_Projection>`\ ) :ref:`🔗<class_Vector4_operator_mul_Projection>`
Transforma (multiplica) el **Vector4** por la transpuesta de la matriz :ref:`Projection<class_Projection>` dada.
Para transformar por la inversa de una proyección, se puede usar en su lugar ``projection.inverse() * vector``. Véase :ref:`Projection.inverse()<class_Projection_method_inverse>`.
.. rst-class:: classref-item-separator
----
.. _class_Vector4_operator_mul_Vector4:
.. rst-class:: classref-operator
:ref:`Vector4<class_Vector4>` **operator ***\ (\ right\: :ref:`Vector4<class_Vector4>`\ ) :ref:`🔗<class_Vector4_operator_mul_Vector4>`
Multiplica cada componente del **Vector4** por los componentes del **Vector4** dado.
::
print(Vector4(10, 20, 30, 40) * Vector4(3, 4, 5, 6)) # Imprime (30.0, 80.0, 150.0, 240.0)
.. rst-class:: classref-item-separator
----
.. _class_Vector4_operator_mul_float:
.. rst-class:: classref-operator
:ref:`Vector4<class_Vector4>` **operator ***\ (\ right\: :ref:`float<class_float>`\ ) :ref:`🔗<class_Vector4_operator_mul_float>`
Multiplica cada componente del **Vector4** por el :ref:`float<class_float>` dado.
::
print(Vector4(10, 20, 30, 40) * 2) # Imprime (20.0, 40.0, 60.0, 80.0)
.. rst-class:: classref-item-separator
----
.. _class_Vector4_operator_mul_int:
.. rst-class:: classref-operator
:ref:`Vector4<class_Vector4>` **operator ***\ (\ right\: :ref:`int<class_int>`\ ) :ref:`🔗<class_Vector4_operator_mul_int>`
Multiplica cada componente del **Vector4** por el :ref:`int<class_int>` dado.
.. rst-class:: classref-item-separator
----
.. _class_Vector4_operator_sum_Vector4:
.. rst-class:: classref-operator
:ref:`Vector4<class_Vector4>` **operator +**\ (\ right\: :ref:`Vector4<class_Vector4>`\ ) :ref:`🔗<class_Vector4_operator_sum_Vector4>`
Suma cada componente del **Vector4** con los componentes del **Vector4** dado.
::
print(Vector4(10, 20, 30, 40) + Vector4(3, 4, 5, 6)) # Imprime (13.0, 24.0, 35.0, 46.0)
.. rst-class:: classref-item-separator
----
.. _class_Vector4_operator_dif_Vector4:
.. rst-class:: classref-operator
:ref:`Vector4<class_Vector4>` **operator -**\ (\ right\: :ref:`Vector4<class_Vector4>`\ ) :ref:`🔗<class_Vector4_operator_dif_Vector4>`
Resta cada componente del **Vector4** por los componentes del **Vector4** dado.
::
print(Vector4(10, 20, 30, 40) - Vector4(3, 4, 5, 6)) # Imprime (7.0, 16.0, 25.0, 34.0)
.. rst-class:: classref-item-separator
----
.. _class_Vector4_operator_div_Vector4:
.. rst-class:: classref-operator
:ref:`Vector4<class_Vector4>` **operator /**\ (\ right\: :ref:`Vector4<class_Vector4>`\ ) :ref:`🔗<class_Vector4_operator_div_Vector4>`
Divide cada componente del **Vector4** por los componentes del **Vector4** dado.
::
print(Vector4(10, 20, 30, 40) / Vector4(2, 5, 3, 4)) # Imprime (5.0, 4.0, 10.0, 10.0)
.. rst-class:: classref-item-separator
----
.. _class_Vector4_operator_div_float:
.. rst-class:: classref-operator
:ref:`Vector4<class_Vector4>` **operator /**\ (\ right\: :ref:`float<class_float>`\ ) :ref:`🔗<class_Vector4_operator_div_float>`
Divide cada componente del **Vector4** por el :ref:`float<class_float>` dado.
::
print(Vector4(10, 20, 30, 40) / 2) # Imprime (5.0, 10.0, 15.0, 20.0)
.. rst-class:: classref-item-separator
----
.. _class_Vector4_operator_div_int:
.. rst-class:: classref-operator
:ref:`Vector4<class_Vector4>` **operator /**\ (\ right\: :ref:`int<class_int>`\ ) :ref:`🔗<class_Vector4_operator_div_int>`
Divide cada componente del **Vector4** por el :ref:`int<class_int>` dado.
.. rst-class:: classref-item-separator
----
.. _class_Vector4_operator_lt_Vector4:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator <**\ (\ right\: :ref:`Vector4<class_Vector4>`\ ) :ref:`🔗<class_Vector4_operator_lt_Vector4>`
Compara dos vectores **Vector4** comprobando primero si el valor X del vector izquierdo 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, los valores Z de los dos vectores, y luego con los valores W. 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 NaNs.
.. rst-class:: classref-item-separator
----
.. _class_Vector4_operator_lte_Vector4:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator <=**\ (\ right\: :ref:`Vector4<class_Vector4>`\ ) :ref:`🔗<class_Vector4_operator_lte_Vector4>`
Compara dos vectores **Vector4** comprobando primero si el valor X del vector izquierdo 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, los valores Z de los dos vectores, y luego con los valores W. 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 NaNs.
.. rst-class:: classref-item-separator
----
.. _class_Vector4_operator_eq_Vector4:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator ==**\ (\ right\: :ref:`Vector4<class_Vector4>`\ ) :ref:`🔗<class_Vector4_operator_eq_Vector4>`
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_Vector4_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_Vector4_operator_gt_Vector4:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator >**\ (\ right\: :ref:`Vector4<class_Vector4>`\ ) :ref:`🔗<class_Vector4_operator_gt_Vector4>`
Compara dos vectores **Vector4** comprobando primero si el valor X del vector izquierdo 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, los valores Z de los dos vectores, y luego con los valores W. 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 NaNs.
.. rst-class:: classref-item-separator
----
.. _class_Vector4_operator_gte_Vector4:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator >=**\ (\ right\: :ref:`Vector4<class_Vector4>`\ ) :ref:`🔗<class_Vector4_operator_gte_Vector4>`
Compara dos vectores **Vector4** comprobando primero si el valor X del vector izquierdo 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, los valores Z de los dos vectores, y luego con los valores W. 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 NaNs.
.. rst-class:: classref-item-separator
----
.. _class_Vector4_operator_idx_int:
.. rst-class:: classref-operator
:ref:`float<class_float>` **operator []**\ (\ index\: :ref:`int<class_int>`\ ) :ref:`🔗<class_Vector4_operator_idx_int>`
Accede a los componentes del vector usando su ``index``. ``v[0]`` es equivalente a ``v.x``, ``v[1]`` es equivalente a ``v.y``, ``v[2]`` es equivalente a ``v.z``, y ``v[3]`` es equivalente a ``v.w``.
.. rst-class:: classref-item-separator
----
.. _class_Vector4_operator_unplus:
.. rst-class:: classref-operator
:ref:`Vector4<class_Vector4>` **operator unary+**\ (\ ) :ref:`🔗<class_Vector4_operator_unplus>`
Devuelve el mismo valor como si el ``+`` no estuviera ahí. El ``+`` unario no hace nada, pero a veces puede hacer que tu código sea más legible.
.. rst-class:: classref-item-separator
----
.. _class_Vector4_operator_unminus:
.. rst-class:: classref-operator
:ref:`Vector4<class_Vector4>` **operator unary-**\ (\ ) :ref:`🔗<class_Vector4_operator_unminus>`
Devuelve el valor negativo del **Vector4**. Esto es lo mismo que escribir ``Vector4(-v.x, -v.y, -v.z, -v.w)``. Esta operación invierte la dirección del vector manteniendo la misma magnitud. Con los floats, el número cero puede ser tanto positivo como 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.)`
Reference in New Issue View Git Blame Copy Permalink