CanvasItem

Hérite de : Node < Object

Hérité par : Control, Node2D

Classe de base abstraite pour tout ce qui est dans l'espace 2D.

Description

Classe de base abstraite pour tout dans l'espace 2D. Les objets de canevas sont disposés en un arbre, les enfants héritent et étendent la transformation de leurs parents. CanvasItem est étendu par Control pour les nœuds liés à l'interface graphique, et par Node2D pour les objets de jeu 2D.

Tout CanvasItem peut dessiner. Pour cela, queue_redraw() est appelé par le moteur, puis NOTIFICATION_DRAW sera reçu pendant le temps d'inactivité pour demander un redessin. Grâce à cela, les objets de canveas n'ont pas besoin d'être redessinés à chaque trame, améliorant considérablement la performance. Plusieurs fonctions pour dessiner sur le CanvasItem sont fournies (voir les fonctions draw_*). Cependant, elles ne peuvent être utilisés qu'à l'intérieur de _draw(), sa Object._notification() correspondante ou les méthodes reliées au signal de dessin draw.

Les objets de canevas sont dessinés dans l'ordre de l'arbre sur leur calque de toile. Par défaut, les enfants sont au-dessus de leurs parents, donc une racine CanvasItem sera dessinée derrière tout. Ce comportement peut être modifié par objet.

Un CanvasItem peut être caché, ce qui cachera également ses enfants. En ajustant diverses autres propriétés d'un CanvasItem, vous pouvez également moduler sa couleur (via modulate ou self_modulate), changer son Z-index, le mode de mélange, et plus encore.

Notez que les propriétés comme la transformation, la modulation et la visibilité sont uniquement propagées à nœuds enfants CanvasItem directs . S'il y a un nœud non-CanvasItem entre, comme Node ou AnimationPlayer, les nœuds CanvasItem ci-dessous auront une position et une chaîne modulate indépendantes. Voir aussi top_level.

Tutoriels

Propriétés

ClipChildrenMode	clip_children	`0`
int	light_mask	`1`
Material	material
Color	modulate	`Color(1, 1, 1, 1)`
Color	self_modulate	`Color(1, 1, 1, 1)`
bool	show_behind_parent	`false`
TextureFilter	texture_filter	`0`
TextureRepeat	texture_repeat	`0`
bool	top_level	`false`
bool	use_parent_material	`false`
int	visibility_layer	`1`
bool	visible	`true`
bool	y_sort_enabled	`false`
bool	z_as_relative	`true`
int	z_index	`0`

Méthodes

void	_draw() virtual
void	draw_animation_slice(animation_length: float, slice_begin: float, slice_end: float, offset: float = 0.0)
void	draw_arc(center: Vector2, radius: float, start_angle: float, end_angle: float, point_count: int, color: Color, width: float = -1.0, antialiased: bool = false)
void	draw_char(font: Font, pos: Vector2, char: String, font_size: int = 16, modulate: Color = Color(1, 1, 1, 1), oversampling: float = 0.0) const
void	draw_char_outline(font: Font, pos: Vector2, char: String, font_size: int = 16, size: int = -1, modulate: Color = Color(1, 1, 1, 1), oversampling: float = 0.0) const
void	draw_circle(position: Vector2, radius: float, color: Color, filled: bool = true, width: float = -1.0, antialiased: bool = false)
void	draw_colored_polygon(points: PackedVector2Array, color: Color, uvs: PackedVector2Array = PackedVector2Array(), texture: Texture2D = null)
void	draw_dashed_line(from: Vector2, to: Vector2, color: Color, width: float = -1.0, dash: float = 2.0, aligned: bool = true, antialiased: bool = false)
void	draw_end_animation()
void	draw_lcd_texture_rect_region(texture: Texture2D, rect: Rect2, src_rect: Rect2, modulate: Color = Color(1, 1, 1, 1))
void	draw_line(from: Vector2, to: Vector2, color: Color, width: float = -1.0, antialiased: bool = false)
void	draw_mesh(mesh: Mesh, texture: Texture2D, transform: Transform2D = Transform2D(1, 0, 0, 1, 0, 0), modulate: Color = Color(1, 1, 1, 1))
void	draw_msdf_texture_rect_region(texture: Texture2D, rect: Rect2, src_rect: Rect2, modulate: Color = Color(1, 1, 1, 1), outline: float = 0.0, pixel_range: float = 4.0, scale: float = 1.0)
void	draw_multiline(points: PackedVector2Array, color: Color, width: float = -1.0, antialiased: bool = false)
void	draw_multiline_colors(points: PackedVector2Array, colors: PackedColorArray, width: float = -1.0, antialiased: bool = false)
void	draw_multiline_string(font: Font, pos: Vector2, text: String, alignment: HorizontalAlignment = 0, width: float = -1, font_size: int = 16, max_lines: int = -1, modulate: Color = Color(1, 1, 1, 1), brk_flags: BitField[LineBreakFlag] = 3, justification_flags: BitField[JustificationFlag] = 3, direction: Direction = 0, orientation: Orientation = 0, oversampling: float = 0.0) const
void	draw_multiline_string_outline(font: Font, pos: Vector2, text: String, alignment: HorizontalAlignment = 0, width: float = -1, font_size: int = 16, max_lines: int = -1, size: int = 1, modulate: Color = Color(1, 1, 1, 1), brk_flags: BitField[LineBreakFlag] = 3, justification_flags: BitField[JustificationFlag] = 3, direction: Direction = 0, orientation: Orientation = 0, oversampling: float = 0.0) const
void	draw_multimesh(multimesh: MultiMesh, texture: Texture2D)
void	draw_polygon(points: PackedVector2Array, colors: PackedColorArray, uvs: PackedVector2Array = PackedVector2Array(), texture: Texture2D = null)
void	draw_polyline(points: PackedVector2Array, color: Color, width: float = -1.0, antialiased: bool = false)
void	draw_polyline_colors(points: PackedVector2Array, colors: PackedColorArray, width: float = -1.0, antialiased: bool = false)
void	draw_primitive(points: PackedVector2Array, colors: PackedColorArray, uvs: PackedVector2Array, texture: Texture2D = null)
void	draw_rect(rect: Rect2, color: Color, filled: bool = true, width: float = -1.0, antialiased: bool = false)
void	draw_set_transform(position: Vector2, rotation: float = 0.0, scale: Vector2 = Vector2(1, 1))
void	draw_set_transform_matrix(xform: Transform2D)
void	draw_string(font: Font, pos: Vector2, text: String, alignment: HorizontalAlignment = 0, width: float = -1, font_size: int = 16, modulate: Color = Color(1, 1, 1, 1), justification_flags: BitField[JustificationFlag] = 3, direction: Direction = 0, orientation: Orientation = 0, oversampling: float = 0.0) const
void	draw_string_outline(font: Font, pos: Vector2, text: String, alignment: HorizontalAlignment = 0, width: float = -1, font_size: int = 16, size: int = 1, modulate: Color = Color(1, 1, 1, 1), justification_flags: BitField[JustificationFlag] = 3, direction: Direction = 0, orientation: Orientation = 0, oversampling: float = 0.0) const
void	draw_style_box(style_box: StyleBox, rect: Rect2)
void	draw_texture(texture: Texture2D, position: Vector2, modulate: Color = Color(1, 1, 1, 1))
void	draw_texture_rect(texture: Texture2D, rect: Rect2, tile: bool, modulate: Color = Color(1, 1, 1, 1), transpose: bool = false)
void	draw_texture_rect_region(texture: Texture2D, rect: Rect2, src_rect: Rect2, modulate: Color = Color(1, 1, 1, 1), transpose: bool = false, clip_uv: bool = true)
void	force_update_transform()
RID	get_canvas() const
RID	get_canvas_item() const
CanvasLayer	get_canvas_layer_node() const
Transform2D	get_canvas_transform() const
Vector2	get_global_mouse_position() const
Transform2D	get_global_transform() const
Transform2D	get_global_transform_with_canvas() const
Variant	get_instance_shader_parameter(name: StringName) const
Vector2	get_local_mouse_position() const
Transform2D	get_screen_transform() const
Transform2D	get_transform() const
Rect2	get_viewport_rect() const
Transform2D	get_viewport_transform() const
bool	get_visibility_layer_bit(layer: int) const
World2D	get_world_2d() const
void	hide()
bool	is_local_transform_notification_enabled() const
bool	is_transform_notification_enabled() const
bool	is_visible_in_tree() const
Vector2	make_canvas_position_local(viewport_point: Vector2) const
InputEvent	make_input_local(event: InputEvent) const
void	move_to_front()
void	queue_redraw()
void	set_instance_shader_parameter(name: StringName, value: Variant)
void	set_notify_local_transform(enable: bool)
void	set_notify_transform(enable: bool)
void	set_visibility_layer_bit(layer: int, enabled: bool)
void	show()

