Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-ui

Source of release 0.19.1

0.19.1 / tests / pixels / present_retry_pixels.lucb

## A present the GPU skips is drawn again on a later turn, without input to mark the
## frame dirty. Ordering the window out makes Metal skip (the host is not visible);
## while it is out the loop retries on a backoff (a few turns, not a spin), and once
## it is back the frame is drawn.
import c
import interop
import memory
import ownership
import time
from luce_gpu import gpu
from luce_ui import ui
from luce_ui.ui import Application, Viewport, Widget

extern func objc_getClass(name: c.str) -> void*
extern func sel_registerName(name: c.str) -> void*
extern func msg as "objc_msgSend"(object: void*, selector: void*) -> void*
extern func msg_count as "objc_msgSend"(object: void*, selector: void*) -> u64
extern func msg_index as "objc_msgSend"(object: void*, selector: void*, index: u64) -> void*
extern func msg_text as "objc_msgSend"(object: void*, selector: void*) -> c.str
extern func msg_order as "objc_msgSend"(object: void*, selector: void*, sender: void*?)

let title = "Present retry"

func native_window() -> void*:
    let app = msg(objc_getClass("NSApplication"), sel_registerName("sharedApplication"))
    let windows = msg(app, sel_registerName("windows"))
    for index in 0..<msg_count(windows, sel_registerName("count")):
        let native = msg_index(windows, sel_registerName("objectAtIndex:"), index)
        if (str)msg_text(msg(native, sel_registerName("title")), sel_registerName("UTF8String")) == title:
            return native
    trap("the test window is not registered with AppKit")

## Phase 0 waits for the first draw and orders the window out; phase 1 counts the
## turns while it is out, then orders it back in; phase 2 waits for a draw.
struct Probe:
    var app: Application*
    var phase: i64
    var since: u64
    var turns: i64
    var draws: i64
    var draws_hidden: i64
    var failed: bool

    func frame(elapsed: f64) -> interop.Outcome[unit]:
        _ = elapsed
        let now = time.now()
        if self.phase == 0 and self.draws > 0:
            msg_order(native_window(), sel_registerName("orderOut:"), none)
            self.app.invalidate()
            self.phase = 1
            self.since = now
        elif self.phase == 1:
            self.turns += 1
            if now - self.since > 1200000000:
                self.draws_hidden = self.draws
                msg_order(native_window(), sel_registerName("orderFront:"), none)
                self.phase = 2
                self.since = now
        elif self.phase == 2:
            if self.draws > self.draws_hidden:
                self.app.stop()
            elif now - self.since > 3000000000:
                self.failed = true
                self.app.stop()
        return interop.Outcome[unit].success(interop.Owned[unit](()))

    func draw(target: interop.View[gpu.RenderTarget]) -> interop.Outcome[unit]:
        _ = target
        self.draws += 1
        return interop.Outcome[unit].success(interop.Owned[unit](()))

    func close():
        self.phase = 0

    func trace(visit: func(ownership.Object*, void*) -> unit, context: void*):
        _ = visit
        _ = context

let probe_type: interop.Type[Probe] = interop.Type[Probe]("present retry probe", Probe.close, Probe.trace)

pub func skipped_presents() -> !:
    let view = try interop.Reference[Viewport].adopt(new Viewport(64.0, 40.0) in memory.heap, ui.viewport_type, memory.heap)
    defer view.release()
    let content = view.as_interface[Widget](view.value())
    defer content.release()
    let app = try interop.Reference[Application].adopt(new Application(content, title = title, width = 160, height = 100) in memory.heap, ui.application_type, memory.heap)
    defer app.release()
    let probe = try interop.Reference[Probe].adopt(new Probe(app = app.value(), phase = 0, since = 0, turns = 0, draws = 0, draws_hidden = 0, failed = false) in memory.heap, probe_type, memory.heap)
    defer probe.release()
    let frames = try interop.Callback[f64, unit].bind_mutating(probe, Probe.frame)
    defer frames.release()
    let drawing = try interop.Callback[interop.View[gpu.RenderTarget], unit].bind_mutating(probe, Probe.draw)
    defer drawing.release()
    let frame_connection = try app.value().on_frame(frames)
    defer frame_connection.release()
    let draw_connection = try view.value().on_render(drawing)
    defer draw_connection.release()
    let outcome = app.value().run()
    defer outcome.release()
    try outcome.get()
    let result = probe.value()
    # 1.2 s out: retries at about 16, 48, 112, 240, 496 and 1008 ms, where a loop that
    # forgot the skipped frame turns only for the odd window event, and a spin thousands.
    assert(not result.failed and result.turns >= 5 and result.turns <= 40)
    print(f"ok a skipped present is retried on a backoff ({result.turns} turns hidden) and drawn once visible")