GeomDrawGeom.Draw

enum Geom.ThicknessSpace

Geom.SPACE_WORLDGeom.ThicknessSpace.World = 0

World units, the same as a node's position.

Geom.SPACE_VIEWPORT_PIXELSGeom.ThicknessSpace.ViewportPixels = 1

The viewport's pixels. Constant size on screen at any zoom.

Geom.SPACE_VIEWPORT_PERCENTGeom.ThicknessSpace.ViewportPercent = 2

Percent of the viewport's shorter side. Like CSS vmin.

enum Geom.LineEndCap

Geom.CAP_NONEGeom.LineEndCap.None = 0

Cut off exactly at an endpoint.

Geom.CAP_SQUAREGeom.LineEndCap.Square = 1

Extend by half the thickness at an endpoint.

Geom.CAP_ROUNDGeom.LineEndCap.Round = 2

Extend by half the thickness, rounded.

enum Geom.LineGeometry

Geom.LINE_BILLBOARDGeom.LineGeometry.Billboard = 1

A flat quad that turns to face the camera.

Geom.LINE_VOLUMETRICGeom.LineGeometry.Volumetric3D = 2

Real tube geometry, with volume.

enum Geom.PolylineJoin

Geom.JOIN_SIMPLEGeom.PolylineJoin.Simple = 0

The two segments meet at plain width, so the outside of the corner pinches in.

Geom.JOIN_MITERGeom.PolylineJoin.Miter = 1

The outside edges extend until they meet, clamped on sharp turns.

Geom.JOIN_ROUNDGeom.PolylineJoin.Round = 2

A disc over each corner.

Geom.JOIN_BEVELGeom.PolylineJoin.Bevel = 3

The outside of the corner cut off square.

enum Geom.BlendMode

Geom.BLEND_OPAQUEGeom.BlendMode.Opaque = 0

Sorts by position. Hard edges: no anti-aliasing, and alpha is ignored.

Geom.BLEND_TRANSPARENTGeom.BlendMode.Transparent = 1

Standard alpha blending. The default.

Geom.BLEND_ADDITIVEGeom.BlendMode.Additive = 2

Adds this color to what is behind.

Geom.BLEND_MULTIPLYGeom.BlendMode.Multiply = 3

Multiplies what is behind by this color.

Geom.BLEND_SUBTRACTGeom.BlendMode.Subtract = 4

Subtracts this color from the background.

Geom.BLEND_TRANSPARENT_DEPTHGeom.BlendMode.TransparentDepth = 5

Transparent, but writes depth, so shapes with alpha 1 sort by position with anti-aliased edges. A translucent color behaves like Transparent.

enum Geom.DashSpace

Geom.DASH_WORLDGeom.DashSpace.World = 0

Dash size and spacing are lengths in world units.

Geom.DASH_RELATIVEGeom.DashSpace.Relative = 1

Dash size and spacing are multiples of the thickness.

Geom.DASH_FIXED_COUNTGeom.DashSpace.FixedCount = 2

Dash size is a number of dashes. Spacing is the gap relative to the dash.

enum Geom.DashSnap

Geom.SNAP_OFFGeom.DashSnap.Off = 0

The pattern is cut wherever the shape ends.

Geom.SNAP_TILINGGeom.DashSnap.Tiling = 1

A whole number of dashes around the shape, so the pattern has no seam.

Geom.SNAP_END_TO_ENDGeom.DashSnap.EndToEnd = 2

A whole dash at each end of a line or arc.

enum Geom.DashType

Geom.DASH_BASICGeom.DashType.Basic = 0

Square dash ends.

Geom.DASH_ANGLEDGeom.DashType.Angled = 1

Dash ends sheared into a parallelogram by dash_modifier on GeomDraw or modifier on GeomDash. At 0 it looks like DASH_BASIC.

Geom.DASH_ROUNDEDGeom.DashType.Rounded = 2

Rounded dash ends.

BlendModeBlendMode blend_modeBlendMode

How shapes blend with what is behind them.

ColorColor colorColor

Color for shapes drawn without an explicit one.

ThicknessSpaceThicknessSpace radius_spaceRadiusSpace

How radii are measured.

