reflow_svg_xform.c

Go to the documentation of this file.

 
#include <math.h>
 
#include "ra8_attributes.h"
#include "reflow_svg_internal.h"
 
/* ===========================================================================
 * Coordinate transform + affine `transform=` parsing
 * ===========================================================================
 */

RA8_INTERNAL
static int32_t internal_ux(const svg_xform_t* t, int32_t sx)
{
  return (int32_t)(((float)sx * t->ua) + t->ue);
}

RA8_INTERNAL
static int32_t internal_uy(const svg_xform_t* t, int32_t sy)
{
  return (int32_t)(((float)sy * t->ud) + t->uf);
}

bool priv_ra8_svgp_has_rot(const svg_xform_t* t)
{
  return (t->ub != 0.0F) || (t->uc != 0.0F);
}

void priv_ra8_svgp_map_point(const svg_xform_t* t, int32_t ux, int32_t uy, int32_t* fx, int32_t* fy)
{
  const int32_t px = (int32_t)(((float)ux * t->ua) + ((float)uy * t->uc) + t->ue);
  const int32_t py = (int32_t)(((float)ux * t->ub) + ((float)uy * t->ud) + t->uf);
  *fx              = t->bx + (int32_t)(((int64_t)(px - t->vx) * (int64_t)t->bw) / (int64_t)t->vw);
  *fy              = t->by + (int32_t)(((int64_t)(py - t->vy) * (int64_t)t->bh) / (int64_t)t->vh);
}

int32_t priv_ra8_svgp_mx(const svg_xform_t* t, int32_t sx)
{
  const int32_t ux = internal_ux(t, sx);
  return t->bx + (int32_t)(((int64_t)(ux - t->vx) * (int64_t)t->bw) / (int64_t)t->vw);
}

int32_t priv_ra8_svgp_my(const svg_xform_t* t, int32_t sy)
{
  const int32_t uy = internal_uy(t, sy);
  return t->by + (int32_t)(((int64_t)(uy - t->vy) * (int64_t)t->bh) / (int64_t)t->vh);
}

int32_t priv_ra8_svgp_sx(const svg_xform_t* t, int32_t sw)
{
  const int32_t uw = (int32_t)((float)sw * t->ua);
  return (int32_t)(((int64_t)uw * (int64_t)t->bw) / (int64_t)t->vw);
}

float priv_ra8_svgp_numf(const uint8_t* s, size_t len, size_t* i)
{
  while ((*i < len) && (priv_ra8_svgp_ws((char)s[*i]) || (s[*i] == (uint8_t)','))) {
    ++(*i);
  }
  float sgn = 1.0F;
  if ((*i < len) && ((s[*i] == (uint8_t)'-') || (s[*i] == (uint8_t)'+'))) {
    sgn = (s[*i] == (uint8_t)'-') ? -1.0F : 1.0F;
    ++(*i);
  }
  float v = 0.0F;
  while ((*i < len) && (s[*i] >= (uint8_t)'0') && (s[*i] <= (uint8_t)'9')) {
    v = (v * (float)k_svg_dec) + ((float)s[*i] - (float)'0');
    ++(*i);
  }
  if ((*i < len) && (s[*i] == (uint8_t)'.')) {
    ++(*i);
    float frac = 1.0F;
    while ((*i < len) && (s[*i] >= (uint8_t)'0') && (s[*i] <= (uint8_t)'9')) {
      frac /= (float)k_svg_dec;
      v += frac * ((float)s[*i] - (float)'0');
      ++(*i);
    }
  }
  return v * sgn;
}

RA8_INTERNAL
static svg_utf_t internal_utf_identity(void)
{
  svg_utf_t id = {.a = 1.0F, .b = 0.0F, .c = 0.0F, .d = 1.0F, .e = 0.0F, .f = 0.0F};
  return id;
}