Signaux

draw() 🔗

Émis lorsque l'élément CanvasItem doit se redessiner, après la notification NOTIFICATION_DRAW associée et avant que _draw() soit appelée.

Remarque : Les connexions différées ne permettent pas de dessiner via les méthodes draw_*.

hidden() 🔗

Émis lorsque ce nœud devient masqué, c'est-à-dire qu'il n'est plus visible dans l'arborescence (voir is_visible_in_tree()).

item_rect_changed() 🔗

Émis lorsque les limites (position ou taille) du CanvasItem changent, ou lorsqu'une action a eu lieu qui pourrait avoir affecté ces limites (p. ex. modifier Sprite2D.texture).

visibility_changed() 🔗

Émis lorsque la visibilité du CanvasItem change, soit parce que sa propre propriété visible a changé ou parce que sa visibilité dans l'arborescence a changé (voir is_visible_in_tree()).

Ce signal est émis après la notification correspondante NOTIFICATION_VISIBILITY_CHANGED.

Énumérations

enum TextureFilter: 🔗

TextureFilter TEXTURE_FILTER_PARENT_NODE = 0

Le CanvasItem héritera le filtre de son parent.

TextureFilter TEXTURE_FILTER_NEAREST = 1

Le filtrage de texture lit le pixel le plus proche seulement. Cela rend la texture pixelisée de loin, et granuleuse à une certaine distance (à cause des mipmaps qui ne sont pas échantillonnées).

TextureFilter TEXTURE_FILTER_LINEAR = 2

Le filtrage de texture mélange les 4 pixels les plus proches. Cela rend la texture lisse de près, et granuleuse à une certaine distance (à cause des mipmaps qui ne sont pas échantillonnées).

TextureFilter TEXTURE_FILTER_NEAREST_WITH_MIPMAPS = 3

Le filtrage de texture lit à partir du pixel le plus proche et fusionne les deux mipmaps les plus proches (ou utilise la mipmap le plus proche si ProjectSettings.rendering/textures/default_filters/use_nearest_mipmap_filter vaut true). Cela donne à la texture un aspect pixelisé de près et lisse de loin.

Utilisez ce filtre pour les textures non pixel art susceptibles d'être visualisées à petite échelle (par exemple, à cause du zoom d'une Camera2D ou à la mise à l'échelle des sprites), car les mipmaps sont importantes pour lisser les pixels qui sont plus petits que les pixels à l'écran.

TextureFilter TEXTURE_FILTER_LINEAR_WITH_MIPMAPS = 4

Le filtrage de texture fusionne les 4 pixels les plus proches et les 2 mipmaps les plus proches (ou utilise la mipmap le plus proche si ProjectSettings.rendering/textures/default_filters/use_nearest_mipmap_filter est true). Cela rend la texture lisse de près et lisse de loin.

Utilisez ce filtre pour les textures non pixel art susceptibles d'être visualisées à petite échelle (par exemple, grâce au zoom d'une Camera2D ou à la mise à l'échelle du sprite), car les mipmaps sont importantes pour lisser les pixels plus petits que ceux à l'écran.

TextureFilter TEXTURE_FILTER_NEAREST_WITH_MIPMAPS_ANISOTROPIC = 5

Le filtrage de texture lit à partir du pixel le plus proche et fusionne les deux mipmaps (ou utilise la mipmap le plus proche si ProjectSettings.rendering/textures/default_filters/use_nearest_mipmap_filter vaut true) en fonction de l'angle entre la surface et la vue de la caméra. Cela donne à la texture un aspect pixelisé de près et lisse de loin. Le filtrage anisotrope améliore la qualité de la texture sur les surfaces presque alignées avec la caméra, mais est légèrement plus lent. Le niveau de filtrage anisotrope peut être modifié en ajustant ProjectSettings.rendering/textures/default_filters/anisotropic_filtering_level.

Remarque : Ce filtrage de texture est rarement utile dans des projets 2D. TEXTURE_FILTER_NEAREST_WITH_MIPMAPS est généralement plus approprié dans ce cas.

TextureFilter TEXTURE_FILTER_LINEAR_WITH_MIPMAPS_ANISOTROPIC = 6