ThicknessSpaceThicknessSpace size_spaceSizeSpace

How rectangle and texture sizes are measured.

floatfloat thicknessThickness

Line and outline thickness, in thickness_space.

ThicknessSpaceThicknessSpace thickness_spaceThicknessSpace

How thickness is measured.

boolbool arc_end_cap_roundArcEndCapRound

Round off an arc's ends.

boolbool borderBorder

Draw rectangles, regular polygons, triangles and quads as outlines of thickness instead of fills.

Discs and polygons ignore it. Their outlines are ring, arc and a closed polyline.

LineEndCapLineEndCap line_end_capLineEndCap

How a line's ends are finished.

LineGeometryLineGeometry line_geometryLineGeometry

Whether 3D lines are flat billboards or solid tubes.

intint line_sidesLineSides

Segments around a volumetric line, 3 to 64.

PolylineJoinPolylineJoin polyline_joinPolylineJoin

How a polyline's corners are drawn.

Vector4Vector4 corner_radiiCornerRadii

Rectangle corner radii as fractions of half the shorter side. On the canvas x is top-left and the rest follow clockwise; in 3D x is bottom-left and the rest follow counterclockwise. set_corner_roundness sets all four at once.

floatfloat polygon_anglePolygonAngle

Rotation of regular polygons, in radians. At 0 an edge's midpoint points along +X, not a vertex.

boolbool polygon_convex_onlyPolygonConvexOnly

Skip the work a concave polygon needs. Cheaper, but a concave polygon then draws wrong.

boolbool rect_pivot_cornerRectPivotCorner

Position rectangles by the top-left corner on the canvas, or bottom-left in 3D, instead of the center.

floatfloat roundnessRoundness

Regular polygon corner rounding, 0 sharp to 1 circular.

boolbool billboardBillboard

Always face the camera.

boolbool cone_capConeCap

Close a cone's base with a disc. Off leaves it open underneath.

intint primitive_detailPrimitiveDetail

Segments around a sphere, cone or torus. More is rounder and costs more vertices.

floatfloat shadingShading

How strongly solids are shaded, 0 flat to 1 full.

FontFont fontFont

Font for text. Empty uses the engine's fallback.

intint font_sizeFontSize

Text size, in points.

floatfloat dash_modifierDashModifier

Shear for angled dashes, -1 to 1. At the default of 0, Angled looks like Basic.

floatfloat dash_offsetDashOffset

Shifts the pattern along the shape, as a fraction of one dash and gap.

floatfloat dash_sizeDashSize

Length of one dash, measured per dash_space.

DashSnapDashSnap dash_snapDashSnap

Whether the pattern is stretched to fit the shape.

DashSpaceDashSpace dash_spaceDashSpace

What dash_size and dash_spacing are measured in.

floatfloat dash_spacingDashSpacing

Gap between dashes, measured like dash_size. Equal size and spacing give equal dash and gap in every space.

DashTypeDashType dash_typeDashType

Dash shape: Basic, Angled or Rounded.

boolbool dashedDashed

Dash lines and the outlines of rings, arcs, rectangles and regular polygons.

Transform3DTransform3D transformTransform

Applied to 3D positions before drawing.

Transform2DTransform2D transform_2dTransform2D

Applied to 2D positions before drawing.

voidvoid begin_frame()BeginFrame()

Called by the engine at the start of every frame. Not for scripts.

voidvoid flush_frame()FlushFrame()

Called by the engine at the end of every frame. Not for scripts.

voidvoid request_editor_redraw()RequestEditorRedraw()

Asks the editor to render the next frame. Call it every frame from a tool script whose drawing animates. Does nothing in a running game.

intint draw_calls_3d()DrawCalls3D()

Draw calls the 3D side will issue this frame: one per run of consecutive shapes sharing a program.

intint queued_3d()Queued3D()

Number of 3D shapes queued this frame.

intint draw_calls_2d()DrawCalls2D()

Draw calls the 2D side will issue this frame, text included.

intint queued_2d()Queued2D()

Number of 2D shapes queued this frame.

voidvoid draw_into(viewport: Viewport)DrawInto(Viewport viewport)

Draws the shapes that follow into viewport instead of the main window, or the edited scene in the editor. Needed for a SubViewport.

