mirror of
https://github.com/godotengine/godot-docs-l10n.git
synced 2025-12-31 09:49:22 +03:00
497 lines
28 KiB
ReStructuredText
497 lines
28 KiB
ReStructuredText
:github_url: hide
|
||
|
||
.. _class_Rect2i:
|
||
|
||
Rect2i
|
||
======
|
||
|
||
Двумерная ограничивающая рамка, выровненная по осям, с использованием целочисленных координат.
|
||
|
||
.. rst-class:: classref-introduction-group
|
||
|
||
Описание
|
||
----------------
|
||
|
||
Встроенный тип :ref:`Variant<class_Variant>` **Rect2i** представляет собой выровненный по осям прямоугольник в двумерном пространстве с использованием целочисленных координат. Он определяется его :ref:`position<class_Rect2i_property_position>` и :ref:`size<class_Rect2i_property_size>`, которые являются :ref:`Vector2i<class_Vector2i>`. Поскольку он не вращается, он часто используется для быстрых тестов на перекрытие (см. :ref:`intersects()<class_Rect2i_method_intersects>`).
|
||
|
||
Для координат с плавающей точкой см. :ref:`Rect2<class_Rect2>`.
|
||
|
||
\ **Примечание:** Отрицательные значения для :ref:`size<class_Rect2i_property_size>` не поддерживаются. При отрицательном размере большинство методов **Rect2i** работают некорректно. Используйте :ref:`abs()<class_Rect2i_method_abs>`, чтобы получить эквивалентный **Rect2i** с неотрицательным размером.
|
||
|
||
\ **Примечание:** В булевом контексте **Rect2i** оценивается как ``false``, если и :ref:`position<class_Rect2i_property_position>`, и :ref:`size<class_Rect2i_property_size>` равны нулю (равно :ref:`Vector2i.ZERO<class_Vector2i_constant_ZERO>`). В противном случае всегда принимается значение ``true``.
|
||
|
||
.. note::
|
||
|
||
Существуют заметные различия при использовании данного API с C#. Подробнее см. :ref:`doc_c_sharp_differences`.
|
||
|
||
.. rst-class:: classref-introduction-group
|
||
|
||
Обучающие материалы
|
||
--------------------------------------
|
||
|
||
- :doc:`Каталог математической документации <../tutorials/math/index>`
|
||
|
||
- :doc:`Векторная математика <../tutorials/math/vector_math>`
|
||
|
||
.. rst-class:: classref-reftable-group
|
||
|
||
Свойства
|
||
----------------
|
||
|
||
.. table::
|
||
:widths: auto
|
||
|
||
+---------------------------------+-------------------------------------------------+--------------------+
|
||
| :ref:`Vector2i<class_Vector2i>` | :ref:`end<class_Rect2i_property_end>` | ``Vector2i(0, 0)`` |
|
||
+---------------------------------+-------------------------------------------------+--------------------+
|
||
| :ref:`Vector2i<class_Vector2i>` | :ref:`position<class_Rect2i_property_position>` | ``Vector2i(0, 0)`` |
|
||
+---------------------------------+-------------------------------------------------+--------------------+
|
||
| :ref:`Vector2i<class_Vector2i>` | :ref:`size<class_Rect2i_property_size>` | ``Vector2i(0, 0)`` |
|
||
+---------------------------------+-------------------------------------------------+--------------------+
|
||
|
||
.. rst-class:: classref-reftable-group
|
||
|
||
Конструкторы
|
||
------------------------
|
||
|
||
.. table::
|
||
:widths: auto
|
||
|
||
+-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Rect2i<class_Rect2i>` | :ref:`Rect2i<class_Rect2i_constructor_Rect2i>`\ (\ ) |
|
||
+-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Rect2i<class_Rect2i>` | :ref:`Rect2i<class_Rect2i_constructor_Rect2i>`\ (\ from\: :ref:`Rect2i<class_Rect2i>`\ ) |
|
||
+-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Rect2i<class_Rect2i>` | :ref:`Rect2i<class_Rect2i_constructor_Rect2i>`\ (\ from\: :ref:`Rect2<class_Rect2>`\ ) |
|
||
+-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Rect2i<class_Rect2i>` | :ref:`Rect2i<class_Rect2i_constructor_Rect2i>`\ (\ position\: :ref:`Vector2i<class_Vector2i>`, size\: :ref:`Vector2i<class_Vector2i>`\ ) |
|
||
+-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Rect2i<class_Rect2i>` | :ref:`Rect2i<class_Rect2i_constructor_Rect2i>`\ (\ x\: :ref:`int<class_int>`, y\: :ref:`int<class_int>`, width\: :ref:`int<class_int>`, height\: :ref:`int<class_int>`\ ) |
|
||
+-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
|
||
.. rst-class:: classref-reftable-group
|
||
|
||
Методы
|
||
------------
|
||
|
||
.. table::
|
||
:widths: auto
|
||
|
||
+---------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Rect2i<class_Rect2i>` | :ref:`abs<class_Rect2i_method_abs>`\ (\ ) |const| |
|
||
+---------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`encloses<class_Rect2i_method_encloses>`\ (\ b\: :ref:`Rect2i<class_Rect2i>`\ ) |const| |
|
||
+---------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Rect2i<class_Rect2i>` | :ref:`expand<class_Rect2i_method_expand>`\ (\ to\: :ref:`Vector2i<class_Vector2i>`\ ) |const| |
|
||
+---------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`int<class_int>` | :ref:`get_area<class_Rect2i_method_get_area>`\ (\ ) |const| |
|
||
+---------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Vector2i<class_Vector2i>` | :ref:`get_center<class_Rect2i_method_get_center>`\ (\ ) |const| |
|
||
+---------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Rect2i<class_Rect2i>` | :ref:`grow<class_Rect2i_method_grow>`\ (\ amount\: :ref:`int<class_int>`\ ) |const| |
|
||
+---------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Rect2i<class_Rect2i>` | :ref:`grow_individual<class_Rect2i_method_grow_individual>`\ (\ left\: :ref:`int<class_int>`, top\: :ref:`int<class_int>`, right\: :ref:`int<class_int>`, bottom\: :ref:`int<class_int>`\ ) |const| |
|
||
+---------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Rect2i<class_Rect2i>` | :ref:`grow_side<class_Rect2i_method_grow_side>`\ (\ side\: :ref:`int<class_int>`, amount\: :ref:`int<class_int>`\ ) |const| |
|
||
+---------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`has_area<class_Rect2i_method_has_area>`\ (\ ) |const| |
|
||
+---------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`has_point<class_Rect2i_method_has_point>`\ (\ point\: :ref:`Vector2i<class_Vector2i>`\ ) |const| |
|
||
+---------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Rect2i<class_Rect2i>` | :ref:`intersection<class_Rect2i_method_intersection>`\ (\ b\: :ref:`Rect2i<class_Rect2i>`\ ) |const| |
|
||
+---------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`intersects<class_Rect2i_method_intersects>`\ (\ b\: :ref:`Rect2i<class_Rect2i>`\ ) |const| |
|
||
+---------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`Rect2i<class_Rect2i>` | :ref:`merge<class_Rect2i_method_merge>`\ (\ b\: :ref:`Rect2i<class_Rect2i>`\ ) |const| |
|
||
+---------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
|
||
.. rst-class:: classref-reftable-group
|
||
|
||
Операторы
|
||
------------------
|
||
|
||
.. table::
|
||
:widths: auto
|
||
|
||
+-------------------------+-------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`operator !=<class_Rect2i_operator_neq_Rect2i>`\ (\ right\: :ref:`Rect2i<class_Rect2i>`\ ) |
|
||
+-------------------------+-------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`operator ==<class_Rect2i_operator_eq_Rect2i>`\ (\ right\: :ref:`Rect2i<class_Rect2i>`\ ) |
|
||
+-------------------------+-------------------------------------------------------------------------------------------------+
|
||
|
||
.. rst-class:: classref-section-separator
|
||
|
||
----
|
||
|
||
.. rst-class:: classref-descriptions-group
|
||
|
||
Описания свойств
|
||
--------------------------------
|
||
|
||
.. _class_Rect2i_property_end:
|
||
|
||
.. rst-class:: classref-property
|
||
|
||
:ref:`Vector2i<class_Vector2i>` **end** = ``Vector2i(0, 0)`` :ref:`🔗<class_Rect2i_property_end>`
|
||
|
||
Конечная точка. Обычно это нижний правый угол прямоугольника, и эквивалентно ``position + size``. Установка этой точки влияет на :ref:`size<class_Rect2i_property_size>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Rect2i_property_position:
|
||
|
||
.. rst-class:: classref-property
|
||
|
||
:ref:`Vector2i<class_Vector2i>` **position** = ``Vector2i(0, 0)`` :ref:`🔗<class_Rect2i_property_position>`
|
||
|
||
Начальная точка. Обычно это верхний левый угол прямоугольника.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Rect2i_property_size:
|
||
|
||
.. rst-class:: classref-property
|
||
|
||
:ref:`Vector2i<class_Vector2i>` **size** = ``Vector2i(0, 0)`` :ref:`🔗<class_Rect2i_property_size>`
|
||
|
||
Ширина и высота прямоугольника, начиная с :ref:`position<class_Rect2i_property_position>`. Установка этого значения также влияет на точку :ref:`end<class_Rect2i_property_end>`.
|
||
|
||
\ **Примечание:** Рекомендуется устанавливать ширину и высоту на неотрицательные значения, так как большинство методов в Godot предполагают, что :ref:`position<class_Rect2i_property_position>` — это верхний левый угол, а :ref:`end<class_Rect2i_property_end>` — это нижний правый угол. Чтобы получить эквивалентный прямоугольник с неотрицательным размером, используйте :ref:`abs()<class_Rect2i_method_abs>`.
|
||
|
||
.. rst-class:: classref-section-separator
|
||
|
||
----
|
||
|
||
.. rst-class:: classref-descriptions-group
|
||
|
||
Описания конструктора
|
||
------------------------------------------
|
||
|
||
.. _class_Rect2i_constructor_Rect2i:
|
||
|
||
.. rst-class:: classref-constructor
|
||
|
||
:ref:`Rect2i<class_Rect2i>` **Rect2i**\ (\ ) :ref:`🔗<class_Rect2i_constructor_Rect2i>`
|
||
|
||
Создает **Rect2i** с его :ref:`position<class_Rect2i_property_position>` и :ref:`size<class_Rect2i_property_size>`, установленными на :ref:`Vector2i.ZERO<class_Vector2i_constant_ZERO>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. rst-class:: classref-constructor
|
||
|
||
:ref:`Rect2i<class_Rect2i>` **Rect2i**\ (\ from\: :ref:`Rect2i<class_Rect2i>`\ )
|
||
|
||
Создает **Rect2i** как копию заданного **Rect2i**.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. rst-class:: classref-constructor
|
||
|
||
:ref:`Rect2i<class_Rect2i>` **Rect2i**\ (\ from\: :ref:`Rect2<class_Rect2>`\ )
|
||
|
||
Создает **Rect2i** из :ref:`Rect2<class_Rect2>`. Координаты с плавающей точкой усекаются.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. rst-class:: classref-constructor
|
||
|
||
:ref:`Rect2i<class_Rect2i>` **Rect2i**\ (\ position\: :ref:`Vector2i<class_Vector2i>`, size\: :ref:`Vector2i<class_Vector2i>`\ )
|
||
|
||
Создает **Rect2i** по ``position`` и ``size``.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. rst-class:: classref-constructor
|
||
|
||
:ref:`Rect2i<class_Rect2i>` **Rect2i**\ (\ x\: :ref:`int<class_int>`, y\: :ref:`int<class_int>`, width\: :ref:`int<class_int>`, height\: :ref:`int<class_int>`\ )
|
||
|
||
Создает **Rect2i**, устанавливая его :ref:`position<class_Rect2i_property_position>` на (``x``, ``y``), а его :ref:`size<class_Rect2i_property_size>` на (``width``, ``height``).
|
||
|
||
.. rst-class:: classref-section-separator
|
||
|
||
----
|
||
|
||
.. rst-class:: classref-descriptions-group
|
||
|
||
Описания метода
|
||
------------------------------
|
||
|
||
.. _class_Rect2i_method_abs:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`Rect2i<class_Rect2i>` **abs**\ (\ ) |const| :ref:`🔗<class_Rect2i_method_abs>`
|
||
|
||
Возвращает **Rect2i**, эквивалентный данному прямоугольнику, с измененной шириной и высотой, которые стали неотрицательными значениями, и с :ref:`position<class_Rect2i_property_position>`, являющейся верхним левым углом прямоугольника.
|
||
|
||
|
||
.. tabs::
|
||
|
||
.. code-tab:: gdscript
|
||
|
||
var rect = Rect2i(25, 25, -100, -50)
|
||
var absolute = rect.abs() # абсолютный — Rect2i(-75, -25, 100, 50)
|
||
|
||
.. code-tab:: csharp
|
||
|
||
var rect = new Rect2I(25, 25, -100, -50);
|
||
var absolute = rect.Abs(); // абсолютный — Rect2i(-75, -25, 100, 50)
|
||
|
||
|
||
|
||
\ **Примечание:** Рекомендуется использовать этот метод, когда :ref:`size<class_Rect2i_property_size>` отрицательный, так как большинство других методов в Godot предполагают, что :ref:`position<class_Rect2i_property_position>` — это верхний левый угол, а :ref:`end<class_Rect2i_property_end>` — нижний правый угол.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Rect2i_method_encloses:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`bool<class_bool>` **encloses**\ (\ b\: :ref:`Rect2i<class_Rect2i>`\ ) |const| :ref:`🔗<class_Rect2i_method_encloses>`
|
||
|
||
Возвращает ``true``, если этот **Rect2i** полностью охватывает другой.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Rect2i_method_expand:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`Rect2i<class_Rect2i>` **expand**\ (\ to\: :ref:`Vector2i<class_Vector2i>`\ ) |const| :ref:`🔗<class_Rect2i_method_expand>`
|
||
|
||
Возвращает копию этого прямоугольника, расширенную для выравнивания краев с заданной точкой ``to``, если это необходимо.
|
||
|
||
|
||
.. tabs::
|
||
|
||
.. code-tab:: gdscript
|
||
|
||
var rect = Rect2i(0, 0, 5, 2)
|
||
|
||
rect = rect.expand(Vector2i(10, 0)) # прямоугольник равен Rect2i(0, 0, 10, 2)
|
||
rect = rect.expand(Vector2i(-5, 5)) # прямоугольник равен Rect2i(-5, 0, 15, 5)
|
||
|
||
.. code-tab:: csharp
|
||
|
||
var rect = new Rect2I(0, 0, 5, 2);
|
||
|
||
rect = rect.Expand(new Vector2I(10, 0)); // прямоугольник равен Rect2i(0, 0, 10, 2)
|
||
rect = rect.Expand(new Vector2I(-5, 5)); // прямоугольник равен Rect2i(-5, 0, 15, 5)
|
||
|
||
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Rect2i_method_get_area:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`int<class_int>` **get_area**\ (\ ) |const| :ref:`🔗<class_Rect2i_method_get_area>`
|
||
|
||
Возвращает площадь прямоугольника. Это эквивалентно ``size.x * size.y``. См. также :ref:`has_area()<class_Rect2i_method_has_area>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Rect2i_method_get_center:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`Vector2i<class_Vector2i>` **get_center**\ (\ ) |const| :ref:`🔗<class_Rect2i_method_get_center>`
|
||
|
||
Возвращает центральную точку прямоугольника. Это то же самое, что ``position + (size / 2)``.
|
||
|
||
\ **Примечание:** Если :ref:`size<class_Rect2i_property_size>` нечетный, результат будет округлен в сторону member position].
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Rect2i_method_grow:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`Rect2i<class_Rect2i>` **grow**\ (\ amount\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_Rect2i_method_grow>`
|
||
|
||
Возвращает копию этого прямоугольника, расширенного со всех сторон на заданный ``amount``. Отрицательное ``amount`` вместо этого сжимает прямоугольник. См. также :ref:`grow_individual()<class_Rect2i_method_grow_individual>` и :ref:`grow_side()<class_Rect2i_method_grow_side>`.
|
||
|
||
|
||
.. tabs::
|
||
|
||
.. code-tab:: gdscript
|
||
|
||
var a = Rect2i(4, 4, 8, 8).grow(4) # а — это Rect2i(0, 0, 16, 16)
|
||
var b = Rect2i(0, 0, 8, 4).grow(2) # b — это Rect2i(-2, -2, 12, 8)
|
||
|
||
.. code-tab:: csharp
|
||
|
||
var a = new Rect2I(4, 4, 8, 8).Grow(4); // а — это Rect2i(0, 0, 16, 16)
|
||
var b = new Rect2I(0, 0, 8, 4).Grow(2); // b — это Rect2i(-2, -2, 12, 8)
|
||
|
||
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Rect2i_method_grow_individual:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`Rect2i<class_Rect2i>` **grow_individual**\ (\ left\: :ref:`int<class_int>`, top\: :ref:`int<class_int>`, right\: :ref:`int<class_int>`, bottom\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_Rect2i_method_grow_individual>`
|
||
|
||
Возвращает копию этого прямоугольника со сторонами ``left``, ``top``, ``right`` и ``bottom``, расширенными на заданные значения. Отрицательные значения вместо этого сжимают стороны. См. также :ref:`grow()<class_Rect2i_method_grow>` и :ref:`grow_side()<class_Rect2i_method_grow_side>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Rect2i_method_grow_side:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`Rect2i<class_Rect2i>` **grow_side**\ (\ side\: :ref:`int<class_int>`, amount\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_Rect2i_method_grow_side>`
|
||
|
||
Возвращает копию этого прямоугольника с его ``side``, расширенным на заданное ``amount`` (см. константы :ref:`Side<enum_@GlobalScope_Side>`). Отрицательное ``amount`` вместо этого сжимает прямоугольник. См. также :ref:`grow()<class_Rect2i_method_grow>` и :ref:`grow_individual()<class_Rect2i_method_grow_individual>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Rect2i_method_has_area:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`bool<class_bool>` **has_area**\ (\ ) |const| :ref:`🔗<class_Rect2i_method_has_area>`
|
||
|
||
Возвращает ``true``, если этот прямоугольник имеет положительную ширину и высоту. См. также :ref:`get_area()<class_Rect2i_method_get_area>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Rect2i_method_has_point:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`bool<class_bool>` **has_point**\ (\ point\: :ref:`Vector2i<class_Vector2i>`\ ) |const| :ref:`🔗<class_Rect2i_method_has_point>`
|
||
|
||
Возвращает ``true``, если прямоугольник содержит заданный ``point``. По соглашению, точки на правом и нижнем краях **не** включены.
|
||
|
||
\ **Примечание:** Этот метод ненадежен для **Rect2i** с *отрицательным* :ref:`size<class_Rect2i_property_size>`. Сначала используйте :ref:`abs()<class_Rect2i_method_abs>`, чтобы получить допустимый прямоугольник.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Rect2i_method_intersection:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`Rect2i<class_Rect2i>` **intersection**\ (\ b\: :ref:`Rect2i<class_Rect2i>`\ ) |const| :ref:`🔗<class_Rect2i_method_intersection>`
|
||
|
||
Возвращает пересечение между этим прямоугольником и ``b``. Если прямоугольники не пересекаются, возвращает пустой **Rect2i**.
|
||
|
||
|
||
.. tabs::
|
||
|
||
.. code-tab:: gdscript
|
||
|
||
var a = Rect2i(0, 0, 5, 10)
|
||
var b = Rect2i(2, 0, 8, 4)
|
||
|
||
var c = a.intersection(b) # c — это Rect2i(2, 0, 3, 4)
|
||
|
||
.. code-tab:: csharp
|
||
|
||
var a = new Rect2I(0, 0, 5, 10);
|
||
var b = new Rect2I(2, 0, 8, 4);
|
||
|
||
var c = rect1.Intersection(rect2); // c — это Rect2i(2, 0, 3, 4)
|
||
|
||
|
||
|
||
\ **Примечание:** Если вам нужно только узнать, перекрываются ли два прямоугольника, используйте вместо этого :ref:`intersects()<class_Rect2i_method_intersects>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Rect2i_method_intersects:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`bool<class_bool>` **intersects**\ (\ b\: :ref:`Rect2i<class_Rect2i>`\ ) |const| :ref:`🔗<class_Rect2i_method_intersects>`
|
||
|
||
Возвращает ``true``, если этот прямоугольник перекрывается с прямоугольником ``b``. Края обоих прямоугольников исключаются.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Rect2i_method_merge:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`Rect2i<class_Rect2i>` **merge**\ (\ b\: :ref:`Rect2i<class_Rect2i>`\ ) |const| :ref:`🔗<class_Rect2i_method_merge>`
|
||
|
||
Возвращает **Rect2i**, который охватывает этот прямоугольник и ``b`` по краям. См. также :ref:`encludes()<class_Rect2i_method_encludes>`.
|
||
|
||
.. rst-class:: classref-section-separator
|
||
|
||
----
|
||
|
||
.. rst-class:: classref-descriptions-group
|
||
|
||
Описания оператора
|
||
------------------------------------
|
||
|
||
.. _class_Rect2i_operator_neq_Rect2i:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`bool<class_bool>` **operator !=**\ (\ right\: :ref:`Rect2i<class_Rect2i>`\ ) :ref:`🔗<class_Rect2i_operator_neq_Rect2i>`
|
||
|
||
Возвращает ``true``, если :ref:`position<class_Rect2i_property_position>` или :ref:`size<class_Rect2i_property_size>` обоих прямоугольников не равны.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_Rect2i_operator_eq_Rect2i:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`bool<class_bool>` **operator ==**\ (\ right\: :ref:`Rect2i<class_Rect2i>`\ ) :ref:`🔗<class_Rect2i_operator_eq_Rect2i>`
|
||
|
||
Возвращает ``true``, если :ref:`position<class_Rect2i_property_position>` и :ref:`size<class_Rect2i_property_size>` прямоугольников равны.
|
||
|
||
.. |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 (Нет возвращаемого значения.)`
|