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