dymokomi/luce-vector
Source of release 0.6.0
0.6.0 / src / vector / render.lucb
#==============================================================================================
#
# vector/render - A vector layer's elements drawn into its tiles
#
# DESCRIPTION:
# The elements' cells are merged bottom up: an element's edge makes a cell an edge
# cell, and its inside, one opaque fill over everything below, makes the cell inside
# that element alone. Edge cells are drawn from bins of nearby elements a window at a
# time (windows.lucb); each element's inside cells come out one color, so one is drawn
# and the others share its tile.
#
#==============================================================================================
## Draw `list`'s visible elements into `tiles` (a layer's pixels, as large as
## the canvas): when `dirty` marks cells, only those, which the caller has
## cleared; else every cell, into tiles with nothing painted.
pub func draw_elements(tiles: Tiles*, list: const VectorElement[], dirty: CellMask*?) -> !:
let device = tiles.device()
let width = tiles.width()
let height = tiles.height()
let whole = ShapeReach(left = 0, top = 0, right = tile_columns(width), bottom = tile_columns(height))
var region = whole
if let cells = dirty:
region = cells.bounds() else return
# Every cell's kind for the elements together, and whose inside an inside cell is.
let cell_count = (usize)whole.right * (usize)whole.bottom
let kinds = try new u8[cell_count] --- in memory.heap
defer free(kinds) in memory.heap
memory.set(kinds, cell_outside)
let owners = try new u32[cell_count] --- in memory.heap
defer free(owners) in memory.heap
# The elements the region needs.
let chosen = try new ShapeSpec[list.length if list.length > 0 else 1] --- in memory.heap
defer free(chosen) in memory.heap
let places = try new u32[list.length if list.length > 0 else 1] --- in memory.heap
defer free(places) in memory.heap
var included: usize = 0
for at in 0..<list.length:
let spec = list[at].spec
if not list[at].visible or not drawable(spec):
continue
let reach = shape_reach(spec, width, height) else continue
if not reaches_overlap(reach, region):
continue
# Only what reaches a marked cell: an edit far from most of a graph's
# clones parses and sorts the few near it.
if let cells = dirty:
if not cells.touches(reach):
continue
chosen[included] = spec
places[included] = (u32)at
included += 1
if included == 0:
return
# Sorted into bins, each parsed once: every element's cells come from its
# bin's drawing, and each window is drawn from the elements near it.
var bins = try Bins.make(chosen[..<included], width, height)
defer bins.close()
for at in 0..<included:
var plan = try bins.plan(at, chosen[at]) else continue
merge_plan(&plan, dirty, kinds, owners, whole.right, places[at])
plan.close()
var painter = try WindowPainter.make(device, none, width, height)
defer painter.close()
try draw_binned(&painter, &bins, kinds, whole.right, whole.bottom, cell_edge, tiles, none)
try draw_insides(&painter, &bins, kinds, whole.right, whole.bottom, owners, list.length, tiles)
## The inside cells: each element's first drawn, and when it comes out one color
## the element's others share its tile; when not, they are drawn too.
func draw_insides(painter: WindowPainter*, bins: const Bins*, kinds: u8[], columns: u32, rows: u32, owners: const u32[], elements: usize, tiles: Tiles*) -> !:
if elements == 0:
return
let samples = try new i64[elements] --- in memory.heap
defer free(samples) in memory.heap
for owner in 0..<elements:
samples[owner] = -1
for at in 0..<kinds.length:
if kinds[at] == cell_inside and samples[(usize)owners[at]] < 0:
samples[(usize)owners[at]] = (i64)at
kinds[at] = cell_sample
let uniform = try new u8[kinds.length] --- in memory.heap
defer free(uniform) in memory.heap
memory.set(uniform, 0)
try draw_binned(painter, bins, kinds, columns, rows, cell_sample, tiles, uniform)
for at in 0..<kinds.length:
if kinds[at] == cell_sample:
kinds[at] = cell_outside
continue
if kinds[at] != cell_inside:
continue
let sample = (usize)samples[(usize)owners[at]]
kinds[at] = cell_outside
if uniform[sample] != 0:
try tiles.share((u32)(at % (usize)columns), (u32)(at // (usize)columns), (u32)(sample % (usize)columns), (u32)(sample // (usize)columns))
else:
kinds[at] = cell_redraw
try draw_binned(painter, bins, kinds, columns, rows, cell_redraw, tiles, none)