Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-image

Source of release 0.45.1

0.45.1 / src / canvas / quick_mask.lucb

#==============================================================================================
#
#   canvas/quick_mask - Quick Mask: the selection painted as a mask
#
#   DESCRIPTION:
#       Entering Quick Mask puts the selection into the mask of a layer kept outside the
#       tree (Document.begin_quick): never composited, exported or saved, but found by its
#       id, so the brush, the eraser, fills, gradients and filters all paint it as they
#       paint any layer's mask: white selects, black masks, gray is partial. The selection
#       stops clipping meanwhile, and the view tints what is masked (`draw_quick_overlay`).
#       Leaving reads the mask back as the selection, a cell at a time, and takes the layer
#       down. Each way is one undo step, in Photoshop's order: Quick Mask, the strokes on
#       the mask, Exit Quick Mask. The document's states carry the layer (TreeState), so
#       undoing Exit Quick Mask brings the mode back with its mask as painted, and the
#       strokes before it undo on that mask; undoing Quick Mask takes the mode down.
#
#==============================================================================================

extend Canvas:
    ## Select › Quick Mask on: the selection becomes a mask the painting tools
    ## edit (white selects, black masks), one undo step.
    pub func enter_quick_mask() -> !:
        try self.require_open()
        try self.require_idle()
        let document = self.document else error(invalid, "draw the document once before using Quick Mask")
        if document.quick_layer() != none:
            return
        try self.remember_state("Quick Mask")
        let tiles = try quick_tiles_from(&self, &document.selection)
        _ = try document.begin_quick(tiles)

    ## Quick Mask off: the mask painted becomes the selection, one undo step.
    pub func exit_quick_mask() -> !:
        try self.require_open()
        try self.require_idle()
        let document = self.document else return
        let quick = document.quick_layer() else return
        let mask = quick.mask_tiles() else trap("Quick Mask's layer has a mask")
        let device = self.device else trap("Quick Mask without a device")
        let was_empty = document.selection.is_empty()
        var found = try Selection.create(self.extent_x, self.extent_y)
        errdefer found.destroy()
        var source = TilesSource(tiles = mask)
        # Where the mask has no tile it reveals: selected.
        try found.load(selection_sources.gpu_reader((void*)&source, device, tiles_cell_texture), 0, 255, Mode.replace)
        try self.remember_state("Exit Quick Mask")
        document.end_quick()
        # Nothing masked from nothing selected stays nothing selected.
        if was_empty and full(&found):
            found.clear()
        document.selection.destroy()
        document.selection = found

    pub func quick_mask() -> bool:
        let document = self.document else return false
        return document.quick_layer() != none

## The overlay's tint and strength, as Photoshop's default: red at half.
let quick_red: f32 = 1.0
let quick_opacity: f32 = 0.5

## The selection as a mask's tiles: a wholly selected cell has no tile (a mask
## reveals where it has none), a wholly masked one shares one black tile, the
## rest carry their coverage in red, green and blue, alpha one.
func quick_tiles_from(canvas: Canvas*, selection: const Selection*) -> Tiles!:
    let device = canvas.device else error(invalid, "draw the document once before using Quick Mask")
    var tiles = try Tiles.create(device, canvas.extent_x, canvas.extent_y)
    errdefer tiles.destroy()
    if selection.is_empty():
        # Nothing selected: nothing masked.
        return tiles
    var halves: u16[256]
    for value in 0..<(usize)256:
        halves[value] = to_half((f32)value / 255.0)
    let one = to_half(1.0)
    let bytes = try new u8[(usize)tile_size * (usize)tile_size * 8] --- in memory.heap
    defer free(bytes) in memory.heap
    var black_column: i64 = -1
    var black_row: u32 = 0
    for row in 0..<tiles.rows():
        for column in 0..<tiles.columns():
            let value = selection.cell_value(column, row)
            if value == 255:
                continue
            if value == 0 and black_column >= 0:
                try tiles.share(column, row, (u32)black_column, black_row)
                continue
            let area = tiles.region(column, row)
            let coverage = selection.cell_bytes(column, row)
            for y in 0..<(usize)area.height:
                for x in 0..<(usize)tile_size:
                    var covered: u8 = 0
                    if let cells = coverage:
                        covered = cells[y * (usize)tile_size + x]
                    let half = halves[(usize)covered]
                    let at = (y * (usize)tile_size + x) * 8
                    for channel in 0..<(usize)3:
                        bytes[at + channel * 2] = (u8)(half & 0xff)
                        bytes[at + channel * 2 + 1] = (u8)(half >> 8)
                    bytes[at + 6] = (u8)(one & 0xff)
                    bytes[at + 7] = (u8)(one >> 8)
            var texture = try tiles.blank()
            errdefer texture.destroy()
            try texture.upload(bytes[..<(usize)area.height * (usize)tile_size * 8], gpu.Region(0, 0, tile_size, area.height))
            try tiles.set(column, row, texture)
            if value == 0 and area.width == tile_size and area.height == tile_size:
                black_column = (i64)column
                black_row = row
    return tiles

