reflow_svg_path.c

Go to the documentation of this file.

 
#include "ra8_attributes.h"
#include "reflow_svg_internal.h"
 
/* ===========================================================================
 * Path (`d` mini-language; curves approximated by their endpoint chords)
 * ===========================================================================
 */

RA8_INTERNAL
static int32_t internal_cmd_argc(char u)
{
  switch (u) {
    case 'm':
    case 'l':
    case 't':
      return (int32_t)k_svg_path_ep;
    case 'h':
    case 'v':
      return 1;
    case 'c':
      return (int32_t)k_svg_argc_cube;
    case 's':
    case 'q':
      return (int32_t)k_svg_argc_quad;
    case 'a':
      return (int32_t)k_svg_path_args;
    case 'z':
      return 0;
    default:
      return -1;
  }
}

RA8_INTERNAL
static void
internal_path_step(char u, bool rel, const int32_t* args, int32_t na, int32_t* cx, int32_t* cy)
{
  if (u == 'h') {
    *cx = rel ? (*cx + args[0]) : args[0];
    return;
  }
  if (u == 'v') {
    *cy = rel ? (*cy + args[0]) : args[0];
    return;
  }
  const int32_t ex = args[na - (int32_t)k_svg_path_ep];
  const int32_t ey = args[na - 1];
  *cx              = rel ? (*cx + ex) : ex;
  *cy              = rel ? (*cy + ey) : ey;
}

RA8_INTERNAL
static float internal_bezier1(float tt, float c0, float c1, float c2, float c3)
{
  static const float k_cubic = 3.0F;
  const float        mt      = 1.0F - tt;
  return ((mt * mt * mt) * c0) + (k_cubic * (mt * mt) * tt * c1) + (k_cubic * mt * (tt * tt) * c2) +
         ((tt * tt * tt) * c3);
}

RA8_INTERNAL
static void internal_flatten_cubic(const svg_xform_t* t,
                                   svg_pt_t           p0,
                                   svg_pt_t           p1,
                                   svg_pt_t           p2,
                                   svg_pt_t           p3,
                                   int32_t*           xs,
                                   int32_t*           ys,
                                   int32_t*           n)
{
  /* Bounded: k_svg_curve_seg samples, capped by k_svg_poly_max. */
  for (int32_t j = 1; (j <= (int32_t)k_svg_curve_seg) && (*n < (int32_t)k_svg_poly_max); ++j) {
    const float tt = (float)j / (float)k_svg_curve_seg;
    const float bx = internal_bezier1(tt, (float)p0.x, (float)p1.x, (float)p2.x, (float)p3.x);
    const float by = internal_bezier1(tt, (float)p0.y, (float)p1.y, (float)p2.y, (float)p3.y);
    priv_ra8_svgp_map_point(t, (int32_t)bx, (int32_t)by, &xs[*n], &ys[*n]);
    ++(*n);
  }
}

RA8_INTERNAL
static svg_pt_t internal_arg_pt(bool rel, int32_t cx, int32_t cy, int32_t ax, int32_t ay)
{
  const svg_pt_t p = {.x = rel ? (cx + ax) : ax, .y = rel ? (cy + ay) : ay};
  return p;
}

typedef struct {
  int32_t  cx;   
  int32_t  cy;   
  svg_pt_t ctrl; 
  char     kind; 
} path_state_t;

RA8_INTERNAL
static float internal_bezier_q1(float tt, float c0, float c1, float c2)
{
  static const float k_quadratic = 2.0F;
  const float        mt          = 1.0F - tt;
  return ((mt * mt) * c0) + (k_quadratic * mt * tt * c1) + ((tt * tt) * c2);
}

RA8_INTERNAL
static void internal_flatten_quad(const svg_xform_t* t,
                                  svg_pt_t           p0,
                                  svg_pt_t           p1,
                                  svg_pt_t           p2,
                                  int32_t*           xs,
                                  int32_t*           ys,
                                  int32_t*           n)
{
  /* Bounded: k_svg_curve_seg samples, capped by k_svg_poly_max. */
  for (int32_t j = 1; (j <= (int32_t)k_svg_curve_seg) && (*n < (int32_t)k_svg_poly_max); ++j) {
    const float tt = (float)j / (float)k_svg_curve_seg;
    const float bx = internal_bezier_q1(tt, (float)p0.x, (float)p1.x, (float)p2.x);
    const float by = internal_bezier_q1(tt, (float)p0.y, (float)p1.y, (float)p2.y);
    priv_ra8_svgp_map_point(t, (int32_t)bx, (int32_t)by, &xs[*n], &ys[*n]);
    ++(*n);
  }
}

