dymokomi/luce-ui
Source of release 0.19.6
0.19.6 / src / layout / layers.lucb
#==============================================================================================
#
# layout/layers - Retained boxes: subtrees drawn into layers kept between frames
#
# DESCRIPTION:
# A retained box (`Layout.set_retained`) and the boxes under it draw into a texture
# of the box's size at the window's backing scale, which each frame copies into the
# window. The layer draws again only when a digest of what it shows moves: its boxes'
# own change stamps (`Layout.painted`), their places, clips, hover and focus, the
# backing scale, and the layer epoch (`refresh_layers`). Anything else that changes
# in the window (a panel's hover, a value beside it) leaves it as it is.
#
#==============================================================================================
## The most retained boxes a window keeps layers for; more draw as other boxes do.
let layer_limit: usize = 8
## The draws one layer's frame may record: luce-gpu's ceiling, as a window's.
let layer_draws: usize = 65536
## One kept layer: the retained box it belongs to (0 for a free slot), its texture
## and texel size, the digest of what it shows, and whether this frame drew it.
struct Layer:
var identifier: u64
var texture: gpu.Texture
var width: u32
var height: u32
var digest: u64
var used: bool
extend Tree:
## Draw the retained box at `index`, with the part of its subtree drawn in
## `pass`, from its kept layer, drawing the layer again first when what it
## shows changed. None when no layer can be kept for it (a frame without a
## device, a box too large, every layer taken): the caller draws the subtree
## as usual. Otherwise the outcome of the subtree's widgets, the first failure.
func draw_layer(index: usize, pass: usize, target: interop.View[gpu.RenderTarget]) -> interop.Outcome[unit]?!:
let box = self.entries[index].box.value()
let native = try target.get()
let size = try native.size()
if size.width <= 0.0:
return none
let scale = size.pixel_width / size.width
let columns = math.ceil(box.rectangle.width * scale)
let rows = math.ceil(box.rectangle.height * scale)
if not (scale >= 1.0 and scale <= 16.0) or columns < 1.0 or rows < 1.0 or columns > 16384.0 or rows > 16384.0:
return none
var device = gpu.device_of(native) catch failure:
return none
defer device.destroy()
let slot = try self.layer_slot(box.identifier) else return none
let layer = &self.layers[slot]
layer.used = true
let digest = self.subtree_digest(index, pass, scale)
var stale = digest != layer.digest
if layer.width != (u32)columns or layer.height != (u32)rows:
var previous = layer.texture
layer.texture = gpu.Texture()
layer.width = 0
layer.height = 0
previous.destroy()
layer.texture = try gpu.Texture.create(device, (u32)columns, (u32)rows, gpu.Format.rgba8)
layer.width = (u32)columns
layer.height = (u32)rows
stale = true
var outcome = result.success[unit](())
if stale:
outcome.release()
outcome = try self.render_layer(index, pass, layer.texture, scale, box.appearance.background)
# A layer whose widgets failed draws again next frame.
layer.digest = digest if outcome.is_success() else 0
let clipped = try native.clipped(box.clipping)
defer clipped.release()
try gpu.copy_image(try clipped.get(), layer.texture, box.rectangle)
return outcome
## Draw the subtree at `index` (its boxes drawn in `pass`) into `texture`, a
## point being `scale` texels, over the box's `background`.
func render_layer(index: usize, pass: usize, texture: gpu.Texture, scale: f64, background: gpu.Color) -> interop.Outcome[unit]!:
let entry = self.entries[index]
let origin = Point(entry.box.value().rectangle.x, entry.box.value().rectangle.y)
let frame = try texture.frame(scale = scale)
defer frame.release()
let root = try frame.value().target()
defer root.release()
try root.value().allow_draws(layer_draws)
var failed: interop.Outcome[unit]? = none
for inner in index..<entry.end:
let box = self.entries[inner].box.value()
if popup_depth(self.entries, inner) != pass or box.clipping.width <= 0.0 or box.clipping.height <= 0.0:
continue
let drawn = self.draw_entry(inner, root, origin)
if drawn.is_success():
drawn.release()
elif failed == none:
failed = drawn
else:
drawn.release()
_ = try frame.value().present(background)
if let first = failed:
return first
return result.success[unit](())
## What the layer of the retained box at `index` shows, as a number: its boxes'
## change stamps, places, clips and hover and focus flags, the backing `scale`
## and the layer epoch. The pointer's position is not in it: a widget that draws
## at the pointer repaints (`Layout.hover_part`).
func subtree_digest(index: usize, pass: usize, scale: f64) -> u64:
var digest = mix(1469598103934665603, layer_epoch)
digest = mix(digest, quantized(scale))
for inner in index..<self.entries[index].end:
if popup_depth(self.entries, inner) != pass:
continue
let box = self.entries[inner].box.value()
digest = mix(digest, box.identifier)
digest = mix(digest, box.painted)
for value in [box.rectangle.x, box.rectangle.y, box.rectangle.width, box.rectangle.height,
box.clipping.x, box.clipping.y, box.clipping.width, box.clipping.height]:
digest = mix(digest, quantized(value))
var flags: u64 = 0
var bit: u64 = 1
for set in [box.hovered, box.pointer_within, box.focused, box.focus_within, box.drop_hovered, box.active]:
if set:
flags += bit
bit *= 2
digest = mix(digest, flags)
return digest
## The slot of the layer kept for box `identifier`, taking a free one; none
## when every one is taken.
func layer_slot(identifier: u64) -> usize?!:
if self.layers.length == 0:
let made = try new Layer[layer_limit] --- in memory.heap
for slot in 0..<layer_limit:
made[slot] = Layer(identifier = 0, texture = gpu.Texture(), width = 0, height = 0, digest = 0, used = false)
self.layers = made
var open: usize? = none
for slot in 0..<self.layers.length:
if self.layers[slot].identifier == identifier:
return slot
if open == none and self.layers[slot].identifier == 0:
open = slot
let chosen = open else return none
self.layers[chosen].identifier = identifier
self.layers[chosen].digest = 0
return chosen
## Mark every layer unused before a frame draws.
func begin_layers():
for slot in 0..<self.layers.length:
self.layers[slot].used = false
## Give back the layers the frame did not draw: their boxes are gone, hidden or
## no longer retained.
func release_unused_layers():
for slot in 0..<self.layers.length:
if self.layers[slot].identifier != 0 and not self.layers[slot].used:
free_layer(&self.layers[slot])
## Give back every layer, when the tree closes.
func drop_layers():
if self.layers.length == 0:
return
for slot in 0..<self.layers.length:
free_layer(&self.layers[slot])
let previous = self.layers
var none_left: Layer[]
self.layers = none_left
free(previous) in memory.heap
func free_layer(layer: Layer*):
var texture = layer.texture
layer.texture = gpu.Texture()
layer.identifier = 0
layer.width = 0
layer.height = 0
layer.digest = 0
layer.used = false
texture.destroy()
func mix(digest: u64, value: u64) -> u64:
return (digest ^ value) *% 1099511628211
## A coordinate in 64ths of a point, as a nonnegative number for the digest.
func quantized(value: f64) -> u64:
return (u64)((i64)(math.clamp(value, -1048576.0, 1048576.0) * 64.0) + 134217728)