dymokomi/luce-ui
Source of release 0.19.0
## Immediate-mode drawing for widgets and applications: filled and rounded
## rectangles, triangles, meshes, lines, images and text on a render target,
## in the target's logical points.
from luce_gpu import gpu
import interop
import ownership
from luce_std import math
import memory
import result
from font import Font, selected_font
from image import Image
from geometry import Point
## A convenience painter over a checked target. Retaining the painter does not
## extend the target's frame lifetime; every drawing call validates it again.
pub struct Painter:
let target_view: interop.View[gpu.RenderTarget]
pub func init(target: interop.View[gpu.RenderTarget]) -> !:
_ = try target.get().size()
self.target_view = target.clone()
pub func target() -> interop.View[gpu.RenderTarget]:
return self.target_view.clone()
## Fill `rectangle` with `color` at `opacity` (0..1). An empty rectangle or
## target draws nothing.
pub func rectangle(rectangle: gpu.Rect, color: gpu.Color, opacity: f64 = 1.0) -> !:
if not math.is_finite(opacity) or opacity < 0.0 or opacity > 1.0:
error(result.invalid, "rectangle opacity must be in 0..1")
let target = try self.target_view.get()
let size = try target.size()
if size.width <= 0.0 or size.height <= 0.0 or rectangle.width <= 0.0 or rectangle.height <= 0.0:
return
let left = (f32)(rectangle.x * 2.0 / size.width - 1.0)
let right = (f32)((rectangle.x + rectangle.width) * 2.0 / size.width - 1.0)
let top = (f32)(1.0 - rectangle.y * 2.0 / size.height)
let bottom = (f32)(1.0 - (rectangle.y + rectangle.height) * 2.0 / size.height)
let a = gpu.Vertex(x = left, y = top, red = (f32)color.red, green = (f32)color.green, blue = (f32)color.blue, alpha = (f32)opacity)
var b = a
var c = a
var d = a
b.x = right
c.x = right
c.y = bottom
d.y = bottom
try target.triangles([a, b, c, a, c, d])
## A rectangle with corners rounded by `radius` points (clamped to half the
## shorter side); zero draws a plain rectangle. `corners` picks which round:
## bit 1 top-left, 2 top-right, 4 bottom-right, 8 bottom-left (15 = all), so a
## tab can round its top only. One batched draw: a fan of triangles from the
## center through eight-segment corner arcs.
pub func rounded_rectangle(rectangle: gpu.Rect, color: gpu.Color, radius: f64, opacity: f64 = 1.0, corners: i64 = 15) -> !:
if not math.is_finite(radius) or radius < 0.0:
error(result.invalid, "corner radius must be finite and nonnegative")
let r = math.min(radius, math.min(rectangle.width, rectangle.height) * 0.5)
if r < 0.5 or corners & 15 == 0:
try self.rectangle(rectangle, color, opacity)
return
if rectangle.width <= 0.0 or rectangle.height <= 0.0:
return
let target = try self.target_view.get()
let size = try target.size()
if size.width <= 0.0 or size.height <= 0.0:
return
# The outline: 8 segments per corner, so 36 points around, fanned from the center.
let segments: usize = 8
let around = (segments + 1) * 4
var vertices = try new gpu.Vertex[around * 3] --- in memory.heap
defer free(vertices) in memory.heap
let cx = rectangle.x + rectangle.width * 0.5
let cy = rectangle.y + rectangle.height * 0.5
let centre = clip_vertex(cx, cy, size.width, size.height, color, opacity)
var outline = try new Point[around] --- in memory.heap
defer free(outline) in memory.heap
var index: usize = 0
for corner in 0..<(usize)4:
# Corner centers clockwise from the top-right; angles sweep a quarter turn each.
let ox = rectangle.x + rectangle.width - r if corner == 0 or corner == 1 else rectangle.x + r
let oy = rectangle.y + r if corner == 0 or corner == 3 else rectangle.y + rectangle.height - r
let start = -math.pi * 0.5 + (f64)corner * math.pi * 0.5
# Clockwise from the top-right, the corner bits run 2, 4, 8, 1.
let bit: i64 = 2 if corner == 0 else (4 if corner == 1 else (8 if corner == 2 else 1))
let rounded = corners & bit != 0
for step in 0..<(segments + 1):
let angle = start + (f64)step / (f64)segments * math.pi * 0.5
if rounded:
outline[index] = Point(ox + math.cos(angle) * r, oy + math.sin(angle) * r)
else:
# A square corner: every point of its arc sits on the corner itself.
outline[index] = Point(ox + (r if corner == 0 or corner == 1 else -r), oy + (-r if corner == 0 or corner == 3 else r))
index += 1
for point in 0..<around:
let next = outline[(point + 1) % around]
vertices[point * 3] = centre
vertices[point * 3 + 1] = clip_vertex(outline[point].x, outline[point].y, size.width, size.height, color, opacity)
vertices[point * 3 + 2] = clip_vertex(next.x, next.y, size.width, size.height, color, opacity)
try target.triangles(vertices)
## Draw `source` of `image` (all of it by default) scaled onto `rectangle`,
## at `opacity`, sampled with `filter`.
pub func image(image: interop.Reference[Image], rectangle: gpu.Rect, source: gpu.Region? = none, opacity: f64 = 1.0,
filter: gpu.Filter = gpu.Filter.linear) -> !:
try image.value().draw(self.target_view, rectangle, source, opacity, filter)
## Draw one line of `text` with its top-left at `x`, `y`, in `font` or the
## default monospace font.
pub func text(text: str, x: f64 = 0.0, y: f64 = 0.0,
color: gpu.Color = gpu.Color(red = 0.82, green = 0.9, blue = 1.0),
font: interop.Reference[Font]? = none) -> !:
var selected = try selected_font(font)
defer selected.release()
try selected.value().draw(self.target_view, text, x, y, color)
## Vector shapes share the target's logical coordinate system and clipping.
pub func triangle(a: Point, b: Point, c: Point, color: gpu.Color) -> !:
let target = try self.target_view.get()
let size = try target.size()
if size.width <= 0.0 or size.height <= 0.0:
return
var vertices: gpu.Vertex[3] = [gpu.Vertex(), gpu.Vertex(), gpu.Vertex()]
var index: usize = 0
for point in [a, b, c]:
vertices[index] = gpu.Vertex(x = (f32)(point.x * 2.0 / size.width - 1.0),
y = (f32)(1.0 - point.y * 2.0 / size.height),
red = (f32)color.red, green = (f32)color.green, blue = (f32)color.blue)
index += 1
try target.triangles(vertices)
## Fill many triangles in a single draw. `points` are triangle vertices in logical
## coordinates (every three make one triangle); a trailing partial triangle is
## ignored. Batching keeps a shape of many segments to one canvas draw, not one each.
pub func mesh(points: const Point[], color: gpu.Color) -> !:
if points.length < 3:
return
let target = try self.target_view.get()
let size = try target.size()
if size.width <= 0.0 or size.height <= 0.0:
return
let count = points.length - points.length % 3
var vertices = try new gpu.Vertex[count] --- in memory.heap
defer free(vertices) in memory.heap
for index in 0..<count:
vertices[index] = gpu.Vertex(x = (f32)(points[index].x * 2.0 / size.width - 1.0),
y = (f32)(1.0 - points[index].y * 2.0 / size.height),
red = (f32)color.red, green = (f32)color.green, blue = (f32)color.blue)
try target.triangles(vertices)
## Fill many triangles with a color per vertex, in one draw: `colors` runs
## parallel to `points`. Gradients (a color picker's field, a hue strip) are
## drawn this way, as a grid of shaded cells.
pub func shaded_mesh(points: const Point[], colors: const gpu.Color[], opacity: f64 = 1.0) -> !:
if points.length != colors.length:
error(result.invalid, "a shaded mesh needs one color per point")
if not math.is_finite(opacity) or opacity < 0.0 or opacity > 1.0:
error(result.invalid, "mesh opacity must be in 0..1")
if points.length < 3:
return
let target = try self.target_view.get()
let size = try target.size()
if size.width <= 0.0 or size.height <= 0.0:
return
let count = points.length - points.length % 3
var vertices = try new gpu.Vertex[count] --- in memory.heap
defer free(vertices) in memory.heap
for index in 0..<count:
vertices[index] = clip_vertex(points[index].x, points[index].y, size.width, size.height, colors[index], opacity)
try target.triangles(vertices)
## A straight segment from `a` to `b`, `width` points thick, with square
## (unextended) ends. A zero-length segment draws nothing.
pub func line(a: Point, b: Point, width: f64, color: gpu.Color) -> !:
if not math.is_finite(width) or width <= 0.0:
error(result.invalid, "line width must be positive and finite")
_ = try self.target_view.get().size()
let dx = b.x - a.x
let dy = b.y - a.y
let length = math.sqrt(dx * dx + dy * dy)
if length == 0.0:
return
let x = -dy * width * 0.5 / length
let y = dx * width * 0.5 / length
try self.triangle(Point(a.x + x, a.y + y), Point(b.x + x, b.y + y), Point(b.x - x, b.y - y), color)
try self.triangle(Point(a.x + x, a.y + y), Point(b.x - x, b.y - y), Point(a.x - x, a.y - y), color)
pub func close():
self.target_view.release()
func trace(visit: func(ownership.Object*, void*) -> unit, context: void*):
self.target_view.trace(visit, context)
pub let painter_type: interop.Type[Painter] = interop.Type[Painter]("UI painter", Painter.close, Painter.trace, closeable = true, main_thread = true)
## A point in target coordinates as a clip-space vertex of one color.
func clip_vertex(x: f64, y: f64, width: f64, height: f64, color: gpu.Color, opacity: f64) -> gpu.Vertex:
return gpu.Vertex(x = (f32)(x * 2.0 / width - 1.0), y = (f32)(1.0 - y * 2.0 / height),
red = (f32)color.red, green = (f32)color.green, blue = (f32)color.blue, alpha = (f32)opacity)