## Take Quick Mask down without keeping it (the canvas closing).
func drop_quick_mask(canvas: Canvas*):
    let document = canvas.document else return
    document.end_quick()

## Whether every pixel is selected.
func full(selection: const Selection*) -> bool:
    if selection.is_empty():
        return false
    for row in 0..<tile_columns(selection.height()):
        for column in 0..<tile_columns(selection.width()):
            if selection.cell_value(column, row) != 255:
                return false
    return true

## Tint what Quick Mask masks over the document as `draw` drew it.
func draw_quick_overlay(canvas: Canvas*, target: interop.View[gpu.RenderTarget], rectangle: gpu.Rect, zoom: f64, offset_x: f64, offset_y: f64) -> !:
    let document = canvas.document else return
    let quick = document.quick_layer() else return
    let mask = quick.mask_tiles() else return
    try draw_matte(canvas, target, rectangle, zoom, offset_x, offset_y, mask, 0, true, [quick_red, 0.0, 0.0], quick_opacity)

## Cover what `coverage` leaves out (its red channel, a mask's or the
## selection's, its tiles `coverage_level` pyramid levels down: a preview's)
## with `color` at `opacity`, over the document as `draw` drew it, at the
## view's level, only the cells on screen. A cell without a tile is wholly
## covered in a mask (`mask`), wholly left out in a selection. In a document
## that blends in sRGB the matte mixes with the composite under it (and the
## checkerboard) as encoded values, as Photoshop's does.
func draw_matte(canvas: Canvas*, target: interop.View[gpu.RenderTarget], rectangle: gpu.Rect, zoom: f64, offset_x: f64, offset_y: f64,
                coverage: const Tiles*, coverage_level: u32, mask: bool, color: f32[3], opacity: f32) -> !:
    let checked = try target.get()
    let pipeline = try canvas.quick_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
    let placement = try checked.placement()
    let composer = canvas.composer else return
    let document = canvas.document else return
    let srgb = document.srgb_flag()
    let squares_x = (placement.x + rectangle.x + offset_x) * scale
    let squares_y = (placement.y + rectangle.y + offset_y) * scale
    let light_grey = canvas.checker_light
    let dark_grey = canvas.checker_dark
    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
            if mask and not (try coverage_here(composer, coverage, column, row, within)):
                # A mask reveals where it has no tile: nothing to cover.
                continue
            # What the matte mixes with, when it mixes encoded values: the
            # composite as the view shows it (fetched first: its request lets
            # go of what came before).
            var under = composer_blank(canvas)
            if srgb > 0.5:
                under = try composer.tile(document, column, row, level)
            let texture = (try composer.level_texture(coverage, column, row, within, mask)) else composer_blank(canvas)
            var params: f32[24] = [(f32)((placement.x + left) * scale), (f32)((placement.y + top) * scale), (f32)(zoom * step * scale), opacity,
                                   (f32)covered_x, (f32)covered_y, srgb, (f32)(canvas.checker_cell * scale), color[0], color[1], color[2], 1.0,
                                   (f32)squares_x, (f32)squares_y, 0.0, 0.0, light_grey, light_grey, light_grey, 1.0, dark_grey, dark_grey, dark_grey, 1.0]
            try gpu.shade(area, pipeline, gpu.Rect(left, top, width, height), u8[]((u8*)&params[0], 96), [texture, under],
                          gpu.Filter.nearest if zoom * step >= 1.0 else gpu.Filter.linear)

## Whether `coverage` has a tile in cell (`column`, `row`) at `level`.
func coverage_here(composer: Composer*, coverage: const Tiles*, column: u32, row: u32, level: u32) -> bool!:
    return (try composer.level_texture(coverage, column, row, level, true)) != none