Le filtrage de texture fusionne les 4 pixels les plus proches et les 2 mipmaps (ou utilise la mipmap le plus proche si ProjectSettings.rendering/textures/default_filters/use_nearest_mipmap_filter vaut true) en fonction de l'angle entre la surface et la vue de la caméra. Cela rend la texture lisse de près et lisse de loin. Le filtrage anisotrope améliore la qualité de la texture sur les surfaces presque alignées avec la caméra, mais est légèrement plus lent. Le niveau du filtrage anisotrope peut être modifié en ajustant ProjectSettings.rendering/textures/default_filters/anisotropic_filtering_level.

Remarque : Ce filtrage de texture est rarement utile dans les projets 2D. TEXTURE_FILTER_LINEAR_WITH_MIPMAPS est généralement plus approprié dans ce cas.

TextureFilter TEXTURE_FILTER_MAX = 7

Représente la taille de l’énumération TextureFilter.

enum TextureRepeat: 🔗

TextureRepeat TEXTURE_REPEAT_PARENT_NODE = 0

Le CanvasItem héritera le filtre de son parent.

TextureRepeat TEXTURE_REPEAT_DISABLED = 1

La texture ne se répète pas. Échantillonner la texture au-delà de son étendue entraînera un étirement des pixels de bord. Vous pouvez éviter ce problème en prévoyant une bordure entièrement transparente d'un pixel de chaque côté de la texture.

TextureRepeat TEXTURE_REPEAT_ENABLED = 2

La texture se répète lorsque sa taille est dépassée.

TextureRepeat TEXTURE_REPEAT_MIRROR = 3

La texture se répète lorsque la taille de la texture est dépassée en mode mosaïque 2×2. Les textures répétées à des positions paires sont mises en miroir.

TextureRepeat TEXTURE_REPEAT_MAX = 4

Représente la taille de l’énumération TextureRepeat.

enum ClipChildrenMode: 🔗

ClipChildrenMode CLIP_CHILDREN_DISABLED = 0

Les enfants sont dessinés par dessus ce nœud et ne sont pas coupés.

ClipChildrenMode CLIP_CHILDREN_ONLY = 1

This node is used as a mask and is not drawn. The mask is based on this node's alpha channel: Opaque pixels are kept, transparent pixels are discarded, and semi-transparent pixels are blended in according to their opacity. Children are clipped to this node's drawn area.

ClipChildrenMode CLIP_CHILDREN_AND_DRAW = 2

This node is used as a mask and is also drawn. The mask is based on this node's alpha channel: Opaque pixels are kept, transparent pixels are discarded, and semi-transparent pixels are blended in according to their opacity. Children are clipped to the parent's drawn area.

ClipChildrenMode CLIP_CHILDREN_MAX = 3

Représente la taille de l'énumération ClipChildrenMode.

Constantes

NOTIFICATION_TRANSFORM_CHANGED = 2000 🔗

Notification reçue lorsque la transformation globale de ce nœud change, si is_transform_notification_enabled() vaut true. Voir aussi set_notify_transform() et get_transform().

Note : Plusieurs éléments de canevas tels que Camera2D ou CollisionShape2D activent automatiquement cela afin de fonctionner correctement.

NOTIFICATION_LOCAL_TRANSFORM_CHANGED = 35 🔗

Notification reçue lorsque la transformation de ce nœud change, si is_local_transform_notification_enabled() vaut true. Ceci n'est pas reçu lorsque la transformation d'un Node2D parent change. Voir aussi set_notify_local_transform().

Note : Plusieurs éléments de canevas tels que Camera2D ou CollisionShape2D activent automatiquement cela afin de fonctionner correctement.

NOTIFICATION_DRAW = 30 🔗

Il a été demandé au CanvasItem de dessiner (voir _draw()).

NOTIFICATION_VISIBILITY_CHANGED = 31 🔗

Notification reçue lorsque la visibilité de ce nœud change (voir visible et is_visible_in_tree()).

Cette notification est reçue avant le signal visibility_changed correspondant.

NOTIFICATION_ENTER_CANVAS = 32 🔗

Le CanvasItem est entré dans le canevas.

NOTIFICATION_EXIT_CANVAS = 33 🔗

Le CanvasItem a quitté le canevas.

NOTIFICATION_WORLD_2D_CHANGED = 36 🔗

Notification reçue lorsque ce CanvasItem est enregistré dans un nouveau World2D (voir get_world_2d()).

Descriptions des propriétés

ClipChildrenMode clip_children = 0 🔗

void set_clip_children_mode(value: ClipChildrenMode)
ClipChildrenMode get_clip_children_mode()

Le mode avec lequel ce nœud découpe ses enfants, agissant comme un masque.

Remarque : Les nœuds de découpage ne peuvent pas être imbriqués ni placés dans un CanvasGroup. Si un ancêtre de ce nœud découpe ses enfants ou est un CanvasGroup, le mode de découpage de ce nœud doit être défini sur CLIP_CHILDREN_DISABLED pour éviter tout comportement inattendu.

int light_mask = 1 🔗

void set_light_mask(value: int)
int get_light_mask()

Les calques de rendu où le CanvasItem est affecté par les nœuds Light2D.

Material material 🔗

void set_material(value: Material)
Material get_material()

Le matériau appliqué à ce CanvasItem.

Color modulate = Color(1, 1, 1, 1) 🔗

void set_modulate(value: Color)
Color get_modulate()

La couleur appliquée à ce CanvasItem. Cette propriété affecte les CanvasItems enfants, contrairement à self_modulate qui n'affecte que le nœud lui-même.

Color self_modulate = Color(1, 1, 1, 1) 🔗

void set_self_modulate(value: Color)
Color get_self_modulate()

La couleur appliquée à ce CanvasItem. Cette propriété n'affecte pas les CanvasItems enfants, contrairement à modulate qui affecte à la fois le nœud lui-même et ses enfants.

Note : Les enfants internes ne sont pas affectés par cette propriété (voir le paramètre include_internal de Node.add_child()). Pour les nœuds intégrés, cela inclut les sliders dans ColorPicker, et la barre d'onglets dans TabContainer.

bool show_behind_parent = false 🔗

void set_draw_behind_parent(value: bool)
bool is_draw_behind_parent_enabled()

Si true, ce nœud dessine derrière son parent.

TextureFilter texture_filter = 0 🔗

void set_texture_filter(value: TextureFilter)
TextureFilter get_texture_filter()

Le mode de filtrage utilisé pour rendre la ou les textures de ce CanvasItem.

TextureRepeat texture_repeat = 0 🔗

void set_texture_repeat(value: TextureRepeat)
TextureRepeat get_texture_repeat()

Le mode de répétition utilisé pour rendre la/les texture(s) de ce CanvasItem. Cela affecte le comportement lorsque la texture est échantillonnée hors de son étendue, par exemple en définissant un Sprite2D.region_rect plus grand que la texture ou en assignant des points UV Polygon2D hors de la texture.

