Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-image

Source of release 0.45.1

0.45.1 / src / style.lucb

## Layer styles: the effects a layer's `Style` asks for, rendered for the
## compositor. The layer is flattened into one document-sized texture, its
## alpha blurred (shadows, glow), dilated (the stroke outside) or eroded (the
## stroke inside) in separable passes over that texture, and `style.frag`
## writes, per cell, what goes under the layer and — when the style has
## effects inside it — the layer recolored by them.
from luce_gpu import gpu
from luce_std import math
import memory
from luce_canvas.tiles import Tiles, tile_size, flatten
from document import Document, Layer, Style
from shaders import spread_frag_words, spread_frag_msl, style_frag_words, style_frag_msl
from luce_raster.errors import invalid, limit

## The most pixels a styled layer's document may have: four whole-document textures are held while rendering.
pub let style_pixel_limit: usize = 4096 * 4096

## The spread passes: a blur, a dilation, an erosion.
let blurred: f64 = 0.0
let dilated: f64 = 1.0
let eroded_mode: f64 = 2.0

## A style rendered: the tiles under the layer, and the layer recolored when
## its style changes its own colors (`has_over`).
pub struct Rendered:
    pub var under: Tiles
    pub var over: Tiles
    pub var has_over: bool

    pub func destroy():
        self.under.destroy()
        if self.has_over:
            self.over.destroy()

