@group(1) @binding(0) var<storage, read> b_path_vertices: array<PathRasterizationVertex>;
struct PathRasterizationVertex {
xy_position: vec2<f32>,
st_position: vec2<f32>,
color: Background,
bounds: Bounds,
}
struct PathRasterizationVarying {
@builtin(position) position: vec4<f32>,
@location(0) st_position: vec2<f32>,
@location(1) @interpolate(flat) vertex_id: u32,
@location(2) clip_distances: vec4<f32>,
}
fn load_path_vertex(vertex_id: u32) -> PathRasterizationVertex {
return b_path_vertices[vertex_id];
}
@vertex
fn vs_path_rasterization(@builtin(vertex_index) vertex_id: u32) -> PathRasterizationVarying {
let v = load_path_vertex(vertex_id);
var out = PathRasterizationVarying();
out.position = to_device_position_impl(v.xy_position);
out.st_position = v.st_position;
out.vertex_id = vertex_id;
out.clip_distances = distance_from_clip_rect_impl(v.xy_position, v.bounds);
return out;
}
@fragment
fn fs_path_rasterization(input: PathRasterizationVarying) -> @location(0) vec4<f32> {
let dx = dpdx(input.st_position);
let dy = dpdy(input.st_position);
if (any(input.clip_distances < vec4<f32>(0.0))) {
return vec4<f32>(0.0);
}
let v = load_path_vertex(input.vertex_id);
let background = v.color;
let bounds = v.bounds;
var alpha: f32;
if (length(vec2<f32>(dx.x, dy.x)) < 0.001) {
alpha = 1.0;
} else {
let gradient = 2.0 * input.st_position.xx * vec2<f32>(dx.x, dy.x) - vec2<f32>(dx.y, dy.y);
let f = input.st_position.x * input.st_position.x - input.st_position.y;
let distance = f / length(gradient);
alpha = saturate(0.5 - distance);
}
let prepared_gradient = prepare_gradient_color(
background.tag,
background.color_space,
background.solid,
background.color0,
background.color1,
);
let color = gradient_color(
background,
input.position.xy,
bounds,
prepared_gradient.solid,
prepared_gradient.color0,
prepared_gradient.color1,
);
return vec4<f32>(color.rgb * color.a * alpha, color.a * alpha);
}