Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-ui

Source of release 0.19.6

0.19.6 / src / painter.lucb

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