dymokomi/luce-svg
Source of release 0.9.1
0.9.1 / src / svg / render_more.lucb
#==============================================================================================
#
# svg/render_more - Drawing images and pattern tiles
#
#==============================================================================================
extend Renderer:
## An image: its raster's rectangle filled with the raster, edges padded.
func image(item: const Item*, transform: Matrix, canvas: Canvas*) -> !:
if not item.visible:
return
let raster = self.picture.rasters.items[item.raster]
var tile = try Canvas.make(0, 0, raster.width, raster.height)
defer tile.release()
for index in 0..<raster.width * raster.height:
let at = index * 4
let alpha = (f64)raster.pixels[at + 3] / 255.0
for channel in 0..<(usize)3:
var value = (f64)raster.pixels[at + channel] / 255.0
if self.linear:
value = transfer.srgb_decode(value)
tile.pixels[at + channel] = (f32)(value * alpha)
tile.pixels[at + 3] = (f32)alpha
let inverse = invert(transform) else return
var area = Path()
defer area.release()
try area.rect(0.0, 0.0, (f64)raster.width, (f64)raster.height)
self.lines.clear()
try flatten(&area, transform, 1.0, &self.lines)
self.cover.outline(&self.lines)
if not self.cover.resolve(false, false):
return
let nearest = item.pixelated or (math.abs(transform.a - 1.0) < 1e-6 and math.abs(transform.b) < 1e-6 and math.abs(transform.c) < 1e-6 and math.abs(transform.d - 1.0) < 1e-6)
let shader = Shader(kind = BrushKind.pattern, linear = self.linear, inverse = inverse, tile = &tile, nearest = nearest, pad = true)
paint_coverage(canvas, &self.cover, &shader)
## The shader of pattern brush `brush` for `item` under `transform`: the tile drawn
## at the device's scale into `self.tile`, as resvg draws it, and repeated.
func pattern_shader(brush: Brush, item: const Item*, transform: Matrix) -> Shader?!:
let pattern = self.picture.patterns.items[brush.server]
var rect = pattern.rect
var content = Matrix()
let base = self.context_transform if brush.context else transform
if pattern.bbox_units or pattern.content_bbox_units:
let box = (self.context_box if brush.context else self.item_box(item)) else return none
if not (box.w > 0.0) or not (box.h > 0.0):
return none
if pattern.bbox_units:
rect = rect_in_bbox(rect, box)
if pattern.content_bbox_units:
content = Matrix(a = box.w, d = box.h)
if let view = pattern.view_box:
content = view_box_transform(view, pattern.aspect, rect.w, rect.h)
let pattern_space = multiply(base, pattern.transform)
let (sx, sy) = axis_scales(pattern_space)
let tile_w = math.round(rect.w * sx)
let tile_h = math.round(rect.h * sy)
if not (tile_w >= 1.0) or not (tile_h >= 1.0) or tile_w * tile_h > 16777216.0:
return none
self.tile.release()
self.tile = try Canvas.make(0, 0, (usize)tile_w, (usize)tile_h)
var tiler = try Renderer.make(self.picture, (usize)tile_w, (usize)tile_h, self.linear)
defer tiler.release()
try tiler.children(pattern.root, multiply(Matrix(a = sx, d = sy), content), &self.tile)
let to_tile = multiply(multiply(pattern_space, Matrix(e = rect.x, f = rect.y)), Matrix(a = 1.0 / sx, d = 1.0 / sy))
let inverse = invert(to_tile) else return none
let nearest = math.abs(to_tile.a - 1.0) < 1e-6 and math.abs(to_tile.b) < 1e-6 and math.abs(to_tile.c) < 1e-6 and math.abs(to_tile.d - 1.0) < 1e-6
return Shader(kind = BrushKind.pattern, opacity = brush.opacity, linear = self.linear, inverse = inverse, tile = &self.tile, nearest = nearest)