RA8_INTERNAL
static svg_utf_t internal_utf_compose(svg_utf_t a, svg_utf_t b)
{
  svg_utf_t r = {.a = (a.a * b.a) + (a.c * b.b),
                 .b = (a.b * b.a) + (a.d * b.b),
                 .c = (a.a * b.c) + (a.c * b.d),
                 .d = (a.b * b.c) + (a.d * b.d),
                 .e = (a.a * b.e) + (a.c * b.f) + a.e,
                 .f = (a.b * b.e) + (a.d * b.f) + a.f};
  return r;
}

RA8_INTERNAL
static bool internal_is_num_start(const uint8_t* s, size_t len, size_t at)
{
  if (at >= len) {
    return false;
  }
  const char c = (char)s[at];
  return ((c >= '0') && (c <= '9')) || (c == '-') || (c == '+') || (c == '.');
}

typedef enum : uint8_t {
  k_svg_xf_none      = 0U, 
  k_svg_xf_translate = 1U, 
  k_svg_xf_scale     = 2U, 
  k_svg_xf_rotate    = 3U, 
  k_svg_xf_skewx     = 4U, 
  k_svg_xf_skewy     = 5U, 
  k_svg_xf_matrix    = 6U, 
} svg_xf_kind_t;

typedef enum : uint8_t {
  k_svg_xf_arg_a = 0U, 
  k_svg_xf_arg_b = 1U, 
  k_svg_xf_arg_c = 2U, 
  k_svg_xf_arg_d = 3U, 
  k_svg_xf_arg_e = 4U, 
  k_svg_xf_arg_f = 5U, 
} svg_xf_arg_t;

RA8_INTERNAL
static float internal_deg2rad(float deg)
{
  static const float k_pi       = 3.14159265F;
  static const float k_deg_half = 180.0F;
  return deg * (k_pi / k_deg_half);
}

RA8_INTERNAL
static int32_t internal_xform_read(const uint8_t* v, size_t vlen, size_t* j, float* args)
{
  int32_t na = 0;
  /* Bounded: <= k_svg_argc_cube args; each priv_ra8_svgp_numf advances *j. */
  while (na < (int32_t)k_svg_argc_cube) {
    while ((*j < vlen) && (priv_ra8_svgp_ws((char)v[*j]) || (v[*j] == (uint8_t)','))) {
      ++(*j);
    }
    if (!internal_is_num_start(v, vlen, *j)) {
      break;
    }
    args[na] = priv_ra8_svgp_numf(v, vlen, j);
    ++na;
  }
  return na;
}

RA8_INTERNAL
static svg_utf_t internal_xform_rotate(const float* args, int32_t na)
{
  const float co = cosf(internal_deg2rad(args[0]));
  const float si = sinf(internal_deg2rad(args[0]));
  const float cx = (na >= 3) ? args[1] : 0.0F;
  const float cy = (na >= 3) ? args[2] : 0.0F;
  return (svg_utf_t){.a = co,
                     .b = si,
                     .c = -si,
                     .d = co,
                     .e = (cx * (1.0F - co)) + (cy * si),
                     .f = (cy * (1.0F - co)) - (cx * si)};
}