Remarque : TextureRect n'est pas affecté par texture_repeat, car il utilise sa propre implémentation de répétition de texture.

bool top_level = false 🔗

void set_as_top_level(value: bool)
bool is_set_as_top_level()

Si true, ce CanvasItem n'héritera pas sa transformation de son CanvasItem parent. Son ordre d'affichage sera également modifié pour qu'il dessine sur les autres CanvasItem qui n'ont pas top_level à true. Le CanvasItem se comportera effectivement comme s'il était placé comme un enfant d'un Node vide.

bool use_parent_material = false 🔗

void set_use_parent_material(value: bool)
bool get_use_parent_material()

Si true, le matériau material du CanvasItem parent est utilisé comme matériau de ce nœud.

int visibility_layer = 1 🔗

void set_visibility_layer(value: int)
int get_visibility_layer()

La couche de rendu dans laquelle ce CanvasItem est rendu par les nœuds Viewport. Un Viewport rendra un CanvasItem s'il et tous ses parents partagent une couche avec le masque de cull du canevas du Viewport.

bool visible = true 🔗

void set_visible(value: bool)
bool is_visible()

Si true, ce CanvasItem peut être dessiné. Que ce CanvasItem soit effectivement tiré dépend de la visibilité de tous ses ancêtres CanvasItem. En d'autres termes, ce CanvasItem sera dessiné lorsque is_visible_in_tree() renvoie true et que tous les ancêtres CanvasItem partagent au moins un visibility_layer avec ce CanvasItem.

Note : Pour les contrôles qui héritent de Popup, la bonne façon de les rendre visibles est d'appeler l'une des multiples fonction popup*() à la place.

bool y_sort_enabled = false 🔗

void set_y_sort_enabled(value: bool)
bool is_y_sort_enabled()

Si true, ce nœud et les nœuds CanvasItem enfants avec une position Y plus élevée sont rendus devant les nœuds avec une position Y plus basse. Si false, ce nœud et les nœuds CanvasItem enfants sont rendus normalement dans l'ordre de l'arborescence de scène.

Si le tri Y est activé sur un nœud parent ('A') mais désactivé sur un nœud enfant ('B'), le nœud enfant ('B') est trié, mais ses nœuds enfants ('C1', 'C2', etc.) sont rendus ensemble à la même position Y que le nœud enfant ('B'). Cela vous permet d'organiser l'ordre du rendu d'une scène sans modifier l'arborescence de scène.

Les nœuds sont triés les uns par rapport aux autres uniquement s'ils se trouvent sur le même z_index.

bool z_as_relative = true 🔗

void set_z_as_relative(value: bool)
bool is_z_relative()

Si true, l'index Z final de ce nœud est relatif à l'index Z de son parent.

Par exemple, si z_index vaut 2 et que l'index Z final de son parent vaut 3, alors l'index Z final de ce nœud sera 5 (2 + 3).

int z_index = 0 🔗

void set_z_index(value: int)
int get_z_index()

L'ordre dans lequel ce nœud est dessiné. Un nœud avec un index Z supérieur s'affichera par dessus les autres. Doit être entre RenderingServer.CANVAS_ITEM_Z_MIN et RenderingServer.CANVAS_ITEM_Z_MAX (inclusifs).

Note : L'index Z n'affecte pas l'ordre dans lequel les nœuds CanvasItem sont traités ou la façon dont les événements d'entrée sont traités. Il est particulièrement important de garder ceci à l'esprit pour les nœuds Control.

Descriptions des méthodes

void _draw() virtual 🔗

Appelée lorsque le CanvasItem a été demandé de redessiner (après que queue_redraw() soit appelée, manuellement ou par le moteur).

Correspond à la notification NOTIFICATION_DRAW dans Object._notification().

void draw_animation_slice(animation_length: float, slice_begin: float, slice_end: float, offset: float = 0.0) 🔗

Les commandes de dessin qui suivent seront ignorées sauf si elles tombent dans la tranche d'animation spécifiée. C'est une manière plus rapide d'implémenter des animations qui bouclent en arrière-plan au lieu de devoir constamment redessiner.

void draw_arc(center: Vector2, radius: float, start_angle: float, end_angle: float, point_count: int, color: Color, width: float = -1.0, antialiased: bool = false) 🔗

Dessine un arc non rempli entre les angles donnés avec une couleur (color) et une épaisseur (width) uniformes, ainsi qu'un anticrénelage facultatif (pris en charge uniquement si width est positif). Plus la valeur de point_count est grande, plus la courbe est lisse. Voir aussi draw_circle().

Si width est négatif, il sera ignoré et l'arc sera dessiné à l'aide de RenderingServer.PRIMITIVE_LINE_STRIP. Cela signifie que lorsque le CanvasItem est mis à l'échelle, l'arc restera mince. Si ce comportement n'est pas souhaité, transmettez une width positive comme 1.0.

L'arc est tracé de start_angle vers la valeur de end_angle donc dans le sens des aiguilles d'une montre si start_angle < end_angle et dans le sens inverse des aiguilles d'une montre sinon. Passer les mêmes angles mais dans l’ordre inversé produira le même arc. Si la différence absolue entre start_angle et end_angle est supérieure à @GDScript.TAU radians, alors un arc de cercle complet est dessiné (c'est-à-dire que l'arc ne se chevauchera pas).

void draw_char(font: Font, pos: Vector2, char: String, font_size: int = 16, modulate: Color = Color(1, 1, 1, 1), oversampling: float = 0.0) const 🔗

Dessine le premier caractère d'une chaîne de caractères en utilisant une police personnalisée. Si oversampling est supérieur à zéro, il est utilisé comme facteur de sur-échantillonnage de la police, sinon les paramètres de sur-échantillonnage du viewport sont utilisés. pos est défini dans l'espace local.

void draw_char_outline(font: Font, pos: Vector2, char: String, font_size: int = 16, size: int = -1, modulate: Color = Color(1, 1, 1, 1), oversampling: float = 0.0) const 🔗

Dessine le contour du premier caractère d'une chaîne en utilisant une police personnalisée. Si oversampling est supérieur à zéro, il est utilisé comme facteur de sur-échantillonnage de la police, sinon les paramètres de sur-échantillonnage du viewport sont utilisés. pos est défini dans l'espace local.

void draw_circle(position: Vector2, radius: float, color: Color, filled: bool = true, width: float = -1.0, antialiased: bool = false) 🔗

Dessine un cercle, avec position défini dans l'espace local. Voir aussi draw_arc(), draw_polyline(), et draw_polygon().

