Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-svg

Source of release 0.9.2

0.9.2 / 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)