Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-render

Source of release 0.6.1

0.6.1 / src / raster / highp_shaders.lucb

#==============================================================================================
#
#   highp_shaders - the shader stages of the high precision pipeline
#
#   DESCRIPTION:
#       Port of tiny-skia pipeline/highp.rs, part 3, as Skia m144's highp stages compute
#       them on NEON: the matrix stages, the x1 tiling stages of gradients, the gradient
#       stages (gradient lookup, evenly spaced gradients, sweep angle, radius and the
#       two-point conical gradient family with their masks) and tiny-skia's gamma stages.
#
#       Copyright (c) 2018 Google Inc. All rights reserved.
#       Copyright (c) 2020 Yevhenii Reizner All rights reserved.
#       SPDX-License-Identifier: BSD-3-Clause (see LICENSE-skia, LICENSE-tiny-skia)
#
#==============================================================================================

# matrix_2x3 (matrix_translate and matrix_scale_translate compute the same values).
func highp_transform(p: HighpPipeline*):
    let ts = p.ctx.transform

    let tr = highp_mad(p.r, f8_splat(ts.sx), highp_mad(p.g, f8_splat(ts.kx), f8_splat(ts.tx)))
    let tg = highp_mad(p.r, f8_splat(ts.ky), highp_mad(p.g, f8_splat(ts.sy), f8_splat(ts.ty)))
    p.r = tr
    p.g = tg

    highp_next_stage(p)

# matrix_perspective: the row-major 3x3 matrix, then the divide by its z.
func highp_transform_perspective(p: HighpPipeline*):
    let m = p.ctx.transform

    let tr = highp_mad(p.r, f8_splat(m.sx), highp_mad(p.g, f8_splat(m.kx), f8_splat(m.tx)))
    let tg = highp_mad(p.r, f8_splat(m.ky), highp_mad(p.g, f8_splat(m.sy), f8_splat(m.ty)))
    let tz = highp_mad(p.r, f8_splat(m.persp0), highp_mad(p.g, f8_splat(m.persp1), f8_splat(m.persp2)))
    p.r = f8_mul(tr, f8_rcp_precise(tz))
    p.g = f8_mul(tg, f8_rcp_precise(tz))

    highp_next_stage(p)

## matrix_perspective on one point: (x, y) through the row-major 3x3 matrix `ts`, divided
## by its z with NEON's rcp_precise, as the stage computes each lane.
pub func perspective_sample_point(ts: Transform, x: f32, y: f32) -> Point:
    let r = math32.fma(x, ts.sx, math32.fma(y, ts.kx, ts.tx))
    let g = math32.fma(x, ts.ky, math32.fma(y, ts.sy, ts.ty))
    let z = math32.fma(x, ts.persp0, math32.fma(y, ts.persp1, ts.persp2))
    let rcp = f4_rcp_precise(f32[4](z))[0]
    return Point.from_xy(r * rcp, g * rcp)

# matrix_scale_translate with a unit y scale (y = y * 1 + 0 is y).
func highp_scale_translate_x(p: HighpPipeline*):
    let m = p.ctx.scale_translate_x
    p.r = highp_mad(p.r, f8_splat(m.sx), f8_splat(m.tx))

    highp_next_stage(p)

# Clamp x to [0,1], both sides inclusive (think, gradients). Even repeat and mirror funnel
# through a clamp to handle bad inputs like +Inf, NaN.

func highp_clamp_x_1(p: HighpPipeline*):
    p.r = f8_clamp_01(p.r)

    highp_next_stage(p)

func highp_mirror_x_1(p: HighpPipeline*):
    let one = f8_splat(1.0)
    let x = f8_sub(p.r, one)
    p.r = f8_clamp_01(f8_abs(f8_sub(f8_sub(x, highp_two(f8_vfloor(f8_mul(x, f8_splat(0.5))))), one)))

    highp_next_stage(p)