Si filled vaut true, le cercle sera rempli avec la couleur color spécifiée. Si filled vaut false, le cercle sera dessiné avec un trait de couleur color et de largeur width spécifiées.

Si width est négative, alors des primitives à deux points seront dessinées au lieu de celles à 4 points. Cela signifie que lorsque le CanvasItem est redimensionné, les lignes resteront fines. Si ce comportement n'est pas souhaité, passez une largeur width positive comme 1.0.

Si antialiased vaut true, des « gaines » à moitié transparentes seront attachées aux bords, rendant les contours lisses.

Note : width est seulement effectif si filled vaut false.

void draw_colored_polygon(points: PackedVector2Array, color: Color, uvs: PackedVector2Array = PackedVector2Array(), texture: Texture2D = null) 🔗

Dessine un polygone coloré à n'importe quel nombre de points, convexe ou concave. Les points dans le tableau points sont définis en espace local. Unlike draw_polygon(), a single color must be specified for the whole polygon.

Remarque : Si un polygone avec un nombre considérable de sommets est fréquemment redessiné, il serait conseillé de pré-calculer la triangulation avec Geometry2D.triangulate_polygon() et utiliser la méthode draw_mesh(), draw_multimesh(), ou RenderingServer.canvas_item_add_triangle_array().

void draw_dashed_line(from: Vector2, to: Vector2, color: Color, width: float = -1.0, dash: float = 2.0, aligned: bool = true, antialiased: bool = false) 🔗

Dessine une ligne en tirets d'un point 2D à un autre, avec une couleur et une largeur données. Les positions from et to sont définies dans l'espace local. Voir aussi draw_line(), draw_multiline(), et draw_polyline().

Si width est négative, alors des primitives à deux points seront dessinées au lieu de celles à 4 points. Cela signifie que lorsque le CanvasItem est redimensionné, les lignes resteront fines. Si ce comportement n'est pas souhaité, passez une largeur width positive comme 1.0.

dash est la longueur de chaque tiret en pixels, avec l'écart entre chaque tiret étant la même longueur. Si aligned vaut true, la longueur des premier et dernier tirets peut être raccourcie ou allongée pour permettre à la ligne de commencer et de se terminer aux points précis définis par from et to. Les deux extrémités sont toujours symétriques lorsque aligned vaut true. Si aligned vaut false, tous les tirets auront la même longueur, mais la ligne peut apparaître incomplète à la fin à cause de la longueur du tiret qui ne divise pas parfaitement la longueur de la ligne. Seules les tirets complets sont dessinés lorsque aligned vaut false.

Si antialiased vaut true, des « gaines » à moitié transparentes seront attachées aux bords, rendant les contours lisses.

Note : antialiased est seulement effectif si width est supérieure à 0.0.

void draw_end_animation() 🔗

Après l'envoi de toutes les tranches d'animations via draw_animation_slice(), cette fonction peut être utilisée pour restaurer le dessin à l'état par défaut (toutes les commandes de dessin qui suivent seront visibles). Si ce cas d'utilisation particulier peut être négligé, l'utilisation de cette fonction après l'envoi des tranches n'est pas requis.

void draw_lcd_texture_rect_region(texture: Texture2D, rect: Rect2, src_rect: Rect2, modulate: Color = Color(1, 1, 1, 1)) 🔗

Dessine un rectangle texturé de la texture de la police avec anticrénelage des sous-pixels LCD à une position donnée, éventuellement modulé par une couleur. Le paramètre rect est défini dans l'espace local.

La texture est dessinée à l'aide de l'opération de fusion suivante ; le mode de fusion de CanvasItemMaterial est ignoré :

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);

void draw_line(from: Vector2, to: Vector2, color: Color, width: float = -1.0, antialiased: bool = false) 🔗

Dessine une ligne d'un point 2D à un autre, avec une couleur et une largeur données. Elle peut être en option anti-crénelée. Les positions from et to sont définies dans l'espace local. Voir aussi draw_dashed_line(), draw_multiline(), et draw_polyline().

Si width est négative, alors des primitives à deux points seront dessinées au lieu de celles à 4 points. Cela signifie que lorsque le CanvasItem est redimensionné, les lignes resteront fines. Si ce comportement n'est pas souhaité, passez une largeur width positive comme 1.0.

void draw_mesh(mesh: Mesh, texture: Texture2D, transform: Transform2D = Transform2D(1, 0, 0, 1, 0, 0), modulate: Color = Color(1, 1, 1, 1)) 🔗

Dessine un Mesh en 2D, en utilisant la texture spécifiée. Voir MeshInstance2D pour la documentation en rapport. La transformation transform est définie dans l'espace local.

void draw_msdf_texture_rect_region(texture: Texture2D, rect: Rect2, src_rect: Rect2, modulate: Color = Color(1, 1, 1, 1), outline: float = 0.0, pixel_range: float = 4.0, scale: float = 1.0) 🔗

Dessine une région rectangulaire texturée de la texture du champ de distance signé multicanal à une position donnée, avec modulation optionnelle par une couleur. Le rect est défini en espace local. Voir FontFile.multichannel_signed_distance_field pour plus d'informations et d'avertissements sur le rendu de police en CDSM.

Si la valeur outline est positive, chaque valeur de canal alpha d'un pixel dans la région est affectée a la valeur maximale de la distance réelle dans le rayon outline.

La valeur de pixel_range doit être la même que celle qui a été utilisée pour la génération de la texture de distance signées.

void draw_multiline(points: PackedVector2Array, color: Color, width: float = -1.0, antialiased: bool = false) 🔗

Dessine des lignes déconnectées avec une largueur width et une couleur color uniformes. Chaque ligne est définie par deux points consécutifs du tableau points, c.à.d. le i-ème segment est formé des points points[2 * i] et points[2 * i + 1]. Lorsque vous dessinez de grandes quantités de lignes, ceci est plus rapide que d'utiliser des appels individuels à draw_line(). Pour tracer des lignes interconnectées, utilisez draw_polyline() à la place.

Si width est négative, alors des primitives à deux points seront dessinées au lieu de celles à 4 points. Cela signifie que lorsque le CanvasItem est redimensionné, les lignes resteront fines. Si ce comportement n'est pas souhaité, passez une largeur width positive comme 1.0.

Note : antialiased n'est effectif que si width est supérieur à 0.0.

void draw_multiline_colors(points: PackedVector2Array, colors: PackedColorArray, width: float = -1.0, antialiased: bool = false) 🔗

