reflow_svg_shape.c

Go to the documentation of this file.

 
#include <math.h>
 
#include "ra8_attributes.h"
#include "ra8_gfx.h"
#include "reflow_svg_internal.h"

static const float s_svg_2pi = 6.28318531F;
 
/* ===========================================================================
 * Basic shapes (rect / circle / line)
 * ===========================================================================
 */

void priv_ra8_svgp_draw_rect(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);
  if ((gi < 0) && (fill == (uint32_t)k_svg_no_paint)) {
    return;
  }
  const int32_t rx = priv_ra8_svgp_attr_num(s, len, "x", 0);
  const int32_t ry = priv_ra8_svgp_attr_num(s, len, "y", 0);
  const int32_t rw = priv_ra8_svgp_attr_num(s, len, "width", 0);
  const int32_t rh = priv_ra8_svgp_attr_num(s, len, "height", 0);
  if ((gi < 0) && !priv_ra8_svgp_has_rot(t)) {
    (void)ra8_gfx_rect(priv_ra8_svgp_mx(t, rx),
                       priv_ra8_svgp_my(t, ry),
                       priv_ra8_svgp_sx(t, rw),
                       priv_ra8_svgp_sx(t, rh),
                       fill,
                       true);
    return;
  }
  int32_t xs[k_svg_rect_pts] = {};
  int32_t ys[k_svg_rect_pts] = {};
  priv_ra8_svgp_map_point(t, rx, ry, &xs[0], &ys[0]);
  priv_ra8_svgp_map_point(t, rx + rw, ry, &xs[1], &ys[1]);
  priv_ra8_svgp_map_point(t, rx + rw, ry + rh, &xs[2], &ys[2]);
  priv_ra8_svgp_map_point(t, rx, ry + rh, &xs[3], &ys[3]);
  if (gi >= 0) {
    priv_ra8_svgp_fill_poly_grad(xs, ys, (int32_t)k_svg_rect_pts, &t->grads->g[gi]);
  } else {
    priv_ra8_svgp_fill_poly(xs, ys, (int32_t)k_svg_rect_pts, fill);
  }
}

void priv_ra8_svgp_draw_circle(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);
  if ((gi < 0) && (fill == (uint32_t)k_svg_no_paint)) {
    return;
  }
  const int32_t cx = priv_ra8_svgp_attr_num(s, len, "cx", 0);
  const int32_t cy = priv_ra8_svgp_attr_num(s, len, "cy", 0);
  const int32_t r  = priv_ra8_svgp_attr_num(s, len, "r", 0);
  if ((gi < 0) && !priv_ra8_svgp_has_rot(t)) {
    (void)ra8_gfx_circle(priv_ra8_svgp_mx(t, cx),
                         priv_ra8_svgp_my(t, cy),
                         priv_ra8_svgp_sx(t, r),
                         fill,
                         true);
    return;
  }
  int32_t xs[k_svg_circle_seg] = {};
  int32_t ys[k_svg_circle_seg] = {};
  /* Bounded: k_svg_circle_seg vertices around the circle. */
  for (int32_t k = 0; k < (int32_t)k_svg_circle_seg; ++k) {
    const float ang = (s_svg_2pi * (float)k) / (float)k_svg_circle_seg;
    const float dx  = (float)r * cosf(ang);
    const float dy  = (float)r * sinf(ang);
    priv_ra8_svgp_map_point(t, cx + (int32_t)dx, cy + (int32_t)dy, &xs[k], &ys[k]);
  }
  if (gi >= 0) {
    priv_ra8_svgp_fill_poly_grad(xs, ys, (int32_t)k_svg_circle_seg, &t->grads->g[gi]);
  } else {
    priv_ra8_svgp_fill_poly(xs, ys, (int32_t)k_svg_circle_seg, fill);
  }
}