RA8_INTERNAL
static svg_pt_t internal_reflect(svg_pt_t cur, svg_pt_t ctrl)
{
  const svg_pt_t r = {.x = (2 * cur.x) - ctrl.x, .y = (2 * cur.y) - ctrl.y};
  return r;
}

RA8_INTERNAL
static svg_pt_t internal_smooth_ctrl(svg_pt_t p0, const path_state_t* st, char want)
{
  return (st->kind == want) ? internal_reflect(p0, st->ctrl) : p0;
}

RA8_INTERNAL
static int32_t internal_emit_cubic(const svg_xform_t* t,
                                   svg_pt_t           p0,
                                   svg_pt_t           p1,
                                   svg_pt_t           p2,
                                   svg_pt_t           p3,
                                   path_state_t*      st,
                                   int32_t*           xs,
                                   int32_t*           ys,
                                   int32_t            n)
{
  int32_t m = n;
  internal_flatten_cubic(t, p0, p1, p2, p3, xs, ys, &m);
  st->ctrl = p2;
  st->kind = 'c';
  st->cx   = p3.x;
  st->cy   = p3.y;
  return m;
}

RA8_INTERNAL
static int32_t internal_emit_quad(const svg_xform_t* t,
                                  svg_pt_t           p0,
                                  svg_pt_t           p1,
                                  svg_pt_t           p2,
                                  path_state_t*      st,
                                  int32_t*           xs,
                                  int32_t*           ys,
                                  int32_t            n)
{
  int32_t m = n;
  internal_flatten_quad(t, p0, p1, p2, xs, ys, &m);
  st->ctrl = p1;
  st->kind = 'q';
  st->cx   = p2.x;
  st->cy   = p2.y;
  return m;
}

RA8_INTERNAL
static int32_t internal_path_curve(const svg_xform_t* t,
                                   char               u,
                                   bool               rel,
                                   const int32_t*     args,
                                   path_state_t*      st,
                                   int32_t*           xs,
                                   int32_t*           ys,
                                   int32_t            n)
{
  const svg_pt_t p0 = {.x = st->cx, .y = st->cy};
  if ((u == 'q') || (u == 't')) {
    const bool     sm = (u == 't');
    const svg_pt_t p1 = sm ? internal_smooth_ctrl(p0, st, 'q')
                           : internal_arg_pt(rel, st->cx, st->cy, args[0], args[1]);
    const int32_t  e  = sm ? INT32_C(0) : INT32_C(2);
    const svg_pt_t p2 = internal_arg_pt(rel, st->cx, st->cy, args[e], args[e + 1]);
    return internal_emit_quad(t, p0, p1, p2, st, xs, ys, n);
  }
  if ((u == 'c') || (u == 's')) {
    const bool     sm = (u == 's');
    const svg_pt_t p1 = sm ? internal_smooth_ctrl(p0, st, 'c')
                           : internal_arg_pt(rel, st->cx, st->cy, args[0], args[1]);
    const int32_t  b  = sm ? INT32_C(0) : INT32_C(2);
    const svg_pt_t p2 = internal_arg_pt(rel, st->cx, st->cy, args[b], args[b + 1]);
    const svg_pt_t p3 = internal_arg_pt(rel, st->cx, st->cy, args[b + 2], args[b + 3]);
    return internal_emit_cubic(t, p0, p1, p2, p3, st, xs, ys, n);
  }
  if (u == 'a') {
    const svg_pt_t p_end =
      internal_arg_pt(rel, st->cx, st->cy, args[k_svg_arc_ex], args[k_svg_arc_ey]);
    int32_t m = n;
    priv_ra8_svgp_flatten_arc(t, p0, args, p_end, xs, ys, &m);
    st->kind = 0; /* an arc breaks the smooth-reflection chain */
    st->cx   = p_end.x;
    st->cy   = p_end.y;
    return m;
  }
  return -1;
}