Dessine des lignes déconnectées avec une largeur width uniforme et une coloration segment par segment. Chaque ligne est définie par deux points consécutifs du tableau points et une couleur correspondante du tableau colors, c.à.d. le i-ème segment est formé des points points[2 * i] et points[2 * i + 1] et a comme couleur colors[i]. Lorsque vous dessinez de grandes quantités de lignes, ceci est plus rapide que d'utiliser des appels individuels à draw_line(). Pour tracer des lignes interconnectées, utilisez draw_polyline_colors() à la place.

Si width est négative, alors des primitives à deux points seront dessinées au lieu de celles à 4 points. Cela signifie que lorsque le CanvasItem est redimensionné, les lignes resteront fines. Si ce comportement n'est pas souhaité, passez une largeur width positive comme 1.0.

Note : antialiased n'est effectif que si width est supérieur à 0.0.

void draw_multiline_string(font: Font, pos: Vector2, text: String, alignment: HorizontalAlignment = 0, width: float = -1, font_size: int = 16, max_lines: int = -1, modulate: Color = Color(1, 1, 1, 1), brk_flags: BitField[LineBreakFlag] = 3, justification_flags: BitField[JustificationFlag] = 3, direction: Direction = 0, orientation: Orientation = 0, oversampling: float = 0.0) const 🔗

Sépare text en lignes et le dessine avec la police font spécifiée à la position pos en espace local (coin supérieur gauche). La couleur du texte sera multipliée par modulate. Si width est supérieur ou égal à 0, le texte sera tronqué s'il dépasse la largeur spécifiée. Si le paramètre oversampling est supérieur à 0, il est utilisé comme facteur de sur-échantillonnage, sinon les paramètres de sur-échantillonnage de la fenêtre d'affichage sont utilisés.

void draw_multiline_string_outline(font: Font, pos: Vector2, text: String, alignment: HorizontalAlignment = 0, width: float = -1, font_size: int = 16, max_lines: int = -1, size: int = 1, modulate: Color = Color(1, 1, 1, 1), brk_flags: BitField[LineBreakFlag] = 3, justification_flags: BitField[JustificationFlag] = 3, direction: Direction = 0, orientation: Orientation = 0, oversampling: float = 0.0) const 🔗

Sépare text en lignes et dessine le contour du texte avec la police font spécifiée à la position pos dans l'espace local (coin supérieur gauche). La couleur du texte sera multipliée par modulate. Si width est supérieure ou égale à 0, le texte sera coupé s'il dépasse la largeur spécifiée. Si oversampling est supérieur à 0, il est utilisé comme facteur de sur-échantillonnage de la police, sinon les paramètres de sur-échantillonnage du viewport sont utilisés.

void draw_multimesh(multimesh: MultiMesh, texture: Texture2D) 🔗

Dessine un MultiMesh en 2D avec la texture spécifiée. Voir MultiMeshInstance2D pour la documentation en rapport.

void draw_polygon(points: PackedVector2Array, colors: PackedColorArray, uvs: PackedVector2Array = PackedVector2Array(), texture: Texture2D = null) 🔗

Dessine un polygone rempli avec un nombre quelconque de points, qu’il soit convexe ou concave. Contrairement à draw_colored_polygon(), la couleur de chaque point peut être modifiée individuellement. Le tableau points est défini dans l’espace local. Voir également draw_polyline() et draw_polyline_colors(). Si vous avez besoin de plus de flexibilité (par exemple pour utiliser des os), utilisez plutôt RenderingServer.canvas_item_add_triangle_array().

Note : Si vous redessinez fréquemment le même polygone avec un grand nombre de sommets, envisagez de pré-calculer la triangulation avec Geometry2D.triangulate_polygon() et en utilisant draw_mesh(), draw_multimesh(), ou RenderingServer.canvas_item_add_triangle_array().

void draw_polyline(points: PackedVector2Array, color: Color, width: float = -1.0, antialiased: bool = false) 🔗

Dessine des segments interconnectés d'une couleur color et d'une épaisseur width uniforme avec un anticrénelage facultatif (supporté seulement pour une width positive). Le tableau points est défini dans l'espace local. Si vous dessinez de grandes quantités de lignes, ceci est plus rapide que d'appeler draw_line() individuellement. Pour dessiner des lignes déconnectées, utilisez plutôt draw_multiline(). Voir aussi draw_polygon().

Si width est négative, elle sera ignorée et la polyligne sera dessinée en utilisant RenderingServer.PRIMITIVE_LINE_STRIP. Cela signifie que lorsque le CanvasItem est redimensionné, la polyligne restera fine. Si ce comportement n'est pas souhaité, passez une width positive comme 1.0.

void draw_polyline_colors(points: PackedVector2Array, colors: PackedColorArray, width: float = -1.0, antialiased: bool = false) 🔗

Dessine des segments de ligne interconnectés avec une largeur width uniforme, une coloration point par point, et un anti-crénelage optionnel (supporté seulement pour une width positive). Les couleurs assignées aux points de la ligne correspondent par index entre points et colors, c'est-à-dire chaque segment de ligne est rempli avec le gradient se trouvant entre les couleurs des points de début et de fin. Le tableau points est défini dans l'espace local. Lorsque vous dessinez de grandes quantités de lignes, ceci est plus rapide que d'utiliser des appels individuels à draw_line(). Pour dessiner des lignes déconnectées, utilisez plutôt draw_multiline_colors(). Voir aussi draw_polygon().

Si width est négative, elle sera ignorée et la polyligne sera dessinée en utilisant RenderingServer.PRIMITIVE_LINE_STRIP. Cela signifie que lorsque le CanvasItem est redimensionné, la polyligne restera fine. Si ce comportement n'est pas souhaité, passez une width positive comme 1.0.

void draw_primitive(points: PackedVector2Array, colors: PackedColorArray, uvs: PackedVector2Array, texture: Texture2D = null) 🔗

Dessine une primitive personnalisée. 1 point pour dessiner un point, 2 points pour une ligne, 3 points pour un triangle, et 4 points pour un quad. Si 0 points ou plus de 4 points sont spécifiés, rien ne sera dessiné et un message d'erreur sera affiché. Voir aussi draw_line(), draw_polyline(), draw_polygon(), et draw_rect().

void draw_rect(rect: Rect2, color: Color, filled: bool = true, width: float = -1.0, antialiased: bool = false) 🔗

Dessine un rectangle. Si filled vaut true, le rectangle sera rempli avec la couleur color spécifiée. Si filled vaut false, le rectangle sera dessiné en tant que trait avec la color et la largeur width spécifiées. Le rect est spécifié dans l'espace local. Voir aussi draw_texture_rect().

Si width est négative, alors des primitives à deux points seront dessinées au lieu de celles à 4 points. Cela signifie que lorsque le CanvasItem est redimensionné, les lignes resteront fines. Si ce comportement n'est pas souhaité, passez une largeur width positive comme 1.0.

