mirror of
https://github.com/godotengine/godot-docs-l10n.git
synced 2025-12-31 09:49:22 +03:00
592 lines
50 KiB
ReStructuredText
592 lines
50 KiB
ReStructuredText
:github_url: hide
|
||
|
||
.. _class_Geometry2D:
|
||
|
||
Geometry2D
|
||
==========
|
||
|
||
**Наследует:** :ref:`Object<class_Object>`
|
||
|
||
Предоставляет методы для некоторых распространенных двумерных геометрических операций.
|
||
|
||
.. rst-class:: classref-introduction-group
|
||
|
||
Описание
|
||
----------------
|
||
|
||
Предоставляет набор вспомогательных функций для создания геометрических фигур, вычисления пересечений между фигурами и обработки различных других геометрических операций в 2D.
|
||
|
||
.. rst-class:: classref-reftable-group
|
||
|
||
Методы
|
||
------------
|
||
|
||
.. 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
|
||
|
||
Перечисления
|
||
------------------------
|
||
|
||
.. _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``
|
||
|
||
Создайте области, в которых заполнены либо объектные, либо отсекающие полигоны (или и те, и другие).
|
||
|
||
.. _class_Geometry2D_constant_OPERATION_DIFFERENCE:
|
||
|
||
.. rst-class:: classref-enumeration-constant
|
||
|
||
:ref:`PolyBooleanOperation<enum_Geometry2D_PolyBooleanOperation>` **OPERATION_DIFFERENCE** = ``1``
|
||
|
||
Создайте области, в которых заполнены полигоны субъекта, за исключением областей, где заполнены полигоны обрезки.
|
||
|
||
.. _class_Geometry2D_constant_OPERATION_INTERSECTION:
|
||
|
||
.. rst-class:: classref-enumeration-constant
|
||
|
||
:ref:`PolyBooleanOperation<enum_Geometry2D_PolyBooleanOperation>` **OPERATION_INTERSECTION** = ``2``
|
||
|
||
Создайте области, в которых заполнены как полигоны объекта, так и полигоны клипа.
|
||
|
||
.. _class_Geometry2D_constant_OPERATION_XOR:
|
||
|
||
.. rst-class:: classref-enumeration-constant
|
||
|
||
:ref:`PolyBooleanOperation<enum_Geometry2D_PolyBooleanOperation>` **OPERATION_XOR** = ``3``
|
||
|
||
Создавайте области, в которых заполнены либо полигоны объекта, либо полигоны обрезки, но не области, в которых заполнены оба полигона.
|
||
|
||
.. 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``
|
||
|
||
Возведение в квадрат применяется равномерно ко всем выпуклым ребрам при ``1 * delta``.
|
||
|
||
.. _class_Geometry2D_constant_JOIN_ROUND:
|
||
|
||
.. rst-class:: classref-enumeration-constant
|
||
|
||
:ref:`PolyJoinType<enum_Geometry2D_PolyJoinType>` **JOIN_ROUND** = ``1``
|
||
|
||
Хотя сглаженные траектории никогда не могут идеально описывать дугу, они аппроксимируются серией хорд дуг.
|
||
|
||
.. _class_Geometry2D_constant_JOIN_MITER:
|
||
|
||
.. rst-class:: classref-enumeration-constant
|
||
|
||
:ref:`PolyJoinType<enum_Geometry2D_PolyJoinType>` **JOIN_MITER** = ``2``
|
||
|
||
Существует необходимый предел для соединений под углом, поскольку смещение кромок, которые соединяются под очень острыми углами, приведет к образованию чрезмерно длинных и узких «шипов». Для любого соединения кромок, если смещение под углом превышает максимальное расстояние, применяется «квадратное» соединение.
|
||
|
||
.. 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``
|
||
|
||
Конечные точки соединяются с использованием значения :ref:`PolyJoinType<enum_Geometry2D_PolyJoinType>`, а путь заполняется в виде многоугольника.
|
||
|
||
.. _class_Geometry2D_constant_END_JOINED:
|
||
|
||
.. rst-class:: classref-enumeration-constant
|
||
|
||
:ref:`PolyEndType<enum_Geometry2D_PolyEndType>` **END_JOINED** = ``1``
|
||
|
||
Конечные точки соединяются с использованием значения :ref:`PolyJoinType<enum_Geometry2D_PolyJoinType>`, а путь заполняется в виде полилинии.
|
||
|
||
.. _class_Geometry2D_constant_END_BUTT:
|
||
|
||
.. rst-class:: classref-enumeration-constant
|
||
|
||
:ref:`PolyEndType<enum_Geometry2D_PolyEndType>` **END_BUTT** = ``2``
|
||
|
||
Конечные точки имеют квадратную форму и не имеют расширения.
|
||
|
||
.. _class_Geometry2D_constant_END_SQUARE:
|
||
|
||
.. rst-class:: classref-enumeration-constant
|
||
|
||
:ref:`PolyEndType<enum_Geometry2D_PolyEndType>` **END_SQUARE** = ``3``
|
||
|
||
Конечные точки возводятся в квадрат и расширяются на единицы ``delta``.
|
||
|
||
.. _class_Geometry2D_constant_END_ROUND:
|
||
|
||
.. rst-class:: classref-enumeration-constant
|
||
|
||
:ref:`PolyEndType<enum_Geometry2D_PolyEndType>` **END_ROUND** = ``4``
|
||
|
||
Конечные точки округляются и расширяются на единицы ``delta``.
|
||
|
||
.. rst-class:: classref-section-separator
|
||
|
||
----
|
||
|
||
.. rst-class:: classref-descriptions-group
|
||
|
||
Описания метода
|
||
------------------------------
|
||
|
||
.. _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>`
|
||
|
||
Возвращает `линию Брезенхэма <https://en.wikipedia.org/wiki/Bresenham%27s_line_algorithm>`__ между точками ``from`` и ``to``. Линия Брезенхэма — это ряд пикселей, которые рисуют линию и всегда имеют толщину 1 пиксель в каждой строке и столбце чертежа (ни больше, ни меньше).
|
||
|
||
Пример кода для рисования линии между двумя узлами :ref:`Marker2D<class_Marker2D>` с использованием ряда вызовов :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>`
|
||
|
||
Обрезает ``polygon_a`` по ``polygon_b`` и возвращает массив обрезанных полигонов. Это выполняет :ref:`OPERATION_DIFFERENCE<class_Geometry2D_constant_OPERATION_DIFFERENCE>` между полигонами. Возвращает пустой массив, если ``polygon_b`` полностью перекрывает ``polygon_a``.
|
||
|
||
Если ``polygon_b`` заключен в ``polygon_a``, возвращает внешний полигон (границу) и внутренний полигон (отверстие), которые можно различить, вызвав :ref:`is_polygon_clock()<class_Geometry2D_method_is_polygon_clock>`.
|
||
|
||
.. 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>`
|
||
|
||
Обрезает ``polyline`` по ``polygon`` и возвращает массив обрезанных полилиний. Это выполняет :ref:`OPERATION_DIFFERENCE<class_Geometry2D_constant_OPERATION_DIFFERENCE>` между полилинией и полигоном. Эту операцию можно рассматривать как разрезание линии с замкнутой формой.
|
||
|
||
.. 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>`
|
||
|
||
Учитывая массив :ref:`Vector2<class_Vector2>`, возвращает выпуклую оболочку как список точек в порядке против часовой стрелки. Последняя точка совпадает с первой.
|
||
|
||
.. 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>`
|
||
|
||
Разбивает ``polygon`` на несколько выпуклых оболочек и возвращает массив :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>`
|
||
|
||
Взаимно исключает общую область, определенную пересечением ``polygon_a`` и ``polygon_b`` (см. :ref:`intersect_polygons()<class_Geometry2D_method_intersect_polygons>`), и возвращает массив исключенных полигонов. Это выполняет :ref:`OPERATION_XOR<class_Geometry2D_constant_OPERATION_XOR>` между полигонами. Другими словами, возвращает все, кроме общей области между полигонами.
|
||
|
||
Операция может привести к получению внешнего полигона (границы) и внутреннего полигона (отверстия), которые можно различить, вызвав :ref:`is_polygon_clock()<class_Geometry2D_method_is_polygon_clock>`.
|
||
|
||
.. 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>`
|
||
|
||
Возвращает 2D-точку на 2D-сегменте (``s1``, ``s2``), которая находится ближе всего к ``point``. Возвращаемая точка всегда будет находиться внутри указанного сегмента.
|
||
|
||
.. 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>`
|
||
|
||
Возвращает 2D-точку на 2D-линии, определенной (``s1``, ``s2``), которая находится ближе всего к ``point``. Возвращаемая точка может находиться внутри сегмента (``s1``, ``s2``) или за его пределами, т. е. где-то на линии, выходящей из сегмента.
|
||
|
||
.. 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>`
|
||
|
||
Учитывая два 2D-сегмента (``p1``, ``q1``) и (``p2``, ``q2``), находит те две точки на двух сегментах, которые находятся ближе всего друг к другу. Возвращает :ref:`PackedVector2Array<class_PackedVector2Array>`, который содержит эту точку на (``p1``, ``q1``), а также сопутствующую точку на (``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>`
|
||
|
||
Пересекает ``polygon_a`` с ``polygon_b`` и возвращает массив пересеченных полигонов. Это выполняет :ref:`OPERATION_INTERSECTION<class_Geometry2D_constant_OPERATION_INTERSECTION>` между полигонами. Другими словами, возвращает общую область, разделяемую полигонами. Возвращает пустой массив, если пересечения не происходит.
|
||
|
||
Операция может привести к получению внешнего полигона (границы) и внутреннего полигона (отверстия), которые можно различить, вызвав :ref:`is_polygon_clock()<class_Geometry2D_method_is_polygon_clock>`.
|
||
|
||
.. 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>`
|
||
|
||
Пересекает ``polyline`` с ``polygon`` и возвращает массив пересеченных полилиний. Это выполняет :ref:`OPERATION_INTERSECTION<class_Geometry2D_constant_OPERATION_INTERSECTION>` между полилинией и полигоном. Эту операцию можно рассматривать как нарезание линии замкнутой формой.
|
||
|
||
.. 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>`
|
||
|
||
Возвращает ``true``, если ``point`` находится внутри круга или если он расположен точно *на* границе круга, в противном случае возвращает ``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>`
|
||
|
||
Возвращает ``true``, если ``point`` находится внутри ``polygon`` или если она расположена точно *на* границе полигона, в противном случае возвращает ``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>`
|
||
|
||
Возвращает ``true``, если вершины ``polygon`` упорядочены по часовой стрелке, в противном случае возвращает ``false``.
|
||
|
||
\ **Примечание:** Предполагается декартова система координат, где ``+x`` — справа, а ``+y`` — сверху. При использовании экранных координат (``+y`` — снизу), результат необходимо будет перевернуть (т. е. результат ``true`` будет указывать против часовой стрелки).
|
||
|
||
.. 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>`
|
||
|
||
Возвращает точку пересечения между двумя линиями (``from_a``, ``dir_a``) и (``from_b``, ``dir_b``). Возвращает :ref:`Vector2<class_Vector2>` или ``null``, если линии параллельны.
|
||
|
||
\ ``from`` и ``dir`` являются *не* конечными точками отрезка линии или луча, а наклоном (``dir``) и известной точкой (``from``) на этой линии.
|
||
|
||
|
||
.. tabs::
|
||
|
||
.. code-tab:: gdscript
|
||
|
||
var from_a = Vector2.ZERO
|
||
var dir_a = Vector2.RIGHT
|
||
var from_b = Vector2.DOWN
|
||
|
||
# Возвращает Vector2(1, 0)
|
||
Geometry2D.line_intersects_line(from_a, dir_a, from_b, Vector2(1, -1))
|
||
# Возвращает Vector2(-1, 0)
|
||
Geometry2D.line_intersects_line(from_a, dir_a, from_b, Vector2(-1, -1))
|
||
# Возвращает 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;
|
||
|
||
// Возвращает new Vector2(1, 0)
|
||
Geometry2D.LineIntersectsLine(fromA, dirA, fromB, new Vector2(1, -1));
|
||
// Возвращает new Vector2(-1, 0)
|
||
Geometry2D.LineIntersectsLine(fromA, dirA, fromB, new Vector2(-1, -1));
|
||
# Возвращает 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>`
|
||
|
||
Учитывая массив :ref:`Vector2<class_Vector2>`, представляющий тайлы, создает атлас. Возвращаемый словарь имеет два ключа: ``points`` — это :ref:`PackedVector2Array<class_PackedVector2Array>`, который определяет позиции каждого тайла, и ``size`` содержит общий размер всего атласа как :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>`
|
||
|
||
Объединяет (комбинирует) ``polygon_a`` и ``polygon_b`` и возвращает массив объединенных полигонов. Это выполняет :ref:`OPERATION_UNION<class_Geometry2D_constant_OPERATION_UNION>` между полигонами.
|
||
|
||
Операция может привести к образованию внешнего полигона (границы) и нескольких внутренних полигонов (отверстий), которые можно различить, вызвав :ref:`is_polygon_clock()<class_Geometry2D_method_is_polygon_clock>`.
|
||
|
||
.. 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>`
|
||
|
||
Раздувает или сдувает ``polygon`` на ``delta`` единиц (пикселей). Если ``delta`` положительно, то полигон растет наружу. Если ``delta`` отрицательно, то полигон сжимается внутрь. Возвращает массив полигонов, поскольку раздувание/сдувание может привести к появлению нескольких дискретных полигонов. Возвращает пустой массив, если ``delta`` отрицательно и его абсолютное значение приблизительно превышает минимальные размеры ограничивающего прямоугольника полигона.
|
||
|
||
Вершины каждого полигона будут округлены, как определено ``join_type``.
|
||
|
||
Операция может привести к получению внешнего полигона (границы) и внутреннего полигона (отверстия), которые можно различить, вызвав :ref:`is_polygon_clock()<class_Geometry2D_method_is_polygon_clock>`.
|
||
|
||
\ **Примечание:** Чтобы переместить вершины полигона конкретно, умножьте их на :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) # Выводит [(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); // Выводит [(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>`
|
||
|
||
Раздувает или сдувает ``polyline`` на ``delta`` единиц (пикселей), создавая полигоны. Если ``delta`` положительно, полилиния растет наружу. Возвращает массив полигонов, поскольку раздувание/сдувание может привести к появлению нескольких дискретных полигонов. Если ``delta`` отрицательно, возвращает пустой массив.
|
||
|
||
Вершины каждого полигона будут округлены, как определено ``join_type``.
|
||
|
||
Конечные точки каждого полигона будут округлены, как определено ``end_type``.
|
||
|
||
В результате операции могут быть получены внешний полигон (граница) и внутренний полигон (отверстие), которые можно различить, вызвав :ref:`is_polygon_clock()<class_Geometry2D_method_is_polygon_clock>`.
|
||
|
||
.. 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>`
|
||
|
||
Возвращает, если ``point`` находится внутри треугольника, заданного ``a``, ``b`` и ``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>`
|
||
|
||
Учитывая 2D-сегмент (``segment_from``, ``segment_to``), возвращает позицию на сегменте (как число от 0 до 1), в которой сегмент касается окружности, расположенной в позиции ``circle_position`` и имеющей радиус ``circle_radius``. Если сегмент не пересекает окружность, возвращается -1 (это также имеет место, если линия, продолжающая сегмент, пересекает окружность, но не пересекает сегмент).
|
||
|
||
.. 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>`
|
||
|
||
Проверяет, пересекаются ли два сегмента (``from_a``, ``to_a``) и (``from_b``, ``to_b``). Если да, возвращает точку пересечения как :ref:`Vector2<class_Vector2>`. Если пересечения не происходит, возвращает ``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>`
|
||
|
||
Триангулирует область, указанную дискретным набором ``points``, таким образом, что ни одна точка не находится внутри описанной окружности любого полученного треугольника. Возвращает :ref:`PackedInt32Array<class_PackedInt32Array>`, где каждый треугольник состоит из трех последовательных индексов точек в ``points`` (т. е. возвращаемый массив будет иметь ``n * 3`` элементов, где ``n`` — количество найденных треугольников). Если триангуляция не удалась, возвращается пустой :ref:`PackedInt32Array<class_PackedInt32Array>`.
|
||
|
||
.. 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>`
|
||
|
||
Триангулирует многоугольник, указанный точками в ``polygon``. Возвращает :ref:`PackedInt32Array<class_PackedInt32Array>`, где каждый треугольник состоит из трех последовательных индексов точек в ``polygon`` (т. е. возвращаемый массив будет иметь ``n * 3`` элементов, где ``n`` — количество найденных треугольников). Выходные треугольники всегда будут против часовой стрелки, а контур будет перевернут, если он по часовой стрелке. Если триангуляция не удалась, возвращается пустой :ref:`PackedInt32Array<class_PackedInt32Array>`.
|
||
|
||
.. |virtual| replace:: :abbr:`virtual (Этот метод обычно должен быть переопределен пользователем, чтобы иметь какой-либо эффект.)`
|
||
.. |required| replace:: :abbr:`required (This method is required to be overridden when extending its base class.)`
|
||
.. |const| replace:: :abbr:`const (Этот метод не имеет побочных эффектов. Он не изменяет ни одну из переменных-членов экземпляра.)`
|
||
.. |vararg| replace:: :abbr:`vararg (Этот метод принимает любое количество аргументов после описанных здесь.)`
|
||
.. |constructor| replace:: :abbr:`constructor (Этот метод используется для создания типа.)`
|
||
.. |static| replace:: :abbr:`static (Этот метод не нуждается в вызове экземпляра, поэтому его можно вызвать напрямую, используя имя класса.)`
|
||
.. |operator| replace:: :abbr:`operator (Этот метод описывает допустимый оператор для использования с этим типом в качестве левого операнда.)`
|
||
.. |bitfield| replace:: :abbr:`BitField (Это значение является целым числом, составленным как битовая маска следующих флагов.)`
|
||
.. |void| replace:: :abbr:`void (Нет возвращаемого значения.)`
|