Vendor things

third-party/vendor/tiny-skia-path/src/dash.rs

@@ -0,0 +1,873 @@
+// 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
+}