Luce packages
LuceLuce BaseLuciaOS

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*)&params[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