873 lines
27 KiB
Rust
873 lines
27 KiB
Rust
// Copyright 2014 Google Inc.
|
|
// Copyright 2020 Yevhenii Reizner
|
|
//
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
// found in the LICENSE file.
|
|
|
|
// This module is a mix of SkDashPath, SkDashPathEffect, SkContourMeasure and SkPathMeasure.
|
|
|
|
use alloc::vec::Vec;
|
|
|
|
use arrayref::array_ref;
|
|
|
|
use crate::{Path, Point};
|
|
|
|
use crate::floating_point::{FiniteF32, NonZeroPositiveF32, NormalizedF32, NormalizedF32Exclusive};
|
|
use crate::path::{PathSegment, PathSegmentsIter, PathVerb};
|
|
use crate::path_builder::PathBuilder;
|
|
use crate::path_geometry;
|
|
use crate::scalar::Scalar;
|
|
|
|
#[cfg(all(not(feature = "std"), feature = "no-std-float"))]
|
|
use crate::NoStdFloat;
|
|
|
|
/// A stroke dashing properties.
|
|
///
|
|
/// Contains an array of pairs, where the first number indicates an "on" interval
|
|
/// and the second one indicates an "off" interval;
|
|
/// a dash offset value and internal properties.
|
|
///
|
|
/// # Guarantees
|
|
///
|
|
/// - The dash array always have an even number of values.
|
|
/// - All dash array values are finite and >= 0.
|
|
/// - There is at least two dash array values.
|
|
/// - The sum of all dash array values is positive and finite.
|
|
/// - Dash offset is finite.
|
|
#[derive(Clone, PartialEq, Debug)]
|
|
pub struct StrokeDash {
|
|
array: Vec<f32>,
|
|
offset: f32,
|
|
interval_len: NonZeroPositiveF32,
|
|
first_len: f32, // TODO: PositiveF32
|
|
first_index: usize,
|
|
}
|
|
|
|
impl StrokeDash {
|
|
/// Creates a new stroke dashing object.
|
|
pub fn new(dash_array: Vec<f32>, dash_offset: f32) -> Option<Self> {
|
|
let dash_offset = FiniteF32::new(dash_offset)?;
|
|
|
|
if dash_array.len() < 2 || dash_array.len() % 2 != 0 {
|
|
return None;
|
|
}
|
|
|
|
if dash_array.iter().any(|n| *n < 0.0) {
|
|
return None;
|
|
}
|
|
|
|
let interval_len: f32 = dash_array.iter().sum();
|
|
let interval_len = NonZeroPositiveF32::new(interval_len)?;
|
|
|
|
let dash_offset = adjust_dash_offset(dash_offset.get(), interval_len.get());
|
|
debug_assert!(dash_offset >= 0.0);
|
|
debug_assert!(dash_offset < interval_len.get());
|
|
|
|
let (first_len, first_index) = find_first_interval(&dash_array, dash_offset);
|
|
debug_assert!(first_len >= 0.0);
|
|
debug_assert!(first_index < dash_array.len());
|
|
|
|
Some(StrokeDash {
|
|
array: dash_array,
|
|
offset: dash_offset,
|
|
interval_len,
|
|
first_len,
|
|
first_index,
|
|
})
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use alloc::vec;
|
|
|
|
#[test]
|
|
fn test() {
|
|
assert_eq!(StrokeDash::new(vec![], 0.0), None);
|
|
assert_eq!(StrokeDash::new(vec![1.0], 0.0), None);
|
|
assert_eq!(StrokeDash::new(vec![1.0, 2.0, 3.0], 0.0), None);
|
|
assert_eq!(StrokeDash::new(vec![1.0, -2.0], 0.0), None);
|
|
assert_eq!(StrokeDash::new(vec![0.0, 0.0], 0.0), None);
|
|
assert_eq!(StrokeDash::new(vec![1.0, -1.0], 0.0), None);
|
|
assert_eq!(StrokeDash::new(vec![1.0, 1.0], f32::INFINITY), None);
|
|
assert_eq!(StrokeDash::new(vec![1.0, f32::INFINITY], 0.0), None);
|
|
}
|
|
|
|
#[test]
|
|
fn bug_26() {
|
|
let mut pb = PathBuilder::new();
|
|
pb.move_to(665.54, 287.3);
|
|
pb.line_to(675.67, 273.04);
|
|
pb.line_to(675.52, 271.32);
|
|
pb.line_to(674.79, 269.61);
|
|
pb.line_to(674.05, 268.04);
|
|
pb.line_to(672.88, 266.47);
|
|
pb.line_to(671.27, 264.9);
|
|
let path = pb.finish().unwrap();
|
|
|
|
let stroke_dash = StrokeDash::new(vec![6.0, 4.5], 0.0).unwrap();
|
|
|
|
assert!(path.dash(&stroke_dash, 1.0).is_some());
|
|
}
|
|
}
|
|
|
|
// Adjust phase to be between 0 and len, "flipping" phase if negative.
|
|
// e.g., if len is 100, then phase of -20 (or -120) is equivalent to 80.
|
|
fn adjust_dash_offset(mut offset: f32, len: f32) -> f32 {
|
|
if offset < 0.0 {
|
|
offset = -offset;
|
|
if offset > len {
|
|
offset %= len;
|
|
}
|
|
|
|
offset = len - offset;
|
|
|
|
// Due to finite precision, it's possible that phase == len,
|
|
// even after the subtract (if len >>> phase), so fix that here.
|
|
debug_assert!(offset <= len);
|
|
if offset == len {
|
|
offset = 0.0;
|
|
}
|
|
|
|
offset
|
|
} else if offset >= len {
|
|
offset % len
|
|
} else {
|
|
offset
|
|
}
|
|
}
|
|
|
|
fn find_first_interval(dash_array: &[f32], mut dash_offset: f32) -> (f32, usize) {
|
|
for (i, gap) in dash_array.iter().copied().enumerate() {
|
|
if dash_offset > gap || (dash_offset == gap && gap != 0.0) {
|
|
dash_offset -= gap;
|
|
} else {
|
|
return (gap - dash_offset, i);
|
|
}
|
|
}
|
|
|
|
// If we get here, phase "appears" to be larger than our length. This
|
|
// shouldn't happen with perfect precision, but we can accumulate errors
|
|
// during the initial length computation (rounding can make our sum be too
|
|
// big or too small. In that event, we just have to eat the error here.
|
|
(dash_array[0], 0)
|
|
}
|
|
|
|
impl Path {
|
|
/// Converts the current path into a dashed one.
|
|
///
|
|
/// `resolution_scale` can be obtained via
|
|
/// [`compute_resolution_scale`](crate::PathStroker::compute_resolution_scale).
|
|
pub fn dash(&self, dash: &StrokeDash, resolution_scale: f32) -> Option<Path> {
|
|
dash_impl(self, dash, resolution_scale)
|
|
}
|
|
}
|
|
|
|
fn dash_impl(src: &Path, dash: &StrokeDash, res_scale: f32) -> Option<Path> {
|
|
// We do not support the `cull_path` branch here.
|
|
// Skia has a lot of code for cases when a path contains only a single zero-length line
|
|
// or when a path is a rect. Not sure why.
|
|
// We simply ignoring it for the sake of simplicity.
|
|
|
|
// We also doesn't support the `SpecialLineRec` case.
|
|
// I have no idea what the point in it.
|
|
|
|
fn is_even(x: usize) -> bool {
|
|
x % 2 == 0
|
|
}
|
|
|
|
let mut pb = PathBuilder::new();
|
|
let mut dash_count = 0.0;
|
|
for contour in ContourMeasureIter::new(src, res_scale) {
|
|
let mut skip_first_segment = contour.is_closed;
|
|
let mut added_segment = false;
|
|
let length = contour.length;
|
|
let mut index = dash.first_index;
|
|
|
|
// Since the path length / dash length ratio may be arbitrarily large, we can exert
|
|
// significant memory pressure while attempting to build the filtered path. To avoid this,
|
|
// we simply give up dashing beyond a certain threshold.
|
|
//
|
|
// The original bug report (http://crbug.com/165432) is based on a path yielding more than
|
|
// 90 million dash segments and crashing the memory allocator. A limit of 1 million
|
|
// segments seems reasonable: at 2 verbs per segment * 9 bytes per verb, this caps the
|
|
// maximum dash memory overhead at roughly 17MB per path.
|
|
const MAX_DASH_COUNT: usize = 1000000;
|
|
dash_count += length * (dash.array.len() >> 1) as f32 / dash.interval_len.get();
|
|
if dash_count > MAX_DASH_COUNT as f32 {
|
|
return None;
|
|
}
|
|
|
|
// Using double precision to avoid looping indefinitely due to single precision rounding
|
|
// (for extreme path_length/dash_length ratios). See test_infinite_dash() unittest.
|
|
let mut distance = 0.0;
|
|
let mut d_len = dash.first_len;
|
|
|
|
while distance < length {
|
|
debug_assert!(d_len >= 0.0);
|
|
added_segment = false;
|
|
if is_even(index) && !skip_first_segment {
|
|
added_segment = true;
|
|
contour.push_segment(distance as f32, (distance + d_len) as f32, true, &mut pb);
|
|
}
|
|
|
|
distance += d_len;
|
|
|
|
// clear this so we only respect it the first time around
|
|
skip_first_segment = false;
|
|
|
|
// wrap around our intervals array if necessary
|
|
index += 1;
|
|
debug_assert!(index <= dash.array.len());
|
|
if index == dash.array.len() {
|
|
index = 0;
|
|
}
|
|
|
|
// fetch our next d_len
|
|
d_len = dash.array[index];
|
|
}
|
|
|
|
// extend if we ended on a segment and we need to join up with the (skipped) initial segment
|
|
if contour.is_closed && is_even(dash.first_index) && dash.first_len >= 0.0 {
|
|
contour.push_segment(0.0, dash.first_len, !added_segment, &mut pb);
|
|
}
|
|
}
|
|
|
|
pb.finish()
|
|
}
|
|
|
|
const MAX_T_VALUE: u32 = 0x3FFFFFFF;
|
|
|
|
struct ContourMeasureIter<'a> {
|
|
iter: PathSegmentsIter<'a>,
|
|
tolerance: f32,
|
|
}
|
|
|
|
impl<'a> ContourMeasureIter<'a> {
|
|
fn new(path: &'a Path, res_scale: f32) -> Self {
|
|
// can't use tangents, since we need [0..1..................2] to be seen
|
|
// as definitely not a line (it is when drawn, but not parametrically)
|
|
// so we compare midpoints
|
|
const CHEAP_DIST_LIMIT: f32 = 0.5; // just made this value up
|
|
|
|
ContourMeasureIter {
|
|
iter: path.segments(),
|
|
tolerance: CHEAP_DIST_LIMIT * res_scale.invert(),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Iterator for ContourMeasureIter<'_> {
|
|
type Item = ContourMeasure;
|
|
|
|
// If it encounters a zero-length contour, it is skipped.
|
|
fn next(&mut self) -> Option<Self::Item> {
|
|
// Note:
|
|
// as we accumulate distance, we have to check that the result of +=
|
|
// actually made it larger, since a very small delta might be > 0, but
|
|
// still have no effect on distance (if distance >>> delta).
|
|
//
|
|
// We do this check below, and in compute_quad_segs and compute_cubic_segs
|
|
|
|
let mut contour = ContourMeasure::default();
|
|
|
|
let mut point_index = 0;
|
|
let mut distance = 0.0;
|
|
let mut have_seen_close = false;
|
|
let mut prev_p = Point::zero();
|
|
while let Some(seg) = self.iter.next() {
|
|
match seg {
|
|
PathSegment::MoveTo(p0) => {
|
|
contour.points.push(p0);
|
|
prev_p = p0;
|
|
}
|
|
PathSegment::LineTo(p0) => {
|
|
let prev_d = distance;
|
|
distance = contour.compute_line_seg(prev_p, p0, distance, point_index);
|
|
|
|
if distance > prev_d {
|
|
contour.points.push(p0);
|
|
point_index += 1;
|
|
}
|
|
|
|
prev_p = p0;
|
|
}
|
|
PathSegment::QuadTo(p0, p1) => {
|
|
let prev_d = distance;
|
|
distance = contour.compute_quad_segs(
|
|
prev_p,
|
|
p0,
|
|
p1,
|
|
distance,
|
|
0,
|
|
MAX_T_VALUE,
|
|
point_index,
|
|
self.tolerance,
|
|
);
|
|
|
|
if distance > prev_d {
|
|
contour.points.push(p0);
|
|
contour.points.push(p1);
|
|
point_index += 2;
|
|
}
|
|
|
|
prev_p = p1;
|
|
}
|
|
PathSegment::CubicTo(p0, p1, p2) => {
|
|
let prev_d = distance;
|
|
distance = contour.compute_cubic_segs(
|
|
prev_p,
|
|
p0,
|
|
p1,
|
|
p2,
|
|
distance,
|
|
0,
|
|
MAX_T_VALUE,
|
|
point_index,
|
|
self.tolerance,
|
|
);
|
|
|
|
if distance > prev_d {
|
|
contour.points.push(p0);
|
|
contour.points.push(p1);
|
|
contour.points.push(p2);
|
|
point_index += 3;
|
|
}
|
|
|
|
prev_p = p2;
|
|
}
|
|
PathSegment::Close => {
|
|
have_seen_close = true;
|
|
}
|
|
}
|
|
|
|
// TODO: to contour iter?
|
|
if self.iter.next_verb() == Some(PathVerb::Move) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
if !distance.is_finite() {
|
|
return None;
|
|
}
|
|
|
|
if have_seen_close {
|
|
let prev_d = distance;
|
|
let first_pt = contour.points[0];
|
|
distance = contour.compute_line_seg(
|
|
contour.points[point_index],
|
|
first_pt,
|
|
distance,
|
|
point_index,
|
|
);
|
|
|
|
if distance > prev_d {
|
|
contour.points.push(first_pt);
|
|
}
|
|
}
|
|
|
|
contour.length = distance;
|
|
contour.is_closed = have_seen_close;
|
|
|
|
if contour.points.is_empty() {
|
|
None
|
|
} else {
|
|
Some(contour)
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Copy, Clone, PartialEq, Debug)]
|
|
enum SegmentType {
|
|
Line,
|
|
Quad,
|
|
Cubic,
|
|
}
|
|
|
|
#[derive(Copy, Clone, Debug)]
|
|
struct Segment {
|
|
distance: f32, // total distance up to this point
|
|
point_index: usize, // index into the ContourMeasure::points array
|
|
t_value: u32,
|
|
kind: SegmentType,
|
|
}
|
|
|
|
impl Segment {
|
|
fn scalar_t(&self) -> f32 {
|
|
debug_assert!(self.t_value <= MAX_T_VALUE);
|
|
// 1/kMaxTValue can't be represented as a float, but it's close and the limits work fine.
|
|
const MAX_T_RECIPROCAL: f32 = 1.0 / MAX_T_VALUE as f32;
|
|
self.t_value as f32 * MAX_T_RECIPROCAL
|
|
}
|
|
}
|
|
|
|
#[derive(Default, Debug)]
|
|
struct ContourMeasure {
|
|
segments: Vec<Segment>,
|
|
points: Vec<Point>,
|
|
length: f32,
|
|
is_closed: bool,
|
|
}
|
|
|
|
impl ContourMeasure {
|
|
fn push_segment(
|
|
&self,
|
|
mut start_d: f32,
|
|
mut stop_d: f32,
|
|
start_with_move_to: bool,
|
|
pb: &mut PathBuilder,
|
|
) -> Option<()> {
|
|
if start_d < 0.0 {
|
|
start_d = 0.0;
|
|
}
|
|
|
|
if stop_d > self.length {
|
|
stop_d = self.length;
|
|
}
|
|
|
|
if !(start_d <= stop_d) {
|
|
// catch NaN values as well
|
|
return None;
|
|
}
|
|
|
|
if self.segments.is_empty() {
|
|
return None;
|
|
}
|
|
|
|
let (seg_index, mut start_t) = self.distance_to_segment(start_d)?;
|
|
let mut seg = self.segments[seg_index];
|
|
|
|
let (stop_seg_index, stop_t) = self.distance_to_segment(stop_d)?;
|
|
let stop_seg = self.segments[stop_seg_index];
|
|
|
|
debug_assert!(stop_seg_index <= stop_seg_index);
|
|
let mut p = Point::zero();
|
|
if start_with_move_to {
|
|
compute_pos_tan(
|
|
&self.points[seg.point_index..],
|
|
seg.kind,
|
|
start_t,
|
|
Some(&mut p),
|
|
None,
|
|
);
|
|
pb.move_to(p.x, p.y);
|
|
}
|
|
|
|
if seg.point_index == stop_seg.point_index {
|
|
segment_to(
|
|
&self.points[seg.point_index..],
|
|
seg.kind,
|
|
start_t,
|
|
stop_t,
|
|
pb,
|
|
);
|
|
} else {
|
|
let mut new_seg_index = seg_index;
|
|
loop {
|
|
segment_to(
|
|
&self.points[seg.point_index..],
|
|
seg.kind,
|
|
start_t,
|
|
NormalizedF32::ONE,
|
|
pb,
|
|
);
|
|
|
|
let old_point_index = seg.point_index;
|
|
loop {
|
|
new_seg_index += 1;
|
|
if self.segments[new_seg_index].point_index != old_point_index {
|
|
break;
|
|
}
|
|
}
|
|
seg = self.segments[new_seg_index];
|
|
|
|
start_t = NormalizedF32::ZERO;
|
|
|
|
if seg.point_index >= stop_seg.point_index {
|
|
break;
|
|
}
|
|
}
|
|
|
|
segment_to(
|
|
&self.points[seg.point_index..],
|
|
seg.kind,
|
|
NormalizedF32::ZERO,
|
|
stop_t,
|
|
pb,
|
|
);
|
|
}
|
|
|
|
Some(())
|
|
}
|
|
|
|
fn distance_to_segment(&self, distance: f32) -> Option<(usize, NormalizedF32)> {
|
|
debug_assert!(distance >= 0.0 && distance <= self.length);
|
|
|
|
let mut index = find_segment(&self.segments, distance);
|
|
// don't care if we hit an exact match or not, so we xor index if it is negative
|
|
index ^= index >> 31;
|
|
let index = index as usize;
|
|
let seg = self.segments[index];
|
|
|
|
// now interpolate t-values with the prev segment (if possible)
|
|
let mut start_t = 0.0;
|
|
let mut start_d = 0.0;
|
|
// check if the prev segment is legal, and references the same set of points
|
|
if index > 0 {
|
|
start_d = self.segments[index - 1].distance;
|
|
if self.segments[index - 1].point_index == seg.point_index {
|
|
debug_assert!(self.segments[index - 1].kind == seg.kind);
|
|
start_t = self.segments[index - 1].scalar_t();
|
|
}
|
|
}
|
|
|
|
debug_assert!(seg.scalar_t() > start_t);
|
|
debug_assert!(distance >= start_d);
|
|
debug_assert!(seg.distance > start_d);
|
|
|
|
let t =
|
|
start_t + (seg.scalar_t() - start_t) * (distance - start_d) / (seg.distance - start_d);
|
|
let t = NormalizedF32::new(t)?;
|
|
Some((index, t))
|
|
}
|
|
|
|
fn compute_line_seg(
|
|
&mut self,
|
|
p0: Point,
|
|
p1: Point,
|
|
mut distance: f32,
|
|
point_index: usize,
|
|
) -> f32 {
|
|
let d = p0.distance(p1);
|
|
debug_assert!(d >= 0.0);
|
|
let prev_d = distance;
|
|
distance += d;
|
|
if distance > prev_d {
|
|
debug_assert!(point_index < self.points.len());
|
|
self.segments.push(Segment {
|
|
distance,
|
|
point_index,
|
|
t_value: MAX_T_VALUE,
|
|
kind: SegmentType::Line,
|
|
});
|
|
}
|
|
|
|
distance
|
|
}
|
|
|
|
fn compute_quad_segs(
|
|
&mut self,
|
|
p0: Point,
|
|
p1: Point,
|
|
p2: Point,
|
|
mut distance: f32,
|
|
min_t: u32,
|
|
max_t: u32,
|
|
point_index: usize,
|
|
tolerance: f32,
|
|
) -> f32 {
|
|
if t_span_big_enough(max_t - min_t) != 0 && quad_too_curvy(p0, p1, p2, tolerance) {
|
|
let mut tmp = [Point::zero(); 5];
|
|
let half_t = (min_t + max_t) >> 1;
|
|
|
|
path_geometry::chop_quad_at(&[p0, p1, p2], NormalizedF32Exclusive::HALF, &mut tmp);
|
|
distance = self.compute_quad_segs(
|
|
tmp[0],
|
|
tmp[1],
|
|
tmp[2],
|
|
distance,
|
|
min_t,
|
|
half_t,
|
|
point_index,
|
|
tolerance,
|
|
);
|
|
distance = self.compute_quad_segs(
|
|
tmp[2],
|
|
tmp[3],
|
|
tmp[4],
|
|
distance,
|
|
half_t,
|
|
max_t,
|
|
point_index,
|
|
tolerance,
|
|
);
|
|
} else {
|
|
let d = p0.distance(p2);
|
|
let prev_d = distance;
|
|
distance += d;
|
|
if distance > prev_d {
|
|
debug_assert!(point_index < self.points.len());
|
|
self.segments.push(Segment {
|
|
distance,
|
|
point_index,
|
|
t_value: max_t,
|
|
kind: SegmentType::Quad,
|
|
});
|
|
}
|
|
}
|
|
|
|
distance
|
|
}
|
|
|
|
fn compute_cubic_segs(
|
|
&mut self,
|
|
p0: Point,
|
|
p1: Point,
|
|
p2: Point,
|
|
p3: Point,
|
|
mut distance: f32,
|
|
min_t: u32,
|
|
max_t: u32,
|
|
point_index: usize,
|
|
tolerance: f32,
|
|
) -> f32 {
|
|
if t_span_big_enough(max_t - min_t) != 0 && cubic_too_curvy(p0, p1, p2, p3, tolerance) {
|
|
let mut tmp = [Point::zero(); 7];
|
|
let half_t = (min_t + max_t) >> 1;
|
|
|
|
path_geometry::chop_cubic_at2(
|
|
&[p0, p1, p2, p3],
|
|
NormalizedF32Exclusive::HALF,
|
|
&mut tmp,
|
|
);
|
|
distance = self.compute_cubic_segs(
|
|
tmp[0],
|
|
tmp[1],
|
|
tmp[2],
|
|
tmp[3],
|
|
distance,
|
|
min_t,
|
|
half_t,
|
|
point_index,
|
|
tolerance,
|
|
);
|
|
distance = self.compute_cubic_segs(
|
|
tmp[3],
|
|
tmp[4],
|
|
tmp[5],
|
|
tmp[6],
|
|
distance,
|
|
half_t,
|
|
max_t,
|
|
point_index,
|
|
tolerance,
|
|
);
|
|
} else {
|
|
let d = p0.distance(p3);
|
|
let prev_d = distance;
|
|
distance += d;
|
|
if distance > prev_d {
|
|
debug_assert!(point_index < self.points.len());
|
|
self.segments.push(Segment {
|
|
distance,
|
|
point_index,
|
|
t_value: max_t,
|
|
kind: SegmentType::Cubic,
|
|
});
|
|
}
|
|
}
|
|
|
|
distance
|
|
}
|
|
}
|
|
|
|
fn find_segment(base: &[Segment], key: f32) -> i32 {
|
|
let mut lo = 0u32;
|
|
let mut hi = (base.len() - 1) as u32;
|
|
|
|
while lo < hi {
|
|
let mid = (hi + lo) >> 1;
|
|
if base[mid as usize].distance < key {
|
|
lo = mid + 1;
|
|
} else {
|
|
hi = mid;
|
|
}
|
|
}
|
|
|
|
if base[hi as usize].distance < key {
|
|
hi += 1;
|
|
hi = !hi;
|
|
} else if key < base[hi as usize].distance {
|
|
hi = !hi;
|
|
}
|
|
|
|
hi as i32
|
|
}
|
|
|
|
fn compute_pos_tan(
|
|
points: &[Point],
|
|
seg_kind: SegmentType,
|
|
t: NormalizedF32,
|
|
pos: Option<&mut Point>,
|
|
tangent: Option<&mut Point>,
|
|
) {
|
|
match seg_kind {
|
|
SegmentType::Line => {
|
|
if let Some(pos) = pos {
|
|
*pos = Point::from_xy(
|
|
interp(points[0].x, points[1].x, t),
|
|
interp(points[0].y, points[1].y, t),
|
|
);
|
|
}
|
|
|
|
if let Some(tangent) = tangent {
|
|
tangent.set_normalize(points[1].x - points[0].x, points[1].y - points[0].y);
|
|
}
|
|
}
|
|
SegmentType::Quad => {
|
|
let src = array_ref![points, 0, 3];
|
|
if let Some(pos) = pos {
|
|
*pos = path_geometry::eval_quad_at(src, t);
|
|
}
|
|
|
|
if let Some(tangent) = tangent {
|
|
*tangent = path_geometry::eval_quad_tangent_at(src, t);
|
|
tangent.normalize();
|
|
}
|
|
}
|
|
SegmentType::Cubic => {
|
|
let src = array_ref![points, 0, 4];
|
|
if let Some(pos) = pos {
|
|
*pos = path_geometry::eval_cubic_pos_at(src, t);
|
|
}
|
|
|
|
if let Some(tangent) = tangent {
|
|
*tangent = path_geometry::eval_cubic_tangent_at(src, t);
|
|
tangent.normalize();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn segment_to(
|
|
points: &[Point],
|
|
seg_kind: SegmentType,
|
|
start_t: NormalizedF32,
|
|
stop_t: NormalizedF32,
|
|
pb: &mut PathBuilder,
|
|
) {
|
|
debug_assert!(start_t <= stop_t);
|
|
|
|
if start_t == stop_t {
|
|
if let Some(pt) = pb.last_point() {
|
|
// If the dash as a zero-length on segment, add a corresponding zero-length line.
|
|
// The stroke code will add end caps to zero length lines as appropriate.
|
|
pb.line_to(pt.x, pt.y);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
match seg_kind {
|
|
SegmentType::Line => {
|
|
if stop_t == NormalizedF32::ONE {
|
|
pb.line_to(points[1].x, points[1].y);
|
|
} else {
|
|
pb.line_to(
|
|
interp(points[0].x, points[1].x, stop_t),
|
|
interp(points[0].y, points[1].y, stop_t),
|
|
);
|
|
}
|
|
}
|
|
SegmentType::Quad => {
|
|
let mut tmp0 = [Point::zero(); 5];
|
|
let mut tmp1 = [Point::zero(); 5];
|
|
if start_t == NormalizedF32::ZERO {
|
|
if stop_t == NormalizedF32::ONE {
|
|
pb.quad_to_pt(points[1], points[2]);
|
|
} else {
|
|
let stop_t = NormalizedF32Exclusive::new_bounded(stop_t.get());
|
|
path_geometry::chop_quad_at(points, stop_t, &mut tmp0);
|
|
pb.quad_to_pt(tmp0[1], tmp0[2]);
|
|
}
|
|
} else {
|
|
let start_tt = NormalizedF32Exclusive::new_bounded(start_t.get());
|
|
path_geometry::chop_quad_at(points, start_tt, &mut tmp0);
|
|
if stop_t == NormalizedF32::ONE {
|
|
pb.quad_to_pt(tmp0[3], tmp0[4]);
|
|
} else {
|
|
let new_t = (stop_t.get() - start_t.get()) / (1.0 - start_t.get());
|
|
let new_t = NormalizedF32Exclusive::new_bounded(new_t);
|
|
path_geometry::chop_quad_at(&tmp0[2..], new_t, &mut tmp1);
|
|
pb.quad_to_pt(tmp1[1], tmp1[2]);
|
|
}
|
|
}
|
|
}
|
|
SegmentType::Cubic => {
|
|
let mut tmp0 = [Point::zero(); 7];
|
|
let mut tmp1 = [Point::zero(); 7];
|
|
if start_t == NormalizedF32::ZERO {
|
|
if stop_t == NormalizedF32::ONE {
|
|
pb.cubic_to_pt(points[1], points[2], points[3]);
|
|
} else {
|
|
let stop_t = NormalizedF32Exclusive::new_bounded(stop_t.get());
|
|
path_geometry::chop_cubic_at2(array_ref![points, 0, 4], stop_t, &mut tmp0);
|
|
pb.cubic_to_pt(tmp0[1], tmp0[2], tmp0[3]);
|
|
}
|
|
} else {
|
|
let start_tt = NormalizedF32Exclusive::new_bounded(start_t.get());
|
|
path_geometry::chop_cubic_at2(array_ref![points, 0, 4], start_tt, &mut tmp0);
|
|
if stop_t == NormalizedF32::ONE {
|
|
pb.cubic_to_pt(tmp0[4], tmp0[5], tmp0[6]);
|
|
} else {
|
|
let new_t = (stop_t.get() - start_t.get()) / (1.0 - start_t.get());
|
|
let new_t = NormalizedF32Exclusive::new_bounded(new_t);
|
|
path_geometry::chop_cubic_at2(array_ref![tmp0, 3, 4], new_t, &mut tmp1);
|
|
pb.cubic_to_pt(tmp1[1], tmp1[2], tmp1[3]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn t_span_big_enough(t_span: u32) -> u32 {
|
|
debug_assert!(t_span <= MAX_T_VALUE);
|
|
t_span >> 10
|
|
}
|
|
|
|
fn quad_too_curvy(p0: Point, p1: Point, p2: Point, tolerance: f32) -> bool {
|
|
// diff = (a/4 + b/2 + c/4) - (a/2 + c/2)
|
|
// diff = -a/4 + b/2 - c/4
|
|
let dx = (p1.x).half() - (p0.x + p2.x).half().half();
|
|
let dy = (p1.y).half() - (p0.y + p2.y).half().half();
|
|
|
|
let dist = dx.abs().max(dy.abs());
|
|
dist > tolerance
|
|
}
|
|
|
|
fn cubic_too_curvy(p0: Point, p1: Point, p2: Point, p3: Point, tolerance: f32) -> bool {
|
|
let n0 = cheap_dist_exceeds_limit(
|
|
p1,
|
|
interp_safe(p0.x, p3.x, 1.0 / 3.0),
|
|
interp_safe(p0.y, p3.y, 1.0 / 3.0),
|
|
tolerance,
|
|
);
|
|
|
|
let n1 = cheap_dist_exceeds_limit(
|
|
p2,
|
|
interp_safe(p0.x, p3.x, 2.0 / 3.0),
|
|
interp_safe(p0.y, p3.y, 2.0 / 3.0),
|
|
tolerance,
|
|
);
|
|
|
|
n0 || n1
|
|
}
|
|
|
|
fn cheap_dist_exceeds_limit(pt: Point, x: f32, y: f32, tolerance: f32) -> bool {
|
|
let dist = (x - pt.x).abs().max((y - pt.y).abs());
|
|
// just made up the 1/2
|
|
dist > tolerance
|
|
}
|
|
|
|
/// Linearly interpolate between A and B, based on t.
|
|
///
|
|
/// If t is 0, return A. If t is 1, return B else interpolate.
|
|
fn interp(a: f32, b: f32, t: NormalizedF32) -> f32 {
|
|
a + (b - a) * t.get()
|
|
}
|
|
|
|
fn interp_safe(a: f32, b: f32, t: f32) -> f32 {
|
|
debug_assert!(t >= 0.0 && t <= 1.0);
|
|
a + (b - a) * t
|
|
}
|