dymokomi/luce-image
Source of release 0.45.0
0.45.0 / src / canvas / drawing.lucb
#==============================================================================================
#
# canvas/drawing - Drawing the document onto a target
#
#==============================================================================================
extend Canvas:
## Draw the view into textures of `texel_format` rather than a window's surface
## (none): what the view's own pipelines (the checkerboard and tints, the
## channel view, mattes) are made for. For headless renderers and benchmarks.
pub func set_view_format(texel_format: gpu.Format?):
self.drop_view_pipelines()
self.view_format = texel_format
## Let the view's own pipelines go, to be made again when next drawn.
func drop_view_pipelines():
if let pipeline = self.quick_overlay:
var owned = pipeline
owned.destroy()
self.quick_overlay = none
if let shader = self.quick_shader:
var owned = shader
owned.destroy()
self.quick_shader = none
if let pipeline = self.channels_view:
var owned = pipeline
owned.destroy()
self.channels_view = none
if let shader = self.channels_shader:
var owned = shader
owned.destroy()
self.channels_shader = none
func quick_pipeline() -> gpu.Pipeline!:
if let existing = self.quick_overlay:
return existing
let device = self.device else error(invalid, "draw the document once first")
var shader = try gpu.Shader.create(device, quickmask_frag_words, quickmask_frag_msl)
errdefer shader.destroy()
let pipeline = try gpu.Pipeline.create(device, shader, gpu.Blend.over, self.view_format)
self.quick_shader = shader
self.quick_overlay = pipeline
return pipeline
func channels_pipeline() -> gpu.Pipeline!:
if let existing = self.channels_view:
return existing
let device = self.device else error(invalid, "draw the document once first")
var shader = try gpu.Shader.create(device, channels_frag_words, channels_frag_msl)
errdefer shader.destroy()
let pipeline = try gpu.Pipeline.create(device, shader, gpu.Blend.over, self.view_format)
self.channels_shader = shader
self.channels_view = pipeline
return pipeline
func ants_pipeline() -> gpu.Pipeline!:
if let existing = self.ants:
return existing
let device = self.device else error(invalid, "draw the document once first")
var shader = try gpu.Shader.create(device, ants_frag_words, ants_frag_msl)
errdefer shader.destroy()
let pipeline = try gpu.Pipeline.create(device, shader, gpu.Blend.over)
self.ants_shader = shader
self.ants = pipeline
return pipeline
## Draw the document onto `target`, clipped to `rectangle` (in the target's
## points), with its top-left corner at `rectangle`'s origin plus `offset`,
## scaled by `zoom` (document pixels to points). Binds the device on first
## use. Pixels are crisp at and above 100% and filtered below it.
pub func draw(target: interop.View[gpu.RenderTarget], rectangle: gpu.Rect, zoom: f64, offset_x: f64, offset_y: f64) -> !:
try self.require_open()
try self.settle_stroke()
if not math.is_finite(zoom) or zoom <= 0.0 or zoom > 256.0 or not math.is_finite(offset_x) or not math.is_finite(offset_y):
error(invalid, "zoom must be in 0..256 and offsets finite")
let checked = try target.get()
if rectangle.width <= 0.0 or rectangle.height <= 0.0:
return
try self.bind(checked)
# A standalone frame has no device; it records nothing.
let document = self.document else return
let composer = self.composer else return
# The bands of a picture still opening that are ready since the last frame.
try self.continue_opening()
# A new frame: what the last one pinned may move, within the memory budget,
# once this draw is done with it. Later draws into the same frame keep what
# this one pins.
let settles = begin_frame(checked.frame_serial())
self.quick_drawn = false
if composite_shown_count(&self) == 0:
# No composite channel shown: an alpha channel alone, or nothing.
try draw_channel_view(&self, target, rectangle, zoom, offset_x, offset_y, 0)
if settles:
try settle_tiers(&self)
return
let sources = try tint_sources(&self)
var shading = try composite_shading(&self, checked, sources.count > 0)
shading.squares_x = rectangle.x + offset_x
shading.squares_y = rectangle.y + offset_y
let clipped = try checked.clipped(rectangle)
defer clipped.release()
let area = clipped.value()
# The pyramid level whose tiles are at most one texel per point.
var level: u32 = 0
while level < 16 and zoom * (f64)(1u32 << (level + 1)) <= 1.0:
level += 1
let span = 1u32 << level
let tile_points = (f64)tile_size * (f64)span * zoom
let origin_x = rectangle.x + offset_x
let origin_y = rectangle.y + offset_y
let columns = (tile_columns(self.extent_x) + span - 1) // span
let rows = (tile_columns(self.extent_y) + span - 1) // span
let first_column = visible_cell(rectangle.x - origin_x, tile_points, columns)
let first_row = visible_cell(rectangle.y - origin_y, tile_points, rows)
let last_column = max_u32(first_column, visible_cell(rectangle.x + rectangle.width - origin_x, tile_points, columns - 1) + 1)
let last_row = max_u32(first_row, visible_cell(rectangle.y + rectangle.height - origin_y, tile_points, rows - 1) + 1)
# Tiles a background batch brought back since the last frame.
_ = try prefetch_collect()
# A batch that failed to decode something: this frame brings what it lacks
# back itself, so the failure is reported.
let waits = not progressive_loading or prefetch_had_failure()
if waits:
# The layer tiles the cells in view will need, brought back together first.
try composer.gather(document, first_column, first_row, min_u32(last_column, columns), min_u32(last_row, rows), level)
var lacking = Gathering.deferred()
defer lacking.release()
self.coarse_shown = false
for row in 0..<rows:
let top = origin_y + (f64)row * tile_points
if top >= rectangle.y + rectangle.height or top + tile_points <= rectangle.y:
continue
for column in 0..<columns:
let left = origin_x + (f64)column * tile_points
if left >= rectangle.x + rectangle.width or left + tile_points <= rectangle.x:
continue
# The texels the document covers in this tile, and their extent in points.
let covered_x = min_u32(tile_size, (self.extent_x - column * span * tile_size + span - 1) // span)
let covered_y = min_u32(tile_size, (self.extent_y - row * span * tile_size + span - 1) // span)
let destination = gpu.Rect(left, top, (f64)covered_x * (f64)span * zoom, (f64)covered_y * (f64)span * zoom)
if not waits and not composer.kept(document, column, row, level) and (try composer.lacking(document, column, row, level, &lacking)) > 0:
# Its tiles come back in the background: a coarser level kept stands in.
if let coarse = composer.coarser(document, column, row, level, covered_x, covered_y):
let tints = try tints_at(&self, composer, &sources, column, row, level)
try draw_view_tile(area, &shading, coarse.texture, destination, coarse.region, gpu.Filter.linear, &tints)
self.coarse_shown = true
continue
# Nothing coarser is kept (the first frame): this cell waits.
try composer.gather(document, column, row, column + 1, row + 1, level)
let texture = try composer.tile(document, column, row, level)
# After the composite: its request lets go of what came before.
let tints = try tints_at(&self, composer, &sources, column, row, level)
try draw_view_tile(area, &shading, texture, destination, gpu.Region(0, 0, covered_x, covered_y),
gpu.Filter.nearest if zoom >= 1.0 else gpu.Filter.linear, &tints)
try lacking.finish()
self.quick_drawn = sources.count > 0 and sources.mask[0]
# The alpha channels shown that had no room in the draw, red over the picture.
try draw_channel_view(&self, target, rectangle, zoom, offset_x, offset_y, sources.channels)
if settles:
try settle_tiers(&self)
## Draw one layer's own pixels (or its mask when `mask` is set) scaled into
## `rectangle` of `target`, for thumbnails. Needs the document bound.
pub func draw_layer(target: interop.View[gpu.RenderTarget], index: i64, rectangle: gpu.Rect, mask: bool = false) -> !:
try self.require_open()
try self.settle_stroke()
let record = try self.record(index)
if rectangle.width <= 0.0 or rectangle.height <= 0.0:
return
let checked = try target.get()
let document = self.document else return
let layer = document.find(record.id) else return
let tiles = (layer.mask_tiles() else return) if mask else (layer.tiles() else return)
let composer = self.composer else return
let scale_x = rectangle.width / (f64)self.extent_x
let scale_y = rectangle.height / (f64)self.extent_y
# From the layer's level about a texel a point: a thumbnail is a few cells at most.
let level = view_level(math.min(scale_x, scale_y))
let span = (f64)((u64)tile_size << level)
composer.hold()
for row in 0..<level_cells(self.extent_y, level):
for column in 0..<level_cells(self.extent_x, level):
let texture = (try composer.level_texture(tiles, column, row, level, mask)) else continue
let covered_x = covered_at(self.extent_x, column, level)
let covered_y = covered_at(self.extent_y, row, level)
let step = (f64)(1u64 << level)
let destination = gpu.Rect(rectangle.x + (f64)column * span * scale_x, rectangle.y + (f64)row * span * scale_y,
(f64)covered_x * step * scale_x, (f64)covered_y * step * scale_y)
try gpu.draw_image(checked, texture, destination, gpu.Region(0, 0, covered_x, covered_y), 1.0, gpu.Filter.linear)
## Draw the document as `draw` does, but with layer `id` shown displaced by
## (`dx`, `dy`) document pixels without touching its pixels: the live
## preview of a move. The displaced layer is drawn on top of the rest in
## normal blending at its opacity.
pub func draw_moving(target: interop.View[gpu.RenderTarget], rectangle: gpu.Rect, zoom: f64, offset_x: f64, offset_y: f64,
id: i64, dx: f64, dy: f64) -> !:
try self.require_open()
try self.settle_stroke()
let index = try self.index((u64)id)
if self.document == none:
try self.draw(target, rectangle, zoom, offset_x, offset_y)
return
let document = self.document else trap("checked")
let layer = document.find((u64)id) else error(invalid, "no such layer")
let shown = layer.visible
layer.visible = false
document.revision += 1
try self.draw(target, rectangle, zoom, offset_x, offset_y)
layer.visible = shown
document.revision += 1
if not shown or rectangle.width <= 0.0 or rectangle.height <= 0.0:
return
# The moving layer shows on the canvas only, what it had past the canvas included.
let left = math.max(rectangle.x, rectangle.x + offset_x)
let top = math.max(rectangle.y, rectangle.y + offset_y)
let right = math.min(rectangle.x + rectangle.width, rectangle.x + offset_x + (f64)self.extent_x * zoom)
let bottom = math.min(rectangle.y + rectangle.height, rectangle.y + offset_y + (f64)self.extent_y * zoom)
if right <= left or bottom <= top:
return
let checked = try target.get()
let clipped = try checked.clipped(gpu.Rect(left, top, right - left, bottom - top))
defer clipped.release()
let tiles = layer.tiles() else return
let opacity = self.records[index].opacity
let filter = gpu.Filter.nearest if zoom >= 1.0 else gpu.Filter.linear
let level = view_level(zoom)
if level > 0:
# Zoomed out: the layer's level, cell by cell, only those that show (what
# it has past the canvas shows again at full size).
let composer = self.composer else return
composer.hold()
let span = (f64)((u64)tile_size << level)
let step = (f64)(1u64 << level)
for row in 0..<level_cells(self.extent_y, level):
for column in 0..<level_cells(self.extent_x, level):
let destination = gpu.Rect(rectangle.x + offset_x + ((f64)column * span + dx) * zoom, rectangle.y + offset_y + ((f64)row * span + dy) * zoom,
(f64)covered_at(self.extent_x, column, level) * step * zoom, (f64)covered_at(self.extent_y, row, level) * step * zoom)
if not overlaps(destination, left, top, right, bottom):
continue
let texture = (try composer.level_texture(tiles, column, row, level)) else continue
try gpu.draw_image(clipped.value(), texture, destination, gpu.Region(0, 0, covered_at(self.extent_x, column, level), covered_at(self.extent_y, row, level)), opacity, filter)
return
var parts = try pieces(tiles)
defer parts.destroy()
for at in 0..<parts.count:
let piece = parts.at(at)
let destination = gpu.Rect(rectangle.x + offset_x + ((f64)piece.x + dx) * zoom, rectangle.y + offset_y + ((f64)piece.y + dy) * zoom,
(f64)piece.source.width * zoom, (f64)piece.source.height * zoom)
if not overlaps(destination, left, top, right, bottom):
continue
try gpu.draw_image(clipped.value(), piece.texture, destination, piece.source, opacity, filter)
## `Canvas.draw_selection`: marching ants along the selection's edge at screen resolution.
func draw_canvas_selection(canvas: Canvas*, target: interop.View[gpu.RenderTarget], rectangle: gpu.Rect, zoom: f64, offset_x: f64, offset_y: f64, phase: f64) -> !:
try canvas.require_open()
if not canvas.has_selection() or rectangle.width <= 0.0 or rectangle.height <= 0.0:
return
if not math.is_finite(zoom) or zoom <= 0.0 or not math.is_finite(phase):
error(invalid, "zoom must be positive and the phase finite")
let document = canvas.document else return
# The cells the view shows go to the GPU first, the rest a few a frame.
let tiles = (try document.selection_tiles_within(shown_cells(canvas, rectangle, zoom, offset_x, offset_y), ants_extra_cells)) else return
try draw_ants(canvas, target, rectangle, zoom, offset_x, offset_y, phase, tiles, 0)
## Selection cells caught up each frame beyond those shown: about 10 ms of uploads.
let ants_extra_cells: usize = 96
## The document cells a view (as `draw_ants` draws it) reads: whole cells of
## its level, and the cell right of and below each for the edge between.
func shown_cells(canvas: const Canvas*, rectangle: gpu.Rect, zoom: f64, offset_x: f64, offset_y: f64) -> CellRange:
let level = view_level(zoom)
let span = (f64)((u64)tile_size << level)
let left = math.max(0.0, math.floor(-offset_x / zoom / span))
let top = math.max(0.0, math.floor(-offset_y / zoom / span))
let right = math.max(0.0, math.floor((rectangle.width - offset_x) / zoom / span) + 2.0)
let bottom = math.max(0.0, math.floor((rectangle.height - offset_y) / zoom / span) + 2.0)
let step = (i64)1 << (i64)level
return CellRange(left = (i64)left * step, top = (i64)top * step, right = (i64)right * step, bottom = (i64)bottom * step)
## Marching ants along the edge of the selection `coverage` holds (its tiles
## `coverage_level` pyramid levels down: a preview's), over the document as
## `draw` drew it.
func draw_ants(canvas: Canvas*, target: interop.View[gpu.RenderTarget], rectangle: gpu.Rect, zoom: f64, offset_x: f64, offset_y: f64, phase: f64,
coverage: const Tiles*, coverage_level: u32) -> !:
let checked = try target.get()
let pipeline = try canvas.ants_pipeline()
let clipped = try checked.clipped(rectangle)
defer clipped.release()
let area = clipped.value()
let size = try checked.size()
let scale = size.pixel_width / size.width if size.width > 0.0 else 1.0
# gl_FragCoord counts from the frame's corner, not this target's.
let placement = try checked.placement()
# At the view's level: the ants follow the edge a texel a point, and the
# cells drawn are the screen's, whatever the document's size. A preview
# coarser than the view is drawn at its own level, scaled up.
let composer = canvas.composer else return
composer.hold()
let level = max_u32(view_level(zoom), coverage_level)
let within = level - coverage_level
let span = (f64)((u64)tile_size << level)
let step = (f64)(1u64 << level)
for row in 0..<level_cells(canvas.extent_y, level):
for column in 0..<level_cells(canvas.extent_x, level):
let covered_x = covered_at(canvas.extent_x, column, level)
let covered_y = covered_at(canvas.extent_y, row, level)
let left = rectangle.x + offset_x + (f64)column * span * zoom
let top = rectangle.y + offset_y + (f64)row * span * zoom
let width = (f64)covered_x * step * zoom
let height = (f64)covered_y * step * zoom
if left >= rectangle.x + rectangle.width or top >= rectangle.y + rectangle.height or left + width <= rectangle.x or top + height <= rectangle.y:
continue
# A cell with nothing selected still draws the edge with the cell after it.
let own = try composer.level_texture(coverage, column, row, within)
let right = try composer.level_texture(coverage, column + 1, row, within)
let below = try composer.level_texture(coverage, column, row + 1, within)
if own == none and right == none and below == none:
continue
let texture = own else composer_blank(canvas)
let right_tile = right else composer_blank(canvas)
let below_tile = below else composer_blank(canvas)
let limit_x = ((f64)canvas.extent_x - (f64)column * span) / step
let limit_y = ((f64)canvas.extent_y - (f64)row * span) / step
var params: f32[8] = [(f32)((placement.x + left) * scale), (f32)((placement.y + top) * scale), (f32)(zoom * step * scale), (f32)phase, (f32)covered_x, (f32)covered_y, (f32)limit_x, (f32)limit_y]
try gpu.shade(area, pipeline, gpu.Rect(left, top, width, height), u8[]((u8*)¶ms[0], 32), [texture, right_tile, below_tile], gpu.Filter.nearest)
## Whether frames draw cells lacking tiles from a coarser level while the
## tiles come back in the background (`Canvas.set_progressive_loading`).
var progressive_loading: bool = false
## The cell `offset` points into a row of cells `tile_points` wide lies in,
## held to 0..`most`.
func visible_cell(offset: f64, tile_points: f64, most: u32) -> u32:
let cell = math.floor(offset / tile_points)
if not (cell > 0.0):
return 0
return (u32)math.min(cell, (f64)most)
## A transparent texel for absent neighbor tiles.
func composer_blank(canvas: Canvas*) -> gpu.Texture:
return (canvas.painter else trap("bound")).black
## The pyramid level whose texels are at most a point each at `zoom`.
func view_level(zoom: f64) -> u32:
var level: u32 = 0
while level < 16 and zoom * (f64)(1u32 << (level + 1)) <= 1.0:
level += 1
return level
## How many cells a side of `extent` pixels has at `level`.
func level_cells(extent: u32, level: u32) -> u32:
let span = (u64)tile_size << level
return (u32)(((u64)extent + span - 1) // span)
## Whether `box` reaches into `left`..`right`, `top`..`bottom`.
func overlaps(box: gpu.Rect, left: f64, top: f64, right: f64, bottom: f64) -> bool:
return box.x < right and box.y < bottom and box.x + box.width > left and box.y + box.height > top