Draw state: the resets clear it, so set it after the reset each frame.

voidvoid draw_into_default()DrawIntoDefault()

Draws the shapes that follow into the default viewport again.

voidvoid pop_state()PopState()

Restores the state saved by the matching push_state. With nothing pushed, reports an error and does nothing.

voidvoid push_state()PushState()

Saves the draw state, to be restored by pop_state. Bracket a change so a border or dashed left on does not reach whatever draws next:

GeomDraw.push_state()
GeomDraw.border = true
GeomDraw.rect_2d(here, size)
GeomDraw.pop_state()

Geom.Draw.PushState();
Geom.Draw.Border = true;
Geom.Draw.Rect2D(here, size);
Geom.Draw.PopState();

The transform is saved too. Saved states are a stack.

voidvoid reset_all_draw_states()ResetAllDrawStates()

Resets styling and transforms.

voidvoid reset_style()ResetStyle()

Resets styling but keeps the transforms.

voidvoid reset_transform()ResetTransform()

Resets both transforms to identity.

voidvoid set_corner_roundness(roundness: float)SetCornerRoundness(float roundness)

Sets all four rectangle corner radii, 0 square to 1 fully rounded.

voidvoid set_fill(fill: Resource)SetFill(Resource fill)

Applies a fill resource to the draw state, or clears back to a flat color when given nothing. Equivalent to the matching set_fill_* call.

A fill the next shape cannot draw falls back to color: lines, triangles and quads take only linear and per-corner fills.

voidvoid set_fill_angular(start: Color, end: Color)SetFillAngular(Color start, Color end)

A gradient around a shape's sweep.

voidvoid set_fill_corners(a: Color, b: Color, c: Color, d: Color)SetFillCorners(Color a, Color b, Color c, Color d)

A color at each of a shape's four corners.

On the canvas a is top-left and b, c, d follow clockwise; in 3D a is bottom-left and they follow counterclockwise. On a quad they are its four points in order. On a disc or polygon the axes are sweep and radius, so a and b are the inner edge.

voidvoid set_fill_linear(start: Color, end: Color, angle_degrees: float)SetFillLinear(Color start, Color end, float angleDegrees)

A gradient along an axis, angle_degrees counterclockwise from the shape's local +X. Steps of about 1.4 degrees.

voidvoid set_fill_radial(inner: Color, outer: Color)SetFillRadial(Color inner, Color outer)

A gradient from the center of a shape to its edge.

voidvoid set_fill_solid(color: Color)SetFillSolid(Color color)

One flat color. Also clears any gradient.

voidvoid line_2d(from: Vector2, to: Vector2)Line2D(Vector2 from, Vector2 to)

Line between two points on the canvas.

voidvoid line_2d_colored(from: Vector2, to: Vector2, color: Color)Line2DColored(Vector2 from, Vector2 to, Color color)

Line on the canvas in an explicit color.

voidvoid line_2d_gradient(from: Vector2, to: Vector2, color_a: Color, color_b: Color)Line2DGradient(Vector2 from, Vector2 to, Color colorA, Color colorB)

Line on the canvas with a gradient from color_a to color_b.

voidvoid lines_2d(from: PackedVector2Array, to: PackedVector2Array, colors: PackedColorArray)Lines2D(Vector2[] from, Vector2[] to, Color[] colors)

Batch line segments on the canvas.

voidvoid arc_2d(center: Vector2, radius: float, angle_start: float, angle_end: float)Arc2D(Vector2 center, float radius, float angleStart, float angleEnd)

Arc of a ring on the canvas. Angles in radians, sweeping forward from the start.

voidvoid arc_2d_colored(center: Vector2, radius: float, angle_start: float, angle_end: float, color: Color)Arc2DColored(Vector2 center, float radius, float angleStart, float angleEnd, Color color)

Arc on the canvas in an explicit color.

voidvoid arcs_2d(centers: PackedVector2Array, radii: PackedFloat32Array, angle_starts: PackedFloat32Array, angle_ends: PackedFloat32Array, colors: PackedColorArray)Arcs2D(Vector2[] centers, float[] radii, float[] angleStarts, float[] angleEnds, Color[] colors)

