include/rive/math/raw_path_utils.hpp

/*
 * Copyright 2022 Rive
 */

#ifndef _RIVE_RAW_PATH_UTILS_HPP_
#define _RIVE_RAW_PATH_UTILS_HPP_

#include "rive/math/vec2d.hpp"

namespace rive
{
static inline Vec2D two(Vec2D v) { return v + v; }

// Caches the setup to evaluate a quadratic bezier. Useful if you
// want to evaluate the save curve at multiple t values.
// clang-format off
    struct EvalQuad {
        const Vec2D a, b, c; // at^2 + bt + c

        // pts are the 3 quadratic bezier control points
        EvalQuad(const Vec2D pts[3]) :
            a(pts[0] - two(pts[1]) + pts[2]),
            b(two(pts[1] - pts[0])),
            c(pts[0]) {}

        Vec2D operator()(float t) const { return (a * t + b) * t + c; }
    };
// clang-format on

// Caches the setup to evaluate a cubic bezier. Useful if you
// want to evaluate the save curve at multiple t values.
struct EvalCubic
{
    const Vec2D a, b, c, d; // at^3 + bt^2 + ct + d

    // pts are the 4 cubic bezier control points
    EvalCubic(const Vec2D pts[4]) :
        a(pts[3] + 3 * (pts[1] - pts[2]) - pts[0]),
        b(3 * (pts[2] - two(pts[1]) + pts[0])),
        c(3 * (pts[1] - pts[0])),
        d(pts[0])
    {}

    Vec2D operator()(float t) const { return ((a * t + b) * t + c) * t + d; }
};

// These compute the number of line segments need to apprixmate the bezier
// curve to the specified inverse-tolerance. We take inverse since we need
// to divide by the "tolerance", and we want to save the cost of the divide.
//
// At "standard" tolerance might be 0.5 (half a pixel error), so the caller
// would base 2.0 as its inverse.
//
// These always return at least 1
//

extern int computeApproximatingQuadLineSegments(const Vec2D bezier[3], float invTolerance);

extern int computeApproximatingCubicLineSegments(const Vec2D bezier[4], float invTolerance);

// Extract a subcurve from the curve (given start and end t-values)

extern void quad_subdivide(const Vec2D src[3], float t, Vec2D dst[5]);
extern void cubic_subdivide(const Vec2D src[4], float t, Vec2D dst[7]);

extern void line_extract(const Vec2D src[2], float startT, float endT, Vec2D dst[2]);
extern void quad_extract(const Vec2D src[3], float startT, float endT, Vec2D dst[3]);
extern void cubic_extract(const Vec2D src[4], float startT, float endT, Vec2D dst[4]);

} // namespace rive

#endif