pub struct Styler:
    var spread_shader: gpu.Shader
    var spread: gpu.Pipeline
    var style_shader: gpu.Shader
    var style: gpu.Pipeline

    pub static func create(device: gpu.Device) -> Styler!:
        var spread_shader = try gpu.Shader.create(device, spread_frag_words, spread_frag_msl)
        errdefer spread_shader.destroy()
        var spread = try gpu.Pipeline.create(device, spread_shader, gpu.Blend.replace, gpu.Format.rgba16_float)
        errdefer spread.destroy()
        var style_shader = try gpu.Shader.create(device, style_frag_words, style_frag_msl)
        errdefer style_shader.destroy()
        var style = try gpu.Pipeline.create(device, style_shader, gpu.Blend.replace, gpu.Format.rgba16_float)
        errdefer style.destroy()
        return Styler(spread_shader = spread_shader, spread = spread, style_shader = style_shader, style = style)

    ## The effects `layer`'s style asks for, freshly rendered: the tiles drawn
    ## under its pixels, and the layer recolored by what goes inside it when
    ## anything does, their colors mixed as sRGB-encoded values with `srgb`.
    ## The caller owns them.
    pub func render(layer: const Layer*, srgb: bool) -> Rendered!:
        let tiles = layer.tiles() else error(invalid, "a group has no pixels to style")
        let style = layer.style
        let width = tiles.width()
        let height = tiles.height()
        if (usize)width * (usize)height > style_pixel_limit:
            error(limit, "layer styles work on documents up to 4096 by 4096 pixels")
        # The layer as one texture; every texture here lives on the tiles' device.
        let device = tiles.device()
        var flat = try flatten(device, tiles)
        defer flat.destroy()
        # How far the stroke reaches outside the edge and inside it, by its position.
        let outside = 0.0 if not style.stroke or style.stroke_position > 1.5 else (style.stroke_size * 0.5 if style.stroke_position > 0.5 else style.stroke_size)
        let inside = 0.0 if not style.stroke or style.stroke_position < 0.5 else (style.stroke_size * 0.5 if style.stroke_position < 1.5 else style.stroke_size)
        var under = try Tiles.create(device, width, height)
        errdefer under.destroy()
        if style.under():
            var shadow = try self.spread_alpha(device, flat, width, height, style.shadow_blur if style.shadow else 0.0, blurred)
            defer shadow.destroy()
            var stroke = try self.spread_alpha(device, flat, width, height, outside, dilated)
            defer stroke.destroy()
            var glow = try self.spread_alpha(device, flat, width, height, style.glow_size * 0.5 if style.glow else 0.0, blurred)
            defer glow.destroy()
            var params: f32[22] = [0.0, 0.0, (f32)width, (f32)height, 0.0,
                                   1.0 if style.shadow else 0.0, (f32)style.shadow_dx, (f32)style.shadow_dy, (f32)style.shadow_red, (f32)style.shadow_green, (f32)style.shadow_blue, (f32)style.shadow_opacity,
                                   1.0 if outside > 0.0 else 0.0, (f32)style.stroke_red, (f32)style.stroke_green, (f32)style.stroke_blue, (f32)style.stroke_opacity,
                                   1.0 if style.glow else 0.0, (f32)style.glow_red, (f32)style.glow_green, (f32)style.glow_blue, (f32)style.glow_opacity]
            try self.draw(&under, params, [flat, shadow, stroke, glow], srgb)
        if not style.over():
            return Rendered(under = under, over = Tiles(), has_over = false)
        var inner = try self.spread_alpha(device, flat, width, height, style.inner_blur if style.inner else 0.0, blurred)
        defer inner.destroy()
        var eroded = try self.spread_alpha(device, flat, width, height, inside, eroded_mode)
        defer eroded.destroy()
        var over = try Tiles.create(device, width, height)
        errdefer over.destroy()
        var params: f32[22] = [0.0, 0.0, (f32)width, (f32)height, 1.0,
                               1.0 if style.inner else 0.0, (f32)style.inner_dx, (f32)style.inner_dy, (f32)style.inner_red, (f32)style.inner_green, (f32)style.inner_blue, (f32)style.inner_opacity,
                               1.0 if inside > 0.0 else 0.0, (f32)style.stroke_red, (f32)style.stroke_green, (f32)style.stroke_blue, (f32)style.stroke_opacity,
                               1.0 if style.overlay and not style.inner_glow else 0.0, (f32)style.overlay_red, (f32)style.overlay_green, (f32)style.overlay_blue, (f32)style.overlay_opacity]
        if style.inner_glow:
            # An inner glow goes first, over the overlay and under the inner shadow
            # and stroke (Photoshop's order); its result is the second pass's base.
            var glowed = try self.inner_glow(device, flat, eroded, width, height, style, srgb)
            defer glowed.destroy()
            try self.draw(&over, params, [glowed, inner, eroded, flat], srgb)
        else:
            try self.draw(&over, params, [flat, inner, eroded, flat], srgb)
        return Rendered(under = under, over = over, has_over = true)

    ## The layer with its overlay and inner glow on it, as one texture: the
    ## inward pass with no offset and the glow's color.
    func inner_glow(device: gpu.Device, flat: gpu.Texture, eroded: gpu.Texture, width: u32, height: u32, style: Style, srgb: bool) -> gpu.Texture!:
        var spread = try self.spread_alpha(device, flat, width, height, style.inner_glow_size * 0.5, blurred)
        defer spread.destroy()
        let params: f32[22] = [0.0, 0.0, (f32)width, (f32)height, 1.0,
                               1.0, 0.0, 0.0, (f32)style.inner_glow_red, (f32)style.inner_glow_green, (f32)style.inner_glow_blue, (f32)style.inner_glow_opacity,
                               0.0, 0.0, 0.0, 0.0, 0.0,
                               1.0 if style.overlay else 0.0, (f32)style.overlay_red, (f32)style.overlay_green, (f32)style.overlay_blue, (f32)style.overlay_opacity]
        var glowed = try Tiles.create(device, width, height)
        defer glowed.destroy()
        try self.draw(&glowed, params, [flat, spread, eroded, flat], srgb)
        return try flatten(device, &glowed)

    ## Every cell of `tiles` drawn by `style.frag` with `params` (the cell's
    ## origin filled in) from `images`, mixing encoded values with `srgb`.
    func draw(tiles: Tiles*, params: f32[22], images: gpu.Texture[4], srgb: bool) -> !:
        var values: f32[24]
        for index in 0..<(usize)22:
            values[index] = params[index]
        values[22] = 1.0 if srgb else 0.0
        values[23] = 0.0
        for row in 0..<tiles.rows():
            for column in 0..<tiles.columns():
                values[0] = (f32)(column * tile_size)
                values[1] = (f32)(row * tile_size)
                var fresh = try tiles.blank()
                errdefer fresh.destroy()
                let frame = try fresh.frame()
                defer frame.release()
                let target = try frame.value().target()
                defer target.release()
                try gpu.shade(target.value(), self.style, gpu.Rect(width = (f64)tile_size, height = (f64)tile_size), u8[]((u8*)&values[0], 96), images, gpu.Filter.nearest)
                _ = try frame.value().present(gpu.Color(0.0, 0.0, 0.0, 0.0))
                try tiles.set(column, row, fresh)

    ## `source`'s alpha spread by `amount` pixels in both axes: a Gaussian of
    ## that sigma (`blurred`), a dilation (`dilated`) or an erosion
    ## (`eroded_mode`). Zero amount copies the alpha.
    func spread_alpha(device: gpu.Device, source: gpu.Texture, width: u32, height: u32, amount: f64, mode: f64) -> gpu.Texture!:
        let clamped = math.clamp(amount, 0.0, 250.0)
        let taps = math.ceil(clamped) if mode > 0.5 else math.min(255.0, math.ceil(clamped * 3.0))
        var horizontal = try self.pass(device, source, width, height, taps, clamped, true, mode)
        errdefer horizontal.destroy()
        var vertical = try self.pass(device, horizontal, width, height, taps, clamped, false, mode)
        horizontal.destroy()
        return vertical

    func pass(device: gpu.Device, source: gpu.Texture, width: u32, height: u32, taps: f64, sigma: f64, horizontal: bool, mode: f64) -> gpu.Texture!:
        var output = try gpu.Texture.create(device, width, height, gpu.Format.rgba16_float)
        errdefer output.destroy()
        var params: f32[6] = [(f32)taps, (f32)math.max(sigma, 0.001), 1.0 if horizontal else 0.0, (f32)mode, (f32)width, (f32)height]
        let frame = try output.frame()
        defer frame.release()
        let target = try frame.value().target()
        defer target.release()
        try gpu.shade(target.value(), self.spread, gpu.Rect(width = (f64)width, height = (f64)height), u8[]((u8*)&params[0], 24), [source], gpu.Filter.nearest)
        _ = try frame.value().present(gpu.Color(0.0, 0.0, 0.0, 0.0))
        return output

    pub func destroy():
        self.style.destroy()
        self.style_shader.destroy()
        self.spread.destroy()
        self.spread_shader.destroy()