Batch arcs on the canvas.

voidvoid disc_2d(center: Vector2, radius: float)Disc2D(Vector2 center, float radius)

Filled circle on the canvas.

voidvoid disc_2d_colored(center: Vector2, radius: float, color: Color)Disc2DColored(Vector2 center, float radius, Color color)

Filled circle on the canvas in an explicit color.

voidvoid discs_2d(centers: PackedVector2Array, radii: PackedFloat32Array, colors: PackedColorArray)Discs2D(Vector2[] centers, float[] radii, Color[] colors)

Batch filled circles on the canvas.

voidvoid pie_2d(center: Vector2, radius: float, angle_start: float, angle_end: float)Pie2D(Vector2 center, float radius, float angleStart, float angleEnd)

Filled sector on the canvas. Angles in radians, sweeping forward from the start.

voidvoid pie_2d_colored(center: Vector2, radius: float, angle_start: float, angle_end: float, color: Color)Pie2DColored(Vector2 center, float radius, float angleStart, float angleEnd, Color color)

Filled sector on the canvas in an explicit color.

voidvoid pies_2d(centers: PackedVector2Array, radii: PackedFloat32Array, angle_starts: PackedFloat32Array, angle_ends: PackedFloat32Array, colors: PackedColorArray)Pies2D(Vector2[] centers, float[] radii, float[] angleStarts, float[] angleEnds, Color[] colors)

Batch filled sectors on the canvas. Angles in radians.

voidvoid ring_2d(center: Vector2, radius: float)Ring2D(Vector2 center, float radius)

Circle outline on the canvas.

voidvoid ring_2d_colored(center: Vector2, radius: float, color: Color)Ring2DColored(Vector2 center, float radius, Color color)

Circle outline on the canvas in an explicit color.

voidvoid rings_2d(centers: PackedVector2Array, radii: PackedFloat32Array, colors: PackedColorArray)Rings2D(Vector2[] centers, float[] radii, Color[] colors)

Batch circle outlines on the canvas.

voidvoid rect_2d(center: Vector2, size: Vector2)Rect2D(Vector2 center, Vector2 size)

Rectangle on the canvas. Honors corner_radii, rect_pivot_corner and border.

voidvoid rect_2d_colored(center: Vector2, size: Vector2, color: Color)Rect2DColored(Vector2 center, Vector2 size, Color color)

Rectangle on the canvas in an explicit color.

voidvoid rects_2d(centers: PackedVector2Array, sizes: PackedVector2Array, colors: PackedColorArray)Rects2D(Vector2[] centers, Vector2[] sizes, Color[] colors)

Batch rectangles on the canvas.

voidvoid regular_polygon_2d(center: Vector2, radius: float, sides: int)RegularPolygon2D(Vector2 center, float radius, int sides)

Regular polygon on the canvas. radius is center to vertex. Honors border.

voidvoid regular_polygon_2d_colored(center: Vector2, radius: float, sides: int, color: Color)RegularPolygon2DColored(Vector2 center, float radius, int sides, Color color)

Regular polygon on the canvas in an explicit color.

voidvoid regular_polygons_2d(centers: PackedVector2Array, radii: PackedFloat32Array, sides: PackedInt32Array, colors: PackedColorArray)RegularPolygons2D(Vector2[] centers, float[] radii, int[] sides, Color[] colors)

Batch regular polygons on the canvas.

voidvoid quad_2d(a: Vector2, b: Vector2, c: Vector2, d: Vector2)Quad2D(Vector2 a, Vector2 b, Vector2 c, Vector2 d)

Quad on the canvas, through four points in order.

voidvoid quad_2d_colored(a: Vector2, b: Vector2, c: Vector2, d: Vector2, color: Color)Quad2DColored(Vector2 a, Vector2 b, Vector2 c, Vector2 d, Color color)

Quad on the canvas in an explicit color.

voidvoid quads_2d(points: PackedVector2Array, colors: PackedColorArray)Quads2D(Vector2[] points, Color[] colors)

Many quads on the canvas, four points each, in order.

voidvoid triangle_2d(a: Vector2, b: Vector2, c: Vector2)Triangle2D(Vector2 a, Vector2 b, Vector2 c)