void priv_ra8_svgp_draw_line(const uint8_t* s, size_t len, const svg_xform_t* t)
{
  const uint32_t stroke = priv_ra8_svgp_attr_paint(s, len, "stroke", (uint32_t)k_svg_no_paint);
  if (stroke == (uint32_t)k_svg_no_paint) {
    return;
  }
  const int32_t x1  = priv_ra8_svgp_attr_num(s, len, "x1", 0);
  const int32_t y1  = priv_ra8_svgp_attr_num(s, len, "y1", 0);
  const int32_t x2  = priv_ra8_svgp_attr_num(s, len, "x2", 0);
  const int32_t y2  = priv_ra8_svgp_attr_num(s, len, "y2", 0);
  int32_t       fx1 = 0;
  int32_t       fy1 = 0;
  int32_t       fx2 = 0;
  int32_t       fy2 = 0;
  priv_ra8_svgp_map_point(t, x1, y1, &fx1, &fy1);
  priv_ra8_svgp_map_point(t, x2, y2, &fx2, &fy2);
  (void)ra8_gfx_line(fx1, fy1, fx2, fy2, stroke);
}
 
/* ===========================================================================
 * Polygon / polyline (a `points` list + a scanline polygon fill)
 * ===========================================================================
 */

RA8_INTERNAL
static int32_t
internal_parse_points(const uint8_t* v, size_t vlen, const svg_xform_t* t, int32_t* xs, int32_t* ys)
{
  size_t  k = 0U;
  int32_t n = 0;
  /* Bounded: <= k_svg_poly_max pairs; k advances past each number. */
  while (n < (int32_t)k_svg_poly_max) {
    while ((k < vlen) && (priv_ra8_svgp_ws((char)v[k]) || (v[k] == (uint8_t)','))) {
      ++k;
    }
    if (k >= vlen) {
      break;
    }
    const int32_t ux = priv_ra8_svgp_num(v, vlen, &k);
    const int32_t uy = priv_ra8_svgp_num(v, vlen, &k);
    priv_ra8_svgp_map_point(t, ux, uy, &xs[n], &ys[n]);
    ++n;
  }
  return n;
}

RA8_INTERNAL
static void internal_sort_i32(int32_t* a, int32_t m)
{
  /* Bounded: m <= k_svg_poly_max. */
  for (int32_t i = 1; i < m; ++i) {
    const int32_t key = a[i];
    int32_t       j   = i - 1;
    while ((j >= 0) && (a[j] > key)) {
      a[j + 1] = a[j];
      --j;
    }
    a[j + 1] = key;
  }
}

RA8_INTERNAL
static int32_t
internal_scanline_x(const int32_t* xs, const int32_t* ys, int32_t n, int32_t y, int32_t* xint)
{
  int32_t m = 0;
  /* Bounded: one test per polygon edge (n edges). */
  /* mcdc-deactivated: the polygon point count n is itself capped at k_svg_poly_max by the point parser, so the crossing count m (<= edges processed <= i < n <= k_svg_poly_max) can never reach k_svg_poly_max before i exhausts n; (m < k_svg_poly_max) is invariantly true and its false arm is unreachable. */
  for (int32_t i = 0; (i < n) && (m < (int32_t)k_svg_poly_max); ++i) {
    const int32_t j  = (i + 1) % n;
    const int32_t y0 = ys[i];
    const int32_t y1 = ys[j];
    /* mcdc-deactivated: the fourth condition (y < y0) is the exact boolean negation of the first (y0 <= y), so it cannot be flipped independently of C1; the C4 independence pair is structurally unreachable. */
    if (((y0 <= y) && (y < y1)) || ((y1 <= y) && (y < y0))) {
      const int32_t x0      = xs[i];
      const int32_t x1      = xs[j];
      const int64_t y_delta = (int64_t)y - (int64_t)y0;
      const int64_t x_delta = (int64_t)x1 - (int64_t)x0;
      const int64_t divisor = (int64_t)y1 - (int64_t)y0;
      const int64_t offset  = (y_delta * x_delta) / divisor;
      xint[m]               = x0 + (int32_t)offset;
      ++m;
    }
  }
  return m;
}

void priv_ra8_svgp_fill_poly(const int32_t* xs, const int32_t* ys, int32_t n, uint32_t color)
{
  if (n < (int32_t)k_svg_poly_min) {
    return;
  }
  int32_t ymin = ys[0];
  int32_t ymax = ys[0];
  for (int32_t i = 1; i < n; ++i) {
    ymin = (ys[i] < ymin) ? ys[i] : ymin;
    ymax = (ys[i] > ymax) ? ys[i] : ymax;
  }
  /* Bounded: ymax - ymin <= the framebuffer-box height. */
  for (int32_t y = ymin; y <= ymax; ++y) {
    int32_t       xint[k_svg_poly_max] = {};
    const int32_t m                    = internal_scanline_x(xs, ys, n, y, xint);
    internal_sort_i32(xint, m);
    for (int32_t k = 0; (k + 1) < m; k += 2) {
      (void)ra8_gfx_line(xint[k], y, xint[k + 1], y, color);
    }
  }
}

