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

522 lines
24 KiB
ReStructuredText
Raw Permalink Blame History

:github_url: hide
.. _class_Plane:
Plane
=====
Un plano en forma normal de Hesse.
.. rst-class:: classref-introduction-group
Descripción
----------------------
Representa una ecuación de plano normalizada. :ref:`normal<class_Plane_property_normal>` es la normal del plano (a, b, c normalizados), y :ref:`d<class_Plane_property_d>` es la distancia desde el origen al plano (en la dirección de "normal"). Se considera "Sobre" o "Por encima" del plano el lado del plano hacia donde apunta la normal.
.. rst-class:: classref-introduction-group
Tutoriales
--------------------
- :doc:`Índice de documentación matemática <../tutorials/math/index>`
.. rst-class:: classref-reftable-group
Propiedades
----------------------
.. table::
:widths: auto
+-------------------------------+--------------------------------------------+----------------------+
| :ref:`float<class_float>` | :ref:`d<class_Plane_property_d>` | ``0.0`` |
+-------------------------------+--------------------------------------------+----------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`normal<class_Plane_property_normal>` | ``Vector3(0, 0, 0)`` |
+-------------------------------+--------------------------------------------+----------------------+
| :ref:`float<class_float>` | :ref:`x<class_Plane_property_x>` | ``0.0`` |
+-------------------------------+--------------------------------------------+----------------------+
| :ref:`float<class_float>` | :ref:`y<class_Plane_property_y>` | ``0.0`` |
+-------------------------------+--------------------------------------------+----------------------+
| :ref:`float<class_float>` | :ref:`z<class_Plane_property_z>` | ``0.0`` |
+-------------------------------+--------------------------------------------+----------------------+
.. rst-class:: classref-reftable-group
Constructores
--------------------------
.. table::
:widths: auto
+---------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Plane<class_Plane>` | :ref:`Plane<class_Plane_constructor_Plane>`\ (\ ) |
+---------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Plane<class_Plane>` | :ref:`Plane<class_Plane_constructor_Plane>`\ (\ from\: :ref:`Plane<class_Plane>`\ ) |
+---------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Plane<class_Plane>` | :ref:`Plane<class_Plane_constructor_Plane>`\ (\ a\: :ref:`float<class_float>`, b\: :ref:`float<class_float>`, c\: :ref:`float<class_float>`, d\: :ref:`float<class_float>`\ ) |
+---------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Plane<class_Plane>` | :ref:`Plane<class_Plane_constructor_Plane>`\ (\ normal\: :ref:`Vector3<class_Vector3>`\ ) |
+---------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Plane<class_Plane>` | :ref:`Plane<class_Plane_constructor_Plane>`\ (\ normal\: :ref:`Vector3<class_Vector3>`, d\: :ref:`float<class_float>`\ ) |
+---------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Plane<class_Plane>` | :ref:`Plane<class_Plane_constructor_Plane>`\ (\ normal\: :ref:`Vector3<class_Vector3>`, point\: :ref:`Vector3<class_Vector3>`\ ) |
+---------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Plane<class_Plane>` | :ref:`Plane<class_Plane_constructor_Plane>`\ (\ point1\: :ref:`Vector3<class_Vector3>`, point2\: :ref:`Vector3<class_Vector3>`, point3\: :ref:`Vector3<class_Vector3>`\ ) |
+---------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
.. rst-class:: classref-reftable-group
Métodos
--------------
.. table::
:widths: auto
+-------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`distance_to<class_Plane_method_distance_to>`\ (\ point\: :ref:`Vector3<class_Vector3>`\ ) |const| |
+-------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`get_center<class_Plane_method_get_center>`\ (\ ) |const| |
+-------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`has_point<class_Plane_method_has_point>`\ (\ point\: :ref:`Vector3<class_Vector3>`, tolerance\: :ref:`float<class_float>` = 1e-05\ ) |const| |
+-------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Variant<class_Variant>` | :ref:`intersect_3<class_Plane_method_intersect_3>`\ (\ b\: :ref:`Plane<class_Plane>`, c\: :ref:`Plane<class_Plane>`\ ) |const| |
+-------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Variant<class_Variant>` | :ref:`intersects_ray<class_Plane_method_intersects_ray>`\ (\ from\: :ref:`Vector3<class_Vector3>`, dir\: :ref:`Vector3<class_Vector3>`\ ) |const| |
+-------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Variant<class_Variant>` | :ref:`intersects_segment<class_Plane_method_intersects_segment>`\ (\ from\: :ref:`Vector3<class_Vector3>`, to\: :ref:`Vector3<class_Vector3>`\ ) |const| |
+-------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_equal_approx<class_Plane_method_is_equal_approx>`\ (\ to_plane\: :ref:`Plane<class_Plane>`\ ) |const| |
+-------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_finite<class_Plane_method_is_finite>`\ (\ ) |const| |
+-------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_point_over<class_Plane_method_is_point_over>`\ (\ point\: :ref:`Vector3<class_Vector3>`\ ) |const| |
+-------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Plane<class_Plane>` | :ref:`normalized<class_Plane_method_normalized>`\ (\ ) |const| |
+-------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`project<class_Plane_method_project>`\ (\ point\: :ref:`Vector3<class_Vector3>`\ ) |const| |
+-------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------+
.. rst-class:: classref-reftable-group
Operadores
--------------------
.. table::
:widths: auto
+---------------------------+--------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator !=<class_Plane_operator_neq_Plane>`\ (\ right\: :ref:`Plane<class_Plane>`\ ) |
+---------------------------+--------------------------------------------------------------------------------------------------------------+
| :ref:`Plane<class_Plane>` | :ref:`operator *<class_Plane_operator_mul_Transform3D>`\ (\ right\: :ref:`Transform3D<class_Transform3D>`\ ) |
+---------------------------+--------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator ==<class_Plane_operator_eq_Plane>`\ (\ right\: :ref:`Plane<class_Plane>`\ ) |
+---------------------------+--------------------------------------------------------------------------------------------------------------+
| :ref:`Plane<class_Plane>` | :ref:`operator unary+<class_Plane_operator_unplus>`\ (\ ) |
+---------------------------+--------------------------------------------------------------------------------------------------------------+
| :ref:`Plane<class_Plane>` | :ref:`operator unary-<class_Plane_operator_unminus>`\ (\ ) |
+---------------------------+--------------------------------------------------------------------------------------------------------------+
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Constantes
--------------------
.. _class_Plane_constant_PLANE_YZ:
.. rst-class:: classref-constant
**PLANE_YZ** = ``Plane(1, 0, 0, 0)`` :ref:`🔗<class_Plane_constant_PLANE_YZ>`
Un plano que se extiende en los ejes Y y Z (puntos de vector normal +X).
.. _class_Plane_constant_PLANE_XZ:
.. rst-class:: classref-constant
**PLANE_XZ** = ``Plane(0, 1, 0, 0)`` :ref:`🔗<class_Plane_constant_PLANE_XZ>`
Un plano que se extiende en los ejes X y Z (puntos de vector normal +Y).
.. _class_Plane_constant_PLANE_XY:
.. rst-class:: classref-constant
**PLANE_XY** = ``Plane(0, 0, 1, 0)`` :ref:`🔗<class_Plane_constant_PLANE_XY>`
Un plano que se extiende en los ejes X e Y (puntos de vector normal +Z).
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descripciones de Propiedades
--------------------------------------------------------
.. _class_Plane_property_d:
.. rst-class:: classref-property
:ref:`float<class_float>` **d** = ``0.0`` :ref:`🔗<class_Plane_property_d>`
La distancia desde el origen hasta el plano, expresada en términos de :ref:`normal<class_Plane_property_normal>` (según su dirección y magnitud). La distancia absoluta real desde el origen al plano se puede calcular como ``abs(d) / normal.length()`` (si :ref:`normal<class_Plane_property_normal>` tiene longitud cero, entonces este **Plane** no representa un plano válido).
En la ecuación escalar del plano ``ax + by + cz = d``, esto es ``d``, mientras que las coordenadas ``(a, b, c)`` están representadas por la propiedad :ref:`normal<class_Plane_property_normal>`.
.. rst-class:: classref-item-separator
----
.. _class_Plane_property_normal:
.. rst-class:: classref-property
:ref:`Vector3<class_Vector3>` **normal** = ``Vector3(0, 0, 0)`` :ref:`🔗<class_Plane_property_normal>`
La normal del plano, típicamente un vector unitario. No debería ser un vector cero, ya que un **Plane** con tal :ref:`normal<class_Plane_property_normal>` no representa un plano válido.
En la ecuación escalar del plano ``ax + by + cz = d``, este es el vector ``(a, b, c)``, donde ``d`` es la propiedad :ref:`d<class_Plane_property_d>`.
.. rst-class:: classref-item-separator
----
.. _class_Plane_property_x:
.. rst-class:: classref-property
:ref:`float<class_float>` **x** = ``0.0`` :ref:`🔗<class_Plane_property_x>`
El componente X del vector :ref:`normal<class_Plane_property_normal>` del plano.
.. rst-class:: classref-item-separator
----
.. _class_Plane_property_y:
.. rst-class:: classref-property
:ref:`float<class_float>` **y** = ``0.0`` :ref:`🔗<class_Plane_property_y>`
El componente Y del vector :ref:`normal<class_Plane_property_normal>` del plano.
.. rst-class:: classref-item-separator
----
.. _class_Plane_property_z:
.. rst-class:: classref-property
:ref:`float<class_float>` **z** = ``0.0`` :ref:`🔗<class_Plane_property_z>`
El componente Z del vector :ref:`normal<class_Plane_property_normal>` del plano.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descripciones de Constructores
------------------------------------------------------------
.. _class_Plane_constructor_Plane:
.. rst-class:: classref-constructor
:ref:`Plane<class_Plane>` **Plane**\ (\ ) :ref:`🔗<class_Plane_constructor_Plane>`
Construye un **Plane** inicializado por defecto con todos los componentes establecidos a ``0``.
.. rst-class:: classref-item-separator
----
.. rst-class:: classref-constructor
:ref:`Plane<class_Plane>` **Plane**\ (\ from\: :ref:`Plane<class_Plane>`\ )
Construye un **Plane** como una copia del **Plane** dado.
.. rst-class:: classref-item-separator
----
.. rst-class:: classref-constructor
:ref:`Plane<class_Plane>` **Plane**\ (\ a\: :ref:`float<class_float>`, b\: :ref:`float<class_float>`, c\: :ref:`float<class_float>`, d\: :ref:`float<class_float>`\ )
Crea un plano a partir de cuatro parámetros. Los tres componentes de la :ref:`normal<class_Plane_property_normal>` del plano resultante son ``a``, ``b`` y ``c``, y el plano tiene una distancia de ``d`` desde el origen.
.. rst-class:: classref-item-separator
----
.. rst-class:: classref-constructor
:ref:`Plane<class_Plane>` **Plane**\ (\ normal\: :ref:`Vector3<class_Vector3>`\ )
Crea un plano a partir del vector normal. El plano intersecará con el origen.
El ``normal`` del plano debe ser un vector unitario.
.. rst-class:: classref-item-separator
----
.. rst-class:: classref-constructor
:ref:`Plane<class_Plane>` **Plane**\ (\ normal\: :ref:`Vector3<class_Vector3>`, d\: :ref:`float<class_float>`\ )
Crea un plano a partir del vector normal y la distancia del plano al origen.
El ``normal`` del plano debe ser un vector unitario.
.. rst-class:: classref-item-separator
----
.. rst-class:: classref-constructor
:ref:`Plane<class_Plane>` **Plane**\ (\ normal\: :ref:`Vector3<class_Vector3>`, point\: :ref:`Vector3<class_Vector3>`\ )
Crea un plano a partir del vector normal y un punto en el plano.
El ``normal`` del plano debe ser un vector unitario.
.. rst-class:: classref-item-separator
----
.. rst-class:: classref-constructor
:ref:`Plane<class_Plane>` **Plane**\ (\ point1\: :ref:`Vector3<class_Vector3>`, point2\: :ref:`Vector3<class_Vector3>`, point3\: :ref:`Vector3<class_Vector3>`\ )
Crea un plano a partir de los tres puntos, dados en el sentido de las agujas del reloj.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descripciones de Métodos
------------------------------------------------
.. _class_Plane_method_distance_to:
.. rst-class:: classref-method
:ref:`float<class_float>` **distance_to**\ (\ point\: :ref:`Vector3<class_Vector3>`\ ) |const| :ref:`🔗<class_Plane_method_distance_to>`
Devuelve la distancia más corta desde el plano a la posición ``point``. Si el punto está por encima del plano, la distancia será positiva. Si está por debajo, la distancia será negativa.
.. rst-class:: classref-item-separator
----
.. _class_Plane_method_get_center:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **get_center**\ (\ ) |const| :ref:`🔗<class_Plane_method_get_center>`
Devuelve el centro del plano.
.. rst-class:: classref-item-separator
----
.. _class_Plane_method_has_point:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **has_point**\ (\ point\: :ref:`Vector3<class_Vector3>`, tolerance\: :ref:`float<class_float>` = 1e-05\ ) |const| :ref:`🔗<class_Plane_method_has_point>`
Devuelve ``true`` si ``point`` está dentro del plano. La comparación utiliza un umbral mínimo personalizado de ``tolerance``.
.. rst-class:: classref-item-separator
----
.. _class_Plane_method_intersect_3:
.. rst-class:: classref-method
:ref:`Variant<class_Variant>` **intersect_3**\ (\ b\: :ref:`Plane<class_Plane>`, c\: :ref:`Plane<class_Plane>`\ ) |const| :ref:`🔗<class_Plane_method_intersect_3>`
Devuelve el punto de intersección de los tres planos ``b``, ``c`` y este plano. Si no se encuentra ninguna intersección, se devuelve ``null``.
.. rst-class:: classref-item-separator
----
.. _class_Plane_method_intersects_ray:
.. rst-class:: classref-method
:ref:`Variant<class_Variant>` **intersects_ray**\ (\ from\: :ref:`Vector3<class_Vector3>`, dir\: :ref:`Vector3<class_Vector3>`\ ) |const| :ref:`🔗<class_Plane_method_intersects_ray>`
Devuelve el punto de intersección de un rayo que consiste en la posición ``from`` y la dirección normal ``dir`` con este plano. Si no se encuentra ninguna intersección, se devuelve ``null``.
.. rst-class:: classref-item-separator
----
.. _class_Plane_method_intersects_segment:
.. rst-class:: classref-method
:ref:`Variant<class_Variant>` **intersects_segment**\ (\ from\: :ref:`Vector3<class_Vector3>`, to\: :ref:`Vector3<class_Vector3>`\ ) |const| :ref:`🔗<class_Plane_method_intersects_segment>`
Devuelve el punto de intersección de un segmento desde la posición ``from`` hasta la posición ``to`` con este plano. Si no se encuentra ninguna intersección, se devuelve ``null``.
.. rst-class:: classref-item-separator
----
.. _class_Plane_method_is_equal_approx:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_equal_approx**\ (\ to_plane\: :ref:`Plane<class_Plane>`\ ) |const| :ref:`🔗<class_Plane_method_is_equal_approx>`
Devuelve ``true`` si este plano y ``to_plane`` son aproximadamente iguales, ejecutando :ref:`@GlobalScope.is_equal_approx()<class_@GlobalScope_method_is_equal_approx>` en cada componente.
.. rst-class:: classref-item-separator
----
.. _class_Plane_method_is_finite:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_finite**\ (\ ) |const| :ref:`🔗<class_Plane_method_is_finite>`
Devuelve ``true`` si este plano es finito, llamando a :ref:`@GlobalScope.is_finite()<class_@GlobalScope_method_is_finite>` en cada componente.
.. rst-class:: classref-item-separator
----
.. _class_Plane_method_is_point_over:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_point_over**\ (\ point\: :ref:`Vector3<class_Vector3>`\ ) |const| :ref:`🔗<class_Plane_method_is_point_over>`
Devuelve ``true`` si ``point`` se encuentra por encima del plano.
.. rst-class:: classref-item-separator
----
.. _class_Plane_method_normalized:
.. rst-class:: classref-method
:ref:`Plane<class_Plane>` **normalized**\ (\ ) |const| :ref:`🔗<class_Plane_method_normalized>`
Devuelve una copia del plano, con :ref:`normal<class_Plane_property_normal>` normalizado (por lo que es un vector unitario). Devuelve ``Plane(0, 0, 0, 0)`` si :ref:`normal<class_Plane_property_normal>` no se puede normalizar (tiene longitud cero).
.. rst-class:: classref-item-separator
----
.. _class_Plane_method_project:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **project**\ (\ point\: :ref:`Vector3<class_Vector3>`\ ) |const| :ref:`🔗<class_Plane_method_project>`
Devuelve la proyección ortogonal de ``point`` en un punto del plano.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descripciones de Operadores
------------------------------------------------------
.. _class_Plane_operator_neq_Plane:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator !=**\ (\ right\: :ref:`Plane<class_Plane>`\ ) :ref:`🔗<class_Plane_operator_neq_Plane>`
Returns ``true`` if the planes are not equal.
\ **Note:** Due to floating-point precision errors, consider using :ref:`is_equal_approx()<class_Plane_method_is_equal_approx>` instead, which is more reliable.
.. rst-class:: classref-item-separator
----
.. _class_Plane_operator_mul_Transform3D:
.. rst-class:: classref-operator
:ref:`Plane<class_Plane>` **operator ***\ (\ right\: :ref:`Transform3D<class_Transform3D>`\ ) :ref:`🔗<class_Plane_operator_mul_Transform3D>`
Transforma inversamente (multiplica) el **Plane** por la matriz de transformación :ref:`Transform3D<class_Transform3D>` dada.
\ ``plane * transform`` es equivalente a ``transform.affine_inverse() * plane``. Véase :ref:`Transform3D.affine_inverse()<class_Transform3D_method_affine_inverse>`.
.. rst-class:: classref-item-separator
----
.. _class_Plane_operator_eq_Plane:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator ==**\ (\ right\: :ref:`Plane<class_Plane>`\ ) :ref:`🔗<class_Plane_operator_eq_Plane>`
Returns ``true`` if the planes are exactly equal.
\ **Note:** Due to floating-point precision errors, consider using :ref:`is_equal_approx()<class_Plane_method_is_equal_approx>` instead, which is more reliable.
.. rst-class:: classref-item-separator
----
.. _class_Plane_operator_unplus:
.. rst-class:: classref-operator
:ref:`Plane<class_Plane>` **operator unary+**\ (\ ) :ref:`🔗<class_Plane_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_Plane_operator_unminus:
.. rst-class:: classref-operator
:ref:`Plane<class_Plane>` **operator unary-**\ (\ ) :ref:`🔗<class_Plane_operator_unminus>`
Devuelve el valor negativo del **Plane**. Esto es lo mismo que escribir ``Plane(-p.normal, -p.d)``. Esta operación invierte la dirección del vector normal y también invierte el valor de la distancia, lo que da como resultado un Plano que está en el mismo lugar, pero mirando en la dirección opuesta.
.. |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