mirror of
https://github.com/godotengine/godot-docs-l10n.git
synced 2026-01-04 10:09:56 +03:00
592 lines
44 KiB
ReStructuredText
592 lines
44 KiB
ReStructuredText
:github_url: hide
|
|
|
|
.. _class_Geometry2D:
|
|
|
|
Geometry2D
|
|
==========
|
|
|
|
**Hereda:** :ref:`Object<class_Object>`
|
|
|
|
Proporciona métodos para algunas operaciones geométricas 2D comunes.
|
|
|
|
.. rst-class:: classref-introduction-group
|
|
|
|
Descripción
|
|
----------------------
|
|
|
|
Proporciona un conjunto de funciones de ayuda para crear formas geométricas, calcular intersecciones entre formas y procesar varias otras operaciones geométricas en 2D.
|
|
|
|
.. rst-class:: classref-reftable-group
|
|
|
|
Métodos
|
|
--------------
|
|
|
|
.. table::
|
|
:widths: auto
|
|
|
|
+----------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`Array<class_Array>`\[:ref:`Vector2i<class_Vector2i>`\] | :ref:`bresenham_line<class_Geometry2D_method_bresenham_line>`\ (\ from\: :ref:`Vector2i<class_Vector2i>`, to\: :ref:`Vector2i<class_Vector2i>`\ ) |
|
|
+----------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`Array<class_Array>`\[:ref:`PackedVector2Array<class_PackedVector2Array>`\] | :ref:`clip_polygons<class_Geometry2D_method_clip_polygons>`\ (\ polygon_a\: :ref:`PackedVector2Array<class_PackedVector2Array>`, polygon_b\: :ref:`PackedVector2Array<class_PackedVector2Array>`\ ) |
|
|
+----------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`Array<class_Array>`\[:ref:`PackedVector2Array<class_PackedVector2Array>`\] | :ref:`clip_polyline_with_polygon<class_Geometry2D_method_clip_polyline_with_polygon>`\ (\ polyline\: :ref:`PackedVector2Array<class_PackedVector2Array>`, polygon\: :ref:`PackedVector2Array<class_PackedVector2Array>`\ ) |
|
|
+----------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`PackedVector2Array<class_PackedVector2Array>` | :ref:`convex_hull<class_Geometry2D_method_convex_hull>`\ (\ points\: :ref:`PackedVector2Array<class_PackedVector2Array>`\ ) |
|
|
+----------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`Array<class_Array>`\[:ref:`PackedVector2Array<class_PackedVector2Array>`\] | :ref:`decompose_polygon_in_convex<class_Geometry2D_method_decompose_polygon_in_convex>`\ (\ polygon\: :ref:`PackedVector2Array<class_PackedVector2Array>`\ ) |
|
|
+----------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`Array<class_Array>`\[:ref:`PackedVector2Array<class_PackedVector2Array>`\] | :ref:`exclude_polygons<class_Geometry2D_method_exclude_polygons>`\ (\ polygon_a\: :ref:`PackedVector2Array<class_PackedVector2Array>`, polygon_b\: :ref:`PackedVector2Array<class_PackedVector2Array>`\ ) |
|
|
+----------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`Vector2<class_Vector2>` | :ref:`get_closest_point_to_segment<class_Geometry2D_method_get_closest_point_to_segment>`\ (\ point\: :ref:`Vector2<class_Vector2>`, s1\: :ref:`Vector2<class_Vector2>`, s2\: :ref:`Vector2<class_Vector2>`\ ) |
|
|
+----------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`Vector2<class_Vector2>` | :ref:`get_closest_point_to_segment_uncapped<class_Geometry2D_method_get_closest_point_to_segment_uncapped>`\ (\ point\: :ref:`Vector2<class_Vector2>`, s1\: :ref:`Vector2<class_Vector2>`, s2\: :ref:`Vector2<class_Vector2>`\ ) |
|
|
+----------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`PackedVector2Array<class_PackedVector2Array>` | :ref:`get_closest_points_between_segments<class_Geometry2D_method_get_closest_points_between_segments>`\ (\ p1\: :ref:`Vector2<class_Vector2>`, q1\: :ref:`Vector2<class_Vector2>`, p2\: :ref:`Vector2<class_Vector2>`, q2\: :ref:`Vector2<class_Vector2>`\ ) |
|
|
+----------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`Array<class_Array>`\[:ref:`PackedVector2Array<class_PackedVector2Array>`\] | :ref:`intersect_polygons<class_Geometry2D_method_intersect_polygons>`\ (\ polygon_a\: :ref:`PackedVector2Array<class_PackedVector2Array>`, polygon_b\: :ref:`PackedVector2Array<class_PackedVector2Array>`\ ) |
|
|
+----------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`Array<class_Array>`\[:ref:`PackedVector2Array<class_PackedVector2Array>`\] | :ref:`intersect_polyline_with_polygon<class_Geometry2D_method_intersect_polyline_with_polygon>`\ (\ polyline\: :ref:`PackedVector2Array<class_PackedVector2Array>`, polygon\: :ref:`PackedVector2Array<class_PackedVector2Array>`\ ) |
|
|
+----------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`bool<class_bool>` | :ref:`is_point_in_circle<class_Geometry2D_method_is_point_in_circle>`\ (\ point\: :ref:`Vector2<class_Vector2>`, circle_position\: :ref:`Vector2<class_Vector2>`, circle_radius\: :ref:`float<class_float>`\ ) |
|
|
+----------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`bool<class_bool>` | :ref:`is_point_in_polygon<class_Geometry2D_method_is_point_in_polygon>`\ (\ point\: :ref:`Vector2<class_Vector2>`, polygon\: :ref:`PackedVector2Array<class_PackedVector2Array>`\ ) |
|
|
+----------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`bool<class_bool>` | :ref:`is_polygon_clockwise<class_Geometry2D_method_is_polygon_clockwise>`\ (\ polygon\: :ref:`PackedVector2Array<class_PackedVector2Array>`\ ) |
|
|
+----------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`Variant<class_Variant>` | :ref:`line_intersects_line<class_Geometry2D_method_line_intersects_line>`\ (\ from_a\: :ref:`Vector2<class_Vector2>`, dir_a\: :ref:`Vector2<class_Vector2>`, from_b\: :ref:`Vector2<class_Vector2>`, dir_b\: :ref:`Vector2<class_Vector2>`\ ) |
|
|
+----------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`Dictionary<class_Dictionary>` | :ref:`make_atlas<class_Geometry2D_method_make_atlas>`\ (\ sizes\: :ref:`PackedVector2Array<class_PackedVector2Array>`\ ) |
|
|
+----------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`Array<class_Array>`\[:ref:`PackedVector2Array<class_PackedVector2Array>`\] | :ref:`merge_polygons<class_Geometry2D_method_merge_polygons>`\ (\ polygon_a\: :ref:`PackedVector2Array<class_PackedVector2Array>`, polygon_b\: :ref:`PackedVector2Array<class_PackedVector2Array>`\ ) |
|
|
+----------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`Array<class_Array>`\[:ref:`PackedVector2Array<class_PackedVector2Array>`\] | :ref:`offset_polygon<class_Geometry2D_method_offset_polygon>`\ (\ polygon\: :ref:`PackedVector2Array<class_PackedVector2Array>`, delta\: :ref:`float<class_float>`, join_type\: :ref:`PolyJoinType<enum_Geometry2D_PolyJoinType>` = 0\ ) |
|
|
+----------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`Array<class_Array>`\[:ref:`PackedVector2Array<class_PackedVector2Array>`\] | :ref:`offset_polyline<class_Geometry2D_method_offset_polyline>`\ (\ polyline\: :ref:`PackedVector2Array<class_PackedVector2Array>`, delta\: :ref:`float<class_float>`, join_type\: :ref:`PolyJoinType<enum_Geometry2D_PolyJoinType>` = 0, end_type\: :ref:`PolyEndType<enum_Geometry2D_PolyEndType>` = 3\ ) |
|
|
+----------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`bool<class_bool>` | :ref:`point_is_inside_triangle<class_Geometry2D_method_point_is_inside_triangle>`\ (\ point\: :ref:`Vector2<class_Vector2>`, a\: :ref:`Vector2<class_Vector2>`, b\: :ref:`Vector2<class_Vector2>`, c\: :ref:`Vector2<class_Vector2>`\ ) |const| |
|
|
+----------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`float<class_float>` | :ref:`segment_intersects_circle<class_Geometry2D_method_segment_intersects_circle>`\ (\ segment_from\: :ref:`Vector2<class_Vector2>`, segment_to\: :ref:`Vector2<class_Vector2>`, circle_position\: :ref:`Vector2<class_Vector2>`, circle_radius\: :ref:`float<class_float>`\ ) |
|
|
+----------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`Variant<class_Variant>` | :ref:`segment_intersects_segment<class_Geometry2D_method_segment_intersects_segment>`\ (\ from_a\: :ref:`Vector2<class_Vector2>`, to_a\: :ref:`Vector2<class_Vector2>`, from_b\: :ref:`Vector2<class_Vector2>`, to_b\: :ref:`Vector2<class_Vector2>`\ ) |
|
|
+----------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`PackedInt32Array<class_PackedInt32Array>` | :ref:`triangulate_delaunay<class_Geometry2D_method_triangulate_delaunay>`\ (\ points\: :ref:`PackedVector2Array<class_PackedVector2Array>`\ ) |
|
|
+----------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`PackedInt32Array<class_PackedInt32Array>` | :ref:`triangulate_polygon<class_Geometry2D_method_triangulate_polygon>`\ (\ polygon\: :ref:`PackedVector2Array<class_PackedVector2Array>`\ ) |
|
|
+----------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
|
|
|
.. rst-class:: classref-section-separator
|
|
|
|
----
|
|
|
|
.. rst-class:: classref-descriptions-group
|
|
|
|
Enumeraciones
|
|
--------------------------
|
|
|
|
.. _enum_Geometry2D_PolyBooleanOperation:
|
|
|
|
.. rst-class:: classref-enumeration
|
|
|
|
enum **PolyBooleanOperation**: :ref:`🔗<enum_Geometry2D_PolyBooleanOperation>`
|
|
|
|
.. _class_Geometry2D_constant_OPERATION_UNION:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`PolyBooleanOperation<enum_Geometry2D_PolyBooleanOperation>` **OPERATION_UNION** = ``0``
|
|
|
|
Crear regiones en las que se llenen los polígonos del sujeto o del recorte (o ambos).
|
|
|
|
.. _class_Geometry2D_constant_OPERATION_DIFFERENCE:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`PolyBooleanOperation<enum_Geometry2D_PolyBooleanOperation>` **OPERATION_DIFFERENCE** = ``1``
|
|
|
|
Crea regiones en las que se rellenen los polígonos del sujeto, excepto cuando se rellenen los polígonos de clips.
|
|
|
|
.. _class_Geometry2D_constant_OPERATION_INTERSECTION:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`PolyBooleanOperation<enum_Geometry2D_PolyBooleanOperation>` **OPERATION_INTERSECTION** = ``2``
|
|
|
|
Crea regiones en las que se llenen tanto los polígonos del sujeto como los del recorte.
|
|
|
|
.. _class_Geometry2D_constant_OPERATION_XOR:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`PolyBooleanOperation<enum_Geometry2D_PolyBooleanOperation>` **OPERATION_XOR** = ``3``
|
|
|
|
Crea regiones en las que se llenen los polígonos del sujeto o del recorte pero no en las que se llenen ambos.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _enum_Geometry2D_PolyJoinType:
|
|
|
|
.. rst-class:: classref-enumeration
|
|
|
|
enum **PolyJoinType**: :ref:`🔗<enum_Geometry2D_PolyJoinType>`
|
|
|
|
.. _class_Geometry2D_constant_JOIN_SQUARE:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`PolyJoinType<enum_Geometry2D_PolyJoinType>` **JOIN_SQUARE** = ``0``
|
|
|
|
La cuadratura se aplica uniformemente en todas las uniones de bordes convexos en ``1 * delta``.
|
|
|
|
.. _class_Geometry2D_constant_JOIN_ROUND:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`PolyJoinType<enum_Geometry2D_PolyJoinType>` **JOIN_ROUND** = ``1``
|
|
|
|
Mientras que los caminos aplanados nunca pueden trazar perfectamente un arco, son aproximados por una serie de acordes de arco.
|
|
|
|
.. _class_Geometry2D_constant_JOIN_MITER:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`PolyJoinType<enum_Geometry2D_PolyJoinType>` **JOIN_MITER** = ``2``
|
|
|
|
Hay un límite necesario para las uniones a inglete, ya que los bordes desplazados que se unen en ángulos muy agudos producirán "picos" excesivamente largos y estrechos. Para cualquier unión de borde, cuando la compensación de inglete exceda esa distancia máxima, se aplica la unión "cuadrada".
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _enum_Geometry2D_PolyEndType:
|
|
|
|
.. rst-class:: classref-enumeration
|
|
|
|
enum **PolyEndType**: :ref:`🔗<enum_Geometry2D_PolyEndType>`
|
|
|
|
.. _class_Geometry2D_constant_END_POLYGON:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`PolyEndType<enum_Geometry2D_PolyEndType>` **END_POLYGON** = ``0``
|
|
|
|
Los puntos finales se unen usando el valor :ref:`PolyJoinType<enum_Geometry2D_PolyJoinType>` y el camino llenado como un polígono.
|
|
|
|
.. _class_Geometry2D_constant_END_JOINED:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`PolyEndType<enum_Geometry2D_PolyEndType>` **END_JOINED** = ``1``
|
|
|
|
Los puntos finales se unen usando el valor :ref:`PolyJoinType<enum_Geometry2D_PolyJoinType>` y el camino llenado como una polilínea.
|
|
|
|
.. _class_Geometry2D_constant_END_BUTT:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`PolyEndType<enum_Geometry2D_PolyEndType>` **END_BUTT** = ``2``
|
|
|
|
Los puntos finales son cuadrados sin extensión.
|
|
|
|
.. _class_Geometry2D_constant_END_SQUARE:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`PolyEndType<enum_Geometry2D_PolyEndType>` **END_SQUARE** = ``3``
|
|
|
|
Los puntos finales se cuadran y se amplían con unidades ``delta``.
|
|
|
|
.. _class_Geometry2D_constant_END_ROUND:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`PolyEndType<enum_Geometry2D_PolyEndType>` **END_ROUND** = ``4``
|
|
|
|
Los puntos finales se redondean y se amplían con unidades ``delta``.
|
|
|
|
.. rst-class:: classref-section-separator
|
|
|
|
----
|
|
|
|
.. rst-class:: classref-descriptions-group
|
|
|
|
Descripciones de Métodos
|
|
------------------------------------------------
|
|
|
|
.. _class_Geometry2D_method_bresenham_line:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`Array<class_Array>`\[:ref:`Vector2i<class_Vector2i>`\] **bresenham_line**\ (\ from\: :ref:`Vector2i<class_Vector2i>`, to\: :ref:`Vector2i<class_Vector2i>`\ ) :ref:`🔗<class_Geometry2D_method_bresenham_line>`
|
|
|
|
Devuelve la `línea de Bresenham <https://en.wikipedia.org/wiki/Bresenham%27s_line_algorithm>`__ entre los puntos ``from`` y ``to``. Una línea de Bresenham es una serie de píxeles que dibuja una línea y siempre tiene 1 píxel de grosor en cada fila y columna del dibujo (nunca más, nunca menos).
|
|
|
|
Código de ejemplo para dibujar una línea entre dos nodos :ref:`Marker2D<class_Marker2D>` usando una serie de llamadas a :ref:`CanvasItem.draw_rect()<class_CanvasItem_method_draw_rect>`:
|
|
|
|
::
|
|
|
|
func _draw():
|
|
for pixel in Geometry2D.bresenham_line($MarkerA.position, $MarkerB.position):
|
|
draw_rect(Rect2(pixel, Vector2.ONE), Color.WHITE)
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_Geometry2D_method_clip_polygons:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`Array<class_Array>`\[:ref:`PackedVector2Array<class_PackedVector2Array>`\] **clip_polygons**\ (\ polygon_a\: :ref:`PackedVector2Array<class_PackedVector2Array>`, polygon_b\: :ref:`PackedVector2Array<class_PackedVector2Array>`\ ) :ref:`🔗<class_Geometry2D_method_clip_polygons>`
|
|
|
|
Recorta ``polygon_a`` contra ``polygon_b`` y devuelve un array de polígonos recortados. Esto realiza :ref:`OPERATION_DIFFERENCE<class_Geometry2D_constant_OPERATION_DIFFERENCE>` entre los polígonos. Devuelve un array vacío si ``polygon_b`` se superpone completamente a ``polygon_a``.
|
|
|
|
Si ``polygon_b`` está encerrado por ``polygon_a``, devuelve un polígono exterior (límite) y un polígono interior (agujero) que se pueden distinguir llamando a :ref:`is_polygon_clockwise()<class_Geometry2D_method_is_polygon_clockwise>`.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_Geometry2D_method_clip_polyline_with_polygon:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`Array<class_Array>`\[:ref:`PackedVector2Array<class_PackedVector2Array>`\] **clip_polyline_with_polygon**\ (\ polyline\: :ref:`PackedVector2Array<class_PackedVector2Array>`, polygon\: :ref:`PackedVector2Array<class_PackedVector2Array>`\ ) :ref:`🔗<class_Geometry2D_method_clip_polyline_with_polygon>`
|
|
|
|
Recorta ``polyline`` contra ``polygon`` y devuelve un array de polilíneas recortadas. Esto realiza :ref:`OPERATION_DIFFERENCE<class_Geometry2D_constant_OPERATION_DIFFERENCE>` entre la polilínea y el polígono. Esta operación se puede considerar como cortar una línea con una forma cerrada.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_Geometry2D_method_convex_hull:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`PackedVector2Array<class_PackedVector2Array>` **convex_hull**\ (\ points\: :ref:`PackedVector2Array<class_PackedVector2Array>`\ ) :ref:`🔗<class_Geometry2D_method_convex_hull>`
|
|
|
|
Dado un conjunto de :ref:`Vector2<class_Vector2>`, devuelve el casco convexo como una lista de puntos en orden antihorario. El último punto es el mismo que el primero.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_Geometry2D_method_decompose_polygon_in_convex:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`Array<class_Array>`\[:ref:`PackedVector2Array<class_PackedVector2Array>`\] **decompose_polygon_in_convex**\ (\ polygon\: :ref:`PackedVector2Array<class_PackedVector2Array>`\ ) :ref:`🔗<class_Geometry2D_method_decompose_polygon_in_convex>`
|
|
|
|
Descompone el ``polygon`` en múltiples envolventes convexas y devuelve un array de :ref:`PackedVector2Array<class_PackedVector2Array>`.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_Geometry2D_method_exclude_polygons:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`Array<class_Array>`\[:ref:`PackedVector2Array<class_PackedVector2Array>`\] **exclude_polygons**\ (\ polygon_a\: :ref:`PackedVector2Array<class_PackedVector2Array>`, polygon_b\: :ref:`PackedVector2Array<class_PackedVector2Array>`\ ) :ref:`🔗<class_Geometry2D_method_exclude_polygons>`
|
|
|
|
Excluye mutuamente el área común definida por la intersección de ``polygon_a`` y ``polygon_b`` (véase :ref:`intersect_polygons()<class_Geometry2D_method_intersect_polygons>`) y devuelve un array de polígonos excluidos. Esto realiza :ref:`OPERATION_XOR<class_Geometry2D_constant_OPERATION_XOR>` entre polígonos. En otras palabras, devuelve todo excepto el área común entre los polígonos.
|
|
|
|
La operación puede dar como resultado un polígono exterior (límite) y un polígono interior (agujero) producidos que pueden distinguirse llamando a :ref:`is_polygon_clockwise()<class_Geometry2D_method_is_polygon_clockwise>`.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_Geometry2D_method_get_closest_point_to_segment:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`Vector2<class_Vector2>` **get_closest_point_to_segment**\ (\ point\: :ref:`Vector2<class_Vector2>`, s1\: :ref:`Vector2<class_Vector2>`, s2\: :ref:`Vector2<class_Vector2>`\ ) :ref:`🔗<class_Geometry2D_method_get_closest_point_to_segment>`
|
|
|
|
Devuelve el punto 2D en el segmento 2D (``s1``, ``s2``) que está más cerca de ``point``. El punto devuelto siempre estará dentro del segmento especificado.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_Geometry2D_method_get_closest_point_to_segment_uncapped:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`Vector2<class_Vector2>` **get_closest_point_to_segment_uncapped**\ (\ point\: :ref:`Vector2<class_Vector2>`, s1\: :ref:`Vector2<class_Vector2>`, s2\: :ref:`Vector2<class_Vector2>`\ ) :ref:`🔗<class_Geometry2D_method_get_closest_point_to_segment_uncapped>`
|
|
|
|
Devuelve el punto 2D en la línea 2D definida por (``s1``, ``s2``) que está más cerca de ``point``. El punto devuelto puede estar dentro del segmento (``s1``, ``s2``) o fuera de él, es decir, en algún lugar de la línea que se extiende desde el segmento.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_Geometry2D_method_get_closest_points_between_segments:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`PackedVector2Array<class_PackedVector2Array>` **get_closest_points_between_segments**\ (\ p1\: :ref:`Vector2<class_Vector2>`, q1\: :ref:`Vector2<class_Vector2>`, p2\: :ref:`Vector2<class_Vector2>`, q2\: :ref:`Vector2<class_Vector2>`\ ) :ref:`🔗<class_Geometry2D_method_get_closest_points_between_segments>`
|
|
|
|
Dados los dos segmentos 2D (``p1``, ``q1``) y (``p2``, ``q2``), encuentra esos dos puntos en los dos segmentos que están más cerca uno del otro. Devuelve un :ref:`PackedVector2Array<class_PackedVector2Array>` que contiene este punto en (``p1``, ``q1``) así como el punto acompañante en (``p2``, ``q2``).
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_Geometry2D_method_intersect_polygons:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`Array<class_Array>`\[:ref:`PackedVector2Array<class_PackedVector2Array>`\] **intersect_polygons**\ (\ polygon_a\: :ref:`PackedVector2Array<class_PackedVector2Array>`, polygon_b\: :ref:`PackedVector2Array<class_PackedVector2Array>`\ ) :ref:`🔗<class_Geometry2D_method_intersect_polygons>`
|
|
|
|
Interseca ``polygon_a`` con ``polygon_b`` y devuelve un array de polígonos intersecados. Esto realiza :ref:`OPERATION_INTERSECTION<class_Geometry2D_constant_OPERATION_INTERSECTION>` entre los polígonos. En otras palabras, devuelve el área común compartida por los polígonos. Devuelve un array vacío si no se produce ninguna intersección.
|
|
|
|
La operación puede dar como resultado un polígono exterior (límite) y un polígono interior (agujero) producidos que se podrían distinguir llamando a :ref:`is_polygon_clockwise()<class_Geometry2D_method_is_polygon_clockwise>`.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_Geometry2D_method_intersect_polyline_with_polygon:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`Array<class_Array>`\[:ref:`PackedVector2Array<class_PackedVector2Array>`\] **intersect_polyline_with_polygon**\ (\ polyline\: :ref:`PackedVector2Array<class_PackedVector2Array>`, polygon\: :ref:`PackedVector2Array<class_PackedVector2Array>`\ ) :ref:`🔗<class_Geometry2D_method_intersect_polyline_with_polygon>`
|
|
|
|
Interseca ``polyline`` con ``polygon`` y devuelve un array de polilíneas intersecadas. Esto realiza :ref:`OPERATION_INTERSECTION<class_Geometry2D_constant_OPERATION_INTERSECTION>` entre la polilínea y el polígono. Esta operación puede ser pensada como cortar una línea con una forma cerrada.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_Geometry2D_method_is_point_in_circle:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`bool<class_bool>` **is_point_in_circle**\ (\ point\: :ref:`Vector2<class_Vector2>`, circle_position\: :ref:`Vector2<class_Vector2>`, circle_radius\: :ref:`float<class_float>`\ ) :ref:`🔗<class_Geometry2D_method_is_point_in_circle>`
|
|
|
|
Devuelve ``true`` si ``point`` está dentro del círculo o si está situado exactamente *en* el límite del círculo; de lo contrario, devuelve ``false``.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_Geometry2D_method_is_point_in_polygon:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`bool<class_bool>` **is_point_in_polygon**\ (\ point\: :ref:`Vector2<class_Vector2>`, polygon\: :ref:`PackedVector2Array<class_PackedVector2Array>`\ ) :ref:`🔗<class_Geometry2D_method_is_point_in_polygon>`
|
|
|
|
Devuelve ``true`` si ``point`` está dentro de ``polygon`` o si está situado exactamente *en* el límite del polígono; de lo contrario, devuelve ``false``.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_Geometry2D_method_is_polygon_clockwise:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`bool<class_bool>` **is_polygon_clockwise**\ (\ polygon\: :ref:`PackedVector2Array<class_PackedVector2Array>`\ ) :ref:`🔗<class_Geometry2D_method_is_polygon_clockwise>`
|
|
|
|
Devuelve ``true`` si los vértices de ``polygon`` están ordenados en el sentido de las agujas del reloj, de lo contrario devuelve ``false``.
|
|
|
|
\ **Nota:** Asume un sistema de coordenadas cartesianas donde ``+x`` está a la derecha y ``+y`` está arriba. Si usas coordenadas de pantalla (``+y`` está abajo), el resultado tendrá que ser invertido (es decir, un resultado ``true`` indicará el sentido contrario a las agujas del reloj).
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_Geometry2D_method_line_intersects_line:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`Variant<class_Variant>` **line_intersects_line**\ (\ from_a\: :ref:`Vector2<class_Vector2>`, dir_a\: :ref:`Vector2<class_Vector2>`, from_b\: :ref:`Vector2<class_Vector2>`, dir_b\: :ref:`Vector2<class_Vector2>`\ ) :ref:`🔗<class_Geometry2D_method_line_intersects_line>`
|
|
|
|
Devuelve el punto de intersección entre las dos líneas (``from_a``, ``dir_a``) y (``from_b``, ``dir_b``). Devuelve un :ref:`Vector2<class_Vector2>`, o ``null`` si las líneas son paralelas.
|
|
|
|
\ ``from`` y ``dir`` *no* son puntos finales de un segmento de línea o rayo, sino la pendiente (``dir``) y un punto conocido (``from``) en esa línea.
|
|
|
|
|
|
.. tabs::
|
|
|
|
.. code-tab:: gdscript
|
|
|
|
var from_a = Vector2.ZERO
|
|
var dir_a = Vector2.RIGHT
|
|
var from_b = Vector2.DOWN
|
|
|
|
# Devuelve Vector2(1, 0)
|
|
Geometry2D.line_intersects_line(from_a, dir_a, from_b, Vector2(1, -1))
|
|
# Devuelve Vector2(-1, 0)
|
|
Geometry2D.line_intersects_line(from_a, dir_a, from_b, Vector2(-1, -1))
|
|
# Devuelve null
|
|
Geometry2D.line_intersects_line(from_a, dir_a, from_b, Vector2.RIGHT)
|
|
|
|
.. code-tab:: csharp
|
|
|
|
var fromA = Vector2.Zero;
|
|
var dirA = Vector2.Right;
|
|
var fromB = Vector2.Down;
|
|
|
|
// Devuelve new Vector2(1, 0)
|
|
Geometry2D.LineIntersectsLine(fromA, dirA, fromB, new Vector2(1, -1));
|
|
// Devuelve new Vector2(-1, 0)
|
|
Geometry2D.LineIntersectsLine(fromA, dirA, fromB, new Vector2(-1, -1));
|
|
// Devuelve null
|
|
Geometry2D.LineIntersectsLine(fromA, dirA, fromB, Vector2.Right);
|
|
|
|
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_Geometry2D_method_make_atlas:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`Dictionary<class_Dictionary>` **make_atlas**\ (\ sizes\: :ref:`PackedVector2Array<class_PackedVector2Array>`\ ) :ref:`🔗<class_Geometry2D_method_make_atlas>`
|
|
|
|
Dado un array de :ref:`Vector2<class_Vector2>`\ s que representan tiles, construye un atlas. El diccionario devuelto tiene dos claves: ``points`` es un :ref:`PackedVector2Array<class_PackedVector2Array>` que especifica las posiciones de cada tile, ``size`` contiene el tamaño total del atlas como :ref:`Vector2i<class_Vector2i>`.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_Geometry2D_method_merge_polygons:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`Array<class_Array>`\[:ref:`PackedVector2Array<class_PackedVector2Array>`\] **merge_polygons**\ (\ polygon_a\: :ref:`PackedVector2Array<class_PackedVector2Array>`, polygon_b\: :ref:`PackedVector2Array<class_PackedVector2Array>`\ ) :ref:`🔗<class_Geometry2D_method_merge_polygons>`
|
|
|
|
Fusiona (combina) ``polygon_a`` y ``polygon_b`` y devuelve un array de polígonos fusionados. Esto realiza :ref:`OPERATION_UNION<class_Geometry2D_constant_OPERATION_UNION>` entre los polígonos.
|
|
|
|
La operación puede dar como resultado un polígono exterior (límite) y múltiples polígonos interiores (agujeros) producidos que podrían distinguirse llamando a :ref:`is_polygon_clockwise()<class_Geometry2D_method_is_polygon_clockwise>`.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_Geometry2D_method_offset_polygon:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`Array<class_Array>`\[:ref:`PackedVector2Array<class_PackedVector2Array>`\] **offset_polygon**\ (\ polygon\: :ref:`PackedVector2Array<class_PackedVector2Array>`, delta\: :ref:`float<class_float>`, join_type\: :ref:`PolyJoinType<enum_Geometry2D_PolyJoinType>` = 0\ ) :ref:`🔗<class_Geometry2D_method_offset_polygon>`
|
|
|
|
Inflates or deflates ``polygon`` by ``delta`` units (pixels). If ``delta`` is positive, makes the polygon grow outward. If ``delta`` is negative, shrinks the polygon inward. Returns an array of polygons because inflating/deflating may result in multiple discrete polygons. Returns an empty array if ``delta`` is negative and the absolute value of it approximately exceeds the minimum bounding rectangle dimensions of the polygon.
|
|
|
|
Each polygon's vertices will be rounded as determined by ``join_type``.
|
|
|
|
The operation may result in an outer polygon (boundary) and inner polygon (hole) produced which could be distinguished by calling :ref:`is_polygon_clockwise()<class_Geometry2D_method_is_polygon_clockwise>`.
|
|
|
|
\ **Note:** To translate the polygon's vertices specifically, multiply them to a :ref:`Transform2D<class_Transform2D>`:
|
|
|
|
|
|
.. tabs::
|
|
|
|
.. code-tab:: gdscript
|
|
|
|
var polygon = PackedVector2Array([Vector2(0, 0), Vector2(100, 0), Vector2(100, 100), Vector2(0, 100)])
|
|
var offset = Vector2(50, 50)
|
|
polygon = Transform2D(0, offset) * polygon
|
|
print(polygon) # Prints [(50.0, 50.0), (150.0, 50.0), (150.0, 150.0), (50.0, 150.0)]
|
|
|
|
.. code-tab:: csharp
|
|
|
|
Vector2[] polygon = [new Vector2(0, 0), new Vector2(100, 0), new Vector2(100, 100), new Vector2(0, 100)];
|
|
var offset = new Vector2(50, 50);
|
|
polygon = new Transform2D(0, offset) * polygon;
|
|
GD.Print((Variant)polygon); // Prints [(50, 50), (150, 50), (150, 150), (50, 150)]
|
|
|
|
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_Geometry2D_method_offset_polyline:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`Array<class_Array>`\[:ref:`PackedVector2Array<class_PackedVector2Array>`\] **offset_polyline**\ (\ polyline\: :ref:`PackedVector2Array<class_PackedVector2Array>`, delta\: :ref:`float<class_float>`, join_type\: :ref:`PolyJoinType<enum_Geometry2D_PolyJoinType>` = 0, end_type\: :ref:`PolyEndType<enum_Geometry2D_PolyEndType>` = 3\ ) :ref:`🔗<class_Geometry2D_method_offset_polyline>`
|
|
|
|
Inflates or deflates ``polyline`` by ``delta`` units (pixels), producing polygons. If ``delta`` is positive, makes the polyline grow outward. Returns an array of polygons because inflating/deflating may result in multiple discrete polygons. If ``delta`` is negative, returns an empty array.
|
|
|
|
Each polygon's vertices will be rounded as determined by ``join_type``.
|
|
|
|
Each polygon's endpoints will be rounded as determined by ``end_type``.
|
|
|
|
The operation may result in an outer polygon (boundary) and inner polygon (hole) produced which could be distinguished by calling :ref:`is_polygon_clockwise()<class_Geometry2D_method_is_polygon_clockwise>`.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_Geometry2D_method_point_is_inside_triangle:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`bool<class_bool>` **point_is_inside_triangle**\ (\ point\: :ref:`Vector2<class_Vector2>`, a\: :ref:`Vector2<class_Vector2>`, b\: :ref:`Vector2<class_Vector2>`, c\: :ref:`Vector2<class_Vector2>`\ ) |const| :ref:`🔗<class_Geometry2D_method_point_is_inside_triangle>`
|
|
|
|
Devuelve si ``point`` está dentro del triángulo especificado por ``a``, ``b`` y ``c``.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_Geometry2D_method_segment_intersects_circle:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`float<class_float>` **segment_intersects_circle**\ (\ segment_from\: :ref:`Vector2<class_Vector2>`, segment_to\: :ref:`Vector2<class_Vector2>`, circle_position\: :ref:`Vector2<class_Vector2>`, circle_radius\: :ref:`float<class_float>`\ ) :ref:`🔗<class_Geometry2D_method_segment_intersects_circle>`
|
|
|
|
Dado el segmento 2D (``segment_from``, ``segment_to``), devuelve la posición en el segmento (como un número entre 0 y 1) en la que el segmento golpea el círculo que se encuentra en la posición ``circle_position`` y tiene un radio ``circle_radius``. Si el segmento no interseca el círculo, se devuelve -1 (este también es el caso si la línea que extiende el segmento intersecara el círculo, pero el segmento no).
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_Geometry2D_method_segment_intersects_segment:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`Variant<class_Variant>` **segment_intersects_segment**\ (\ from_a\: :ref:`Vector2<class_Vector2>`, to_a\: :ref:`Vector2<class_Vector2>`, from_b\: :ref:`Vector2<class_Vector2>`, to_b\: :ref:`Vector2<class_Vector2>`\ ) :ref:`🔗<class_Geometry2D_method_segment_intersects_segment>`
|
|
|
|
Comprueba si los dos segmentos (``from_a``, ``to_a``) y (``from_b``, ``to_b``) se intersecan. Si es así, devuelve el punto de intersección como :ref:`Vector2<class_Vector2>`. Si no hay intersección, devuelve ``null``.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_Geometry2D_method_triangulate_delaunay:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`PackedInt32Array<class_PackedInt32Array>` **triangulate_delaunay**\ (\ points\: :ref:`PackedVector2Array<class_PackedVector2Array>`\ ) :ref:`🔗<class_Geometry2D_method_triangulate_delaunay>`
|
|
|
|
Triangula el área especificada por un conjunto discreto de ``points`` de tal manera que ningún punto está dentro del circuncírculo de cualquier triángulo resultante. Devuelve un :ref:`PackedInt32Array<class_PackedInt32Array>` donde cada triángulo consiste en tres índices de puntos consecutivos en ``points`` (es decir, el array devuelto tendrá ``n * 3`` elementos, siendo ``n`` el número de triángulos encontrados). Si la triangulación no tiene éxito, se devuelve un :ref:`PackedInt32Array<class_PackedInt32Array>` vacío.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_Geometry2D_method_triangulate_polygon:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`PackedInt32Array<class_PackedInt32Array>` **triangulate_polygon**\ (\ polygon\: :ref:`PackedVector2Array<class_PackedVector2Array>`\ ) :ref:`🔗<class_Geometry2D_method_triangulate_polygon>`
|
|
|
|
Triangula el polígono especificado por los puntos en ``polygon``. Devuelve un :ref:`PackedInt32Array<class_PackedInt32Array>` donde cada triángulo consiste en tres índices de puntos consecutivos en ``polygon`` (es decir, el array devuelto tendrá ``n * 3`` elementos, siendo ``n`` el número de triángulos encontrados). Los triángulos de salida siempre estarán en sentido antihorario, y el contorno se invertirá si está en el sentido de las agujas del reloj. Si la triangulación no tiene éxito, se devuelve un :ref:`PackedInt32Array<class_PackedInt32Array>` vacío.
|
|
|
|
.. |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.)`
|