RA8_INTERNAL
static uint32_t internal_col_lerp(uint32_t a, uint32_t b, float f)
{
  const uint32_t ra_bits = (a >> (uint32_t)k_svg_sh_r) & (uint32_t)k_svg_chan_mask;
  const uint32_t ga_bits = (a >> (uint32_t)k_svg_hex_chan) & (uint32_t)k_svg_chan_mask;
  const uint32_t ba_bits = a & (uint32_t)k_svg_chan_mask;
  const uint32_t rb_bits = (b >> (uint32_t)k_svg_sh_r) & (uint32_t)k_svg_chan_mask;
  const uint32_t gb_bits = (b >> (uint32_t)k_svg_hex_chan) & (uint32_t)k_svg_chan_mask;
  const uint32_t bb_bits = b & (uint32_t)k_svg_chan_mask;
  const int32_t  ra      = (int32_t)ra_bits;
  const int32_t  ga      = (int32_t)ga_bits;
  const int32_t  ba      = (int32_t)ba_bits;
  const int32_t  rb      = (int32_t)rb_bits;
  const int32_t  gb      = (int32_t)gb_bits;
  const int32_t  bb      = (int32_t)bb_bits;
  const int32_t  rd      = rb - ra;
  const int32_t  gd      = gb - ga;
  const int32_t  bd      = bb - ba;
  const int32_t  r       = ra + (int32_t)((float)rd * f);
  const int32_t  g       = ga + (int32_t)((float)gd * f);
  const int32_t  bl      = ba + (int32_t)((float)bd * f);
  return ((uint32_t)r << (uint32_t)k_svg_sh_r) | ((uint32_t)g << (uint32_t)k_svg_hex_chan) |
         (uint32_t)bl;
}

RA8_INTERNAL
static uint32_t internal_grad_eval(const svg_grad_t* g, float px, float py)
{
  if (g->nstops == 0U) {
    return (uint32_t)k_svg_def_fill;
  }
  float p = 0.0F;
  if (g->kind == (uint8_t)k_svg_grad_radial) {
    const float dx = px - g->x1;
    const float dy = py - g->y1;
    const float rr = (g->x2 > 0.0F) ? g->x2 : 1.0F;
    p              = sqrtf((dx * dx) + (dy * dy)) / rr;
  } else {
    const float vx   = g->x2 - g->x1;
    const float vy   = g->y2 - g->y1;
    const float len2 = (vx * vx) + (vy * vy);
    p                = (len2 > 0.0F) ? ((((px - g->x1) * vx) + ((py - g->y1) * vy)) / len2) : 0.0F;
  }
  if (p <= g->stops[0].off) {
    return g->stops[0].col;
  }
  const uint8_t last = (uint8_t)(g->nstops - 1U);
  if (p >= g->stops[last].off) {
    return g->stops[last].col;
  }
  /* Bounded: at most nstops-1 stop brackets. */
  for (uint8_t i = 0U; i < last; ++i) {
    const float o0 = g->stops[i].off;
    const float o1 = g->stops[i + 1U].off;
    /* mcdc-deactivated: the loop is entered only when p > stops[0].off, and reaching bracket i without returning requires p to exceed every earlier stop's upper offset, so p >= o0 (== stops[i].off) invariantly holds regardless of stop ordering; (p >= o0) cannot be flipped false. */
    if ((p >= o0) && (p <= o1)) {
      const float f = (o1 > o0) ? ((p - o0) / (o1 - o0)) : 0.0F;
      return internal_col_lerp(g->stops[i].col, g->stops[i + 1U].col, f);
    }
  }
  return g->stops[last].col;
}