func highp_repeat_x_1(p: HighpPipeline*):
    p.r = f8_clamp_01(f8_sub(p.r, f8_vfloor(p.r)))

    highp_next_stage(p)

func highp_gradient(p: HighpPipeline*):
    let ctx = &p.ctx.gradient

    # N.B. The loop starts at 1 because idx 0 is the color to use before the first stop.
    var idx: M8 = [u32[4](0), u32[4](0)]
    for i in 1..<ctx.len:
        let tt = ctx.t_values.data[i]
        for h: usize in 0..<2:
            for l: usize in 0..<4:
                idx[h][l] +%= (u32)(p.r[h][l] >= tt)
    gradient_lookup(ctx, idx, p.r, &p.r, &p.g, &p.b, &p.a)

    highp_next_stage(p)

func highp_evenly_spaced_gradient(p: HighpPipeline*):
    let ctx = &p.ctx.gradient

    let scale = (f32)(ctx.len - 1)
    var idx: M8 = ---
    for h: usize in 0..<2:
        for l: usize in 0..<4:
            idx[h][l] = (u32)f32_trunc_i32(p.r[h][l] * scale)
    gradient_lookup(ctx, idx, p.r, &p.r, &p.g, &p.b, &p.a)

    highp_next_stage(p)

## The stops' factors and biases at `idx`, then mad(t, factor, bias). An index past the
## context (Skia reads beyond its arrays then) is clamped.
func gradient_lookup(ctx: const GradientCtx*, idx: M8, t: F8, r: F8*, g: F8*, b: F8*, a: F8*):
    let factors = ctx.factors.view()
    let biases = ctx.biases.view()
    let last = (u32)factors.length - 1
    var fr: F8 = ---
    var fg: F8 = ---
    var fb: F8 = ---
    var fa: F8 = ---
    var br: F8 = ---
    var bg: F8 = ---
    var bb: F8 = ---
    var ba: F8 = ---
    for h: usize in 0..<2:
        for l: usize in 0..<4:
            let i = (usize)(idx[h][l] if idx[h][l] < last else last)
            let f = factors[i]
            let bias = biases[i]
            fr[h][l] = f.r
            fg[h][l] = f.g
            fb[h][l] = f.b
            fa[h][l] = f.a
            br[h][l] = bias.r
            bg[h][l] = bias.g
            bb[h][l] = bias.b
            ba[h][l] = bias.a

    *r = highp_mad(t, fr, br)
    *g = highp_mad(t, fg, bg)
    *b = highp_mad(t, fb, bb)
    *a = highp_mad(t, fa, ba)

func highp_evenly_spaced_2_stop_gradient(p: HighpPipeline*):
    let ctx = p.ctx.evenly_spaced_2_stop_gradient

    let t = p.r
    p.r = highp_mad(t, f8_splat(ctx.factor.r), f8_splat(ctx.bias.r))
    p.g = highp_mad(t, f8_splat(ctx.factor.g), f8_splat(ctx.bias.g))
    p.b = highp_mad(t, f8_splat(ctx.factor.b), f8_splat(ctx.bias.b))
    p.a = highp_mad(t, f8_splat(ctx.factor.a), f8_splat(ctx.bias.a))

    highp_next_stage(p)