test "a drop shadow, glow and stroke appear around a layer's pixels":
    var device = gpu.Device.open() catch failure:
        assert(failure.code == gpu.unavailable)
        return
    defer device.destroy()
    let count = (usize)128 * 128 * 4
    let pixels = try new f32[count] --- in memory.heap
    defer free(pixels) in memory.heap
    for index in 0..<count:
        pixels[index] = 0.0
    for y in 40..<(usize)88:
        for x in 40..<(usize)88:
            pixels[(y * 128 + x) * 4] = 1.0
            pixels[(y * 128 + x) * 4 + 3] = 1.0
    var document = try Document.create(device, 128, 128)
    defer document.destroy()
    let id = try document.add_layer("Square")
    var tiles = try Tiles.create(device, 128, 128)
    try tiles.write(pixels)
    try document.set_tiles(id, tiles)
    let layer = document.find(id) else trap("layer")
    var styler = try Styler.create(device)
    defer styler.destroy()
    layer.style.shadow = true
    layer.style.shadow_dx = 10.0
    layer.style.shadow_dy = 10.0
    layer.style.shadow_blur = 2.0
    var effects = try styler.render(layer, true)
    try effects.under.read(pixels)
    # Black shadow shows past the square's bottom-right; nothing at the top-left.
    let shadowed = (94 * 128 + 94) * 4
    assert(pixels[shadowed + 3] > 0.5 and pixels[shadowed] < 0.05 and not effects.has_over)
    assert(pixels[(30 * 128 + 30) * 4 + 3] == 0.0)
    effects.destroy()
    layer.style.shadow = false
    layer.style.stroke = true
    layer.style.stroke_size = 4.0
    layer.style.stroke_green = 1.0
    effects = try styler.render(layer, true)
    try effects.under.read(pixels)
    # A green stroke just outside the square, none inside or far away.
    assert(pixels[(64 * 128 + 90) * 4 + 3] > 0.9 and pixels[(64 * 128 + 90) * 4 + 1] > 0.9)
    assert(pixels[(64 * 128 + 64) * 4 + 3] == 0.0 and pixels[(64 * 128 + 100) * 4 + 3] == 0.0)
    effects.destroy()
    # Inside the edge instead: the square's own border turns green, its middle stays red, nothing outside.
    layer.style.stroke_position = 2.0
    effects = try styler.render(layer, true)
    assert(effects.has_over)
    try effects.over.read(pixels)
    assert(pixels[(64 * 128 + 86) * 4 + 1] > 0.9 and pixels[(64 * 128 + 86) * 4] < 0.1 and pixels[(64 * 128 + 86) * 4 + 3] > 0.99)
    assert(pixels[(64 * 128 + 64) * 4] > 0.99 and pixels[(64 * 128 + 64) * 4 + 1] < 0.01)
    try effects.under.read(pixels)
    assert(pixels[(64 * 128 + 90) * 4 + 3] == 0.0)
    effects.destroy()
    layer.style.stroke = false
    layer.style.glow = true
    layer.style.glow_size = 12.0
    effects = try styler.render(layer, true)
    try effects.under.read(pixels)
    assert(pixels[(64 * 128 + 92) * 4 + 3] > 0.1 and pixels[(64 * 128 + 92) * 4] > 0.9)
    effects.destroy()
    # A blue overlay recolors the square, alpha kept; an inner shadow darkens its top-left inside edge.
    layer.style.glow = false
    layer.style.overlay = true
    layer.style.overlay_red = 0.0
    layer.style.overlay_blue = 1.0
    layer.style.inner = true
    layer.style.inner_dx = 6.0
    layer.style.inner_dy = 6.0
    layer.style.inner_blur = 0.0
    layer.style.inner_opacity = 1.0
    effects = try styler.render(layer, true)
    try effects.over.read(pixels)
    assert(pixels[(70 * 128 + 70) * 4 + 2] > 0.99 and pixels[(70 * 128 + 70) * 4 + 3] > 0.99)
    assert(pixels[(42 * 128 + 42) * 4 + 2] < 0.05 and pixels[(42 * 128 + 42) * 4 + 3] > 0.99)
    assert(pixels[(30 * 128 + 30) * 4 + 3] == 0.0)
    effects.destroy()
    # An inner glow lights the square's edge from inside, over the blue overlay
    # (mixed as encoded values: a third of the way to its color, 0.1 in linear
    # light); its middle stays blue.
    layer.style.inner = false
    layer.style.inner_glow = true
    layer.style.inner_glow_size = 8.0
    layer.style.inner_glow_opacity = 1.0
    effects = try styler.render(layer, true)
    try effects.over.read(pixels)
    assert(pixels[(64 * 128 + 41) * 4] > 0.08 and pixels[(64 * 128 + 41) * 4 + 3] > 0.99)
    assert(pixels[(64 * 128 + 64) * 4] < 0.05 and pixels[(64 * 128 + 64) * 4 + 2] > 0.99)
    effects.destroy()