void priv_ra8_svgp_fill_poly_grad(const int32_t*    xs,
                                  const int32_t*    ys,
                                  int32_t           n,
                                  const svg_grad_t* g)
{
  if (n < (int32_t)k_svg_poly_min) {
    return;
  }
  int32_t xmin = xs[0];
  int32_t xmax = xs[0];
  int32_t ymin = ys[0];
  int32_t ymax = ys[0];
  for (int32_t i = 1; i < n; ++i) {
    xmin = (xs[i] < xmin) ? xs[i] : xmin;
    xmax = (xs[i] > xmax) ? xs[i] : xmax;
    ymin = (ys[i] < ymin) ? ys[i] : ymin;
    ymax = (ys[i] > ymax) ? ys[i] : ymax;
  }
  const float bw = (xmax > xmin) ? (float)((int64_t)xmax - (int64_t)xmin) : 1.0F;
  const float bh = (ymax > ymin) ? (float)((int64_t)ymax - (int64_t)ymin) : 1.0F;
  /* Bounded: ymax - ymin <= the framebuffer-box height. */
  for (int32_t y = ymin; y <= ymax; ++y) {
    int32_t       xint[k_svg_poly_max] = {};
    const int32_t m                    = internal_scanline_x(xs, ys, n, y, xint);
    internal_sort_i32(xint, m);
    const float py = (float)((int64_t)y - (int64_t)ymin) / bh;
    for (int32_t k = 0; (k + 1) < m; k += 2) {
      /* Bounded: xint[k+1] - xint[k] <= the framebuffer-box width. */
      for (int32_t x = xint[k]; x <= xint[k + 1]; ++x) {
        const float px = (float)((int64_t)x - (int64_t)xmin) / bw;
        (void)ra8_gfx_pixel(x, y, internal_grad_eval(g, px, py));
      }
    }
  }
}

void priv_ra8_svgp_draw_polygon(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, "points", &off, &vl)) {
    return;
  }
  int32_t       xs[k_svg_poly_max] = {};
  int32_t       ys[k_svg_poly_max] = {};
  const int32_t n                  = internal_parse_points(&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);
  }
}

void priv_ra8_svgp_draw_polyline(const uint8_t* s, size_t len, const svg_xform_t* t)
{
  const uint32_t stroke = priv_ra8_svgp_attr_paint(s, len, "stroke", (uint32_t)k_svg_no_paint);
  size_t         off    = 0U;
  size_t         vl     = 0U;
  if ((stroke == (uint32_t)k_svg_no_paint) || !priv_ra8_svgp_attr(s, len, "points", &off, &vl)) {
    return;
  }
  int32_t       xs[k_svg_poly_max] = {};
  int32_t       ys[k_svg_poly_max] = {};
  const int32_t n                  = internal_parse_points(&s[off], vl, t, xs, ys);
  /* Bounded: n - 1 segments. */
  for (int32_t i = 0; (i + 1) < n; ++i) {
    (void)ra8_gfx_line(xs[i], ys[i], xs[i + 1], ys[i + 1], stroke);
  }
}

RA8_INTERNAL
static float internal_absf(float v)
{
  return (v < 0.0F) ? -v : v;
}

typedef struct {
  float cx;      
  float cy;      
  float rx;      
  float ry;      
  float cos_phi; 
  float sin_phi; 
  float t1;      
  float dt;      
  bool  ok;      
} svg_arc_t;

RA8_INTERNAL
static void internal_arc_solve(svg_arc_t* a,
                               float      x1p,
                               float      y1p,
                               float      rx,
                               float      ry,
                               float      mx,
                               float      my,
                               bool       large,
                               bool       sweep)
{
  const float rx2 = rx * rx;
  const float ry2 = ry * ry;
  const float num = (rx2 * ry2) - (rx2 * y1p * y1p) - (ry2 * x1p * x1p);
  const float den = (rx2 * y1p * y1p) + (ry2 * x1p * x1p);
  float       co  = sqrtf((num > 0.0F) ? (num / den) : 0.0F);
  if (large == sweep) {
    co = -co;
  }
  const float cxp = co * ((rx * y1p) / ry);
  const float cyp = -co * ((ry * x1p) / rx);
  a->cx           = (a->cos_phi * cxp) - (a->sin_phi * cyp) + mx;
  a->cy           = (a->sin_phi * cxp) + (a->cos_phi * cyp) + my;
  a->t1           = atan2f((y1p - cyp) / ry, (x1p - cxp) / rx);
  float dt        = atan2f((-y1p - cyp) / ry, (-x1p - cxp) / rx) - a->t1;
  if (!sweep && (dt > 0.0F)) {
    dt -= s_svg_2pi;
  } else if (sweep && (dt < 0.0F)) {
    dt += s_svg_2pi;
  } else {
    /* The sweep already has the requested direction. */
  }
  a->dt = dt;
  a->rx = rx;
  a->ry = ry;
  a->ok = true;
}