RA8_INTERNAL
static char internal_next_cmd(const uint8_t* d, size_t dlen, size_t* i, char* last)
{
  while ((*i < dlen) && (priv_ra8_svgp_ws((char)d[*i]) || (d[*i] == (uint8_t)','))) {
    ++(*i);
  }
  if (*i >= dlen) {
    return 0;
  }
  const char c = (char)d[*i];
  if (((c >= 'A') && (c <= 'Z')) || ((c >= 'a') && (c <= 'z'))) {
    *last = c;
    ++(*i);
    return c;
  }
  return *last;
}

RA8_INTERNAL
static int32_t
internal_parse_path(const uint8_t* d, size_t dlen, const svg_xform_t* t, int32_t* xs, int32_t* ys)
{
  int32_t      n    = 0;
  path_state_t st   = {.cx = 0, .cy = 0, .ctrl = {.x = 0, .y = 0}, .kind = 0};
  char         last = 0;
  size_t       i    = 0U;
  /* Bounded: <= k_svg_poly_max commands. Every non-'z' command emits at least
   * one vertex (n advances) or hits the vertex cap, and the 'z' arm advances i
   * on a malformed implicit repeat, so the loop always makes progress and
   * cannot spin on untrusted input (NASA P10 Rule 2). */
  while ((i < dlen) && (n < (int32_t)k_svg_poly_max)) {
    const size_t i_before = i;
    const char   c        = internal_next_cmd(d, dlen, &i, &last);
    const char   u        = priv_ra8_svgp_lc(c);
    /*
     * internal_next_cmd() only ever yields c in {0} U ['A'..'Z'] U ['a'..'z'] (an
     * ASCII path-command letter or the 0 end-marker). Whenever c >= 'a' holds,
     * c is a lowercase letter (0x61..0x7A) and therefore always <= 'z'; no
     * yielded value can make (c >= 'a') true while (c <= 'z') is false. The
     * (c <= 'z') condition thus cannot be flipped independently.
     */
    /* mcdc-deactivated: c is a command letter or 0; (c<='z') is always true once (c>='a') holds. */
    const bool    rel = (c >= 'a') && (c <= 'z');
    const int32_t na  = (c != '\0') ? internal_cmd_argc(u) : -1;
    if (na < 0) {
      break; /* unknown / no current command */
    }
    if (u == 'z') {
      /* Close: the fill closes implicitly. 'z' takes no args, so an implicit
       * repeat after a non-command byte (e.g. the digit in d="Z2") leaves the
       * cursor unmoved and would spin forever -- skip the byte to guarantee
       * forward progress. */
      if (i == i_before) {
        ++i;
      }
      continue;
    }
    int32_t args[k_svg_path_args] = {};
    for (int32_t a = 0; a < na; ++a) {
      args[a] = priv_ra8_svgp_num(d, dlen, &i);
    }
    const int32_t cn = internal_path_curve(t, u, rel, args, &st, xs, ys, n);
    if (cn >= 0) {
      n = cn; /* C/S/Q/T flattened into segments */
    } else {
      internal_path_step(u, rel, args, na, &st.cx, &st.cy);
      priv_ra8_svgp_map_point(t, st.cx, st.cy, &xs[n], &ys[n]);
      ++n;
      st.kind = 0; /* a non-curve breaks the smooth-reflection chain */
    }
    if (u == 'm') {
      last = rel ? 'l' : 'L'; /* implicit coords after M are line-tos */
    }
  }
  return n;
}

void priv_ra8_svgp_draw_path(const uint8_t* s, size_t len, const svg_xform_t* t)
{
  int32_t        gi   = -1;
  const uint32_t fill = priv_ra8_svgp_resolve_fill(s, len, t, (uint32_t)k_svg_def_fill, &gi);
  size_t         off  = 0U;
  size_t         vl   = 0U;
  if (((gi < 0) && (fill == (uint32_t)k_svg_no_paint)) ||
      !priv_ra8_svgp_attr(s, len, "d", &off, &vl)) {
    return;
  }
  int32_t       xs[k_svg_poly_max] = {};
  int32_t       ys[k_svg_poly_max] = {};
  const int32_t n                  = internal_parse_path(&s[off], vl, t, xs, ys);
  if (gi >= 0) {
    priv_ra8_svgp_fill_poly_grad(xs, ys, n, &t->grads->g[gi]);
  } else {
    priv_ra8_svgp_fill_poly(xs, ys, n, fill);
  }
}