godotengine/godot-docs-l10n
1
0
Fork 0
mirror of https://github.com/godotengine/godot-docs-l10n.git synced 2026-01-04 10:09:56 +03:00
Code Issues Packages Projects Releases Wiki Activity
Files
b20bcbb88b461cb864b63ee74a3d6ec1a3a83db7
godot-docs-l10n/classes/uk/class_canvasitem.rst

1645 lines
213 KiB
ReStructuredText
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

:github_url: hide
.. _class_CanvasItem:
CanvasItem
==========
**Успадковує:** :ref:`Node<class_Node>` **<** :ref:`Object<class_Object>`
**Успадковано від:** :ref:`Control<class_Control>`, :ref:`Node2D<class_Node2D>`
Абстрактний базовий клас для всього у 2D-просторі.
.. rst-class:: classref-introduction-group
Опис
--------
Абстрактний базовий клас для всього у 2D-просторі. Вироби з полотна розкладаються деревом; діти успадковують і розширюють трансформацію свого батька. **CanvasItem** розширено за допомогою :ref:`Control<class_Control>` для вузлів, пов’язаних із GUI, і за допомогою :ref:`Node2D<class_Node2D>` для 2D-ігрових об’єктів.
Будь-який **CanvasItem** може малювати. Для цього :ref:`queue_redraw()<class_CanvasItem_method_queue_redraw>` викликається рушієм, потім :ref:`NOTIFICATION_DRAW<class_CanvasItem_constant_NOTIFICATION_DRAW>` буде отримано під час простою для запиту на перемальовування. Завдяки цьому елементи полотна не потрібно перемальовувати на кожному кадрі, що значно покращує продуктивність. Надається декілька функцій для малювання на **CanvasItem** (див. функції ``draw_*``). Однак їх можна використовувати лише всередині :ref:`_draw()<class_CanvasItem_private_method__draw>`, його відповідного :ref:`Object._notification()<class_Object_private_method__notification>` або методів, підключених до сигналу :ref:`draw<class_CanvasItem_signal_draw>`.
Елементи полотна малюються в порядку дерева на своєму шарі плотна. За замовчуванням діти знаходяться поверх своїх батьків, тому корінь **CanvasItem** буде намальовано за всім. Цю поведінку можна змінити для кожного елемента.
\ **CanvasItem** можна приховати, що також приховає його дочірні елементи. Налаштовуючи різні інші властивості **CanvasItem**, ви також можете модулювати його колір (через :ref:`modulate<class_CanvasItem_property_modulate>` або :ref:`self_modulate<class_CanvasItem_property_self_modulate>`), змінювати його Z-індекс, режим змішування тощо.
Зауважте, що такі властивості, як перетворення, модуляція та видимість, поширюються лише до *прямих* дочірніх вузлів **CanvasItem**. Якщо між ними є вузол, який не є **CanvasItem**, наприклад :ref:`Node<class_Node>` або :ref:`AnimationPlayer<class_AnimationPlayer>`, вузли **CanvasItem** нижче матимуть незалежну позицію та ланцюжок :ref:`modulate<class_CanvasItem_property_modulate>`. Дивіться також :ref:`top_level<class_CanvasItem_property_top_level>`.
.. rst-class:: classref-introduction-group
Посібники
------------------
- :doc:`Перетворення вікна перегляду та полотна <../tutorials/2d/2d_transforms>`
- :doc:`Власне малювання в 2D <../tutorials/2d/custom_drawing_in_2d>`
- `Демонстрація візуалізатора аудіоспектру <https://godotengine.org/asset-library/asset/2762>`__
.. rst-class:: classref-reftable-group
Властивості
----------------------
.. table::
:widths: auto
+-----------------------------------------------------------+---------------------------------------------------------------------------+-----------------------+
| :ref:`ClipChildrenMode<enum_CanvasItem_ClipChildrenMode>` | :ref:`clip_children<class_CanvasItem_property_clip_children>` | ``0`` |
+-----------------------------------------------------------+---------------------------------------------------------------------------+-----------------------+
| :ref:`int<class_int>` | :ref:`light_mask<class_CanvasItem_property_light_mask>` | ``1`` |
+-----------------------------------------------------------+---------------------------------------------------------------------------+-----------------------+
| :ref:`Material<class_Material>` | :ref:`material<class_CanvasItem_property_material>` | |
+-----------------------------------------------------------+---------------------------------------------------------------------------+-----------------------+
| :ref:`Color<class_Color>` | :ref:`modulate<class_CanvasItem_property_modulate>` | ``Color(1, 1, 1, 1)`` |
+-----------------------------------------------------------+---------------------------------------------------------------------------+-----------------------+
| :ref:`Color<class_Color>` | :ref:`self_modulate<class_CanvasItem_property_self_modulate>` | ``Color(1, 1, 1, 1)`` |
+-----------------------------------------------------------+---------------------------------------------------------------------------+-----------------------+
| :ref:`bool<class_bool>` | :ref:`show_behind_parent<class_CanvasItem_property_show_behind_parent>` | ``false`` |
+-----------------------------------------------------------+---------------------------------------------------------------------------+-----------------------+
| :ref:`TextureFilter<enum_CanvasItem_TextureFilter>` | :ref:`texture_filter<class_CanvasItem_property_texture_filter>` | ``0`` |
+-----------------------------------------------------------+---------------------------------------------------------------------------+-----------------------+
| :ref:`TextureRepeat<enum_CanvasItem_TextureRepeat>` | :ref:`texture_repeat<class_CanvasItem_property_texture_repeat>` | ``0`` |
+-----------------------------------------------------------+---------------------------------------------------------------------------+-----------------------+
| :ref:`bool<class_bool>` | :ref:`top_level<class_CanvasItem_property_top_level>` | ``false`` |
+-----------------------------------------------------------+---------------------------------------------------------------------------+-----------------------+
| :ref:`bool<class_bool>` | :ref:`use_parent_material<class_CanvasItem_property_use_parent_material>` | ``false`` |
+-----------------------------------------------------------+---------------------------------------------------------------------------+-----------------------+
| :ref:`int<class_int>` | :ref:`visibility_layer<class_CanvasItem_property_visibility_layer>` | ``1`` |
+-----------------------------------------------------------+---------------------------------------------------------------------------+-----------------------+
| :ref:`bool<class_bool>` | :ref:`visible<class_CanvasItem_property_visible>` | ``true`` |
+-----------------------------------------------------------+---------------------------------------------------------------------------+-----------------------+
| :ref:`bool<class_bool>` | :ref:`y_sort_enabled<class_CanvasItem_property_y_sort_enabled>` | ``false`` |
+-----------------------------------------------------------+---------------------------------------------------------------------------+-----------------------+
| :ref:`bool<class_bool>` | :ref:`z_as_relative<class_CanvasItem_property_z_as_relative>` | ``true`` |
+-----------------------------------------------------------+---------------------------------------------------------------------------+-----------------------+
| :ref:`int<class_int>` | :ref:`z_index<class_CanvasItem_property_z_index>` | ``0`` |
+-----------------------------------------------------------+---------------------------------------------------------------------------+-----------------------+
.. rst-class:: classref-reftable-group
Методи
------------
.. table::
:widths: auto
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`_draw<class_CanvasItem_private_method__draw>`\ (\ ) |virtual| |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_animation_slice<class_CanvasItem_method_draw_animation_slice>`\ (\ animation_length\: :ref:`float<class_float>`, slice_begin\: :ref:`float<class_float>`, slice_end\: :ref:`float<class_float>`, offset\: :ref:`float<class_float>` = 0.0\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_arc<class_CanvasItem_method_draw_arc>`\ (\ center\: :ref:`Vector2<class_Vector2>`, radius\: :ref:`float<class_float>`, start_angle\: :ref:`float<class_float>`, end_angle\: :ref:`float<class_float>`, point_count\: :ref:`int<class_int>`, color\: :ref:`Color<class_Color>`, width\: :ref:`float<class_float>` = -1.0, antialiased\: :ref:`bool<class_bool>` = false\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_char<class_CanvasItem_method_draw_char>`\ (\ font\: :ref:`Font<class_Font>`, pos\: :ref:`Vector2<class_Vector2>`, char\: :ref:`String<class_String>`, font_size\: :ref:`int<class_int>` = 16, modulate\: :ref:`Color<class_Color>` = Color(1, 1, 1, 1), oversampling\: :ref:`float<class_float>` = 0.0\ ) |const| |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_char_outline<class_CanvasItem_method_draw_char_outline>`\ (\ font\: :ref:`Font<class_Font>`, pos\: :ref:`Vector2<class_Vector2>`, char\: :ref:`String<class_String>`, font_size\: :ref:`int<class_int>` = 16, size\: :ref:`int<class_int>` = -1, modulate\: :ref:`Color<class_Color>` = Color(1, 1, 1, 1), oversampling\: :ref:`float<class_float>` = 0.0\ ) |const| |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_circle<class_CanvasItem_method_draw_circle>`\ (\ position\: :ref:`Vector2<class_Vector2>`, radius\: :ref:`float<class_float>`, color\: :ref:`Color<class_Color>`, filled\: :ref:`bool<class_bool>` = true, width\: :ref:`float<class_float>` = -1.0, antialiased\: :ref:`bool<class_bool>` = false\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_colored_polygon<class_CanvasItem_method_draw_colored_polygon>`\ (\ points\: :ref:`PackedVector2Array<class_PackedVector2Array>`, color\: :ref:`Color<class_Color>`, uvs\: :ref:`PackedVector2Array<class_PackedVector2Array>` = PackedVector2Array(), texture\: :ref:`Texture2D<class_Texture2D>` = null\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_dashed_line<class_CanvasItem_method_draw_dashed_line>`\ (\ from\: :ref:`Vector2<class_Vector2>`, to\: :ref:`Vector2<class_Vector2>`, color\: :ref:`Color<class_Color>`, width\: :ref:`float<class_float>` = -1.0, dash\: :ref:`float<class_float>` = 2.0, aligned\: :ref:`bool<class_bool>` = true, antialiased\: :ref:`bool<class_bool>` = false\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_end_animation<class_CanvasItem_method_draw_end_animation>`\ (\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_lcd_texture_rect_region<class_CanvasItem_method_draw_lcd_texture_rect_region>`\ (\ texture\: :ref:`Texture2D<class_Texture2D>`, rect\: :ref:`Rect2<class_Rect2>`, src_rect\: :ref:`Rect2<class_Rect2>`, modulate\: :ref:`Color<class_Color>` = Color(1, 1, 1, 1)\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_line<class_CanvasItem_method_draw_line>`\ (\ from\: :ref:`Vector2<class_Vector2>`, to\: :ref:`Vector2<class_Vector2>`, color\: :ref:`Color<class_Color>`, width\: :ref:`float<class_float>` = -1.0, antialiased\: :ref:`bool<class_bool>` = false\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_mesh<class_CanvasItem_method_draw_mesh>`\ (\ mesh\: :ref:`Mesh<class_Mesh>`, texture\: :ref:`Texture2D<class_Texture2D>`, transform\: :ref:`Transform2D<class_Transform2D>` = Transform2D(1, 0, 0, 1, 0, 0), modulate\: :ref:`Color<class_Color>` = Color(1, 1, 1, 1)\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_msdf_texture_rect_region<class_CanvasItem_method_draw_msdf_texture_rect_region>`\ (\ texture\: :ref:`Texture2D<class_Texture2D>`, rect\: :ref:`Rect2<class_Rect2>`, src_rect\: :ref:`Rect2<class_Rect2>`, modulate\: :ref:`Color<class_Color>` = Color(1, 1, 1, 1), outline\: :ref:`float<class_float>` = 0.0, pixel_range\: :ref:`float<class_float>` = 4.0, scale\: :ref:`float<class_float>` = 1.0\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_multiline<class_CanvasItem_method_draw_multiline>`\ (\ points\: :ref:`PackedVector2Array<class_PackedVector2Array>`, color\: :ref:`Color<class_Color>`, width\: :ref:`float<class_float>` = -1.0, antialiased\: :ref:`bool<class_bool>` = false\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_multiline_colors<class_CanvasItem_method_draw_multiline_colors>`\ (\ points\: :ref:`PackedVector2Array<class_PackedVector2Array>`, colors\: :ref:`PackedColorArray<class_PackedColorArray>`, width\: :ref:`float<class_float>` = -1.0, antialiased\: :ref:`bool<class_bool>` = false\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_multiline_string<class_CanvasItem_method_draw_multiline_string>`\ (\ font\: :ref:`Font<class_Font>`, pos\: :ref:`Vector2<class_Vector2>`, text\: :ref:`String<class_String>`, alignment\: :ref:`HorizontalAlignment<enum_@GlobalScope_HorizontalAlignment>` = 0, width\: :ref:`float<class_float>` = -1, font_size\: :ref:`int<class_int>` = 16, max_lines\: :ref:`int<class_int>` = -1, modulate\: :ref:`Color<class_Color>` = Color(1, 1, 1, 1), brk_flags\: |bitfield|\[:ref:`LineBreakFlag<enum_TextServer_LineBreakFlag>`\] = 3, justification_flags\: |bitfield|\[:ref:`JustificationFlag<enum_TextServer_JustificationFlag>`\] = 3, direction\: :ref:`Direction<enum_TextServer_Direction>` = 0, orientation\: :ref:`Orientation<enum_TextServer_Orientation>` = 0, oversampling\: :ref:`float<class_float>` = 0.0\ ) |const| |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_multiline_string_outline<class_CanvasItem_method_draw_multiline_string_outline>`\ (\ font\: :ref:`Font<class_Font>`, pos\: :ref:`Vector2<class_Vector2>`, text\: :ref:`String<class_String>`, alignment\: :ref:`HorizontalAlignment<enum_@GlobalScope_HorizontalAlignment>` = 0, width\: :ref:`float<class_float>` = -1, font_size\: :ref:`int<class_int>` = 16, max_lines\: :ref:`int<class_int>` = -1, size\: :ref:`int<class_int>` = 1, modulate\: :ref:`Color<class_Color>` = Color(1, 1, 1, 1), brk_flags\: |bitfield|\[:ref:`LineBreakFlag<enum_TextServer_LineBreakFlag>`\] = 3, justification_flags\: |bitfield|\[:ref:`JustificationFlag<enum_TextServer_JustificationFlag>`\] = 3, direction\: :ref:`Direction<enum_TextServer_Direction>` = 0, orientation\: :ref:`Orientation<enum_TextServer_Orientation>` = 0, oversampling\: :ref:`float<class_float>` = 0.0\ ) |const| |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_multimesh<class_CanvasItem_method_draw_multimesh>`\ (\ multimesh\: :ref:`MultiMesh<class_MultiMesh>`, texture\: :ref:`Texture2D<class_Texture2D>`\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_polygon<class_CanvasItem_method_draw_polygon>`\ (\ points\: :ref:`PackedVector2Array<class_PackedVector2Array>`, colors\: :ref:`PackedColorArray<class_PackedColorArray>`, uvs\: :ref:`PackedVector2Array<class_PackedVector2Array>` = PackedVector2Array(), texture\: :ref:`Texture2D<class_Texture2D>` = null\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_polyline<class_CanvasItem_method_draw_polyline>`\ (\ points\: :ref:`PackedVector2Array<class_PackedVector2Array>`, color\: :ref:`Color<class_Color>`, width\: :ref:`float<class_float>` = -1.0, antialiased\: :ref:`bool<class_bool>` = false\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_polyline_colors<class_CanvasItem_method_draw_polyline_colors>`\ (\ points\: :ref:`PackedVector2Array<class_PackedVector2Array>`, colors\: :ref:`PackedColorArray<class_PackedColorArray>`, width\: :ref:`float<class_float>` = -1.0, antialiased\: :ref:`bool<class_bool>` = false\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_primitive<class_CanvasItem_method_draw_primitive>`\ (\ points\: :ref:`PackedVector2Array<class_PackedVector2Array>`, colors\: :ref:`PackedColorArray<class_PackedColorArray>`, uvs\: :ref:`PackedVector2Array<class_PackedVector2Array>`, texture\: :ref:`Texture2D<class_Texture2D>` = null\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_rect<class_CanvasItem_method_draw_rect>`\ (\ rect\: :ref:`Rect2<class_Rect2>`, color\: :ref:`Color<class_Color>`, filled\: :ref:`bool<class_bool>` = true, width\: :ref:`float<class_float>` = -1.0, antialiased\: :ref:`bool<class_bool>` = false\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_set_transform<class_CanvasItem_method_draw_set_transform>`\ (\ position\: :ref:`Vector2<class_Vector2>`, rotation\: :ref:`float<class_float>` = 0.0, scale\: :ref:`Vector2<class_Vector2>` = Vector2(1, 1)\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_set_transform_matrix<class_CanvasItem_method_draw_set_transform_matrix>`\ (\ xform\: :ref:`Transform2D<class_Transform2D>`\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_string<class_CanvasItem_method_draw_string>`\ (\ font\: :ref:`Font<class_Font>`, pos\: :ref:`Vector2<class_Vector2>`, text\: :ref:`String<class_String>`, alignment\: :ref:`HorizontalAlignment<enum_@GlobalScope_HorizontalAlignment>` = 0, width\: :ref:`float<class_float>` = -1, font_size\: :ref:`int<class_int>` = 16, modulate\: :ref:`Color<class_Color>` = Color(1, 1, 1, 1), justification_flags\: |bitfield|\[:ref:`JustificationFlag<enum_TextServer_JustificationFlag>`\] = 3, direction\: :ref:`Direction<enum_TextServer_Direction>` = 0, orientation\: :ref:`Orientation<enum_TextServer_Orientation>` = 0, oversampling\: :ref:`float<class_float>` = 0.0\ ) |const| |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_string_outline<class_CanvasItem_method_draw_string_outline>`\ (\ font\: :ref:`Font<class_Font>`, pos\: :ref:`Vector2<class_Vector2>`, text\: :ref:`String<class_String>`, alignment\: :ref:`HorizontalAlignment<enum_@GlobalScope_HorizontalAlignment>` = 0, width\: :ref:`float<class_float>` = -1, font_size\: :ref:`int<class_int>` = 16, size\: :ref:`int<class_int>` = 1, modulate\: :ref:`Color<class_Color>` = Color(1, 1, 1, 1), justification_flags\: |bitfield|\[:ref:`JustificationFlag<enum_TextServer_JustificationFlag>`\] = 3, direction\: :ref:`Direction<enum_TextServer_Direction>` = 0, orientation\: :ref:`Orientation<enum_TextServer_Orientation>` = 0, oversampling\: :ref:`float<class_float>` = 0.0\ ) |const| |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_style_box<class_CanvasItem_method_draw_style_box>`\ (\ style_box\: :ref:`StyleBox<class_StyleBox>`, rect\: :ref:`Rect2<class_Rect2>`\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_texture<class_CanvasItem_method_draw_texture>`\ (\ texture\: :ref:`Texture2D<class_Texture2D>`, position\: :ref:`Vector2<class_Vector2>`, modulate\: :ref:`Color<class_Color>` = Color(1, 1, 1, 1)\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_texture_rect<class_CanvasItem_method_draw_texture_rect>`\ (\ texture\: :ref:`Texture2D<class_Texture2D>`, rect\: :ref:`Rect2<class_Rect2>`, tile\: :ref:`bool<class_bool>`, modulate\: :ref:`Color<class_Color>` = Color(1, 1, 1, 1), transpose\: :ref:`bool<class_bool>` = false\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`draw_texture_rect_region<class_CanvasItem_method_draw_texture_rect_region>`\ (\ texture\: :ref:`Texture2D<class_Texture2D>`, rect\: :ref:`Rect2<class_Rect2>`, src_rect\: :ref:`Rect2<class_Rect2>`, modulate\: :ref:`Color<class_Color>` = Color(1, 1, 1, 1), transpose\: :ref:`bool<class_bool>` = false, clip_uv\: :ref:`bool<class_bool>` = true\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`force_update_transform<class_CanvasItem_method_force_update_transform>`\ (\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`get_canvas<class_CanvasItem_method_get_canvas>`\ (\ ) |const| |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`get_canvas_item<class_CanvasItem_method_get_canvas_item>`\ (\ ) |const| |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`CanvasLayer<class_CanvasLayer>` | :ref:`get_canvas_layer_node<class_CanvasItem_method_get_canvas_layer_node>`\ (\ ) |const| |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Transform2D<class_Transform2D>` | :ref:`get_canvas_transform<class_CanvasItem_method_get_canvas_transform>`\ (\ ) |const| |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`get_global_mouse_position<class_CanvasItem_method_get_global_mouse_position>`\ (\ ) |const| |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Transform2D<class_Transform2D>` | :ref:`get_global_transform<class_CanvasItem_method_get_global_transform>`\ (\ ) |const| |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Transform2D<class_Transform2D>` | :ref:`get_global_transform_with_canvas<class_CanvasItem_method_get_global_transform_with_canvas>`\ (\ ) |const| |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Variant<class_Variant>` | :ref:`get_instance_shader_parameter<class_CanvasItem_method_get_instance_shader_parameter>`\ (\ name\: :ref:`StringName<class_StringName>`\ ) |const| |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`get_local_mouse_position<class_CanvasItem_method_get_local_mouse_position>`\ (\ ) |const| |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Transform2D<class_Transform2D>` | :ref:`get_screen_transform<class_CanvasItem_method_get_screen_transform>`\ (\ ) |const| |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Transform2D<class_Transform2D>` | :ref:`get_transform<class_CanvasItem_method_get_transform>`\ (\ ) |const| |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Rect2<class_Rect2>` | :ref:`get_viewport_rect<class_CanvasItem_method_get_viewport_rect>`\ (\ ) |const| |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Transform2D<class_Transform2D>` | :ref:`get_viewport_transform<class_CanvasItem_method_get_viewport_transform>`\ (\ ) |const| |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`get_visibility_layer_bit<class_CanvasItem_method_get_visibility_layer_bit>`\ (\ layer\: :ref:`int<class_int>`\ ) |const| |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`World2D<class_World2D>` | :ref:`get_world_2d<class_CanvasItem_method_get_world_2d>`\ (\ ) |const| |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`hide<class_CanvasItem_method_hide>`\ (\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_local_transform_notification_enabled<class_CanvasItem_method_is_local_transform_notification_enabled>`\ (\ ) |const| |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_transform_notification_enabled<class_CanvasItem_method_is_transform_notification_enabled>`\ (\ ) |const| |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_visible_in_tree<class_CanvasItem_method_is_visible_in_tree>`\ (\ ) |const| |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`make_canvas_position_local<class_CanvasItem_method_make_canvas_position_local>`\ (\ viewport_point\: :ref:`Vector2<class_Vector2>`\ ) |const| |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`InputEvent<class_InputEvent>` | :ref:`make_input_local<class_CanvasItem_method_make_input_local>`\ (\ event\: :ref:`InputEvent<class_InputEvent>`\ ) |const| |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`move_to_front<class_CanvasItem_method_move_to_front>`\ (\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`queue_redraw<class_CanvasItem_method_queue_redraw>`\ (\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set_instance_shader_parameter<class_CanvasItem_method_set_instance_shader_parameter>`\ (\ name\: :ref:`StringName<class_StringName>`, value\: :ref:`Variant<class_Variant>`\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set_notify_local_transform<class_CanvasItem_method_set_notify_local_transform>`\ (\ enable\: :ref:`bool<class_bool>`\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set_notify_transform<class_CanvasItem_method_set_notify_transform>`\ (\ enable\: :ref:`bool<class_bool>`\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set_visibility_layer_bit<class_CanvasItem_method_set_visibility_layer_bit>`\ (\ layer\: :ref:`int<class_int>`, enabled\: :ref:`bool<class_bool>`\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`show<class_CanvasItem_method_show>`\ (\ ) |
+---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Сигнали
--------------
.. _class_CanvasItem_signal_draw:
.. rst-class:: classref-signal
**draw**\ (\ ) :ref:`🔗<class_CanvasItem_signal_draw>`
Видається, коли **CanvasItem** потрібно перемалювати, *після* пов’язаного сповіщення :ref:`NOTIFICATION_DRAW<class_CanvasItem_constant_NOTIFICATION_DRAW>` і *до* виклику :ref:`_draw()<class_CanvasItem_private_method__draw>`.
\ **Примітка:** Відкладені підключення не дозволяють малювання за допомогою методів ``draw_*``.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_signal_hidden:
.. rst-class:: classref-signal
**hidden**\ (\ ) :ref:`🔗<class_CanvasItem_signal_hidden>`
Викликається, коли цей вузол стає прихованим, тобто він більше не видимий у дереві (див. :ref:`is_visible_in_tree()<class_CanvasItem_method_is_visible_in_tree>`).
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_signal_item_rect_changed:
.. rst-class:: classref-signal
**item_rect_changed**\ (\ ) :ref:`🔗<class_CanvasItem_signal_item_rect_changed>`
Випускається, коли межі **CanvasItem** (позиція чи розмір) змінюються або коли виконується дія, яка могла вплинути на ці межі (наприклад, зміна :ref:`Sprite2D.texture<class_Sprite2D_property_texture>`).
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_signal_visibility_changed:
.. rst-class:: classref-signal
**visibility_changed**\ (\ ) :ref:`🔗<class_CanvasItem_signal_visibility_changed>`
Випускається, коли змінюється видимість **CanvasItem**, або через зміну його власної властивості :ref:`visible<class_CanvasItem_property_visible>`, або через зміну його видимості в дереві (див. метод :ref:`is_visible_in_tree()<class_CanvasItem_method_is_visible_in_tree>`).
Цей сигнал випромінюється *після* пов'язаного сповіщення :ref:`NOTIFICATION_VISIBILITY_CHANGED<class_CanvasItem_constant_NOTIFICATION_VISIBILITY_CHANGED>`.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Переліки
----------------
.. _enum_CanvasItem_TextureFilter:
.. rst-class:: classref-enumeration
enum **TextureFilter**: :ref:`🔗<enum_CanvasItem_TextureFilter>`
.. _class_CanvasItem_constant_TEXTURE_FILTER_PARENT_NODE:
.. rst-class:: classref-enumeration-constant
:ref:`TextureFilter<enum_CanvasItem_TextureFilter>` **TEXTURE_FILTER_PARENT_NODE** = ``0``
**CanvasItem** успадкує фільтр від батьківського.
.. _class_CanvasItem_constant_TEXTURE_FILTER_NEAREST:
.. rst-class:: classref-enumeration-constant
:ref:`TextureFilter<enum_CanvasItem_TextureFilter>` **TEXTURE_FILTER_NEAREST** = ``1``
Фільтр текстур читає лише з найближчого пікселя. Це робить текстуру піксельною зблизька та зернистою на відстані (через те, що MIP-карти не вибираються).
.. _class_CanvasItem_constant_TEXTURE_FILTER_LINEAR:
.. rst-class:: classref-enumeration-constant
:ref:`TextureFilter<enum_CanvasItem_TextureFilter>` **TEXTURE_FILTER_LINEAR** = ``2``
Фільтр текстури змішується між найближчими 4 пікселями. Це робить текстуру гладкою зблизька та зернистою на відстані (через те, що MIP-карти не вибираються).
.. _class_CanvasItem_constant_TEXTURE_FILTER_NEAREST_WITH_MIPMAPS:
.. rst-class:: classref-enumeration-constant
:ref:`TextureFilter<enum_CanvasItem_TextureFilter>` **TEXTURE_FILTER_NEAREST_WITH_MIPMAPS** = ``3``
Фільтр текстур зчитує з найближчого пікселя та змішує між двома найближчими картами mipmap (або використовує найближчу карту mipmap, якщо :ref:`ProjectSettings.rendering/textures/default_filters/use_nearest_mipmap_filter<class_ProjectSettings_property_rendering/textures/default_filters/use_nearest_mipmap_filter>` має значення ``true``). Це робить текстуру піксельною зблизька та гладкою на відстані.
Використовуйте це для непіксельних текстур, які можна переглядати в низькому масштабі (наприклад, через масштабування :ref:`Camera2D<class_Camera2D>` або масштабування спрайтів), оскільки міп-мапи важливі для згладжування пікселів, які менші за пікселі на екрані.
.. _class_CanvasItem_constant_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS:
.. rst-class:: classref-enumeration-constant
:ref:`TextureFilter<enum_CanvasItem_TextureFilter>` **TEXTURE_FILTER_LINEAR_WITH_MIPMAPS** = ``4``
Фільтр текстур змішує найближчі 4 пікселі з найближчими 2 картами mipmap (або використовує найближчу карту mipmap, якщо :ref:`ProjectSettings.rendering/textures/default_filters/use_nearest_mipmap_filter<class_ProjectSettings_property_rendering/textures/default_filters/use_nearest_mipmap_filter>` має значення ``true``). Це робить текстуру гладкою зблизька та гладкою на відстані.
Використовуйте це для непіксельних текстур, які можна переглядати в низькому масштабі (наприклад, через масштабування :ref:`Camera2D<class_Camera2D>` або масштабування спрайтів), оскільки міп-мапи важливі для згладжування пікселів, які менші за пікселі на екрані.
.. _class_CanvasItem_constant_TEXTURE_FILTER_NEAREST_WITH_MIPMAPS_ANISOTROPIC:
.. rst-class:: classref-enumeration-constant
:ref:`TextureFilter<enum_CanvasItem_TextureFilter>` **TEXTURE_FILTER_NEAREST_WITH_MIPMAPS_ANISOTROPIC** = ``5``
Фільтр текстури зчитує з найближчого пікселя та змішує 2 mipmap (або використовує найближче mipmap, якщо :ref:`ProjectSettings.rendering/textures/default_filters/use_nearest_mipmap_filter<class_ProjectSettings_property_rendering/textures/default_filters/use_nearest_mipmap_filter>` має значення ``true``) на основі кута між поверхнею та вид камери. Це робить текстуру піксельною зблизька та гладкою на відстані. Анізотропна фільтрація покращує якість текстури на поверхнях, які знаходяться майже на одній лінії з камерою, але трохи повільніше. Рівень анізотропної фільтрації можна змінити, налаштувавши :ref:`ProjectSettings.rendering/textures/default_filters/anisotropic_filtering_level<class_ProjectSettings_property_rendering/textures/default_filters/anisotropic_filtering_level>`.
\ **Примітка:** Цей текстурний фільтр рідко використовується в 2D-проектах. :ref:`TEXTURE_FILTER_NEAREST_WITH_MIPMAPS<class_CanvasItem_constant_TEXTURE_FILTER_NEAREST_WITH_MIPMAPS>` зазвичай більш доречна в цьому випадку.
.. _class_CanvasItem_constant_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS_ANISOTROPIC:
.. rst-class:: classref-enumeration-constant
:ref:`TextureFilter<enum_CanvasItem_TextureFilter>` **TEXTURE_FILTER_LINEAR_WITH_MIPMAPS_ANISOTROPIC** = ``6``
Фільтр текстури змішує найближчі 4 пікселі та змішує 2 mipmap (або використовує найближче mipmap, якщо :ref:`ProjectSettings.rendering/textures/default_filters/use_nearest_mipmap_filter<class_ProjectSettings_property_rendering/textures/default_filters/use_nearest_mipmap_filter>` має значення ``true``) на основі кута між поверхнею і вигляд камери. Це робить текстуру гладкою зблизька та гладкою на відстані. Анізотропна фільтрація покращує якість текстури на поверхнях, які знаходяться майже на одній лінії з камерою, але трохи повільніше. Рівень анізотропної фільтрації можна змінити, налаштувавши :ref:`ProjectSettings.rendering/textures/default_filters/anisotropic_filtering_level<class_ProjectSettings_property_rendering/textures/default_filters/anisotropic_filtering_level>`.
\ **Примітка:** Цей текстурний фільтр рідко використовується в 2D-проектах. :ref:`TEXTURE_FILTER_LINEAR_WITH_MIPMAPS<class_CanvasItem_constant_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS>` зазвичай більш доречна в цьому випадку.
.. _class_CanvasItem_constant_TEXTURE_FILTER_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`TextureFilter<enum_CanvasItem_TextureFilter>` **TEXTURE_FILTER_MAX** = ``7``
Представляє розмір переліку :ref:`TextureFilter<enum_CanvasItem_TextureFilter>`.
.. rst-class:: classref-item-separator
----
.. _enum_CanvasItem_TextureRepeat:
.. rst-class:: classref-enumeration
enum **TextureRepeat**: :ref:`🔗<enum_CanvasItem_TextureRepeat>`
.. _class_CanvasItem_constant_TEXTURE_REPEAT_PARENT_NODE:
.. rst-class:: classref-enumeration-constant
:ref:`TextureRepeat<enum_CanvasItem_TextureRepeat>` **TEXTURE_REPEAT_PARENT_NODE** = ``0``
**CanvasItem** успадкує фільтр від батьківського.
.. _class_CanvasItem_constant_TEXTURE_REPEAT_DISABLED:
.. rst-class:: classref-enumeration-constant
:ref:`TextureRepeat<enum_CanvasItem_TextureRepeat>` **TEXTURE_REPEAT_DISABLED** = ``1``
Текстура не повторюється. Семплювання текстури за межами її меж призведе до «розтягування» крайових пікселів. Цього можна уникнути, забезпечивши повністю прозору рамку шириною 1 піксель з кожного боку текстури.
.. _class_CanvasItem_constant_TEXTURE_REPEAT_ENABLED:
.. rst-class:: classref-enumeration-constant
:ref:`TextureRepeat<enum_CanvasItem_TextureRepeat>` **TEXTURE_REPEAT_ENABLED** = ``2``
Текстура повторюється, коли перевищує розмір текстури.
.. _class_CanvasItem_constant_TEXTURE_REPEAT_MIRROR:
.. rst-class:: classref-enumeration-constant
:ref:`TextureRepeat<enum_CanvasItem_TextureRepeat>` **TEXTURE_REPEAT_MIRROR** = ``3``
Текстура повторюється, коли перевищує розмір текстури в "мозаичному режимі 2×2". Повторювані текстури в парних положеннях дзеркально відображаються.
.. _class_CanvasItem_constant_TEXTURE_REPEAT_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`TextureRepeat<enum_CanvasItem_TextureRepeat>` **TEXTURE_REPEAT_MAX** = ``4``
Представляє розмір переліку :ref:`TextureRepeat<enum_CanvasItem_TextureRepeat>`.
.. rst-class:: classref-item-separator
----
.. _enum_CanvasItem_ClipChildrenMode:
.. rst-class:: classref-enumeration
enum **ClipChildrenMode**: :ref:`🔗<enum_CanvasItem_ClipChildrenMode>`
.. _class_CanvasItem_constant_CLIP_CHILDREN_DISABLED:
.. rst-class:: classref-enumeration-constant
:ref:`ClipChildrenMode<enum_CanvasItem_ClipChildrenMode>` **CLIP_CHILDREN_DISABLED** = ``0``
Дочірні елементи малюються над цим вузлом і не обрізаються.
.. _class_CanvasItem_constant_CLIP_CHILDREN_ONLY:
.. rst-class:: classref-enumeration-constant
:ref:`ClipChildrenMode<enum_CanvasItem_ClipChildrenMode>` **CLIP_CHILDREN_ONLY** = ``1``
Цей вузол використовується як маска і **не** малюється. Маска базується на альфа-каналі цього вузла: непрозорі пікселі зберігаються, прозорі пікселі відкидаються, а напівпрозорі пікселі змішуються відповідно до їхньої непрозорості. Дочірні елементи обрізаються до намальованої області цього вузла.
.. _class_CanvasItem_constant_CLIP_CHILDREN_AND_DRAW:
.. rst-class:: classref-enumeration-constant
:ref:`ClipChildrenMode<enum_CanvasItem_ClipChildrenMode>` **CLIP_CHILDREN_AND_DRAW** = ``2``
Цей вузол використовується як маска, а також малюється. Маска базується на альфа-каналі цього вузла: непрозорі пікселі зберігаються, прозорі пікселі відкидаються, а напівпрозорі пікселі змішуються відповідно до їхньої непрозорості. Дочірні елементи обрізаються до намальованої області батьківського вузла.
.. _class_CanvasItem_constant_CLIP_CHILDREN_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`ClipChildrenMode<enum_CanvasItem_ClipChildrenMode>` **CLIP_CHILDREN_MAX** = ``3``
Представляє розмір переліку :ref:`ClipChildrenMode<enum_CanvasItem_ClipChildrenMode>`.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Константи
------------------
.. _class_CanvasItem_constant_NOTIFICATION_TRANSFORM_CHANGED:
.. rst-class:: classref-constant
**NOTIFICATION_TRANSFORM_CHANGED** = ``2000`` :ref:`🔗<class_CanvasItem_constant_NOTIFICATION_TRANSFORM_CHANGED>`
Сповіщення отримується, коли змінюється глобальне перетворення цього вузла, якщо :ref:`is_transform_notification_enabled()<class_CanvasItem_method_is_transform_notification_enabled>` має значення ``true``. Див. також :ref:`set_notify_transform()<class_CanvasItem_method_set_notify_transform>` та :ref:`get_transform()<class_CanvasItem_method_get_transform>`.
\ **Примітка:** Багато елементів полотна, такі як :ref:`Camera2D<class_Camera2D>` або :ref:`CollisionObject2D<class_CollisionObject2D>`, автоматично вмикають це для правильної роботи.
.. _class_CanvasItem_constant_NOTIFICATION_LOCAL_TRANSFORM_CHANGED:
.. rst-class:: classref-constant
**NOTIFICATION_LOCAL_TRANSFORM_CHANGED** = ``35`` :ref:`🔗<class_CanvasItem_constant_NOTIFICATION_LOCAL_TRANSFORM_CHANGED>`
Сповіщення отримується, коли змінюється перетворення цього вузла, якщо :ref:`is_local_transform_notification_enabled()<class_CanvasItem_method_is_local_transform_notification_enabled>` має значення ``true``. Це не отримується, коли змінюється перетворення батьківського вузла :ref:`Node2D<class_Node2D>`. Див. також :ref:`set_notify_local_transform()<class_CanvasItem_method_set_notify_local_transform>`.
\ **Примітка:** Багато елементів полотна, такі як :ref:`Camera2D<class_Camera2D>` або :ref:`CollisionShape2D<class_CollisionShape2D>`, автоматично вмикають це для правильної роботи.
.. _class_CanvasItem_constant_NOTIFICATION_DRAW:
.. rst-class:: classref-constant
**NOTIFICATION_DRAW** = ``30`` :ref:`🔗<class_CanvasItem_constant_NOTIFICATION_DRAW>`
**CanvasItem** запитується для малювання (див. :ref:`_draw()<class_CanvasItem_private_method__draw>`).
.. _class_CanvasItem_constant_NOTIFICATION_VISIBILITY_CHANGED:
.. rst-class:: classref-constant
**NOTIFICATION_VISIBILITY_CHANGED** = ``31`` :ref:`🔗<class_CanvasItem_constant_NOTIFICATION_VISIBILITY_CHANGED>`
Сповіщення отримується, коли змінюється видимість цього вузла (див. :ref:`visible<class_CanvasItem_property_visible>` та :ref:`is_visible_in_tree()<class_CanvasItem_method_is_visible_in_tree>`).
Це сповіщення отримується *перед* пов'язаним сигналом :ref:`visibility_changed<class_CanvasItem_signal_visibility_changed>`.
.. _class_CanvasItem_constant_NOTIFICATION_ENTER_CANVAS:
.. rst-class:: classref-constant
**NOTIFICATION_ENTER_CANVAS** = ``32`` :ref:`🔗<class_CanvasItem_constant_NOTIFICATION_ENTER_CANVAS>`
**CanvasItem** перейшов на полотно.
.. _class_CanvasItem_constant_NOTIFICATION_EXIT_CANVAS:
.. rst-class:: classref-constant
**NOTIFICATION_EXIT_CANVAS** = ``33`` :ref:`🔗<class_CanvasItem_constant_NOTIFICATION_EXIT_CANVAS>`
**CanvasItem** вийшов із полотна.
.. _class_CanvasItem_constant_NOTIFICATION_WORLD_2D_CHANGED:
.. rst-class:: classref-constant
**NOTIFICATION_WORLD_2D_CHANGED** = ``36`` :ref:`🔗<class_CanvasItem_constant_NOTIFICATION_WORLD_2D_CHANGED>`
Сповіщення отримано, коли цей **CanvasItem** зареєстровано в новому :ref:`World2D<class_World2D>` (див. :ref:`get_world_2d()<class_CanvasItem_method_get_world_2d>`).
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Описи властивостей
------------------------------------
.. _class_CanvasItem_property_clip_children:
.. rst-class:: classref-property
:ref:`ClipChildrenMode<enum_CanvasItem_ClipChildrenMode>` **clip_children** = ``0`` :ref:`🔗<class_CanvasItem_property_clip_children>`
.. rst-class:: classref-property-setget
- |void| **set_clip_children_mode**\ (\ value\: :ref:`ClipChildrenMode<enum_CanvasItem_ClipChildrenMode>`\ )
- :ref:`ClipChildrenMode<enum_CanvasItem_ClipChildrenMode>` **get_clip_children_mode**\ (\ )
Режим, у якому цей вузол обрізає своїх дочірніх вузлів, діючи як маска.
\ **Примітка:** Вузли обрізання не можуть бути вкладеними або розміщеними всередині :ref:`CanvasGroup<class_CanvasGroup>`. Якщо предок цього вузла обрізає своїх дочірніх вузлів або є :ref:`CanvasGroup<class_CanvasGroup>`, то режим обрізання цього вузла слід встановити на :ref:`CLIP_CHILDREN_DISABLED<class_CanvasItem_constant_CLIP_CHILDREN_DISABLED>`, щоб уникнути неочікуваної поведінки.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_property_light_mask:
.. rst-class:: classref-property
:ref:`int<class_int>` **light_mask** = ``1`` :ref:`🔗<class_CanvasItem_property_light_mask>`
.. rst-class:: classref-property-setget
- |void| **set_light_mask**\ (\ value\: :ref:`int<class_int>`\ )
- :ref:`int<class_int>` **get_light_mask**\ (\ )
Шари візуалізації, у яких цей **CanvasItem** реагує на вузли :ref:`Light2D<class_Light2D>`.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_property_material:
.. rst-class:: classref-property
:ref:`Material<class_Material>` **material** :ref:`🔗<class_CanvasItem_property_material>`
.. rst-class:: classref-property-setget
- |void| **set_material**\ (\ value\: :ref:`Material<class_Material>`\ )
- :ref:`Material<class_Material>` **get_material**\ (\ )
Матеріал, застосований до цього **CanvasItem**.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_property_modulate:
.. rst-class:: classref-property
:ref:`Color<class_Color>` **modulate** = ``Color(1, 1, 1, 1)`` :ref:`🔗<class_CanvasItem_property_modulate>`
.. rst-class:: classref-property-setget
- |void| **set_modulate**\ (\ value\: :ref:`Color<class_Color>`\ )
- :ref:`Color<class_Color>` **get_modulate**\ (\ )
Колір, застосований до цього **CanvasItem**. Ця властивість впливає на дочірні елементи **CanvasItem**, на відміну від :ref:`self_modulate<class_CanvasItem_property_self_modulate>`, яка впливає лише на сам вузол.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_property_self_modulate:
.. rst-class:: classref-property
:ref:`Color<class_Color>` **self_modulate** = ``Color(1, 1, 1, 1)`` :ref:`🔗<class_CanvasItem_property_self_modulate>`
.. rst-class:: classref-property-setget
- |void| **set_self_modulate**\ (\ value\: :ref:`Color<class_Color>`\ )
- :ref:`Color<class_Color>` **get_self_modulate**\ (\ )
Колір, застосований до цього **CanvasItem**. Ця властивість **не** впливає на дочірні **CanvasItem**, на відміну від :ref:`modulate<class_CanvasItem_property_modulate>`, який впливає як на сам вузол, так і на його дочірні елементи.
\ **Примітка:** Внутрішні дочірні елементи також не залежать від цієї властивості (див. параметр ``include_internal`` у :ref:`Node.add_child()<class_Node_method_add_child>`). Для вбудованих вузлів це включає повзунки в :ref:`ColorPicker<class_ColorPicker>` та панель вкладок у :ref:`TabContainer<class_TabContainer>`.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_property_show_behind_parent:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **show_behind_parent** = ``false`` :ref:`🔗<class_CanvasItem_property_show_behind_parent>`
.. rst-class:: classref-property-setget
- |void| **set_draw_behind_parent**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_draw_behind_parent_enabled**\ (\ )
Якщо ``true``, цей вузол малюється позаду свого батьківського вузла.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_property_texture_filter:
.. rst-class:: classref-property
:ref:`TextureFilter<enum_CanvasItem_TextureFilter>` **texture_filter** = ``0`` :ref:`🔗<class_CanvasItem_property_texture_filter>`
.. rst-class:: classref-property-setget
- |void| **set_texture_filter**\ (\ value\: :ref:`TextureFilter<enum_CanvasItem_TextureFilter>`\ )
- :ref:`TextureFilter<enum_CanvasItem_TextureFilter>` **get_texture_filter**\ (\ )
Режим фільтрації, що використовується для рендерингу текстури(текстур) цього **CanvasItem**.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_property_texture_repeat:
.. rst-class:: classref-property
:ref:`TextureRepeat<enum_CanvasItem_TextureRepeat>` **texture_repeat** = ``0`` :ref:`🔗<class_CanvasItem_property_texture_repeat>`
.. rst-class:: classref-property-setget
- |void| **set_texture_repeat**\ (\ value\: :ref:`TextureRepeat<enum_CanvasItem_TextureRepeat>`\ )
- :ref:`TextureRepeat<enum_CanvasItem_TextureRepeat>` **get_texture_repeat**\ (\ )
Режим повторення, який використовується для рендерингу текстури(текстур) цього **CanvasItem**. Він впливає на те, що відбувається, коли текстура семплується поза її межами, наприклад, шляхом встановлення :ref:`Sprite2D.region_rect<class_Sprite2D_property_region_rect>`, більшого за текстуру, або призначення точок UV :ref:`Polygon2D<class_Polygon2D>` поза текстурою.
\ **Примітка:** :ref:`TextureRect<class_TextureRect>` не залежить від :ref:`texture_repeat<class_CanvasItem_property_texture_repeat>`, оскільки він використовує власну реалізацію повторення текстури.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_property_top_level:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **top_level** = ``false`` :ref:`🔗<class_CanvasItem_property_top_level>`
.. rst-class:: classref-property-setget
- |void| **set_as_top_level**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_set_as_top_level**\ (\ )
Якщо ``true``, цей **CanvasItem** *не* успадковуватиме своє перетворення від батьківського **CanvasItem**. Його порядок відображення також буде змінено, щоб він відображався поверх інших **CanvasItem**, у яких для :ref:`top_level<class_CanvasItem_property_top_level>` не встановлено значення ``true``. **CanvasItem** фактично діятиме так, ніби він був розміщений як дочірній елемент голого :ref:`Node<class_Node>`.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_property_use_parent_material:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **use_parent_material** = ``false`` :ref:`🔗<class_CanvasItem_property_use_parent_material>`
.. rst-class:: classref-property-setget
- |void| **set_use_parent_material**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **get_use_parent_material**\ (\ )
Якщо значення ``true``, матеріал :ref:`material<class_CanvasItem_property_material>` батьківського елемента **CanvasItem** використовується як матеріал цього вузла.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_property_visibility_layer:
.. rst-class:: classref-property
:ref:`int<class_int>` **visibility_layer** = ``1`` :ref:`🔗<class_CanvasItem_property_visibility_layer>`
.. rst-class:: classref-property-setget
- |void| **set_visibility_layer**\ (\ value\: :ref:`int<class_int>`\ )
- :ref:`int<class_int>` **get_visibility_layer**\ (\ )
Рівень візуалізації, у якому цей **CanvasItem** візуалізується вузлами :ref:`Viewport<class_Viewport>`. :ref:`Viewport<class_Viewport>` візуалізує **CanvasItem**, якщо він і всі його батьківські елементи спільно використовують шар із маскою відбракування полотна :ref:`Viewport<class_Viewport>`.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_property_visible:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **visible** = ``true`` :ref:`🔗<class_CanvasItem_property_visible>`
.. rst-class:: classref-property-setget
- |void| **set_visible**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_visible**\ (\ )
Якщо ``true``, цей **CanvasItem** можна намалювати. Чи буде цей **CanvasItem** насправді намальований, залежить від видимості всіх його предків **CanvasItem**. Іншими словами: цей **CanvasItem** буде намальовано, коли :ref:`is_visible_in_tree()<class_CanvasItem_method_is_visible_in_tree>` повертає ``true`` і всі предки **CanvasItem** мають спільний принаймні один :ref:`visibility_layer<class_CanvasItem_property_visibility_layer>` з цим **CanvasItem**.
\ **Примітка:** Для елементів керування, які успадковують :ref:`Popup<class_Popup>`, правильний спосіб зробити їх видимими — це викликати одну з кількох функцій ``popup*()``.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_property_y_sort_enabled:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **y_sort_enabled** = ``false`` :ref:`🔗<class_CanvasItem_property_y_sort_enabled>`
.. rst-class:: classref-property-setget
- |void| **set_y_sort_enabled**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_y_sort_enabled**\ (\ )
Якщо ``true``, цей і дочірній вузли **CanvasItem** з вищою позицією Y відображаються перед вузлами з нижчою позицією Y. Якщо ``false``, цей і дочірній вузли **CanvasItem** відображаються зазвичай у порядку дерева сцен.
Якщо Y-сортування ввімкнено на батьківському вузлі ('A'), але вимкнено на дочірньому вузлі ('B'), дочірній вузол ('B') сортується, але його дочірні вузли ('C1', 'C2' тощо) відображаються разом у тій же позиції Y, що й дочірній вузол ('B'). Це дозволяє організовувати порядок візуалізації сцени без зміни дерева сцени.
Вузли сортуються відносно один одного, лише якщо вони знаходяться на одному ``члені z_index``.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_property_z_as_relative:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **z_as_relative** = ``true`` :ref:`🔗<class_CanvasItem_property_z_as_relative>`
.. rst-class:: classref-property-setget
- |void| **set_z_as_relative**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_z_relative**\ (\ )
Якщо ``true``, кінцевий Z-індекс цього вузла залежить від Z-індексу його батьківського вузла.
Наприклад, якщо :ref:`z_index<class_CanvasItem_property_z_index>` дорівнює ``2``, а кінцевий Z-індекс його батьківського вузла дорівнює ``3``, тоді кінцевий Z-індекс цього вузла буде ``5`` (``2 + 3``).
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_property_z_index:
.. rst-class:: classref-property
:ref:`int<class_int>` **z_index** = ``0`` :ref:`🔗<class_CanvasItem_property_z_index>`
.. rst-class:: classref-property-setget
- |void| **set_z_index**\ (\ value\: :ref:`int<class_int>`\ )
- :ref:`int<class_int>` **get_z_index**\ (\ )
Порядок, у якому цей вузол малюється. Вузол з вищим Z-індексом відображатиметься попереду інших. Має бути між :ref:`RenderingServer.CANVAS_ITEM_Z_MIN<class_RenderingServer_constant_CANVAS_ITEM_Z_MIN>` та :ref:`RenderingServer.CANVAS_ITEM_Z_MAX<class_RenderingServer_constant_CANVAS_ITEM_Z_MAX>` (включно).
\ **Примітка:** Z-індекс **не** впливає на порядок обробки вузлів **CanvasItem** або на спосіб обробки вхідних подій. Це особливо важливо пам’ятати для вузлів :ref:`Control<class_Control>`.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Описи методів
--------------------------
.. _class_CanvasItem_private_method__draw:
.. rst-class:: classref-method
|void| **_draw**\ (\ ) |virtual| :ref:`🔗<class_CanvasItem_private_method__draw>`
Викликається, коли **CanvasItem** отримав запит на перемалювання (після виклику :ref:`queue_redraw()<class_CanvasItem_method_queue_redraw>` вручну або механізмом).
Відповідає сповіщенню ``постійне NOTIFICATION_DRAW`` у :ref:`Object._notification()<class_Object_private_method__notification>`.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_draw_animation_slice:
.. rst-class:: classref-method
|void| **draw_animation_slice**\ (\ animation_length\: :ref:`float<class_float>`, slice_begin\: :ref:`float<class_float>`, slice_end\: :ref:`float<class_float>`, offset\: :ref:`float<class_float>` = 0.0\ ) :ref:`🔗<class_CanvasItem_method_draw_animation_slice>`
Подальші команди малювання ігноруватимуться, якщо вони не потраплять у вказаний фрагмент анімації. Це швидший спосіб реалізувати анімацію, яка повторюється на фоні, а не постійно перемальовується.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_draw_arc:
.. rst-class:: classref-method
|void| **draw_arc**\ (\ center\: :ref:`Vector2<class_Vector2>`, radius\: :ref:`float<class_float>`, start_angle\: :ref:`float<class_float>`, end_angle\: :ref:`float<class_float>`, point_count\: :ref:`int<class_int>`, color\: :ref:`Color<class_Color>`, width\: :ref:`float<class_float>` = -1.0, antialiased\: :ref:`bool<class_bool>` = false\ ) :ref:`🔗<class_CanvasItem_method_draw_arc>`
Малює незаповнену дугу між заданими кутами з рівномірним ``color`` і ``width`` та опціональним згладжуванням (підтримується тільки для позитивного ``width``). Чим більше значення ``point_count``, тим плавніша крива. ``center`` визначається в локальному просторі. Див. також :ref:`draw_circle()<class_CanvasItem_method_draw_circle>`.
Якщо ``width`` є від'ємним, воно буде проігноровано, і дуга буде намальована з використанням :ref:`RenderingServer.PRIMITIVE_LINE_STRIP<class_RenderingServer_constant_PRIMITIVE_LINE_STRIP>`. Це означає, що при масштабуванні CanvasItem дуга залишиться тонкою. Якщо така поведінка не є бажаною, передайте додатне ``width``, наприклад ``1.0``.
Дуга малюється від ``start_angle`` до значення ``end_angle``, тобто за годинниковою стрілкою, якщо ``start_angle < end_angle``, і проти годинникової стрілки в іншому випадку. Передача тих самих кутів, але в зворотному порядку, дасть ту саму дугу. Якщо абсолютна різниця між ``start_angle`` і ``end_angle`` більша за :ref:`@GDScript.TAU<class_@GDScript_constant_TAU>` радіан, то малюється повна дуга кола (тобто дуга не перекриватиме сама себе).
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_draw_char:
.. rst-class:: classref-method
|void| **draw_char**\ (\ font\: :ref:`Font<class_Font>`, pos\: :ref:`Vector2<class_Vector2>`, char\: :ref:`String<class_String>`, font_size\: :ref:`int<class_int>` = 16, modulate\: :ref:`Color<class_Color>` = Color(1, 1, 1, 1), oversampling\: :ref:`float<class_float>` = 0.0\ ) |const| :ref:`🔗<class_CanvasItem_method_draw_char>`
Малює перший символ рядка, використовуючи власний шрифт. Якщо ``oversampling`` більше нуля, воно використовується як коефіцієнт передискретизації шрифту, в іншому випадку використовуються налаштування передискретизації вікна перегляду. ``pos`` визначається в локальному просторі.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_draw_char_outline:
.. rst-class:: classref-method
|void| **draw_char_outline**\ (\ font\: :ref:`Font<class_Font>`, pos\: :ref:`Vector2<class_Vector2>`, char\: :ref:`String<class_String>`, font_size\: :ref:`int<class_int>` = 16, size\: :ref:`int<class_int>` = -1, modulate\: :ref:`Color<class_Color>` = Color(1, 1, 1, 1), oversampling\: :ref:`float<class_float>` = 0.0\ ) |const| :ref:`🔗<class_CanvasItem_method_draw_char_outline>`
Малює контур першого символу рядка за допомогою власного шрифту. Якщо ``oversampling`` більше нуля, воно використовується як коефіцієнт передискретизації шрифту, в іншому випадку використовуються налаштування передискретизації вікна перегляду. ``pos`` визначається в локальному просторі.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_draw_circle:
.. rst-class:: classref-method
|void| **draw_circle**\ (\ position\: :ref:`Vector2<class_Vector2>`, radius\: :ref:`float<class_float>`, color\: :ref:`Color<class_Color>`, filled\: :ref:`bool<class_bool>` = true, width\: :ref:`float<class_float>` = -1.0, antialiased\: :ref:`bool<class_bool>` = false\ ) :ref:`🔗<class_CanvasItem_method_draw_circle>`
Малює коло, з ``position`` визначеним у локальному просторі. Дивіться також :ref:`draw_arc()<class_CanvasItem_method_draw_arc>`, :ref:`draw_polyline()<class_CanvasItem_method_draw_polyline>` та :ref:`draw_polygon()<class_CanvasItem_method_draw_polygon>`.
Якщо ``filled`` дорівнює ``true``, коло буде заповнене вказаним ``color``. Якщо ``filled`` має значення ``false``, коло буде намальовано як контур із заданими ``color`` та ``width``.
Якщо ``width`` має від'ємне значення, замість чотириточкових примітивів будуть намальовані двоточковими. Це означає, що при масштабуванні CanvasItem лінії залишаться тонкими. Якщо така поведінка небажана, передайте позитивне значення ``width``, наприклад ``1.0``.
Якщо ``antialiased`` має значення ``true``, до межі будуть додані напівпрозорі «пір'я», що зроблять контури плавними.
\ **Примітка:** ``width`` діє тільки в тому випадку, якщо ``filled`` має значення ``false``.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_draw_colored_polygon:
.. rst-class:: classref-method
|void| **draw_colored_polygon**\ (\ points\: :ref:`PackedVector2Array<class_PackedVector2Array>`, color\: :ref:`Color<class_Color>`, uvs\: :ref:`PackedVector2Array<class_PackedVector2Array>` = PackedVector2Array(), texture\: :ref:`Texture2D<class_Texture2D>` = null\ ) :ref:`🔗<class_CanvasItem_method_draw_colored_polygon>`
Малює кольоровий багатокутник з будь-якою кількістю точок, опуклий або увігнутий. Точки в масиві ``points`` визначаються в локальному просторі. На відміну від :ref:`draw_polygon()<class_CanvasItem_method_draw_polygon>`, для всього багатокутника необхідно вказати один колір.
\ **Примітка:** Якщо ви часто перемальовуєте один і той самий багатокутник з великою кількістю вершин, розгляньте можливість попереднього обчислення триангуляції за допомогою :ref:`Geometry2D.triangulate_polygon()<class_Geometry2D_method_triangulate_polygon>` і використання :ref:`draw_mesh()<class_CanvasItem_method_draw_mesh>`, :ref:`draw_multimesh()<class_CanvasItem_method_draw_multimesh>` або :ref:`RenderingServer.canvas_item_add_triangle_array()<class_RenderingServer_method_canvas_item_add_triangle_array>`.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_draw_dashed_line:
.. rst-class:: classref-method
|void| **draw_dashed_line**\ (\ from\: :ref:`Vector2<class_Vector2>`, to\: :ref:`Vector2<class_Vector2>`, color\: :ref:`Color<class_Color>`, width\: :ref:`float<class_float>` = -1.0, dash\: :ref:`float<class_float>` = 2.0, aligned\: :ref:`bool<class_bool>` = true, antialiased\: :ref:`bool<class_bool>` = false\ ) :ref:`🔗<class_CanvasItem_method_draw_dashed_line>`
Малює пунктирну лінію від однієї 2D точки до іншої, заданого кольору та ширини. Позиції ``from`` та ``to`` визначаються в локальному просторі. Див. також :ref:`draw_line()<class_CanvasItem_method_draw_line>`, :ref:`draw_multiline()<class_CanvasItem_method_draw_multiline>` та :ref:`draw_polyline()<class_CanvasItem_method_draw_polyline>`.
Якщо ``width`` є від'ємним, то замість чотириточкової примітиви буде намальована двоточкова. Це означає, що при масштабуванні CanvasItem частини лінії залишаться тонкими. Якщо така поведінка не є бажаною, то передайте додатне значення ``width``, наприклад ``1.0``.
\ ``dash`` — це довжина кожної риски в пікселях, причому відстань між кожною рискою має однакову довжину. Якщо ``aligned`` дорівнює ``true``, довжина першої та останньої рисок може бути скорочена або подовжена, щоб лінія починалася та закінчувалася в точних точках, визначених ``from`` та ``to``. Обидва кінці завжди симетричні, коли ``aligned`` дорівнює ``true``. Якщо ``aligned`` дорівнює ``false``, всі риски матимуть однакову довжину, але лінія може виглядати неповною в кінці, оскільки довжина риски не ділиться рівно на довжину лінії. Коли ``aligned`` дорівнює ``false``, малюються тільки повні риски.
Якщо ``antialiased`` має значення ``true``, до межі будуть додані напівпрозорі «пір'я», що зроблять контури гладкими.
\ **Примітка:** ``antialiased`` діє тільки в тому випадку, якщо ``width`` більше ``0.0``.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_draw_end_animation:
.. rst-class:: classref-method
|void| **draw_end_animation**\ (\ ) :ref:`🔗<class_CanvasItem_method_draw_end_animation>`
Після надсилання всіх фрагментів анімації через :ref:`draw_animation_slice()<class_CanvasItem_method_draw_animation_slice>` цю функцію можна використати для повернення малюнка до стану за замовчуванням (усі наступні команди малювання будуть видимі). Якщо вас не цікавить цей конкретний варіант використання, використання цієї функції після надсилання фрагментів не потрібне.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_draw_lcd_texture_rect_region:
.. rst-class:: classref-method
|void| **draw_lcd_texture_rect_region**\ (\ texture\: :ref:`Texture2D<class_Texture2D>`, rect\: :ref:`Rect2<class_Rect2>`, src_rect\: :ref:`Rect2<class_Rect2>`, modulate\: :ref:`Color<class_Color>` = Color(1, 1, 1, 1)\ ) :ref:`🔗<class_CanvasItem_method_draw_lcd_texture_rect_region>`
Малює текстуровану прямокутну область текстури шрифту з антиаліасингом субпікселів LCD у заданому положенні, за бажанням модульовану кольором. ``rect`` визначається в локальному просторі.
Текстура малюється за допомогою наступної операції змішування, режим змішування :ref:`CanvasItemMaterial<class_CanvasItemMaterial>` ігнорується:
::
dst.r = texture.r * modulate.r * modulate.a + dst.r * (1.0 - texture.r * modulate.a);
dst.g = texture.g * modulate.g * modulate.a + dst.g * (1.0 - texture.g * modulate.a);
dst.b = texture.b * modulate.b * modulate.a + dst.b * (1.0 - texture.b * modulate.a);
dst.a = modulate.a + dst.a * (1.0 - modulate.a);
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_draw_line:
.. rst-class:: classref-method
|void| **draw_line**\ (\ from\: :ref:`Vector2<class_Vector2>`, to\: :ref:`Vector2<class_Vector2>`, color\: :ref:`Color<class_Color>`, width\: :ref:`float<class_float>` = -1.0, antialiased\: :ref:`bool<class_bool>` = false\ ) :ref:`🔗<class_CanvasItem_method_draw_line>`
Малює лінію від однієї 2D точки до іншої, заданого кольору та ширини. За бажанням можна застосувати згладжування. Позиції ``from`` та ``to`` визначаються в локальному просторі. Див. також :ref:`draw_dashed_line()<class_CanvasItem_method_draw_dashed_line>`, :ref:`draw_multiline()<class_CanvasItem_method_draw_multiline>` та :ref:`draw_polyline()<class_CanvasItem_method_draw_polyline>`.
Якщо ``width`` є від'ємним, то замість чотириточкової примітиви буде намальована двоточкова. Це означає, що при масштабуванні CanvasItem лінія залишиться тонкою. Якщо така поведінка не є бажаною, то передайте додатне значення ``width``, наприклад ``1.0``.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_draw_mesh:
.. rst-class:: classref-method
|void| **draw_mesh**\ (\ mesh\: :ref:`Mesh<class_Mesh>`, texture\: :ref:`Texture2D<class_Texture2D>`, transform\: :ref:`Transform2D<class_Transform2D>` = Transform2D(1, 0, 0, 1, 0, 0), modulate\: :ref:`Color<class_Color>` = Color(1, 1, 1, 1)\ ) :ref:`🔗<class_CanvasItem_method_draw_mesh>`
Малює :ref:`Mesh<class_Mesh>` у 2D, використовуючи надану текстуру. Див. :ref:`MeshInstance2D<class_MeshInstance2D>` для отримання відповідної документації. ``transform`` визначено в локальному просторі.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_draw_msdf_texture_rect_region:
.. rst-class:: classref-method
|void| **draw_msdf_texture_rect_region**\ (\ texture\: :ref:`Texture2D<class_Texture2D>`, rect\: :ref:`Rect2<class_Rect2>`, src_rect\: :ref:`Rect2<class_Rect2>`, modulate\: :ref:`Color<class_Color>` = Color(1, 1, 1, 1), outline\: :ref:`float<class_float>` = 0.0, pixel_range\: :ref:`float<class_float>` = 4.0, scale\: :ref:`float<class_float>` = 1.0\ ) :ref:`🔗<class_CanvasItem_method_draw_msdf_texture_rect_region>`
Малює текстуровану прямокутну область багатоканальної текстури поля відстані зі знаком у заданому положенні, за бажанням модульовану кольором. ``rect`` визначається в локальному просторі. Див. :ref:`FontFile.multichannel_signed_distance_field<class_FontFile_property_multichannel_signed_distance_field>` для отримання додаткової інформації та застережень щодо рендерингу шрифтів MSDF.
Якщо ``outline`` є додатним, кожне значення альфа-каналу пікселя в області встановлюється на максимальне значення справжньої відстані в радіусі ``outline``.
Значення ``pixel_range`` повинно бути таким самим, як те, що використовувалося під час генерації текстури поля відстані.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_draw_multiline:
.. rst-class:: classref-method
|void| **draw_multiline**\ (\ points\: :ref:`PackedVector2Array<class_PackedVector2Array>`, color\: :ref:`Color<class_Color>`, width\: :ref:`float<class_float>` = -1.0, antialiased\: :ref:`bool<class_bool>` = false\ ) :ref:`🔗<class_CanvasItem_method_draw_multiline>`
Малює кілька роз'єднаних ліній з однаковою ``width`` і ``color``. Кожна лінія визначається двома послідовними точками з масиву ``points`` у локальному просторі, тобто i-й сегмент складається з ``points[2 * i]``, ``points[2 * i + 1]`` кінцевих точок. При малювання великої кількості ліній це швидше, ніж використання окремих викликів :ref:`draw_line()<class_CanvasItem_method_draw_line>`. Для малювання взаємопов'язаних ліній використовуйте замість цього :ref:`draw_polyline()<class_CanvasItem_method_draw_polyline>`.
Якщо ``width`` є від'ємним, то замість чотириточкових примітивів будуть намальовані двоточкові. Це означає, що при масштабуванні CanvasItem лінії залишаться тонкими. Якщо така поведінка небажана, передайте позитивне значення ``width``, наприклад ``1.0``.
\ **Примітка:** ``antialiased`` діє тільки в тому випадку, якщо ``width`` більше ``0.0``.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_draw_multiline_colors:
.. rst-class:: classref-method
|void| **draw_multiline_colors**\ (\ points\: :ref:`PackedVector2Array<class_PackedVector2Array>`, colors\: :ref:`PackedColorArray<class_PackedColorArray>`, width\: :ref:`float<class_float>` = -1.0, antialiased\: :ref:`bool<class_bool>` = false\ ) :ref:`🔗<class_CanvasItem_method_draw_multiline_colors>`
Малює кілька роз'єднаних ліній з однаковою шириною ``width`` і забарвленням по сегментах. Кожен сегмент визначається двома послідовними точками з масиву ``points`` у локальному просторі та відповідним кольором з масиву ``colors``, тобто i-й сегмент складається з ``points[2 * i]``, ``points[2 * i + 1] `` кінцевих точок і має колір ``colors[i]``. При малювання великої кількості ліній це швидше, ніж використання окремих викликів :ref:`draw_line()<class_CanvasItem_method_draw_line>`. Для малювання взаємопов'язаних ліній використовуйте замість цього :ref:`draw_polyline_colors()<class_CanvasItem_method_draw_polyline_colors>`.
Якщо ``width`` є від'ємним, то замість чотириточкових примітивів будуть намальовані двоточкові. Це означає, що при масштабуванні CanvasItem лінії залишаться тонкими. Якщо така поведінка небажана, передайте позитивне значення ``width``, наприклад ``1.0``.
\ **Примітка:** ``antialiased`` діє тільки в тому випадку, якщо ``width`` більше ``0.0``.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_draw_multiline_string:
.. rst-class:: classref-method
|void| **draw_multiline_string**\ (\ font\: :ref:`Font<class_Font>`, pos\: :ref:`Vector2<class_Vector2>`, text\: :ref:`String<class_String>`, alignment\: :ref:`HorizontalAlignment<enum_@GlobalScope_HorizontalAlignment>` = 0, width\: :ref:`float<class_float>` = -1, font_size\: :ref:`int<class_int>` = 16, max_lines\: :ref:`int<class_int>` = -1, modulate\: :ref:`Color<class_Color>` = Color(1, 1, 1, 1), brk_flags\: |bitfield|\[:ref:`LineBreakFlag<enum_TextServer_LineBreakFlag>`\] = 3, justification_flags\: |bitfield|\[:ref:`JustificationFlag<enum_TextServer_JustificationFlag>`\] = 3, direction\: :ref:`Direction<enum_TextServer_Direction>` = 0, orientation\: :ref:`Orientation<enum_TextServer_Orientation>` = 0, oversampling\: :ref:`float<class_float>` = 0.0\ ) |const| :ref:`🔗<class_CanvasItem_method_draw_multiline_string>`
Розбиває ``text`` на рядки і малює його, використовуючи вказаний ``font`` в ``pos`` в локальному просторі (верхній лівий кут). Колір тексту буде помножений на ``modulate``. Якщо ``width`` більше або дорівнює 0, текст буде обрізаний, якщо він перевищує вказану ширину. Якщо ``oversampling`` більше нуля, воно використовується як коефіцієнт передискретизації шрифту, в іншому випадку використовуються налаштування передискретизації вікна перегляду.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_draw_multiline_string_outline:
.. rst-class:: classref-method
|void| **draw_multiline_string_outline**\ (\ font\: :ref:`Font<class_Font>`, pos\: :ref:`Vector2<class_Vector2>`, text\: :ref:`String<class_String>`, alignment\: :ref:`HorizontalAlignment<enum_@GlobalScope_HorizontalAlignment>` = 0, width\: :ref:`float<class_float>` = -1, font_size\: :ref:`int<class_int>` = 16, max_lines\: :ref:`int<class_int>` = -1, size\: :ref:`int<class_int>` = 1, modulate\: :ref:`Color<class_Color>` = Color(1, 1, 1, 1), brk_flags\: |bitfield|\[:ref:`LineBreakFlag<enum_TextServer_LineBreakFlag>`\] = 3, justification_flags\: |bitfield|\[:ref:`JustificationFlag<enum_TextServer_JustificationFlag>`\] = 3, direction\: :ref:`Direction<enum_TextServer_Direction>` = 0, orientation\: :ref:`Orientation<enum_TextServer_Orientation>` = 0, oversampling\: :ref:`float<class_float>` = 0.0\ ) |const| :ref:`🔗<class_CanvasItem_method_draw_multiline_string_outline>`
Розбиває ``text`` на рядки і малює контур тексту, використовуючи вказаний ``font`` у ``pos`` у локальному просторі (верхній лівий кут). Колір тексту буде помножений на ``modulate``. Якщо ``width`` більше або дорівнює 0, текст буде обрізаний, якщо він перевищує вказану ширину. Якщо ``oversampling`` більше нуля, воно використовується як коефіцієнт передискретизації шрифту, в іншому випадку використовуються налаштування передискретизації вікна перегляду.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_draw_multimesh:
.. rst-class:: classref-method
|void| **draw_multimesh**\ (\ multimesh\: :ref:`MultiMesh<class_MultiMesh>`, texture\: :ref:`Texture2D<class_Texture2D>`\ ) :ref:`🔗<class_CanvasItem_method_draw_multimesh>`
Малює :ref:`MultiMesh<class_MultiMesh>` у 2D із наданою текстурою. Відповідну документацію див. у :ref:`MultiMeshInstance2D<class_MultiMeshInstance2D>`.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_draw_polygon:
.. rst-class:: classref-method
|void| **draw_polygon**\ (\ points\: :ref:`PackedVector2Array<class_PackedVector2Array>`, colors\: :ref:`PackedColorArray<class_PackedColorArray>`, uvs\: :ref:`PackedVector2Array<class_PackedVector2Array>` = PackedVector2Array(), texture\: :ref:`Texture2D<class_Texture2D>` = null\ ) :ref:`🔗<class_CanvasItem_method_draw_polygon>`
Малює суцільний багатокутник з будь-якою кількістю точок, опуклий або увігнутий. На відміну від :ref:`draw_colored_polygon()<class_CanvasItem_method_draw_colored_polygon>`, колір кожної точки можна змінювати окремо. Масив ``points`` визначається в локальному просторі. Див. також :ref:`draw_polyline()<class_CanvasItem_method_draw_polyline>` та :ref:`draw_polyline_colors()<class_CanvasItem_method_draw_polyline_colors>`. Якщо вам потрібна більша гнучкість (наприклад, можливість використовувати кістки), використовуйте замість цього :ref:`RenderingServer.canvas_item_add_triangle_array()<class_RenderingServer_method_canvas_item_add_triangle_array>`.
\ **Примітка:** Якщо ви часто перемальовуєте один і той самий багатокутник з великою кількістю вершин, розгляньте можливість попереднього обчислення триангуляції за допомогою :ref:`Geometry2D.triangulate_polygon()<class_Geometry2D_method_triangulate_polygon>` і використання :ref:`draw_mesh()<class_CanvasItem_method_draw_mesh>`, :ref:`draw_multimesh()<class_CanvasItem_method_draw_multimesh>` або :ref:`RenderingServer.canvas_item_add_triangle_array()<class_RenderingServer_method_canvas_item_add_triangle_array>`.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_draw_polyline:
.. rst-class:: classref-method
|void| **draw_polyline**\ (\ points\: :ref:`PackedVector2Array<class_PackedVector2Array>`, color\: :ref:`Color<class_Color>`, width\: :ref:`float<class_float>` = -1.0, antialiased\: :ref:`bool<class_bool>` = false\ ) :ref:`🔗<class_CanvasItem_method_draw_polyline>`
Малює взаємопов'язані відрізки ліній з однаковим ``color`` і ``width`` та опціональним згладжуванням (підтримується тільки для позитивного ``width``). Масив ``points`` визначається в локальному просторі. При малюванні великої кількості ліній це швидше, ніж використання окремих викликів :ref:`draw_line()<class_CanvasItem_method_draw_line>`. Щоб намалювати роз'єднані лінії, використовуйте замість цього :ref:`draw_multiline()<class_CanvasItem_method_draw_multiline>`. Див. також :ref:`draw_polygon()<class_CanvasItem_method_draw_polygon>`.
Якщо ``width`` є від’ємним, він буде проігнорований, а полілінія буде намальована за допомогою :ref:`RenderingServer.PRIMITIVE_LINE_STRIP<class_RenderingServer_constant_PRIMITIVE_LINE_STRIP>`. Це означає, що при масштабуванні CanvasItem полілінія залишиться тонкою. Якщо така поведінка є небажаною, передайте додатне значення ``width``, наприклад ``1.0``.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_draw_polyline_colors:
.. rst-class:: classref-method
|void| **draw_polyline_colors**\ (\ points\: :ref:`PackedVector2Array<class_PackedVector2Array>`, colors\: :ref:`PackedColorArray<class_PackedColorArray>`, width\: :ref:`float<class_float>` = -1.0, antialiased\: :ref:`bool<class_bool>` = false\ ) :ref:`🔗<class_CanvasItem_method_draw_polyline_colors>`
Малює взаємопов'язані відрізки ліній з рівномірною ``width``, точковим забарвленням і опціональним згладжуванням (підтримується тільки для позитивного ``width``). Кольори, призначені точкам лінії, відповідають індексу між ``points`` і ``colors``, тобто кожен відрізок лінії заповнюється градієнтом між кольорами кінцевих точок. Масив ``points`` визначається в локальному просторі. При малювання великої кількості ліній це швидше, ніж використання окремих викликів :ref:`draw_line()<class_CanvasItem_method_draw_line>`. Для малювання роз'єднаних ліній використовуйте замість цього :ref:`draw_multiline_colors()<class_CanvasItem_method_draw_multiline_colors>`. Див. також :ref:`draw_polygon()<class_CanvasItem_method_draw_polygon>`.
Якщо ``width`` є від’ємним, він буде проігнорований, а полілінія буде намальована за допомогою :ref:`RenderingServer.PRIMITIVE_LINE_STRIP<class_RenderingServer_constant_PRIMITIVE_LINE_STRIP>`. Це означає, що при масштабуванні CanvasItem полілінія залишиться тонкою. Якщо така поведінка не є бажаною, передайте позитивне значення ``width``, наприклад ``1.0``.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_draw_primitive:
.. rst-class:: classref-method
|void| **draw_primitive**\ (\ points\: :ref:`PackedVector2Array<class_PackedVector2Array>`, colors\: :ref:`PackedColorArray<class_PackedColorArray>`, uvs\: :ref:`PackedVector2Array<class_PackedVector2Array>`, texture\: :ref:`Texture2D<class_Texture2D>` = null\ ) :ref:`🔗<class_CanvasItem_method_draw_primitive>`
Малює користувацький примітив. 1 точка для точки, 2 точки для лінії, 3 точки для трикутника і 4 точки для чотирикутника. Якщо вказано 0 точок або більше 4 точок, нічого не буде намальовано і буде виведено повідомлення про помилку. Масив ``points`` визначається в локальному просторі. Див. також :ref:`draw_line()<class_CanvasItem_method_draw_line>`, :ref:`draw_polyline()<class_CanvasItem_method_draw_polyline>`, :ref:`draw_polygon()<class_CanvasItem_method_draw_polygon>` та :ref:`draw_rect()<class_CanvasItem_method_draw_rect>`.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_draw_rect:
.. rst-class:: classref-method
|void| **draw_rect**\ (\ rect\: :ref:`Rect2<class_Rect2>`, color\: :ref:`Color<class_Color>`, filled\: :ref:`bool<class_bool>` = true, width\: :ref:`float<class_float>` = -1.0, antialiased\: :ref:`bool<class_bool>` = false\ ) :ref:`🔗<class_CanvasItem_method_draw_rect>`
Малює прямокутник. Якщо ``filled`` має значення ``true``, прямокутник буде заповнений вказаним ``color``. Якщо ``filled`` має значення ``false``, прямокутник буде намальований як контур із вказаними ``color`` та ``width``. ``rect`` вказується в локальному просторі. Див. також :ref:`draw_texture_rect()<class_CanvasItem_method_draw_texture_rect>`.
Якщо ``width`` є від'ємним, то замість чотириточкових примітивів будуть намальовані двоточкові. Це означає, що при масштабуванні CanvasItem лінії залишаться тонкими. Якщо така поведінка не є бажаною, то передайте додатне значення ``width``, наприклад ``1.0``.
Якщо ``antialiased`` дорівнює ``true``, до межі будуть додані напівпрозорі «пір'я», що зробить контури гладкими.
\ **Примітка:** ``width`` діє тільки якщо ``filled`` має значення ``false``.
\ **Примітка:** Незаповнені прямокутники, намальовані з від'ємним ``width``, можуть відображатися неідеально. Наприклад, кути можуть бути відсутніми або яскравішими через перекриття ліній (для напівпрозорого ``color``).
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_draw_set_transform:
.. rst-class:: classref-method
|void| **draw_set_transform**\ (\ position\: :ref:`Vector2<class_Vector2>`, rotation\: :ref:`float<class_float>` = 0.0, scale\: :ref:`Vector2<class_Vector2>` = Vector2(1, 1)\ ) :ref:`🔗<class_CanvasItem_method_draw_set_transform>`
Встановлює власне локальне перетворення для малювання за допомогою компонентів. Все, що буде намальовано після цього, буде перетворено за допомогою цього.
\ **Примітка:** :ref:`FontFile.oversampling<class_FontFile_property_oversampling>` *не* враховує ``scale``. Це означає, що збільшення/зменшення масштабу призведе до того, що растрові шрифти та растрові (не MSDF) динамічні шрифти будуть виглядати розмитими або пікселізованими. Щоб текст залишався чітким незалежно від масштабу, можна увімкнути рендеринг шрифтів MSDF, увімкнувши :ref:`ProjectSettings.gui/theme/default_font_multichannel_signed_distance_field<class_ProjectSettings_property_gui/theme/default_font_multichannel_signed_distance_field>` (застосовується тільки до шрифту проекту за замовчуванням) або увімкнувши **Multichannel Signed Distance Field** в опціях імпорту DynamicFont для користувацьких шрифтів. Для системних шрифтів :ref:`SystemFont.multichannel_signed_distance_field<class_SystemFont_property_multichannel_signed_distance_field>` можна ввімкнути в інспекторі.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_draw_set_transform_matrix:
.. rst-class:: classref-method
|void| **draw_set_transform_matrix**\ (\ xform\: :ref:`Transform2D<class_Transform2D>`\ ) :ref:`🔗<class_CanvasItem_method_draw_set_transform_matrix>`
Встановлює власне локальне перетворення для малювання за допомогою матриці. Все, що буде намальовано після цього, буде перетворено цим перетворенням.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_draw_string:
.. rst-class:: classref-method
|void| **draw_string**\ (\ font\: :ref:`Font<class_Font>`, pos\: :ref:`Vector2<class_Vector2>`, text\: :ref:`String<class_String>`, alignment\: :ref:`HorizontalAlignment<enum_@GlobalScope_HorizontalAlignment>` = 0, width\: :ref:`float<class_float>` = -1, font_size\: :ref:`int<class_int>` = 16, modulate\: :ref:`Color<class_Color>` = Color(1, 1, 1, 1), justification_flags\: |bitfield|\[:ref:`JustificationFlag<enum_TextServer_JustificationFlag>`\] = 3, direction\: :ref:`Direction<enum_TextServer_Direction>` = 0, orientation\: :ref:`Orientation<enum_TextServer_Orientation>` = 0, oversampling\: :ref:`float<class_float>` = 0.0\ ) |const| :ref:`🔗<class_CanvasItem_method_draw_string>`
Малює ``text`` за допомогою вказаного ``font`` у ``pos`` у локальному просторі (у нижньому лівому куті, використовуючи базову лінію шрифту). Колір тексту буде помножений на ``modulate``. Якщо ``width`` більше або дорівнює 0, текст буде обрізаний, якщо він перевищує вказану ширину. Якщо ``oversampling`` більше нуля, воно використовується як коефіцієнт передискретизації шрифту, в іншому випадку використовуються налаштування передискретизації вікна перегляду.
\ **Приклад:** Намалюйте «Hello world», використовуючи шрифт за замовчуванням проекту:
.. tabs::
.. code-tab:: gdscript
# Якщо ви використовуєте цей метод у скрипті, який постійно перемальовується, перемістіть
# оголошення `default_font` до змінної-члена, призначеної в `_ready()`,
# щоб елемент управління створювався тільки один раз.
var default_font = ThemeDB.fallback_font
var default_font_size = ThemeDB.fallback_font_size
draw_string(default_font, Vector2(64, 64), "Hello world", HORIZONTAL_ALIGNMENT_LEFT, -1, default_font_size)
.. code-tab:: csharp
// Якщо ви використовуєте цей метод у скрипті, який постійно перемальовується, перемістіть
// оголошення `default_font` до змінної-члена, призначеної в `_Ready()`,
// щоб елемент управління створювався лише один раз.
Font defaultFont = ThemeDB.FallbackFont;
int defaultFontSize = ThemeDB.FallbackFontSize;
DrawString(defaultFont, new Vector2(64, 64), "Hello world", HORIZONTAL_ALIGNMENT_LEFT, -1, defaultFontSize);
Див. також :ref:`Font.draw_string()<class_Font_method_draw_string>`.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_draw_string_outline:
.. rst-class:: classref-method
|void| **draw_string_outline**\ (\ font\: :ref:`Font<class_Font>`, pos\: :ref:`Vector2<class_Vector2>`, text\: :ref:`String<class_String>`, alignment\: :ref:`HorizontalAlignment<enum_@GlobalScope_HorizontalAlignment>` = 0, width\: :ref:`float<class_float>` = -1, font_size\: :ref:`int<class_int>` = 16, size\: :ref:`int<class_int>` = 1, modulate\: :ref:`Color<class_Color>` = Color(1, 1, 1, 1), justification_flags\: |bitfield|\[:ref:`JustificationFlag<enum_TextServer_JustificationFlag>`\] = 3, direction\: :ref:`Direction<enum_TextServer_Direction>` = 0, orientation\: :ref:`Orientation<enum_TextServer_Orientation>` = 0, oversampling\: :ref:`float<class_float>` = 0.0\ ) |const| :ref:`🔗<class_CanvasItem_method_draw_string_outline>`
Малює контур ``text`` за допомогою вказаного ``font`` у ``pos`` у локальному просторі (лівий нижній кут з використанням базової лінії шрифту). Колір тексту буде помножений на ``modulate``. Якщо ``width`` більше або дорівнює 0, текст буде обрізаний, якщо він перевищує вказану ширину. Якщо ``oversampling`` більше нуля, воно використовується як коефіцієнт передискретизації шрифту, в іншому випадку використовуються налаштування передискретизації вікна перегляду.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_draw_style_box:
.. rst-class:: classref-method
|void| **draw_style_box**\ (\ style_box\: :ref:`StyleBox<class_StyleBox>`, rect\: :ref:`Rect2<class_Rect2>`\ ) :ref:`🔗<class_CanvasItem_method_draw_style_box>`
Малює стилізований прямокутник. Параметр ``rect`` визначено в локальному просторі.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_draw_texture:
.. rst-class:: classref-method
|void| **draw_texture**\ (\ texture\: :ref:`Texture2D<class_Texture2D>`, position\: :ref:`Vector2<class_Vector2>`, modulate\: :ref:`Color<class_Color>` = Color(1, 1, 1, 1)\ ) :ref:`🔗<class_CanvasItem_method_draw_texture>`
Малює текстуру в заданій позиції. ``position`` визначається в локальному просторі.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_draw_texture_rect:
.. rst-class:: classref-method
|void| **draw_texture_rect**\ (\ texture\: :ref:`Texture2D<class_Texture2D>`, rect\: :ref:`Rect2<class_Rect2>`, tile\: :ref:`bool<class_bool>`, modulate\: :ref:`Color<class_Color>` = Color(1, 1, 1, 1), transpose\: :ref:`bool<class_bool>` = false\ ) :ref:`🔗<class_CanvasItem_method_draw_texture_rect>`
Малює текстурований прямокутник у заданому положенні, за бажанням модульований кольором. ``rect`` визначається в локальному просторі. Якщо ``transpose`` дорівнює ``true``, координати X і Y текстури будуть поміняні місцями. Див. також :ref:`draw_rect()<class_CanvasItem_method_draw_rect>` і :ref:`draw_texture_rect_region()<class_CanvasItem_method_draw_texture_rect_region>`.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_draw_texture_rect_region:
.. rst-class:: classref-method
|void| **draw_texture_rect_region**\ (\ texture\: :ref:`Texture2D<class_Texture2D>`, rect\: :ref:`Rect2<class_Rect2>`, src_rect\: :ref:`Rect2<class_Rect2>`, modulate\: :ref:`Color<class_Color>` = Color(1, 1, 1, 1), transpose\: :ref:`bool<class_bool>` = false, clip_uv\: :ref:`bool<class_bool>` = true\ ) :ref:`🔗<class_CanvasItem_method_draw_texture_rect_region>`
Малює текстурований прямокутник з області текстури (зазначеної ``src_rect``) у заданій позиції в локальному просторі, за бажанням модульований кольором. Якщо ``transpose`` має значення ``true``, координати X і Y текстури будуть поміняні місцями. Див. також :ref:`draw_texture_rect()<class_CanvasItem_method_draw_texture_rect>`.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_force_update_transform:
.. rst-class:: classref-method
|void| **force_update_transform**\ (\ ) :ref:`🔗<class_CanvasItem_method_force_update_transform>`
Примусово оновлює перетворення вузла. Не вдається, якщо вузол не знаходиться всередині дерева. Див. також :ref:`get_transform()<class_CanvasItem_method_get_transform>`.
\ **Примітка:** З міркувань продуктивності зміни перетворення зазвичай накопичуються та застосовуються *один раз* в кінці кадру. Оновлення також поширюється на дочірні елементи **CanvasItem**. Тому використовуйте цей метод лише тоді, коли вам потрібне актуальне перетворення (наприклад, під час фізичних операцій).
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_get_canvas:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **get_canvas**\ (\ ) |const| :ref:`🔗<class_CanvasItem_method_get_canvas>`
Повертає :ref:`RID<class_RID>` полотна :ref:`World2D<class_World2D>`, на якому зареєстровано цей вузол, що використовується :ref:`RenderingServer<class_RenderingServer>`.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_get_canvas_item:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **get_canvas_item**\ (\ ) |const| :ref:`🔗<class_CanvasItem_method_get_canvas_item>`
Повертає внутрішній елемент полотна :ref:`RID<class_RID>`, який використовується :ref:`RenderingServer<class_RenderingServer>` для цього вузла.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_get_canvas_layer_node:
.. rst-class:: classref-method
:ref:`CanvasLayer<class_CanvasLayer>` **get_canvas_layer_node**\ (\ ) |const| :ref:`🔗<class_CanvasItem_method_get_canvas_layer_node>`
Повертає :ref:`CanvasLayer<class_CanvasLayer>`, який містить цей вузол, або ``null``, якщо вузла немає в жодному :ref:`CanvasLayer<class_CanvasLayer>`.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_get_canvas_transform:
.. rst-class:: classref-method
:ref:`Transform2D<class_Transform2D>` **get_canvas_transform**\ (\ ) |const| :ref:`🔗<class_CanvasItem_method_get_canvas_transform>`
Повертає перетворення цього вузла, конвертоване з системи координат зареєстрованого полотна до системи координат його області перегляду. Див. також :ref:`Node.get_viewport()<class_Node_method_get_viewport>`.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_get_global_mouse_position:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **get_global_mouse_position**\ (\ ) |const| :ref:`🔗<class_CanvasItem_method_get_global_mouse_position>`
Повертає глобальну позицію курсора миші відносно :ref:`CanvasLayer<class_CanvasLayer>`, що містить цей вузол.
\ **Примітка:** Для координат екранного простору (наприклад, під час використання невбудованого :ref:`Popup<class_Popup>`) можна використовувати :ref:`DisplayServer.mouse_get_position()<class_DisplayServer_method_mouse_get_position>`.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_get_global_transform:
.. rst-class:: classref-method
:ref:`Transform2D<class_Transform2D>` **get_global_transform**\ (\ ) |const| :ref:`🔗<class_CanvasItem_method_get_global_transform>`
Повертає матрицю глобального перетворення цього елемента, тобто комбіноване перетворення до найвищого вузла **CanvasItem**. Найвищий елемент — це **CanvasItem**, який не має батьківського елемента, не має батьківського елемента **CanvasItem**, або для нього ввімкнено :ref:`top_level<class_CanvasItem_property_top_level>`.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_get_global_transform_with_canvas:
.. rst-class:: classref-method
:ref:`Transform2D<class_Transform2D>` **get_global_transform_with_canvas**\ (\ ) |const| :ref:`🔗<class_CanvasItem_method_get_global_transform_with_canvas>`
Повертає перетворення з локальної системи координат цього **CanvasItem** у систему координат :ref:`Viewport<class_Viewport>`.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_get_instance_shader_parameter:
.. rst-class:: classref-method
:ref:`Variant<class_Variant>` **get_instance_shader_parameter**\ (\ name\: :ref:`StringName<class_StringName>`\ ) |const| :ref:`🔗<class_CanvasItem_method_get_instance_shader_parameter>`
Отримайте значення параметра шейдера, встановленого на цьому екземплярі.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_get_local_mouse_position:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **get_local_mouse_position**\ (\ ) |const| :ref:`🔗<class_CanvasItem_method_get_local_mouse_position>`
Повертає позицію миші в цьому **CanvasItem**, використовуючи локальну систему координат цього **CanvasItem**.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_get_screen_transform:
.. rst-class:: classref-method
:ref:`Transform2D<class_Transform2D>` **get_screen_transform**\ (\ ) |const| :ref:`🔗<class_CanvasItem_method_get_screen_transform>`
Повертає перетворення цього **CanvasItem** у глобальних координатах екрана (тобто з урахуванням положення вікна). Здебільшого корисний для плагінів редактора.
Дорівнює :ref:`get_global_transform()<class_CanvasItem_method_get_global_transform>`, якщо вікно вбудовано (див. :ref:`Viewport.gui_embed_subwindows<class_Viewport_property_gui_embed_subwindows>`).
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_get_transform:
.. rst-class:: classref-method
:ref:`Transform2D<class_Transform2D>` **get_transform**\ (\ ) |const| :ref:`🔗<class_CanvasItem_method_get_transform>`
Повертає матрицю перетворення цього **CanvasItem**.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_get_viewport_rect:
.. rst-class:: classref-method
:ref:`Rect2<class_Rect2>` **get_viewport_rect**\ (\ ) |const| :ref:`🔗<class_CanvasItem_method_get_viewport_rect>`
Повертає межі області перегляду цього вузла як :ref:`Rect2<class_Rect2>`. Див. також :ref:`Node.get_viewport()<class_Node_method_get_viewport>`.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_get_viewport_transform:
.. rst-class:: classref-method
:ref:`Transform2D<class_Transform2D>` **get_viewport_transform**\ (\ ) |const| :ref:`🔗<class_CanvasItem_method_get_viewport_transform>`
Повертає перетворення цього вузла, конвертоване з системи координат зареєстрованого полотна до системи координат його вбудовника області перегляду. Див. також :ref:`Viewport.get_final_transform()<class_Viewport_method_get_final_transform>` і :ref:`Node.get_viewport()<class_Node_method_get_viewport>`.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_get_visibility_layer_bit:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **get_visibility_layer_bit**\ (\ layer\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_CanvasItem_method_get_visibility_layer_bit>`
Повертає ``true``, якщо шар за заданим індексом встановлено в :ref:`visibility_layer<class_CanvasItem_property_visibility_layer>`.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_get_world_2d:
.. rst-class:: classref-method
:ref:`World2D<class_World2D>` **get_world_2d**\ (\ ) |const| :ref:`🔗<class_CanvasItem_method_get_world_2d>`
Повертає :ref:`World2D<class_World2D>`, у якому зареєстровано цей вузол.
Зазвичай це те саме, що й область перегляду цього вузла (див. :ref:`Node.get_viewport()<class_Node_method_get_viewport>` та :ref:`Viewport.find_world_2d()<class_Viewport_method_find_world_2d>`).
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_hide:
.. rst-class:: classref-method
|void| **hide**\ (\ ) :ref:`🔗<class_CanvasItem_method_hide>`
Приховати **CanvasItem**, якщо він зараз видимий. Це еквівалентно встановленню :ref:`visible<class_CanvasItem_property_visible>` значення ``false``.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_is_local_transform_notification_enabled:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_local_transform_notification_enabled**\ (\ ) |const| :ref:`🔗<class_CanvasItem_method_is_local_transform_notification_enabled>`
Повертає ``true``, якщо вузол отримує :ref:`NOTIFICATION_LOCAL_TRANSFORM_CHANGED<class_CanvasItem_constant_NOTIFICATION_LOCAL_TRANSFORM_CHANGED>` щоразу, коли змінюється його локальне перетворення. Це вмикається за допомогою методу :ref:`set_notify_local_transform()<class_CanvasItem_method_set_notify_local_transform>`.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_is_transform_notification_enabled:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_transform_notification_enabled**\ (\ ) |const| :ref:`🔗<class_CanvasItem_method_is_transform_notification_enabled>`
Повертає ``true``, якщо вузол отримує :ref:`NOTIFICATION_TRANSFORM_CHANGED<class_CanvasItem_constant_NOTIFICATION_TRANSFORM_CHANGED>` щоразу, коли змінюється його глобальне перетворення. Це вмикається за допомогою методу :ref:`set_notify_transform()<class_CanvasItem_method_set_notify_transform>`.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_is_visible_in_tree:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_visible_in_tree**\ (\ ) |const| :ref:`🔗<class_CanvasItem_method_is_visible_in_tree>`
Повертає ``true``, якщо вузол присутній у :ref:`SceneTree<class_SceneTree>`, його властивість :ref:`visible<class_CanvasItem_property_visible>` має значення ``true`` і всі його предки також видимі. Якщо будь-який предок прихований, цей вузол не буде видимим у дереві сцени, і тому не буде намальовано (див. :ref:`_draw()<class_CanvasItem_private_method__draw>`).
Видимість перевіряється лише в батьківських вузлах, які успадковуються від **CanvasItem**, :ref:`CanvasLayer<class_CanvasLayer>` і :ref:`Window<class_Window>`. Якщо батьківський елемент має будь-який інший тип (наприклад, :ref:`Node<class_Node>`, :ref:`AnimationPlayer<class_AnimationPlayer>` або :ref:`Node3D<class_Node3D>`), він вважається видимим.
\ **Примітка:** цей метод не враховує :ref:`visibility_layer<class_CanvasItem_property_visibility_layer>`, тож навіть якщо цей метод повертає ``true``, вузол може не відобразитися.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_make_canvas_position_local:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **make_canvas_position_local**\ (\ viewport_point\: :ref:`Vector2<class_Vector2>`\ ) |const| :ref:`🔗<class_CanvasItem_method_make_canvas_position_local>`
Перетворює ``viewport_point`` із координат вікна перегляду на локальні координати цього вузла.
Для протилежної операції використовуйте :ref:`get_global_transform_with_canvas()<class_CanvasItem_method_get_global_transform_with_canvas>`.
::
var viewport_point = get_global_transform_with_canvas() * local_point
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_make_input_local:
.. rst-class:: classref-method
:ref:`InputEvent<class_InputEvent>` **make_input_local**\ (\ event\: :ref:`InputEvent<class_InputEvent>`\ ) |const| :ref:`🔗<class_CanvasItem_method_make_input_local>`
Повертає копію заданої події ``event`` з її координатами, перетвореними з глобального простору в локальний простір цього **CanvasItem**. Якщо це неможливо, повертає ту саму подію :ref:`InputEvent<class_InputEvent>` без змін.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_move_to_front:
.. rst-class:: classref-method
|void| **move_to_front**\ (\ ) :ref:`🔗<class_CanvasItem_method_move_to_front>`
Переміщує цей вузол нижче його братів і сестер, зазвичай змушуючи вузол малюватися поверх своїх братів і сестер. Нічого не робить, якщо цей вузол не має батьківського вузла. Див. також :ref:`Node.move_child()<class_Node_method_move_child>`.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_queue_redraw:
.. rst-class:: classref-method
|void| **queue_redraw**\ (\ ) :ref:`🔗<class_CanvasItem_method_queue_redraw>`
Ставить **CanvasItem** у чергу для перемальовування. Під час простою, якщо **CanvasItem** є видимим, надсилається :ref:`NOTIFICATION_DRAW<class_CanvasItem_constant_NOTIFICATION_DRAW>` і викликається :ref:`_draw()<class_CanvasItem_private_method__draw>`. Це відбувається лише **один раз** за кадр, навіть якщо цей метод було викликано кілька разів.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_set_instance_shader_parameter:
.. rst-class:: classref-method
|void| **set_instance_shader_parameter**\ (\ name\: :ref:`StringName<class_StringName>`, value\: :ref:`Variant<class_Variant>`\ ) :ref:`🔗<class_CanvasItem_method_set_instance_shader_parameter>`
Встановіть значення шейдерної уніформи лише для цього екземпляра (`per-instance uniform <../tutorials/shaders/shader_reference/shading_language.html#per-instance-uniforms>`__). Дивіться також :ref:`ShaderMaterial.set_shader_parameter()<class_ShaderMaterial_method_set_shader_parameter>`, щоб призначити однорідність для всіх екземплярів, використовуючи той самий :ref:`ShaderMaterial<class_ShaderMaterial>`.
\ **Примітка.** Щоб уніформу шейдера можна було призначати окремо для кожного екземпляра, її *має* визначати ``instance uniform ...``, а не ``uniform ...`` у коді шейдера.
\ **Примітка: ** ``name`` чутлива до регістру та має точно відповідати назві уніформи в коді (а не назві, написаній великими літерами в інспекторі).
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_set_notify_local_transform:
.. rst-class:: classref-method
|void| **set_notify_local_transform**\ (\ enable\: :ref:`bool<class_bool>`\ ) :ref:`🔗<class_CanvasItem_method_set_notify_local_transform>`
Якщо значення ``true``, вузол отримуватиме :ref:`NOTIFICATION_LOCAL_TRANSFORM_CHANGED<class_CanvasItem_constant_NOTIFICATION_LOCAL_TRANSFORM_CHANGED>` щоразу, коли змінюється його локальне перетворення.
\ **Примітка:** Багато елементів полотна, такі як :ref:`Bone2D<class_Bone2D>` або :ref:`CollisionShape2D<class_CollisionShape2D>`, автоматично вмикають це для правильної роботи.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_set_notify_transform:
.. rst-class:: classref-method
|void| **set_notify_transform**\ (\ enable\: :ref:`bool<class_bool>`\ ) :ref:`🔗<class_CanvasItem_method_set_notify_transform>`
Якщо ``true``, вузол отримуватиме :ref:`NOTIFICATION_TRANSFORM_CHANGED<class_CanvasItem_constant_NOTIFICATION_TRANSFORM_CHANGED>` щоразу, коли змінюється глобальне перетворення.
\ **Примітка:** Багато елементів полотна, такі як :ref:`Camera2D<class_Camera2D>` або :ref:`Light2D<class_Light2D>`, автоматично вмикають це для правильної роботи.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_set_visibility_layer_bit:
.. rst-class:: classref-method
|void| **set_visibility_layer_bit**\ (\ layer\: :ref:`int<class_int>`, enabled\: :ref:`bool<class_bool>`\ ) :ref:`🔗<class_CanvasItem_method_set_visibility_layer_bit>`
Встановити/очистити окремі біти на шарі видимості візуалізації. Це спрощує редагування шару видимості цього **CanvasItem**.
.. rst-class:: classref-item-separator
----
.. _class_CanvasItem_method_show:
.. rst-class:: classref-method
|void| **show**\ (\ ) :ref:`🔗<class_CanvasItem_method_show>`
Показувати **CanvasItem**, якщо він наразі прихований. Це еквівалентно встановленню для :ref:`visible<class_CanvasItem_property_visible>` значення ``true``.
\ **Примітка:** Для елементів керування, які успадковують :ref:`Popup<class_Popup>`, правильний спосіб зробити їх видимими – це викликати одну з кількох функцій ``popup*()``.
.. |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 (Значення не повертається.)`
Reference in New Issue View Git Blame Copy Permalink