func highp_xy_to_unit_angle(p: HighpPipeline*):
    let x = p.r
    let y = p.g
    let x_abs = f8_abs(x)
    let y_abs = f8_abs(y)
    let slope = f8_div(f8_vmin(x_abs, y_abs), f8_vmax(x_abs, y_abs))
    let s = f8_mul(slope, slope)
    # Use a 7th degree polynomial to approximate atan.
    # This was generated using sollya.gforge.inria.fr.
    # A float optimized polynomial was generated using the following command.
    # P1 = fpminimax((1/(2*Pi))*atan(x),[|1,3,5,7|],[|24...|],[2^(-40),1],relative);
    var phi = f8_mul(slope, f8_add(f8_splat(0.15912117063999176025390625), f8_mul(s, f8_add(f8_splat(-5.185396969318389892578125e-2), f8_mul(s, f8_add(f8_splat(2.476101927459239959716796875e-2), f8_mul(s, f8_splat(-7.0547382347285747528076171875e-3))))))))
    phi = f8_blend(f8_cmp_lt(x_abs, y_abs), f8_sub(f8_splat(0.25), phi), phi)
    phi = f8_blend(f8_cmp_lt(x, f8_splat(0.0)), f8_sub(f8_splat(0.5), phi), phi)
    phi = f8_blend(f8_cmp_lt(y, f8_splat(0.0)), f8_sub(f8_splat(1.0), phi), phi)
    phi = f8_blend(f8_cmp_ne(phi, phi), f8_splat(0.0), phi)  # Check for NaN.
    p.r = phi
    highp_next_stage(p)

func highp_xy_to_radius(p: HighpPipeline*):
    let x2 = f8_mul(p.r, p.r)
    let y2 = f8_mul(p.g, p.g)
    p.r = f8_sqrt(f8_add(x2, y2))

    highp_next_stage(p)

# Please see https://skia.org/dev/design/conical for how our 2pt conical shader works.

func highp_xy_to_2pt_conical_focal_on_circle(p: HighpPipeline*):
    let x = p.r
    let y = p.g
    p.r = f8_add(x, f8_div(f8_mul(y, y), x))

    highp_next_stage(p)

func highp_xy_to_2pt_conical_well_behaved(p: HighpPipeline*):
    let ctx = p.ctx.two_point_conical_gradient

    let x = p.r
    let y = p.g
    p.r = f8_sub(f8_sqrt(f8_add(f8_mul(x, x), f8_mul(y, y))), f8_mul(x, f8_splat(ctx.p0)))

    highp_next_stage(p)

func highp_xy_to_2pt_conical_greater(p: HighpPipeline*):
    let ctx = p.ctx.two_point_conical_gradient

    let x = p.r
    let y = p.g
    p.r = f8_sub(f8_sqrt(f8_sub(f8_mul(x, x), f8_mul(y, y))), f8_mul(x, f8_splat(ctx.p0)))

    highp_next_stage(p)

func highp_xy_to_2pt_conical_smaller(p: HighpPipeline*):
    let ctx = p.ctx.two_point_conical_gradient

    let x = p.r
    let y = p.g
    p.r = f8_sub(f8_neg(f8_sqrt(f8_sub(f8_mul(x, x), f8_mul(y, y)))), f8_mul(x, f8_splat(ctx.p0)))

    highp_next_stage(p)

func highp_xy_to_2pt_conical_strip(p: HighpPipeline*):
    let ctx = p.ctx.two_point_conical_gradient

    let x = p.r
    let y = p.g
    p.r = f8_add(x, f8_sqrt(f8_sub(f8_splat(ctx.p0), f8_mul(y, y))))

    highp_next_stage(p)

func highp_mask_2pt_conical_nan(p: HighpPipeline*):
    let t = p.r
    let is_degenerate = f8_cmp_ne(t, t)
    p.r = f8_blend(is_degenerate, f8_splat(0.0), t)
    p.ctx.two_point_conical_gradient.mask = cond_to_mask(m8_not(is_degenerate))

    highp_next_stage(p)

func highp_mask_2pt_conical_degenerates(p: HighpPipeline*):
    let t = p.r
    let is_degenerate = m8_or(f8_cmp_le(t, f8_splat(0.0)), f8_cmp_ne(t, t))
    p.r = f8_blend(is_degenerate, f8_splat(0.0), t)
    p.ctx.two_point_conical_gradient.mask = cond_to_mask(m8_not(is_degenerate))

    highp_next_stage(p)

func highp_apply_vector_mask(p: HighpPipeline*):
    let mask = p.ctx.two_point_conical_gradient.mask

    p.r = f8_from_bits(m8_and(f8_to_bits(p.r), mask))
    p.g = f8_from_bits(m8_and(f8_to_bits(p.g), mask))
    p.b = f8_from_bits(m8_and(f8_to_bits(p.b), mask))
    p.a = f8_from_bits(m8_and(f8_to_bits(p.a), mask))

    highp_next_stage(p)

