CanvasItem

public CanvasItem.ClipChildrenMode ClipChildren { get; set; }

The mode in which this node clips its children, acting as a mask. Note: Clipping nodes cannot be nested or placed within a CanvasGroup. If an ancestor of this node clips its children or is a CanvasGroup, then this node's clip mode should be set to CanvasItem.ClipChildrenMode.Disabled to avoid unexpected behavior.

public int LightMask { get; set; }

The rendering layers in which this CanvasItem responds to Light2D nodes.

public Material Material { get; set; }

The 2D item’s own material: CanvasItemMaterial or a ShaderMaterial with a canvas_item program. UseParentMaterial=true selects the parent material instead. Items sharing one ShaderMaterial share its regular uniforms.

public Color Modulate { get; set; }

Color multiplier for the item and inheriting CanvasItem descendants. Account for modulation in a custom shader: the example passes vertex-stage COLOR through a varying and multiplies the separately sampled texture by it. Otherwise assigning fragment-stage COLOR can discard the intended multiplication.

public CanvasItem.OversamplingWithScaleEnum OversamplingWithScale { get; set; }

If enabled, oversampling for this CanvasItem is automatically adjusted with scale. This makes fonts and DpiTexture images automatically re-render to match the actual scale they are drawn at, for crisper visuals. This has a performance impact on the CPU every time the node's scale changes, so it is disabled by default. Note: For Control nodes with Control.OffsetTransformEnabled set to true, scale-based oversampling is only effective if Control.OffsetTransformVisualOnly is false. This ensures there is no performance overhead when using visual-only offset transforms (as often used in animations).

public Color SelfModulate { get; set; }

The color applied to this CanvasItem. This property does not affect child CanvasItems, unlike CanvasItem.Modulate which affects both the node itself and its children. Note: Internal children are also not affected by this property (see the include_internal parameter in Entity.AddChild). For built-in nodes this includes sliders in ColorPicker, and the tab bar in TabContainer.

public bool ShowBehindParent { get; set; }

If true, this node draws behind its parent.

public CanvasItem.TextureFilterEnum TextureFilter { get; set; }

Texture-filter policy for this item. ParentNode inherits the setting; LinearWithMipmaps uses mipmaps when available. The example prepares an ImageTexture with mipmaps for downscaled images. This property neither enables MSAA nor generates mipmaps.

public CanvasItem.TextureRepeatEnum TextureRepeat { get; set; }

The repeating mode used to render this CanvasItem's texture(s). It affects what happens when the texture is sampled outside its extents, for example by setting a Sprite2D.RegionRect that is larger than the texture or assigning Polygon2D UV points outside the texture. Note: TextureRect is not affected by CanvasItem.TextureRepeat, as it uses its own texture repeating implementation.

public bool TopLevel { get; set; }

Stops inheriting the parent CanvasItem transform. Does not remove the item from the tree, move it to another viewport or disable its canvas transform from a camera or CanvasLayer.

public bool UseParentMaterial { get; set; }

If true, drawing uses the parent material instead of the item’s own Material. The assigned own resource remains accessible through its getter. Verification shows parent tint overriding child grayscale and false restoring the child shader.

public uint VisibilityLayer { get; set; }

The rendering layer in which this CanvasItem is rendered by Viewport nodes. A Viewport will render a CanvasItem if it and all its parents share a layer with the Viewport's canvas cull mask. For an easier way to change this value from a script, see CanvasItem.SetVisibilityLayerBit. Note: A CanvasItem does not inherit its parents' visibility layers. This means that if a parent CanvasItem does not have all the same layers as its child, the child may not be visible even if both the parent and child have CanvasItem.Visible set to true. For example, if a parent has layer 1 and a child has layer 2, the child will not be visible in a Viewport with the canvas cull mask set to layer 1 or 2 (see Viewport.CanvasCullMask). To ensure that both the parent and child are visible, the parent must have both layers 1 and 2, or the child must have CanvasItem.TopLevel set to true.

public bool Visible { get; set; }

If true, this CanvasItem may be drawn. Whether this CanvasItem is actually drawn depends on the visibility of all of its CanvasItem ancestors. In other words: this CanvasItem will be drawn when CanvasItem.IsVisibleInTree returns true and all CanvasItem ancestors share at least one CanvasItem.VisibilityLayer with this CanvasItem. Note: For controls that inherit Popup, the correct way to make them visible is to call one of the multiple popup*() functions instead.

public bool YSortEnabled { get; set; }

If true, this and child CanvasItem nodes with a higher Y position are rendered in front of nodes with a lower Y position. If false, this and child CanvasItem nodes are rendered normally in scene tree order. With Y-sorting enabled on a parent node ('A') but disabled on a child node ('B'), the child node ('B') is sorted but its children ('C1', 'C2', etc.) render together on the same Y position as the child node ('B'). This allows you to organize the render order of a scene without changing the scene tree. Nodes sort relative to each other only if they are on the same CanvasItem.ZIndex. Note: Y-sorting does not affect the order in which CanvasItem nodes are processed, or the way input events are handled. This is especially important to keep in mind for Control nodes.

public bool ZAsRelative { get; set; }

If true, this node's final Z index is relative to its parent's Z index. For example, if CanvasItem.ZIndex is 2 and its parent's final Z index is 3, then this node's final Z index will be 5 (2 + 3).