Si antialiased vaut true, des « gaines » à moitié transparentes seront attachées aux bords, rendant les contours lisses.

Note : width est seulement effectif si filled vaut false.

Note : Les rectangles non remplis dessinés avec une width négative peuvent ne pas s'afficher parfaitement. Par exemple, des coins peuvent être manquants ou plus lumineux en raison de lignes se chevauchant (pour une color translucide).

void draw_set_transform(position: Vector2, rotation: float = 0.0, scale: Vector2 = Vector2(1, 1)) 🔗

Définit une transformation locale personnalisée pour le dessin par des composants. Tout ce qui a été dessiné par la suite sera transformé par cela.

Note : FontFile.oversampling ne prend pas scale en compte. Cela signifie que l'agrandissement/le rétrécissement va causer aux polices bitmap et aux polices dynamiques rasterisées (non-MSDF) d'apparaître floues ou pixelisées. Pour garantir que le texte reste net indépendamment de l'échelle, vous pouvez activer le rendu de police MSDF en activant ProjectSettings.gui/theme/default_font_multichannel_signed_distance_field (s'applique uniquement à la police du projet par défaut), ou en activant Champ de Distance Signé Multicanal dans les options d'import d'une DynamicFont pour les polices personnalisées. Sur les polices du système, SystemFont.multichannel_signed_distance_field peut être activé dans l'inspecteur.

void draw_set_transform_matrix(xform: Transform2D) 🔗

Définit une transformation personnalisée pour le dessin via la matrice. Tout ce qui sera dessiné par la suite sera transformé par cela.

void draw_string(font: Font, pos: Vector2, text: String, alignment: HorizontalAlignment = 0, width: float = -1, font_size: int = 16, modulate: Color = Color(1, 1, 1, 1), justification_flags: BitField[JustificationFlag] = 3, direction: Direction = 0, orientation: Orientation = 0, oversampling: float = 0.0) const 🔗

Dessine text en utilisant la police font spécifiée à la position pos dans l'espace local (le coin en bas à gauche correspond à la ligne de base de la police). Le texte aura sa couleur multipliée par modulate. Si width est supérieure ou égale à 0, le texte sera coupé s'il dépasse la largeur spécifiée. Si oversampling est supérieur à zéro, il est utilisé comme facteur de sur-échantillonnage de la police, sinon les paramètres de sur-échantillonnage du viewport sont utilisés.

Exemple : Dessiner "Bonjour le monde", en utilisant la police par défaut du projet :

# Si vous utilisez cette méthode dans un script qui redessine souvent, déplacez la
# déclaration de `default_font` vers une variable membre assignée dans `_Ready()`
# pour que le Control ne soit créé qu'une fois.
var police_par_defaut = ThemeDB.fallback_font
var taille_police_par_defaut = ThemeDB.fallback_font_size
draw_string(police_par_defaut, Vector2(64, 64), "Bonjour le monde", HORIZONTAL_ALIGNMENT_LEFT, -1, taille_police_par_defaut)

// Si vous utilisez cette méthode dans un script qui redessine souvent, déplacez la
// déclaration de `default_font` vers une variable membre assignée dans `_Ready()`
// pour que le Control ne soit créé qu'une fois.
Font policeParDefaut = ThemeDB.FallbackFont;
int taillePoliceParDefaut = ThemeDB.FallbackFontSize;
DrawString(policeParDefaut, new Vector2(64, 64), "Bonjour le monde", HORIZONTAL_ALIGNMENT_LEFT, -1, taillePoliceParDefaut);

Voir aussi Font.draw_string().

void draw_string_outline(font: Font, pos: Vector2, text: String, alignment: HorizontalAlignment = 0, width: float = -1, font_size: int = 16, size: int = 1, modulate: Color = Color(1, 1, 1, 1), justification_flags: BitField[JustificationFlag] = 3, direction: Direction = 0, orientation: Orientation = 0, oversampling: float = 0.0) const 🔗

Dessine le contour du text en utilisant la police font spécifiée à la position pos dans l'espace local (coin en bas à gauche en utilisant la ligne de base de la police). Le texte aura sa couleur multipliée par modulate. Si width est supérieure ou égale à 0, le texte sera coupé s'il dépasse la largeur spécifiée. Si oversampling est supérieur à zéro, il est utilisé comme facteur de sur-échantillonnage de la police, sinon les paramètres de sur-échantillonnage du viewport sont utilisés.

void draw_style_box(style_box: StyleBox, rect: Rect2) 🔗

Dessine un rectangle stylisé. rect est défini dans l'espace local.

void draw_texture(texture: Texture2D, position: Vector2, modulate: Color = Color(1, 1, 1, 1)) 🔗

Dessine une texture à une position donnée. La position est définie dans l'espace local.

void draw_texture_rect(texture: Texture2D, rect: Rect2, tile: bool, modulate: Color = Color(1, 1, 1, 1), transpose: bool = false) 🔗

Dessine un rectangle texturé à une position donnée, possiblement modulé par une couleur. Le rect est défini dans l'espace local. Si transpose vaut true, la texture aura ses coordonnées X et Y échangées. Voir aussi draw_rect() et draw_texture_rect_region().

void draw_texture_rect_region(texture: Texture2D, rect: Rect2, src_rect: Rect2, modulate: Color = Color(1, 1, 1, 1), transpose: bool = false, clip_uv: bool = true) 🔗

Dessine un rectangle texturé depuis une région d'une texture (précisé par src_rect) à une position donnée dans l'espace local, possiblement modulé par une couleur. Si transpose vaut true, la texture aura ses coordonnées X et Y échangées. Voir aussi draw_texture_rect().

void force_update_transform() 🔗

Force la mise à jour de la transformation du nœud. Échoue si le nœud n'est pas dans l'arborescence. Voir aussi get_transform().

Remarque : Pour des raisons de performances, les modifications de transformation sont généralement cumulées et appliquées en une fois à la fin de la trame. La mise à jour se propage également aux CanvasItem enfants. Par conséquent, utilisez cette méthode uniquement lorsque vous avez besoin d'une transformation à jour (par exemple, lors d'opérations de physique).

RID get_canvas() const 🔗

Renvoie le RID du canevas World2D où ce nœud est enregistré, utilisé par le RenderingServer.

RID get_canvas_item() const 🔗

Renvoie le RID de l'élément de canevas interne utilisé par le RenderingServer pour ce nœud.

CanvasLayer get_canvas_layer_node() const 🔗

Renvoie le CanvasLayer qui contient ce nœud, ou null si le nœud n'est pas dans un CanvasLayer.