func highp_alter_2pt_conical_compensate_focal(p: HighpPipeline*):
    let ctx = p.ctx.two_point_conical_gradient

    p.r = f8_add(p.r, f8_splat(ctx.p1))

    highp_next_stage(p)

func highp_alter_2pt_conical_unswap(p: HighpPipeline*):
    p.r = f8_sub(f8_splat(1.0), p.r)

    highp_next_stage(p)

func highp_negate_x(p: HighpPipeline*):
    p.r = f8_neg(p.r)

    highp_next_stage(p)

func highp_gamma_expand_2(p: HighpPipeline*):
    p.r = f8_mul(p.r, p.r)
    p.g = f8_mul(p.g, p.g)
    p.b = f8_mul(p.b, p.b)

    highp_next_stage(p)

func highp_gamma_expand_dst_2(p: HighpPipeline*):
    p.dr = f8_mul(p.dr, p.dr)
    p.dg = f8_mul(p.dg, p.dg)
    p.db = f8_mul(p.db, p.db)

    highp_next_stage(p)

func highp_gamma_compress_2(p: HighpPipeline*):
    p.r = f8_sqrt(p.r)
    p.g = f8_sqrt(p.g)
    p.b = f8_sqrt(p.b)

    highp_next_stage(p)

func highp_gamma_expand_22(p: HighpPipeline*):
    p.r = f8_powf(p.r, 2.2)
    p.g = f8_powf(p.g, 2.2)
    p.b = f8_powf(p.b, 2.2)

    highp_next_stage(p)

func highp_gamma_expand_dst_22(p: HighpPipeline*):
    p.dr = f8_powf(p.dr, 2.2)
    p.dg = f8_powf(p.dg, 2.2)
    p.db = f8_powf(p.db, 2.2)

    highp_next_stage(p)

func highp_gamma_compress_22(p: HighpPipeline*):
    p.r = f8_powf(p.r, 0.45454545)
    p.g = f8_powf(p.g, 0.45454545)
    p.b = f8_powf(p.b, 0.45454545)

    highp_next_stage(p)

func srgb_expand(x: F8) -> F8:
    let small = f8_cmp_le(x, f8_splat(0.04045))
    let linear = f8_div(x, f8_splat(12.92))
    let exp = f8_powf(f8_div(f8_add(x, f8_splat(0.055)), f8_splat(1.055)), 2.4)
    return f8_blend(small, linear, exp)

func srgb_compress(x: F8) -> F8:
    let small = f8_cmp_le(x, f8_splat(0.0031308))
    let linear = f8_mul(x, f8_splat(12.92))
    let exp = f8_sub(f8_mul(f8_powf(x, 0.416666666), f8_splat(1.055)), f8_splat(0.055))
    return f8_blend(small, linear, exp)

func highp_gamma_expand_srgb(p: HighpPipeline*):
    p.r = srgb_expand(p.r)
    p.g = srgb_expand(p.g)
    p.b = srgb_expand(p.b)

    highp_next_stage(p)

func highp_gamma_expand_dst_srgb(p: HighpPipeline*):
    p.dr = srgb_expand(p.dr)
    p.dg = srgb_expand(p.dg)
    p.db = srgb_expand(p.db)

    highp_next_stage(p)

func highp_gamma_compress_srgb(p: HighpPipeline*):
    p.r = srgb_compress(p.r)
    p.g = srgb_compress(p.g)
    p.b = srgb_compress(p.b)

    highp_next_stage(p)

func cond_to_mask(cond: M8) -> M8:
    var m: M8 = ---
    for h: usize in 0..<2:
        for l: usize in 0..<4:
            m[h][l] = all_ones if cond[h][l] != 0 else 0
    return m