Attention: Here be dragons

This is the latest (unstable) version of this documentation, which may document features not available in or compatible with released stable versions of Godot.

Checking the stable version of the documentation...

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_ellipse(position: Vector2, major: float, minor: float, color: Color, filled: bool = true, width: float = -1.0, antialiased: bool = false)
void	draw_ellipse_arc(center: Vector2, major: float, minor: float, start_angle: float, end_angle: float, point_count: int, color: Color, width: float = -1.0, 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

The CanvasItem will inherit the repeat mode from its 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.

Cette notification est envoyée en ordre inverse.

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 si celui-ci et tous ses parents partagent une couche avec le masque de culling du canvas du Viewport.

Note : Un CanvasItem n’hérite pas des couches de visibilité de ses parents. Cela signifie que si un CanvasItem parent ne possède pas toutes les mêmes couches que son enfant, l’enfant peut ne pas être visible même si le parent et l’enfant ont tous deux visible défini sur true. Par exemple, si un parent est sur la couche 1 et un enfant sur la couche 2, l’enfant ne sera pas visible dans un Viewport dont le masque de culling du canvas est réglé sur la couche 1 ou 2 (voir Viewport.canvas_cull_mask). Pour garantir que le parent et l’enfant soient visibles, le parent doit avoir à la fois les couches 1 et 2, ou l’enfant doit avoir top_level défini sur true.

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

Draws an unfilled arc between the given angles with a uniform color and width and optional antialiasing (supported only for positive width). The larger the value of point_count, the smoother the curve. center is defined in local space. For elliptical arcs, see draw_ellipse_arc(). See also draw_circle().

If width is negative, it will be ignored and the arc will be drawn using RenderingServer.PRIMITIVE_LINE_STRIP. This means that when the CanvasItem is scaled, the arc will remain thin. If this behavior is not desired, then pass a positive width like 1.0.

The arc is drawn from start_angle towards the value of end_angle so in clockwise direction if start_angle < end_angle and counter-clockwise otherwise. Passing the same angles but in reversed order will produce the same arc. If absolute difference of start_angle and end_angle is greater than @GDScript.TAU radians, then a full circle arc is drawn (i.e. arc will not overlap itself).

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

Draws a circle, with position defined in local space. See also draw_ellipse(), draw_arc(), draw_polyline(), and draw_polygon().

If filled is true, the circle will be filled with the color specified. If filled is false, the circle will be drawn as a stroke with the color and width specified.

If width is negative, then two-point primitives will be drawn instead of a four-point ones. This means that when the CanvasItem is scaled, the lines will remain thin. If this behavior is not desired, then pass a positive width like 1.0.

If antialiased is true, half transparent "feathers" will be attached to the boundary, making outlines smooth.

Note: width is only effective if filled is 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.

Note: 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().

Note: Les boîtes de styles, les textures et les mailles stockées uniquement dans les variables locales ne devraient pas être utilisées avec cette méthode dans GDScript, parce que l'opération de dessin ne commence pas immédiatement une fois cette méthode appelée. Dans GDScript, lorsque la fonction avec les variables locales se termine, les variables locales sont détruites avant le rendu.

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_ellipse(position: Vector2, major: float, minor: float, color: Color, filled: bool = true, width: float = -1.0, antialiased: bool = false) 🔗

Draws an ellipse with semi-major axis major and semi-minor axis minor. See also draw_circle(), draw_ellipse_arc(), draw_polyline(), and draw_polygon().

If filled is true, the ellipse will be filled with the color specified. If filled is false, the ellipse will be drawn as a stroke with the color and width specified.

If width is negative, then two-point primitives will be drawn instead of four-point ones. This means that when the CanvasItem is scaled, the lines will remain thin. If this behavior is not desired, then pass a positive width like 1.0.

If antialiased is true, half transparent "feathers" will be attached to the boundary, making outlines smooth.

Note: width is only effective if filled is false.

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

Draws an unfilled elliptical arc between the given angles with a uniform color and width and optional antialiasing (supported only for positive width). The larger the value of point_count, the smoother the curve. For circular arcs, see draw_arc(). See also draw_ellipse().

If width is negative, it will be ignored and the arc will be drawn using RenderingServer.PRIMITIVE_LINE_STRIP. This means that when the CanvasItem is scaled, the arc will remain thin. If this behavior is not desired, then pass a positive width like 1.0.

The arc is drawn from start_angle towards the value of end_angle so in clockwise direction if start_angle < end_angle and counter-clockwise otherwise. Passing the same angles but in reversed order will produce the same arc. If absolute difference of start_angle and end_angle is greater than @GDScript.TAU radians, then a full ellipse is drawn (i.e. arc will not overlap itself).

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

Note: Les boîtes de styles, les textures et les maillages stockées uniquement dans les variables locales ne devraient pas être utilisées avec cette méthode dans GDScript, parce que l'opération de dessin ne commence pas immédiatement une fois cette méthode appelée. Dans GDScript, lorsque la fonction avec les variables locales se termine, les variables locales sont détruites avant le rendu.

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 fournie. Voir MeshInstance2D pour une documentation associée. Le transform est défini dans l’espace local.

Note : Les styleboxes, textures et meshes stockés uniquement dans des variables locales ne doivent pas être utilisés avec cette méthode en GDScript, car l’opération de dessin ne commence pas immédiatement lorsque cette méthode est appelée. En GDScript, lorsque la fonction contenant les variables locales se termine, celles-ci sont détruites avant que le rendu n’ait lieu.

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.

Note: Les boîtes de styles, les textures et les mailles stockées uniquement dans les variables locales ne devraient pas être utilisées avec cette méthode dans GDScript, parce que l'opération de dessin ne commence pas immédiatement une fois cette méthode appelée. Dans GDScript, lorsque la fonction avec les variables locales se termine, les variables locales sont détruites avant le rendu.

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 fournie. Voir MultiMeshInstance2D pour une documentation associée.

Note : Les styleboxes, textures et meshes stockés uniquement dans des variables locales ne doivent pas être utilisés avec cette méthode en GDScript, car l’opération de dessin ne commence pas immédiatement lorsque cette méthode est appelée. En GDScript, lorsque la fonction contenant les variables locales se termine, celles-ci sont détruites avant que le rendu n’ait lieu.

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 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().

Note: Les boîtes de styles, les textures et les mailles stockées uniquement dans les variables locales ne devraient pas être utilisées avec cette méthode dans GDScript, parce que l'opération de dessin ne commence pas immédiatement une fois cette méthode appelée. Dans GDScript, lorsque la fonction avec les variables locales se termine, les variables locales sont détruites avant le rendu.

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().

Note: Les boîtes de styles, les textures et les mailles stockées uniquement dans les variables locales ne devraient pas être utilisées avec cette méthode dans GDScript, parce que l'opération de dessin ne commence pas immédiatement une fois cette méthode appelée. Dans GDScript, lorsque la fonction avec les variables locales se termine, les variables locales sont détruites avant le rendu.

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 🔗

Draws text using the specified font at the pos in local space (bottom-left corner using the baseline of the font). The text will have its color multiplied by modulate. If width is greater than or equal to 0, the text will be clipped if it exceeds the specified width. If oversampling is greater than zero, it is used as font oversampling factor, otherwise viewport oversampling settings are used.

Example: Draw "Hello world", using the project's default font:

draw_string(ThemeDB.fallback_font, Vector2(64, 64), "Hello world", HORIZONTAL_ALIGNMENT_LEFT, -1, ThemeDB.fallback_font_size)

DrawString(ThemeDB.FallbackFont, new Vector2(64, 64), "Hello world", HorizontalAlignment.Left, -1, ThemeDB.FallbackFontSize);