Transform2D get_canvas_transform() const 🔗

Renvoie la transformation de ce nœud, convertie du système de coordonnées de son canevas enregistré au système de coordonnées de son viewport. Voir aussi Node.get_viewport().

Vector2 get_global_mouse_position() const 🔗

Renvoie la position globale du curseur de la souris par rapport au CanvasLayer qui contient ce nœud.

Note : Pour les coordonnées de l'espace-écran (p. ex. lors de l'utilisation d'une Popup non intégrée), vous pouvez utiliser DisplayServer.mouse_get_position().

Transform2D get_global_transform() const 🔗

Renvoie la matrice de transformation globale de cet élément, c'est-à-dire la transformation combinée jusqu'au nœud CanvasItem le plus haut. L'élément le plus haut est un CanvasItem qui soit n'a pas de parent, a un parent non-CanvasItem ou a top_level activé.

Transform2D get_global_transform_with_canvas() const 🔗

Renvoie la transformation du système de coordonnées local de ce CanvasItem vers le système de coordonnées du Viewport.

Variant get_instance_shader_parameter(name: StringName) const 🔗

Obtient la valeur d'un paramètre de shader défini sur cette instance.

Vector2 get_local_mouse_position() const 🔗

Renvoie la position de la souris dans le CanvasItem en utilisant le système de coordonnées local à ce CanvasItem.

Transform2D get_screen_transform() const 🔗

Renvoie la transformation de ce CanvasItem dans les coordonnées d'écran globales (c.-à-d. en tenant compte de la position de fenêtre). Généralement utile pour les plugins d'éditeur.

Égal à get_global_transform() si la fenêtre est intégrée (voir Viewport.gui_embed_subwindows).

Transform2D get_transform() const 🔗

Renvoie la matrice de transformation de ce CanvasItem.

Rect2 get_viewport_rect() const 🔗

Renvoie les limites du viewport de ce nœud en tant que Rect2. Voir aussi Node.get_viewport().

Transform2D get_viewport_transform() const 🔗

Renvoie la transformation de ce nœud, convertie du système de coordonnées de son canevas enregistré à son système de coordonnées du viewport intégrant. Voir aussi Viewport.get_final_transform() et Node.get_viewport().

bool get_visibility_layer_bit(layer: int) const 🔗

Renvoie true si l'élément à l'index donné est défini dans visibility_layer.

World2D get_world_2d() const 🔗

Renvoie le World2D auquel ce nœud est enregistré.

En général, il s'agit du même que celui du viewport de ce nœud (voir Node.get_viewport() et Viewport.find_world_2d()).

void hide() 🔗

Cacher les CanvasItem s'ils sont actuellement visibles. C'est équivalent à visible à false.

bool is_local_transform_notification_enabled() const 🔗

Renvoie true si le nœud reçoit NOTIFICATION_LOCAL_TRANSFORM_CHANGED chaque fois que sa transformation locale change. Ceci est activé avec set_notify_local_transform().

bool is_transform_notification_enabled() const 🔗

Renvoie true si le nœud reçoit NOTIFICATION_TRANSFORM_CHANGED chaque fois que sa transformation globale change. Ceci est activé avec set_notify_transform().

bool is_visible_in_tree() const 🔗

Renvoie true si le nœud est présent dans le SceneTree, que sa propriété visible vaut true et que tous ses parents sont également visibles. Si au moins un parent est caché, ce nœud ne sera pas visible dans l'arborescence de la scène, et n'est donc pas dessiné (voir _draw()).

La visibilité n'est vérifiée que dans les nœuds parents héritant de CanvasItem, CanvasLayer et Window. Si le parent est d'un autre type (comme Node, AnimationPlayer, ou Node3D), il est supposé être visible.

Note : Cette méthode ne prend pas en compte visibility_layer, donc même si cette méthode renvoie true, le nœud pourrait finir par ne pas être rendu.

Vector2 make_canvas_position_local(viewport_point: Vector2) const 🔗

Transforme viewport_point des coordonnées de la fenêtre d'affichage aux coordonnées locales de ce nœud.

Pour l'opération inverse, utilisez get_global_transform_with_canvas().

var viewport_point = get_global_transform_with_canvas() * local_point

InputEvent make_input_local(event: InputEvent) const 🔗

Renvoie une copie de l'événement event donné avec ses coordonnées converties de l'espace global à l'espace local du CanvasItem. Si cela n'est pas possible, renvoie le même InputEvent inchangé.

void move_to_front() 🔗

Déplace ce nœud sous ses frères, ce qui provoque généralement son dessin par-dessus. Ne fait rien si ce nœud n'a pas de parent. Voir aussi Node.move_child().

void queue_redraw() 🔗

Met l'élément CanvasItem en file d'attente pour le redessiner. En période d'inactivité, si CanvasItem est visible, NOTIFICATION_DRAW est envoyée et la _draw() est appelée. Cela ne se produit qu'une seule fois par trame, même si cette méthode a été appelée plusieurs fois.

void set_instance_shader_parameter(name: StringName, value: Variant) 🔗

Définit la valeur d'un uniform de shader pour cette instance uniquement (uniform par instance). Voir aussi ShaderMaterial.set_shader_parameter() pour assigner un uniform à toutes les instances utilisant le même ShaderMaterial.

Note : Pour qu'un uniform de shader soit assignable instance par instance, il doit être défini avec instance uniform ... plutôt que uniform ... dans le code du shader.

Note : name est sensible à la casse et doit correspondre exactement au nom de l'uniform dans le code (et non au nom en majuscules dans l'inspecteur).

void set_notify_local_transform(enable: bool) 🔗

Si true, le nœud recevra NOTIFICATION_LOCAL_TRANSFORM_CHANGED chaque fois que sa transformation locale change.

Note : De nombreux éléments de canevas tels que Bone2D ou CollisionShape2D activent automatiquement ceci afin de fonctionner correctement.

void set_notify_transform(enable: bool) 🔗

Si true, le nœud recevra NOTIFICATION_TRANSFORM_CHANGED chaque fois que sa transformation globale change.

Note : De nombreux éléments de canevas tels que Camera2D ou Light2D activent ceci automatiquement afin de fonctionner correctement.

void set_visibility_layer_bit(layer: int, enabled: bool) 🔗

Définit ou efface des bits individuels sur la couche de visibilité de rendu. Cela facilite l'édition de la couche de visibilité de ce CanvasItem.

void show() 🔗

Affiche le CanvasItem s'il est actuellement caché. Ceci est équivalent à definir visible à true.

Note : Pour les contrôles hérités de Popup, la manière correcte de les rendre visible est plutôt d'appeler l'une des fonctions popup*().