RA8_INTERNAL
static svg_utf_t internal_xform_build(svg_xf_kind_t kind, const float* args, int32_t na)
{
  svg_utf_t result = internal_utf_identity();
  switch (kind) {
    case k_svg_xf_translate:
      result = (svg_utf_t){.a = 1.0F,
                           .b = 0.0F,
                           .c = 0.0F,
                           .d = 1.0F,
                           .e = args[0],
                           .f = (na >= 2) ? args[1] : 0.0F};
      break;
    case k_svg_xf_scale:
      result = (svg_utf_t){.a = args[0],
                           .b = 0.0F,
                           .c = 0.0F,
                           .d = (na >= 2) ? args[1] : args[0],
                           .e = 0.0F,
                           .f = 0.0F};
      break;
    case k_svg_xf_rotate:
      result = internal_xform_rotate(args, na);
      break;
    case k_svg_xf_skewx:
      result = (svg_utf_t){.a = 1.0F,
                           .b = 0.0F,
                           .c = tanf(internal_deg2rad(args[0])),
                           .d = 1.0F,
                           .e = 0.0F,
                           .f = 0.0F};
      break;
    case k_svg_xf_skewy:
      result = (svg_utf_t){.a = 1.0F,
                           .b = tanf(internal_deg2rad(args[0])),
                           .c = 0.0F,
                           .d = 1.0F,
                           .e = 0.0F,
                           .f = 0.0F};
      break;
    case k_svg_xf_matrix:
      result = (svg_utf_t){.a = args[k_svg_xf_arg_a],
                           .b = args[k_svg_xf_arg_b],
                           .c = args[k_svg_xf_arg_c],
                           .d = args[k_svg_xf_arg_d],
                           .e = args[k_svg_xf_arg_e],
                           .f = args[k_svg_xf_arg_f]};
      break;
    case k_svg_xf_none:
    default:
      break;
  }
  return result;
}

RA8_INTERNAL
static svg_xf_kind_t internal_xform_kind(const uint8_t* v, size_t vlen, size_t i)
{
  if (priv_ra8_svgp_starts_ci(v, vlen, i, "translate(")) {
    return k_svg_xf_translate;
  }
  if (priv_ra8_svgp_starts_ci(v, vlen, i, "scale(")) {
    return k_svg_xf_scale;
  }
  if (priv_ra8_svgp_starts_ci(v, vlen, i, "rotate(")) {
    return k_svg_xf_rotate;
  }
  if (priv_ra8_svgp_starts_ci(v, vlen, i, "skewx(")) {
    return k_svg_xf_skewx;
  }
  if (priv_ra8_svgp_starts_ci(v, vlen, i, "skewy(")) {
    return k_svg_xf_skewy;
  }
  if (priv_ra8_svgp_starts_ci(v, vlen, i, "matrix(")) {
    return k_svg_xf_matrix;
  }
  return k_svg_xf_none;
}

RA8_INTERNAL
static svg_utf_t internal_parse_xform(const uint8_t* v, size_t vlen)
{
  svg_utf_t acc = internal_utf_identity();
  size_t    i   = 0U;
  /* Bounded: each pass consumes one `name(...)` group or breaks; <= vlen steps. */
  while (i < vlen) {
    while ((i < vlen) && (priv_ra8_svgp_ws((char)v[i]) || (v[i] == (uint8_t)','))) {
      ++i;
    }
    const svg_xf_kind_t kind = internal_xform_kind(v, vlen, i);
    size_t              op   = i;
    while ((op < vlen) && (v[op] != (uint8_t)'(')) {
      ++op;
    }
    if (op >= vlen) {
      break;
    }
    size_t j = op + 1U;
    if (kind != k_svg_xf_none) {
      float         args[k_svg_path_args] = {};
      const int32_t na                    = internal_xform_read(v, vlen, &j, args);
      acc = internal_utf_compose(acc, internal_xform_build(kind, args, na));
    }
    while ((j < vlen) && (v[j] != (uint8_t)')')) {
      ++j;
    }
    i = (j < vlen) ? (j + 1U) : vlen;
  }
  return acc;
}

void priv_ra8_svgp_apply_xform(svg_xform_t* t, const uint8_t* tag, size_t tlen)
{
  size_t off = 0U;
  size_t vl  = 0U;
  if (!priv_ra8_svgp_attr(tag, tlen, "transform", &off, &vl)) {
    return;
  }
  const svg_utf_t cur = {.a = t->ua, .b = t->ub, .c = t->uc, .d = t->ud, .e = t->ue, .f = t->uf};
  const svg_utf_t out = internal_utf_compose(cur, internal_parse_xform(&tag[off], vl));
  t->ua               = out.a;
  t->ub               = out.b;
  t->uc               = out.c;
  t->ud               = out.d;
  t->ue               = out.e;
  t->uf               = out.f;
}