Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-svg

Source of release 0.9.2

0.9.2 / src / svg / render_scene.lucb

#==============================================================================================
#
#   svg/render_scene - Drawing a picture's render tree
#
#   DESCRIPTION:
#       Walks the items of a Picture: a shape is flattened, rasterised into coverage
#       (its fill by its fill rule, its stroke through the stroker) and painted; a group
#       that needs isolation is drawn into a layer of its own, which its filters, clip
#       path and mask then shape before it composites onto its parent with its opacity
#       and blend mode, as resvg does. A clip path is the union of its shapes' coverage,
#       intersected with its own clip path; a mask is its content drawn in a layer,
#       limited to its region and turned into coverage by luminance or alpha.
#
#==============================================================================================

## The state of drawing into canvases of one size.
struct Renderer:
    var picture: const Picture*
    var cover: Coverage
    var lines: Polylines = Polylines()
    var linear: bool = false
    ## The tile of the pattern being painted with, if any.
    var tile: Canvas = Canvas()
    ## The innermost context element's transform and box, for context paints.
    var context_transform: Matrix = Matrix()
    var context_box: Rect? = none

    static func make(picture: const Picture*, width: usize, height: usize, linear: bool) -> Renderer!:
        return Renderer(picture = picture, cover = try Coverage.make(width, height), linear = linear)

    func release():
        self.cover.release()
        self.lines.release()
        self.tile.release()

    # mark: Traversal ===========================================================================

    ## Draw the children of group `group` under `transform`.
    func children(group: u32, transform: Matrix, canvas: Canvas*) -> !:
        var child = self.picture.items.items[group].first
        while child != 0:
            try self.item(child, transform, canvas)
            child = self.picture.items.items[child].next

    func item(index: u32, transform: Matrix, canvas: Canvas*) -> !:
        let item = self.picture.items.items[index]
        match item.kind:
            .shape:
                try self.shape(&item, transform, canvas)
            .image:
                try self.image(&item, transform, canvas)
            .group:
                try self.group(index, transform, canvas)

    ## A group: drawn straight into `canvas` unless it needs a layer of its own.
    func group(index: u32, parent_transform: Matrix, canvas: Canvas*) -> !:
        let item = self.picture.items.items[index]
        let transform = multiply(parent_transform, item.transform)
        let saved_transform = self.context_transform
        let saved_box = self.context_box
        defer:
            self.context_transform = saved_transform
            self.context_box = saved_box
        if item.context:
            self.context_transform = transform
            self.context_box = item.context_box
        let isolated = item.opacity < 1.0 or item.clip != 0 or item.mask != 0 or item.filter_count > 0 or item.blend != Blend.normal or item.isolate
        if not isolated:
            try self.children(index, transform, canvas)
            return
        if item.filter_count > 0:
            try self.filtered_group(index, transform, canvas)
            return
        var layer = try Canvas.make(canvas.x, canvas.y, canvas.width, canvas.height)
        defer layer.release()
        try self.children(index, transform, &layer)
        if item.clip != 0:
            try self.apply_clip(item.clip - 1, transform, &layer)
        if item.mask != 0:
            try self.apply_mask(item.mask - 1, transform, &layer)
        composite_layer(canvas, &layer, item.opacity, item.blend)

    # mark: Shapes ==============================================================================

    func shape(item: const Item*, transform: Matrix, canvas: Canvas*) -> !:
        if not item.visible:
            return
        if item.stroke_first:
            try self.stroke_shape(item, transform, canvas)
            try self.fill_shape(item, transform, canvas)
        else:
            try self.fill_shape(item, transform, canvas)
            try self.stroke_shape(item, transform, canvas)

    ## Rasterise the fill of `item` into the coverage; answer whether it touched anything.
    func fill_coverage(item: const Item*, evenodd: bool, transform: Matrix) -> bool!:
        self.lines.clear()
        try flatten(&self.picture.paths.items[item.path], transform, 1.0, &self.lines)
        self.cover.outline(&self.lines)
        return self.cover.resolve(evenodd, item.aliased)

    func fill_shape(item: const Item*, transform: Matrix, canvas: Canvas*) -> !:
        let fill = item.fill else return
        let shader = (try self.shader(fill.brush, item, transform)) else return
        if not try self.fill_coverage(item, fill.evenodd, transform):
            return
        paint_coverage(canvas, &self.cover, &shader)

    func stroke_shape(item: const Item*, transform: Matrix, canvas: Canvas*) -> !:
        let stroke = item.stroke else return
        let shader = (try self.shader(stroke.brush, item, transform)) else return
        let scale = max_stretch(transform)
        self.lines.clear()
        try flatten(&self.picture.paths.items[item.path], Matrix(), scale, &self.lines)
        let shape = StrokeShape(width = stroke.width, cap = stroke.cap, join = stroke.join, miter_limit = stroke.miter_limit,
                                dashes = self.picture.dashes.items[stroke.dash_start..<stroke.dash_start + stroke.dash_count],
                                dash_offset = stroke.dash_offset)
        var target = StrokeTarget(coverage = &self.cover, transform = transform, scale = scale)
        defer target.release()
        try stroke_lines(&self.lines, &shape, &target)
        if not self.cover.resolve(false, item.aliased):
            return
        paint_coverage(canvas, &self.cover, &shader)

    ## The shader `brush` makes for `item` drawn through `transform`, or none when it
    ## paints nothing (a bounding-box server on a shape without area).
    func shader(brush: Brush, item: const Item*, transform: Matrix) -> Shader?!:
        match brush.kind:
            .solid:
                return Shader(color = premultiplied(brush.color, brush.opacity, self.linear), linear = self.linear)
            .linear, .radial:
                let gradient = self.picture.gradients.items[brush.server]
                if gradient.radial and gradient.spread != Spread.hold and math.abs(gradient.r - gradient.fr) < 1e-9 and math.abs(gradient.cx - gradient.fx) + math.abs(gradient.cy - gradient.fy) < 1e-9:
                    return none
                var space = self.context_transform if brush.context else transform
                if gradient.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
                    space = multiply(space, bbox_matrix(box))
                space = multiply(space, gradient.transform)
                let inverse = invert(space) else return none
                let stops = self.picture.stops.items[gradient.stop_start..<gradient.stop_start + gradient.stop_count]
                return Shader(kind = brush.kind, opacity = brush.opacity, linear = self.linear, gradient = gradient, stops = stops, inverse = inverse)
            .pattern:
                return try self.pattern_shader(brush, item, transform)

    ## The box a shape's bounding-box paint servers measure.
    func item_box(item: const Item*) -> Rect?:
        if let box = item.paint_box:
            return box
        return self.picture.paths.items[item.path].bounds()

    # mark: Clip paths and masks ================================================================

    ## Scale `layer` by the coverage of clip path `index` under `transform`.
    func apply_clip(index: usize, transform: Matrix, layer: Canvas*) -> !:
        let mask = try new f32[layer.width * layer.height] in memory.heap
        defer free(mask) in memory.heap
        try self.clip_coverage(index, transform, mask)
        layer.multiply(mask)

    ## Fill `mask` with the coverage of clip path `index` (which it must start cleared).
    func clip_coverage(index: usize, transform: Matrix, mask: f32[]) -> !:
        let clip = self.picture.clips.items[index]
        try self.union_children(clip.root, multiply(transform, clip.transform), mask)
        if clip.clip != 0:
            let outer = try new f32[mask.length] in memory.heap
            defer free(outer) in memory.heap
            try self.clip_coverage(clip.clip - 1, transform, outer)
            for at in 0..<mask.length:
                mask[at] *= outer[at]

    ## Union the coverage of the shapes under `group` into `mask`.
    func union_children(group: u32, transform: Matrix, mask: f32[]) -> !:
        var child = self.picture.items.items[group].first
        while child != 0:
            let item = self.picture.items.items[child]
            match item.kind:
                .shape:
                    if item.visible:
                        let fill = item.fill else FillPaint()
                        if try self.fill_coverage(&item, fill.evenodd, transform):
                            self.union_region(mask)
                .group:
                    let inner = multiply(transform, item.transform)
                    if item.clip != 0:
                        let part = try new f32[mask.length] in memory.heap
                        defer free(part) in memory.heap
                        try self.union_children(child, inner, part)
                        let clip_part = try new f32[mask.length] in memory.heap
                        defer free(clip_part) in memory.heap
                        try self.clip_coverage(item.clip - 1, inner, clip_part)
                        for at in 0..<mask.length:
                            let c = part[at] * clip_part[at]
                            mask[at] = mask[at] + c - mask[at] * c
                    else:
                        try self.union_children(child, inner, mask)
                .image:
                    continue
            child = item.next

    ## Union the coverage's resolved region into `mask`.
    func union_region(mask: f32[]):
        let cover = &self.cover
        for row in cover.row0..<cover.row1:
            for column in cover.col0..<cover.col1:
                let at = row * cover.width + column
                let c = cover.values[at]
                mask[at] = mask[at] + c - mask[at] * c

    ## Scale `layer` by mask `index` under `transform`.
    func apply_mask(index: usize, transform: Matrix, layer: Canvas*) -> !:
        let mask = self.picture.masks.items[index]
        if self.picture.items.items[mask.root].first == 0:
            layer.clear()
            return
        var content = try Canvas.make(layer.x, layer.y, layer.width, layer.height)
        defer content.release()
        try self.children(mask.root, transform, &content)
        # Only the mask's region counts.
        var region = Path()
        defer region.release()
        try region.rect(mask.rect.x, mask.rect.y, mask.rect.w, mask.rect.h)
        self.lines.clear()
        try flatten(&region, transform, 1.0, &self.lines)
        self.cover.outline(&self.lines)
        let values = try new f32[layer.width * layer.height] in memory.heap
        defer free(values) in memory.heap
        if self.cover.resolve(false, false):
            for row in self.cover.row0..<self.cover.row1:
                for column in self.cover.col0..<self.cover.col1:
                    values[row * layer.width + column] = self.cover.values[row * self.cover.width + column]
        content.multiply(values)
        if mask.mask != 0:
            try self.apply_mask(mask.mask - 1, transform, layer)
        for at in 0..<values.length:
            let p = at * 4
            if mask.luminance:
                values[at] = (f32)self.luminance(content.pixels[p], content.pixels[p + 1], content.pixels[p + 2], content.pixels[p + 3])
            else:
                values[at] = content.pixels[p + 3]
        layer.multiply(values)

    ## The luminance-times-alpha of a premultiplied working-space pixel.
    func luminance(r: f32, g: f32, b: f32, a: f32) -> f64:
        if a <= 0.0:
            return 0.0
        var red = (f64)r
        var green = (f64)g
        var blue = (f64)b
        if self.linear:
            let alpha = (f64)a
            red = transfer.srgb_encode(red / alpha) * alpha
            green = transfer.srgb_encode(green / alpha) * alpha
            blue = transfer.srgb_encode(blue / alpha) * alpha
        return math.clamp(red * 0.2126 + green * 0.7152 + blue * 0.0722, 0.0, 1.0)