public int ZIndex { get; set; }

The order in which this node is drawn. A node with a higher Z index will display in front of others. Must be between RenderingServer.CanvasItemZMin and RenderingServer.CanvasItemZMax (inclusive). Note: The Z index does not affect the order in which CanvasItem nodes are processed, or the way input events are handled. This is especially important to keep in mind for Control nodes.

public void DrawAnimationSlice(double animationLength, double sliceBegin, double sliceEnd, double offset = 0d);

Subsequent drawing commands will be ignored unless they fall within the specified animation slice. This is a faster way to implement animations that loop on background rather than redrawing constantly.

public void DrawArc(Vector2 center, float radius, float startAngle, float endAngle, int pointCount, Color color, float width = -1f, bool antialiased = 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 CanvasItem.DrawEllipseArc. See also CanvasItem.DrawCircle. If width is negative, it will be ignored and the arc will be drawn using RenderingServer.PrimitiveType.LineStrip. 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 @C#.TAU radians, then a full circle arc is drawn (i.e. arc will not overlap itself).

public void DrawChar(Font font, Vector2 pos, string @char, int fontSize, Color? modulate);

Draws a string first character using a custom font. If oversampling is greater than zero, it is used as font oversampling factor, otherwise viewport oversampling settings are used. pos is defined in local space.

public void DrawChar(Font font, Vector2 pos, string @char, int fontSize = 16, Color? modulate = default, float oversampling = 0f);

Draws a string first character using a custom font. If oversampling is greater than zero, it is used as font oversampling factor, otherwise viewport oversampling settings are used. pos is defined in local space.

public void DrawCharOutline(Font font, Vector2 pos, string @char, int fontSize, int size, Color? modulate);

Draws a string first character outline using a custom font. If oversampling is greater than zero, it is used as font oversampling factor, otherwise viewport oversampling settings are used. pos is defined in local space.

public void DrawCharOutline(Font font, Vector2 pos, string @char, int fontSize = 16, int size = -1, Color? modulate = default, float oversampling = 0f);

Draws a string first character outline using a custom font. If oversampling is greater than zero, it is used as font oversampling factor, otherwise viewport oversampling settings are used. pos is defined in local space.

public void DrawCircle(Vector2 position, float radius, Color color);

Draws a circle, with position defined in local space. See also CanvasItem.DrawEllipse, CanvasItem.DrawArc, CanvasItem.DrawPolyline, and CanvasItem.DrawPolygon. 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 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.

public void DrawCircle(Vector2 position, float radius, Color color, bool filled = true, float width = -1f, bool antialiased = false);

Draws a circle, with position defined in local space. See also CanvasItem.DrawEllipse, CanvasItem.DrawArc, CanvasItem.DrawPolyline, and CanvasItem.DrawPolygon. 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 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.

public void DrawColoredPolygon(Vector2[] points, Color color, Vector2[] uvs = null, Texture2D texture = null);

Draws a colored polygon of any number of points, convex or concave. The points in the points array are defined in local space. Unlike CanvasItem.DrawPolygon, a single color must be specified for the whole polygon. Note: If you frequently redraw the same polygon with a large number of vertices, consider pre-calculating the triangulation with Geometry2D.TriangulatePolygon and using CanvasItem.DrawMesh, CanvasItem.DrawMultimesh, or RenderingServer.CanvasItemAddTriangleArray. Note: Styleboxes, textures, and meshes stored only inside local variables should not be used with this method in C#, because the drawing operation doesn't begin immediately once this method is called. In C#, when the function with the local variables ends, the local variables get destroyed before the rendering takes place.

public void DrawColoredPolygon(ReadOnlySpan<Vector2> points, Color color, ReadOnlySpan<Vector2> uvs, Texture2D texture);

Draws a colored polygon of any number of points, convex or concave. The points in the points array are defined in local space. Unlike CanvasItem.DrawPolygon, a single color must be specified for the whole polygon. Note: If you frequently redraw the same polygon with a large number of vertices, consider pre-calculating the triangulation with Geometry2D.TriangulatePolygon and using CanvasItem.DrawMesh, CanvasItem.DrawMultimesh, or RenderingServer.CanvasItemAddTriangleArray. Note: Styleboxes, textures, and meshes stored only inside local variables should not be used with this method in C#, because the drawing operation doesn't begin immediately once this method is called. In C#, when the function with the local variables ends, the local variables get destroyed before the rendering takes place.

public void DrawDashedLine(Vector2 from, Vector2 to, Color color, float width, float dash, bool aligned);

Draws a dashed line from a 2D point to another, with a given color and width. The from and to positions are defined in local space. See also CanvasItem.DrawLine, CanvasItem.DrawMultiline, and CanvasItem.DrawPolyline. 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 line parts will remain thin. If this behavior is not desired, then pass a positive width like 1.0. dash is the length of each dash in pixels, with the gap between each dash being the same length. If aligned is true, the length of the first and last dashes may be shortened or lengthened to allow the line to begin and end at the precise points defined by from and to. Both ends are always symmetrical when aligned is true. If aligned is false, all dashes will have the same length, but the line may appear incomplete at the end due to the dash length not dividing evenly into the line length. Only full dashes are drawn when aligned is false. If antialiased is true, half transparent "feathers" will be attached to the boundary, making outlines smooth. Note: antialiased is only effective if width is greater than 0.0.

public void DrawDashedLine(Vector2 from, Vector2 to, Color color, float width = -1f, float dash = 2f, bool aligned = true, bool antialiased = false);

Draws a dashed line from a 2D point to another, with a given color and width. The from and to positions are defined in local space. See also CanvasItem.DrawLine, CanvasItem.DrawMultiline, and CanvasItem.DrawPolyline. 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 line parts will remain thin. If this behavior is not desired, then pass a positive width like 1.0. dash is the length of each dash in pixels, with the gap between each dash being the same length. If aligned is true, the length of the first and last dashes may be shortened or lengthened to allow the line to begin and end at the precise points defined by from and to. Both ends are always symmetrical when aligned is true. If aligned is false, all dashes will have the same length, but the line may appear incomplete at the end due to the dash length not dividing evenly into the line length. Only full dashes are drawn when aligned is false. If antialiased is true, half transparent "feathers" will be attached to the boundary, making outlines smooth. Note: antialiased is only effective if width is greater than 0.0.

public void DrawEllipse(Vector2 position, float major, float minor, Color color, bool filled = true, float width = -1f, bool antialiased = false);

Draws an ellipse with semi-major axis major and semi-minor axis minor. See also CanvasItem.DrawCircle, CanvasItem.DrawEllipseArc, CanvasItem.DrawPolyline, and CanvasItem.DrawPolygon. 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.

public void DrawEllipseArc(Vector2 center, float major, float minor, float startAngle, float endAngle, int pointCount, Color color, float width = -1f, bool antialiased = 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 CanvasItem.DrawArc. See also CanvasItem.DrawEllipse. If width is negative, it will be ignored and the arc will be drawn using RenderingServer.PrimitiveType.LineStrip. 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 @C#.TAU radians, then a full ellipse is drawn (i.e. arc will not overlap itself).

public void DrawEndAnimation();

After submitting all animations slices via CanvasItem.DrawAnimationSlice, this function can be used to revert drawing to its default state (all subsequent drawing commands will be visible). If you don't care about this particular use case, usage of this function after submitting the slices is not required.

public void DrawLcdTextureRectRegion(Texture2D texture, Rect2 rect, Rect2 srcRect, Color? modulate = default);

Draws a textured rectangle region of the font texture with LCD subpixel anti-aliasing at a given position, optionally modulated by a color. The rect is defined in local space. Texture is drawn using the following blend operation, blend mode of the CanvasItemMaterial is ignored:

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: Styleboxes, textures, and meshes stored only inside local variables should not be used with this method in C#, because the drawing operation doesn't begin immediately once this method is called. In C#, when the function with the local variables ends, the local variables get destroyed before the rendering takes place.

public void DrawLine(Vector2 from, Vector2 to, Color color, float width = -1f, bool antialiased = false);

Draws a line from a 2D point to another, with a given color and width. It can be optionally antialiased. The from and to positions are defined in local space. See also CanvasItem.DrawDashedLine, CanvasItem.DrawMultiline, and CanvasItem.DrawPolyline. If width is negative, then a two-point primitive will be drawn instead of a four-point one. This means that when the CanvasItem is scaled, the line will remain thin. If this behavior is not desired, then pass a positive width like 1.0.

public void DrawMesh(Mesh mesh, Texture2D texture, Transform2D? transform = default, Color? modulate = default);

Draws a Mesh in 2D, using the provided texture. See MeshInstance2D for related documentation. The transform is defined in local space. Note: Styleboxes, textures, and meshes stored only inside local variables should not be used with this method in C#, because the drawing operation doesn't begin immediately once this method is called. In C#, when the function with the local variables ends, the local variables get destroyed before the rendering takes place.

public void DrawMsdfTextureRectRegion(Texture2D texture, Rect2 rect, Rect2 srcRect, Color? modulate = default, double outline = 0d, double pixelRange = 4d, double scale = 1d);

Draws a textured rectangle region of the multichannel signed distance field texture at a given position, optionally modulated by a color. The rect is defined in local space. See FontFile.MultichannelSignedDistanceField for more information and caveats about MSDF font rendering. If outline is positive, each alpha channel value of pixel in region is set to maximum value of true distance in the outline radius. Value of the pixel_range should the same that was used during distance field texture generation. Note: Styleboxes, textures, and meshes stored only inside local variables should not be used with this method in C#, because the drawing operation doesn't begin immediately once this method is called. In C#, when the function with the local variables ends, the local variables get destroyed before the rendering takes place.

public void DrawMultiline(Vector2[] points, Color color, float width);

Draws multiple disconnected lines with a uniform width and color. Each line is defined by two consecutive points from points array in local space, i.e. i-th segment consists of points[CanvasItem.DrawLine](/en/docs/api/canvasitem#member-drawline-6049f7c36b) calls. To draw interconnected lines, use [CanvasItem.DrawPolyline](/en/docs/api/canvasitem#member-drawpolyline-a13ae2e4ee) instead. If widthis 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 positivewidthlike1.0. **Note:** antialiasedis only effective ifwidthis greater than0.0`.

public void DrawMultiline(Vector2[] points, Color color, float width = -1f, bool antialiased = false);

Draws multiple disconnected lines with a uniform width and color. Each line is defined by two consecutive points from points array in local space, i.e. i-th segment consists of points[CanvasItem.DrawLine](/en/docs/api/canvasitem#member-drawline-6049f7c36b) calls. To draw interconnected lines, use [CanvasItem.DrawPolyline](/en/docs/api/canvasitem#member-drawpolyline-a13ae2e4ee) instead. If widthis 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 positivewidthlike1.0. **Note:** antialiasedis only effective ifwidthis greater than0.0`.

public void DrawMultiline(ReadOnlySpan<Vector2> points, Color color, float width);

Draws multiple disconnected lines with a uniform width and color. Each line is defined by two consecutive points from points array in local space, i.e. i-th segment consists of points[CanvasItem.DrawLine](/en/docs/api/canvasitem#member-drawline-6049f7c36b) calls. To draw interconnected lines, use [CanvasItem.DrawPolyline](/en/docs/api/canvasitem#member-drawpolyline-a13ae2e4ee) instead. If widthis 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 positivewidthlike1.0. **Note:** antialiasedis only effective ifwidthis greater than0.0`.

public void DrawMultiline(ReadOnlySpan<Vector2> points, Color color, float width, bool antialiased);

Draws multiple disconnected lines with a uniform width and color. Each line is defined by two consecutive points from points array in local space, i.e. i-th segment consists of points[CanvasItem.DrawLine](/en/docs/api/canvasitem#member-drawline-6049f7c36b) calls. To draw interconnected lines, use [CanvasItem.DrawPolyline](/en/docs/api/canvasitem#member-drawpolyline-a13ae2e4ee) instead. If widthis 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 positivewidthlike1.0. **Note:** antialiasedis only effective ifwidthis greater than0.0`.

public void DrawMultilineColors(Vector2[] points, Color[] colors, float width);

Draws multiple disconnected lines with a uniform width and segment-by-segment coloring. Each segment is defined by two consecutive points from points array in local space and a corresponding color from colors array, i.e. i-th segment consists of points[CanvasItem.DrawLine](/en/docs/api/canvasitem#member-drawline-6049f7c36b) calls. To draw interconnected lines, use [CanvasItem.DrawPolylineColors](/en/docs/api/canvasitem#member-drawpolylinecolors-4e239fff36) instead. If widthis 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 positivewidthlike1.0. **Note:** antialiasedis only effective ifwidthis greater than0.0`.

public void DrawMultilineColors(Vector2[] points, Color[] colors, float width = -1f, bool antialiased = false);

Draws multiple disconnected lines with a uniform width and segment-by-segment coloring. Each segment is defined by two consecutive points from points array in local space and a corresponding color from colors array, i.e. i-th segment consists of points[CanvasItem.DrawLine](/en/docs/api/canvasitem#member-drawline-6049f7c36b) calls. To draw interconnected lines, use [CanvasItem.DrawPolylineColors](/en/docs/api/canvasitem#member-drawpolylinecolors-4e239fff36) instead. If widthis 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 positivewidthlike1.0. **Note:** antialiasedis only effective ifwidthis greater than0.0`.

public void DrawMultilineColors(ReadOnlySpan<Vector2> points, ReadOnlySpan<Color> colors, float width);

Draws multiple disconnected lines with a uniform width and segment-by-segment coloring. Each segment is defined by two consecutive points from points array in local space and a corresponding color from colors array, i.e. i-th segment consists of points[CanvasItem.DrawLine](/en/docs/api/canvasitem#member-drawline-6049f7c36b) calls. To draw interconnected lines, use [CanvasItem.DrawPolylineColors](/en/docs/api/canvasitem#member-drawpolylinecolors-4e239fff36) instead. If widthis 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 positivewidthlike1.0. **Note:** antialiasedis only effective ifwidthis greater than0.0`.

public void DrawMultilineColors(ReadOnlySpan<Vector2> points, ReadOnlySpan<Color> colors, float width, bool antialiased);

Draws multiple disconnected lines with a uniform width and segment-by-segment coloring. Each segment is defined by two consecutive points from points array in local space and a corresponding color from colors array, i.e. i-th segment consists of points[CanvasItem.DrawLine](/en/docs/api/canvasitem#member-drawline-6049f7c36b) calls. To draw interconnected lines, use [CanvasItem.DrawPolylineColors](/en/docs/api/canvasitem#member-drawpolylinecolors-4e239fff36) instead. If widthis 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 positivewidthlike1.0. **Note:** antialiasedis only effective ifwidthis greater than0.0`.

public void DrawMultilineString(Font font, Vector2 pos, string text, HorizontalAlignment alignment, float width, int fontSize, int maxLines, Color? modulate, TextServer.LineBreakFlag brkFlags, TextServer.JustificationFlag justificationFlags, TextServer.Direction direction, TextServer.Orientation orientation);

Breaks text into lines and draws it using the specified font at the pos in local space (top-left corner). The text will have its color multiplied by CanvasItem.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.

public void DrawMultilineString(Font font, Vector2 pos, string text, HorizontalAlignment alignment = HorizontalAlignment.Left, float width = -1f, int fontSize = 16, int maxLines = -1, Color? modulate = default, TextServer.LineBreakFlag brkFlags = TextServer.LineBreakFlag.Mandatory | TextServer.LineBreakFlag.WordBound, TextServer.JustificationFlag justificationFlags = TextServer.JustificationFlag.Kashida | TextServer.JustificationFlag.WordBound, TextServer.Direction direction = TextServer.Direction.Auto, TextServer.Orientation orientation = TextServer.Orientation.Horizontal, float oversampling = 0f);

Breaks text into lines and draws it using the specified font at the pos in local space (top-left corner). The text will have its color multiplied by CanvasItem.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.

public void DrawMultilineStringOutline(Font font, Vector2 pos, string text, HorizontalAlignment alignment, float width, int fontSize, int maxLines, int size, Color? modulate, TextServer.LineBreakFlag brkFlags, TextServer.JustificationFlag justificationFlags, TextServer.Direction direction, TextServer.Orientation orientation);

Breaks text to the lines and draws text outline using the specified font at the pos in local space (top-left corner). The text will have its color multiplied by CanvasItem.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.

public void DrawMultilineStringOutline(Font font, Vector2 pos, string text, HorizontalAlignment alignment = HorizontalAlignment.Left, float width = -1f, int fontSize = 16, int maxLines = -1, int size = 1, Color? modulate = default, TextServer.LineBreakFlag brkFlags = TextServer.LineBreakFlag.Mandatory | TextServer.LineBreakFlag.WordBound, TextServer.JustificationFlag justificationFlags = TextServer.JustificationFlag.Kashida | TextServer.JustificationFlag.WordBound, TextServer.Direction direction = TextServer.Direction.Auto, TextServer.Orientation orientation = TextServer.Orientation.Horizontal, float oversampling = 0f);

Breaks text to the lines and draws text outline using the specified font at the pos in local space (top-left corner). The text will have its color multiplied by CanvasItem.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.

public void DrawMultimesh(MultiMesh multimesh, Texture2D texture);

Draws a MultiMesh in 2D with the provided texture. See MultiMeshInstance2D for related documentation. Note: Styleboxes, textures, and meshes stored only inside local variables should not be used with this method in C#, because the drawing operation doesn't begin immediately once this method is called. In C#, when the function with the local variables ends, the local variables get destroyed before the rendering takes place.

public void DrawPolygon(Vector2[] points, Color[] colors, Vector2[] uvs = null, Texture2D texture = null);

Draws a solid polygon of any number of points, convex or concave. Unlike CanvasItem.DrawColoredPolygon, each point's color can be changed individually. The points array is defined in local space. See also CanvasItem.DrawPolyline and CanvasItem.DrawPolylineColors. If you need more flexibility (such as being able to use bones), use RenderingServer.CanvasItemAddTriangleArray instead. Note: If you frequently redraw the same polygon with a large number of vertices, consider pre-calculating the triangulation with Geometry2D.TriangulatePolygon and using CanvasItem.DrawMesh, CanvasItem.DrawMultimesh, or RenderingServer.CanvasItemAddTriangleArray. Note: Styleboxes, textures, and meshes stored only inside local variables should not be used with this method in C#, because the drawing operation doesn't begin immediately once this method is called. In C#, when the function with the local variables ends, the local variables get destroyed before the rendering takes place.

public void DrawPolygon(ReadOnlySpan<Vector2> points, ReadOnlySpan<Color> colors, ReadOnlySpan<Vector2> uvs, Texture2D texture);

Draws a solid polygon of any number of points, convex or concave. Unlike CanvasItem.DrawColoredPolygon, each point's color can be changed individually. The points array is defined in local space. See also CanvasItem.DrawPolyline and CanvasItem.DrawPolylineColors. If you need more flexibility (such as being able to use bones), use RenderingServer.CanvasItemAddTriangleArray instead. Note: If you frequently redraw the same polygon with a large number of vertices, consider pre-calculating the triangulation with Geometry2D.TriangulatePolygon and using CanvasItem.DrawMesh, CanvasItem.DrawMultimesh, or RenderingServer.CanvasItemAddTriangleArray. Note: Styleboxes, textures, and meshes stored only inside local variables should not be used with this method in C#, because the drawing operation doesn't begin immediately once this method is called. In C#, when the function with the local variables ends, the local variables get destroyed before the rendering takes place.

public void DrawPolyline(Vector2[] points, Color color, float width = -1f, bool antialiased = false);

Draws interconnected line segments with a uniform color and width and optional antialiasing (supported only for positive width). The points array is defined in local space. When drawing large amounts of lines, this is faster than using individual CanvasItem.DrawLine calls. To draw disconnected lines, use CanvasItem.DrawMultiline instead. See also CanvasItem.DrawPolygon. If width is negative, it will be ignored and the polyline will be drawn using RenderingServer.PrimitiveType.LineStrip. This means that when the CanvasItem is scaled, the polyline will remain thin. If this behavior is not desired, then pass a positive width like 1.0.

public void DrawPolyline(ReadOnlySpan<Vector2> points, Color color, float width, bool antialiased);

Draws interconnected line segments with a uniform color and width and optional antialiasing (supported only for positive width). The points array is defined in local space. When drawing large amounts of lines, this is faster than using individual CanvasItem.DrawLine calls. To draw disconnected lines, use CanvasItem.DrawMultiline instead. See also CanvasItem.DrawPolygon. If width is negative, it will be ignored and the polyline will be drawn using RenderingServer.PrimitiveType.LineStrip. This means that when the CanvasItem is scaled, the polyline will remain thin. If this behavior is not desired, then pass a positive width like 1.0.

public void DrawPolylineColors(Vector2[] points, Color[] colors, float width = -1f, bool antialiased = false);

Draws interconnected line segments with a uniform width, point-by-point coloring, and optional antialiasing (supported only for positive width). Colors assigned to line points match by index between points and colors, i.e. each line segment is filled with a gradient between the colors of the endpoints. The points array is defined in local space. When drawing large amounts of lines, this is faster than using individual CanvasItem.DrawLine calls. To draw disconnected lines, use CanvasItem.DrawMultilineColors instead. See also CanvasItem.DrawPolygon. If width is negative, it will be ignored and the polyline will be drawn using RenderingServer.PrimitiveType.LineStrip. This means that when the CanvasItem is scaled, the polyline will remain thin. If this behavior is not desired, then pass a positive width like 1.0.

public void DrawPolylineColors(ReadOnlySpan<Vector2> points, ReadOnlySpan<Color> colors, float width, bool antialiased);

Draws interconnected line segments with a uniform width, point-by-point coloring, and optional antialiasing (supported only for positive width). Colors assigned to line points match by index between points and colors, i.e. each line segment is filled with a gradient between the colors of the endpoints. The points array is defined in local space. When drawing large amounts of lines, this is faster than using individual CanvasItem.DrawLine calls. To draw disconnected lines, use CanvasItem.DrawMultilineColors instead. See also CanvasItem.DrawPolygon. If width is negative, it will be ignored and the polyline will be drawn using RenderingServer.PrimitiveType.LineStrip. This means that when the CanvasItem is scaled, the polyline will remain thin. If this behavior is not desired, then pass a positive width like 1.0.

public void DrawPrimitive(Vector2[] points, Color[] colors, Vector2[] uvs, Texture2D texture = null);

Draws a custom primitive. 1 point for a point, 2 points for a line, 3 points for a triangle, and 4 points for a quad. If 0 points or more than 4 points are specified, nothing will be drawn and an error message will be printed. The points array is defined in local space. See also CanvasItem.DrawLine, CanvasItem.DrawPolyline, CanvasItem.DrawPolygon, and CanvasItem.DrawRect. Note: Styleboxes, textures, and meshes stored only inside local variables should not be used with this method in C#, because the drawing operation doesn't begin immediately once this method is called. In C#, when the function with the local variables ends, the local variables get destroyed before the rendering takes place.

public void DrawPrimitive(ReadOnlySpan<Vector2> points, ReadOnlySpan<Color> colors, ReadOnlySpan<Vector2> uvs, Texture2D texture);

Draws a custom primitive. 1 point for a point, 2 points for a line, 3 points for a triangle, and 4 points for a quad. If 0 points or more than 4 points are specified, nothing will be drawn and an error message will be printed. The points array is defined in local space. See also CanvasItem.DrawLine, CanvasItem.DrawPolyline, CanvasItem.DrawPolygon, and CanvasItem.DrawRect. Note: Styleboxes, textures, and meshes stored only inside local variables should not be used with this method in C#, because the drawing operation doesn't begin immediately once this method is called. In C#, when the function with the local variables ends, the local variables get destroyed before the rendering takes place.

public void DrawRect(Rect2 rect, Color color, bool filled, float width);

Draws a rectangle. If filled is true, the rectangle will be filled with the color specified. If filled is false, the rectangle will be drawn as a stroke with the color and width specified. The rect is specified in local space. See also CanvasItem.DrawTextureRect. 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. Note: Unfilled rectangles drawn with a negative width may not display perfectly. For example, corners may be missing or brighter due to overlapping lines (for a translucent color).

public void DrawRect(Rect2 rect, Color color, bool filled = true, float width = -1f, bool antialiased = false);

Draws a rectangle. If filled is true, the rectangle will be filled with the color specified. If filled is false, the rectangle will be drawn as a stroke with the color and width specified. The rect is specified in local space. See also CanvasItem.DrawTextureRect. 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. Note: Unfilled rectangles drawn with a negative width may not display perfectly. For example, corners may be missing or brighter due to overlapping lines (for a translucent color).

public void DrawSetTransform(Vector2 position, float rotation = 0f, Vector2? scale = default);

Sets a custom local transform for drawing via components. Anything drawn afterwards will be transformed by this. Note: FontFile.Oversampling does not take scale into account. This means that scaling up/down will cause bitmap fonts and rasterized (non-MSDF) dynamic fonts to appear blurry or pixelated. To ensure text remains crisp regardless of scale, you can enable MSDF font rendering by enabling ProjectSettings.gui/theme/default_font_multichannel_signed_distance_field (applies to the default project font only), or enabling Multichannel Signed Distance Field in the import options of a DynamicFont for custom fonts. On system fonts, SystemFont.MultichannelSignedDistanceField can be enabled in the inspector.

public void DrawSetTransformMatrix(Transform2D xform);

Sets a custom local transform for drawing via matrix. Anything drawn afterwards will be transformed by this.

public void DrawString(Font font, Vector2 pos, string text, HorizontalAlignment alignment, float width, int fontSize, Color? modulate, TextServer.JustificationFlag justificationFlags, TextServer.Direction direction, TextServer.Orientation orientation);

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 CanvasItem.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:

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

See also Font.DrawString.

public void DrawString(Font font, Vector2 pos, string text, HorizontalAlignment alignment = HorizontalAlignment.Left, float width = -1f, int fontSize = 16, Color? modulate = default, TextServer.JustificationFlag justificationFlags = TextServer.JustificationFlag.Kashida | TextServer.JustificationFlag.WordBound, TextServer.Direction direction = TextServer.Direction.Auto, TextServer.Orientation orientation = TextServer.Orientation.Horizontal, float oversampling = 0f);

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 CanvasItem.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:

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

See also Font.DrawString.

public void DrawStringOutline(Font font, Vector2 pos, string text, HorizontalAlignment alignment, float width, int fontSize, int size, Color? modulate, TextServer.JustificationFlag justificationFlags, TextServer.Direction direction, TextServer.Orientation orientation);

Draws text outline 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 CanvasItem.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.

public void DrawStringOutline(Font font, Vector2 pos, string text, HorizontalAlignment alignment = HorizontalAlignment.Left, float width = -1f, int fontSize = 16, int size = 1, Color? modulate = default, TextServer.JustificationFlag justificationFlags = TextServer.JustificationFlag.Kashida | TextServer.JustificationFlag.WordBound, TextServer.Direction direction = TextServer.Direction.Auto, TextServer.Orientation orientation = TextServer.Orientation.Horizontal, float oversampling = 0f);

Draws text outline 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 CanvasItem.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.

public void DrawStyleBox(StyleBox styleBox, Rect2 rect);

Draws a styled rectangle. The rect is defined in local space. Note: Styleboxes, textures, and meshes stored only inside local variables should not be used with this method in C#, because the drawing operation doesn't begin immediately once this method is called. In C#, when the function with the local variables ends, the local variables get destroyed before the rendering takes place.

public void DrawTexture(Texture2D texture, Vector2 position, Color? modulate = default);

Draws a texture at a given position. The position is defined in local space. Note: Styleboxes, textures, and meshes stored only inside local variables should not be used with this method in C#, because the drawing operation doesn't begin immediately once this method is called. In C#, when the function with the local variables ends, the local variables get destroyed before the rendering takes place.

public void DrawTextureRect(Texture2D texture, Rect2 rect, bool tile, Color? modulate = default, bool transpose = false);

Draws a textured rectangle at a given position, optionally modulated by a color. The rect is defined in local space. If transpose is true, the texture will have its X and Y coordinates swapped. See also CanvasItem.DrawRect and CanvasItem.DrawTextureRectRegion. Note: Styleboxes, textures, and meshes stored only inside local variables should not be used with this method in C#, because the drawing operation doesn't begin immediately once this method is called. In C#, when the function with the local variables ends, the local variables get destroyed before the rendering takes place.

public void DrawTextureRectRegion(Texture2D texture, Rect2 rect, Rect2 srcRect, Color? modulate = default, bool transpose = false, bool clipUV = true);

Draws a textured rectangle from a texture's region (specified by src_rect) at a given position in local space, optionally modulated by a color. If transpose is true, the texture will have its X and Y coordinates swapped. See also CanvasItem.DrawTextureRect. Note: Styleboxes, textures, and meshes stored only inside local variables should not be used with this method in C#, because the drawing operation doesn't begin immediately once this method is called. In C#, when the function with the local variables ends, the local variables get destroyed before the rendering takes place.

public void ForceUpdateTransform();

Forces the node's transform to update. Fails if the node is not inside the tree. See also CanvasItem.GetTransform. Note: For performance reasons, transform changes are usually accumulated and applied once at the end of the frame. The update propagates through CanvasItem children, as well. Therefore, use this method only when you need an up-to-date transform (such as during physics operations).

public Rid GetCanvas();

Returns the Rid of the World2D canvas where this node is registered to, used by the RenderingServer.

public Rid GetCanvasItem();

Returns the internal canvas item Rid used by the RenderingServer for this node.

public CanvasLayer GetCanvasLayerEntity();

Returns the CanvasLayer that contains this node, or null if the node is not in any CanvasLayer.

public Transform2D GetCanvasTransform();

Returns the effective canvas transform: the CanvasLayer final transform or the viewport CanvasTransform. Requires the item in the tree; excludes the item's own local transform and final window stretch.

public Vector2 GetGlobalMousePosition();

Returns mouse cursor's global position relative to the CanvasLayer that contains this node. Note: For screen-space coordinates (e.g. when using a non-embedded Popup), you can use DisplayServer.MouseGetPosition.

public Transform2D GetGlobalTransform();

Returns the global transform matrix of this item, i.e. the combined transform up to the topmost CanvasItem node. The topmost item is a CanvasItem that either has no parent, has non-CanvasItem parent or it has CanvasItem.TopLevel enabled.

public Transform2D GetGlobalTransformWithCanvas();

Composes a CanvasItem-local to canvas/viewport transform using its hierarchy and CanvasLayer or viewport canvas. Its inverse converts a point from the same viewport into local coordinates when invertible.

public Variant GetInstanceShaderParameter(StringName name);

Reads the CanvasItem instance registry current value. After material preparation and Nil reset the declared default is available; an absent entry returns Nil. This is distinct from a shared ShaderMaterial parameter.

public Vector2 GetLocalMousePosition();

Returns the mouse's position in this CanvasItem using the local coordinate system of this CanvasItem.

public Material GetMaterial();

Returns the assigned own resource rather than resolving the effective material under UseParentMaterial.

public Transform2D GetScreenTransform();

Returns the transform of this CanvasItem in global screen coordinates (i.e. taking window position into account). Mostly useful for editor plugins. Equivalent to CanvasItem.GetGlobalTransformWithCanvas if the window is embedded (see Viewport.GuiEmbedSubwindows).

public CanvasItem.TextureFilterEnum GetTextureFilter();

Reads the item’s stored policy. It can return ParentNode rather than the resolved filter after following inheritance.

public Transform2D GetTransform();

Returns the transform matrix of this CanvasItem.

public bool GetUseParentMaterial();

Reads the parent-material selection flag rather than the material itself.

public Rect2 GetViewportRect();

Returns this node's viewport boundaries as a Rect2. See also Entity.GetViewport.

public Transform2D GetViewportTransform();

Returns the transform of this node, converted from its registered canvas's coordinate system to its viewport embedder's coordinate system. See also Viewport.GetFinalTransform and Entity.GetViewport.

public bool GetVisibilityLayerBit(uint layer);

Returns true if the layer at the given index is set in CanvasItem.VisibilityLayer.

public World2D GetWorld2D();

Returns the World2D this node is registered to. Usually, this is the same as this node's viewport (see Entity.GetViewport and Viewport.FindWorld2D).

public void Hide();

Hide the CanvasItem if it's currently visible. This is equivalent to setting CanvasItem.Visible to false.

public bool IsLocalTransformNotificationEnabled();

Returns true if the node receives CanvasItem.NotificationLocalTransformChanged whenever its local transform changes. This is enabled with CanvasItem.SetNotifyLocalTransform.

public bool IsTransformNotificationEnabled();

Returns true if the node receives CanvasItem.NotificationTransformChanged whenever its global transform changes. This is enabled with CanvasItem.SetNotifyTransform.

public bool IsVisibleInTree();

Returns true if the node is present in the EntityTree, its CanvasItem.Visible property is true and all its ancestors are also visible. If any ancestor is hidden, this node will not be visible in the scene tree, and is therefore not drawn (see CanvasItem.Draw). Visibility is checked only in parent nodes that inherit from CanvasItem, CanvasLayer, and Window. If the parent is of any other type (such as Entity, AnimationPlayer, or Entity3D), it is assumed to be visible. Note: This method does not take CanvasItem.VisibilityLayer into account, so even if this method returns true, the node might end up not being rendered.

public Vector2 MakeCanvasPositionLocal(Vector2 viewportPoint);

Converts a logical viewport point to item-local coordinates by affine-inverting canvas transform times GlobalTransform. Requires the item in the tree and an invertible basis; the input must not be an OS screen position.

public InputEvent MakeInputLocal(InputEvent @event);

Returns an event transformed by the inverse canvas and item transform; leaves the original event unchanged. Use for input in the same viewport's logical coordinates, not already-local GUI callback coordinates. Requires the item in the tree and an invertible basis.

public void MoveToFront();

Moves this node below its siblings, usually causing the node to draw on top of its siblings. Does nothing if this node does not have a parent. See also Entity.MoveChild.

public void QueueRedraw();

Queues the CanvasItem to redraw. During idle time, if CanvasItem is visible, CanvasItem.NotificationDraw is sent and CanvasItem.Draw is called. This only occurs once per frame, even if this method has been called multiple times.

public void SetInstanceShaderParameter(StringName name, Variant value);

Sets an instance uniform for one CanvasItem without copying its shared material. Nil resolves and assigns the declared default. Name and type must match the shader instance uniform.

public void SetMaterial(Material material);

Assigns the item’s own material. With UseParentMaterial=true it does not determine current appearance: check inheritance first. null clears the own assignment.

public void SetNotifyLocalTransform(bool enable);

If true, the node will receive CanvasItem.NotificationLocalTransformChanged whenever its local transform changes. Note: Many canvas items such as Bone2D or CollisionShape2D automatically enable this in order to function correctly.

public void SetNotifyTransform(bool enable);

If true, the node will receive CanvasItem.NotificationTransformChanged whenever its global transform changes. Note: Many canvas items such as Camera2D or Light2D automatically enable this in order to function correctly.

public void SetTextureFilter(CanvasItem.TextureFilterEnum mode);

Sets the 2D texture-filter policy and updates inheritance. Pixel art commonly needs Nearest; downscaled photography benefits from linear filtering with prepared mipmaps. Choose for the asset rather than treating maximum filtering as universal.

public void SetUseParentMaterial(bool enable);

Switches parent-material selection for drawing. Does not remove the own Material or copy uniform values between resources.

public void SetVisibilityLayerBit(uint layer, bool enabled);

Set/clear individual bits on the rendering visibility layer (layer is between 0 and 31). This simplifies editing this CanvasItem's visibility layer compared to assigning the CanvasItem.VisibilityLayer property directly.