RA8_INTERNAL
static svg_arc_t internal_arc_center(svg_pt_t p0,
                                     svg_pt_t p_end,
                                     int32_t  rx_in,
                                     int32_t  ry_in,
                                     int32_t  rot_deg,
                                     bool     large,
                                     bool     sweep)
{
  static const float k_pi       = 3.14159265F;
  static const float k_deg_half = 180.0F;
  static const float k_half     = 0.5F;
  svg_arc_t          a          = {};
  float              rx         = internal_absf((float)rx_in);
  float              ry         = internal_absf((float)ry_in);
  if ((rx == 0.0F) || (ry == 0.0F) || ((p0.x == p_end.x) && (p0.y == p_end.y))) {
    a.ok = false;
    return a;
  }
  const float phi = (float)rot_deg * (k_pi / k_deg_half);
  a.cos_phi       = cosf(phi);
  a.sin_phi       = sinf(phi);
  const float dx  = (float)((int64_t)p0.x - (int64_t)p_end.x) * k_half;
  const float dy  = (float)((int64_t)p0.y - (int64_t)p_end.y) * k_half;
  const float x1p = (a.cos_phi * dx) + (a.sin_phi * dy);
  const float y1p = -(a.sin_phi * dx) + (a.cos_phi * dy);
  const float lam = ((x1p * x1p) / (rx * rx)) + ((y1p * y1p) / (ry * ry));
  if (lam > 1.0F) {
    const float s = sqrtf(lam);
    rx *= s;
    ry *= s;
  }
  const float mx = (float)((int64_t)p0.x + (int64_t)p_end.x) * k_half;
  const float my = (float)((int64_t)p0.y + (int64_t)p_end.y) * k_half;
  internal_arc_solve(&a, x1p, y1p, rx, ry, mx, my, large, sweep);
  return a;
}

RA8_INTERNAL
static int32_t internal_arc_segs(float dt)
{
  static const float k_arc_step = 0.39269908F;
  int32_t            segs       = (int32_t)(internal_absf(dt) / k_arc_step) + 1;
  if (segs > (int32_t)k_svg_arc_seg_max) {
    segs = (int32_t)k_svg_arc_seg_max;
  }
  return segs;
}

void priv_ra8_svgp_flatten_arc(const svg_xform_t* t,
                               svg_pt_t           p0,
                               const int32_t*     args,
                               svg_pt_t           p_end,
                               int32_t*           xs,
                               int32_t*           ys,
                               int32_t*           n)
{
  const svg_arc_t a = internal_arc_center(p0,
                                          p_end,
                                          args[k_svg_arc_rx],
                                          args[k_svg_arc_ry],
                                          args[k_svg_arc_rot],
                                          args[k_svg_arc_large] != 0,
                                          args[k_svg_arc_sweep] != 0);
  if (!a.ok) {
    if (*n < (int32_t)k_svg_poly_max) {
      priv_ra8_svgp_map_point(t, p_end.x, p_end.y, &xs[*n], &ys[*n]);
      ++(*n);
    }
    return;
  }
  const int32_t segs = internal_arc_segs(a.dt);
  /* Bounded: segs (<= k_svg_arc_seg_max) samples, capped by k_svg_poly_max. */
  for (int32_t j = 1; (j <= segs) && (*n < (int32_t)k_svg_poly_max); ++j) {
    const float th = a.t1 + (a.dt * ((float)j / (float)segs));
    const float ex = a.rx * cosf(th);
    const float ey = a.ry * sinf(th);
    const float px = a.cx + (a.cos_phi * ex) - (a.sin_phi * ey);
    const float py = a.cy + (a.sin_phi * ex) + (a.cos_phi * ey);
    priv_ra8_svgp_map_point(t, (int32_t)px, (int32_t)py, &xs[*n], &ys[*n]);
    ++(*n);
  }
}