dymokomi/luce-image
Source of release 0.45.0
## 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*)¶ms[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()