Triangle on the canvas.

voidvoid triangle_2d_colored(a: Vector2, b: Vector2, c: Vector2, color: Color)Triangle2DColored(Vector2 a, Vector2 b, Vector2 c, Color color)

Triangle on the canvas in an explicit color.

voidvoid triangles_2d(points: PackedVector2Array, colors: PackedColorArray)Triangles2D(Vector2[] points, Color[] colors)

Many triangles on the canvas, three points each.

voidvoid line(from: Vector3, to: Vector3)Line(Vector3 from, Vector3 to)

Line between two points.

voidvoid line_colored(from: Vector3, to: Vector3, color: Color)LineColored(Vector3 from, Vector3 to, Color color)

Line between two points in an explicit color.

voidvoid line_gradient(from: Vector3, to: Vector3, color_a: Color, color_b: Color)LineGradient(Vector3 from, Vector3 to, Color colorA, Color colorB)

Line with a gradient from color_a at the start to color_b at the end.

voidvoid lines(from: PackedVector3Array, to: PackedVector3Array, colors: PackedColorArray)Lines(Vector3[] from, Vector3[] to, Color[] colors)

Batch line segments in 3D.

voidvoid arc(center: Vector3, radius: float, angle_start: float, angle_end: float)Arc(Vector3 center, float radius, float angleStart, float angleEnd)

Arc of a ring. Angles in radians, sweeping forward from the start. arc_end_cap_round rounds the ends.

voidvoid arc_colored(center: Vector3, radius: float, angle_start: float, angle_end: float, color: Color)ArcColored(Vector3 center, float radius, float angleStart, float angleEnd, Color color)

Arc in an explicit color.

voidvoid arcs(centers: PackedVector3Array, radii: PackedFloat32Array, angle_starts: PackedFloat32Array, angle_ends: PackedFloat32Array, colors: PackedColorArray)Arcs(Vector3[] centers, float[] radii, float[] angleStarts, float[] angleEnds, Color[] colors)

Batch arcs in 3D.

voidvoid disc(center: Vector3, radius: float)Disc(Vector3 center, float radius)

Filled circle.

voidvoid disc_colored(center: Vector3, radius: float, color: Color)DiscColored(Vector3 center, float radius, Color color)

Filled circle in an explicit color.

voidvoid discs(centers: PackedVector3Array, radii: PackedFloat32Array, colors: PackedColorArray)Discs(Vector3[] centers, float[] radii, Color[] colors)

Batch filled circles in 3D.

voidvoid pie(center: Vector3, radius: float, angle_start: float, angle_end: float)Pie(Vector3 center, float radius, float angleStart, float angleEnd)

Filled sector. Angles in radians. The sweep runs forward from the start and wraps, so 350 to 10 degrees is a 20 degree sweep.

voidvoid pie_colored(center: Vector3, radius: float, angle_start: float, angle_end: float, color: Color)PieColored(Vector3 center, float radius, float angleStart, float angleEnd, Color color)

Filled sector in an explicit color.

voidvoid pies(centers: PackedVector3Array, radii: PackedFloat32Array, angle_starts: PackedFloat32Array, angle_ends: PackedFloat32Array, colors: PackedColorArray)Pies(Vector3[] centers, float[] radii, float[] angleStarts, float[] angleEnds, Color[] colors)

Batch filled sectors in 3D. Angles in radians.

voidvoid ring(center: Vector3, radius: float)Ring(Vector3 center, float radius)

Circle outline. radius is to the middle of the wall.

voidvoid ring_colored(center: Vector3, radius: float, color: Color)RingColored(Vector3 center, float radius, Color color)

Circle outline in an explicit color.

voidvoid rings(centers: PackedVector3Array, radii: PackedFloat32Array, colors: PackedColorArray)Rings(Vector3[] centers, float[] radii, Color[] colors)

Batch circle outlines in 3D.

voidvoid rect(center: Vector3, size: Vector2)Rect(Vector3 center, Vector2 size)

Rectangle. Honors corner_radii, rect_pivot_corner and border.

voidvoid rect_colored(center: Vector3, size: Vector2, color: Color)RectColored(Vector3 center, Vector2 size, Color color)