reflow_svg_internal.h

Go to the documentation of this file.

#pragma once
 
#include <stddef.h>
#include <stdint.h>
 
#include "ra8_attributes.h"

typedef enum : uint32_t {
  k_svg_no_paint    = 0xFFFFFFFFU, 
  k_svg_def_fill    = 0x000000U,   
  k_svg_dec         = 10U,         
  k_svg_hex_base    = 16U,         
  k_svg_hex_a10     = 10U,         
  k_svg_hex_nib     = 4U,          
  k_svg_hex_chan    = 8U,          
  k_svg_hex3        = 3U,          
  k_svg_hex6        = 6U,          
  k_svg_viewbox_n   = 4U,          
  k_svg_bom0        = 0xEFU,       
  k_svg_bom1        = 0xBBU,       
  k_svg_bom2        = 0xBFU,       
  k_svg_bom_len     = 3U,          
  k_svg_poly_max    = 64U,         
  k_svg_poly_min    = 3U,          
  k_svg_path_args   = 7U,          
  k_svg_path_ep     = 2U,          
  k_svg_argc_quad   = 4U,          
  k_svg_argc_cube   = 6U,          
  k_svg_curve_seg   = 12U,         
  k_svg_cube_ey     = 5U,          
  k_svg_arc_rx      = 0U,          
  k_svg_arc_ry      = 1U,          
  k_svg_arc_rot     = 2U,          
  k_svg_arc_large   = 3U,          
  k_svg_arc_sweep   = 4U,          
  k_svg_arc_ex      = 5U,          
  k_svg_arc_ey      = 6U,          
  k_svg_arc_seg_max = 24U,         
  k_svg_g_depth_max = 8U,          
  k_svg_circle_seg  = 24U,         
  k_svg_rect_pts    = 4U,          
  k_svg_grad_max    = 8U,          
  k_svg_grad_stops  = 8U,          
  k_svg_grad_id     = 32U,         
  k_svg_grad_linear = 0U,          
  k_svg_grad_radial = 1U,          
  k_svg_chan_mask   = 0xFFU,       
  k_svg_sh_r        = 16U,         
} priv_svg_consts_t;

typedef struct {
  int32_t x; 
  int32_t y; 
} svg_pt_t;

typedef struct {
  float a; 
  float b; 
  float c; 
  float d; 
  float e; 
  float f; 
} svg_utf_t;

typedef struct svg_grads svg_grads_t;

typedef struct {
  int32_t bx; 
  int32_t by; 
  int32_t bw; 
  int32_t bh; 
  int32_t vx; 
  int32_t vy; 
  int32_t vw; 
  int32_t vh; 
  /* User-space `transform=` as a 2x3 affine, applied to a point BEFORE the
   * viewBox->box map: (x,y) -> (ua*x+uc*y+ue, ub*x+ud*y+uf). Identity
   * (ua=ud=1, others 0) reproduces the untransformed render byte-for-byte; the
   * axis-aligned case (ub==0 && uc==0) keeps the fast-path primitives. */
  float ua; 
  float ub; 
  float uc; 
  float ud; 
  float ue; 
  float uf; 
  /* Gradients defined in the document, scanned once before the render walk.
   * NULL keeps the solid-fill render byte-for-byte unchanged. A shape whose
   * `fill="url(#id)"` resolves here is filled per-pixel via priv_ra8_svgp_fill_poly_grad. */
  const svg_grads_t* grads; 
} svg_xform_t;

typedef struct {
  float    off; 
  uint32_t col; 
} svg_stop_t;

typedef struct {
  uint8_t    kind;                    
  uint8_t    nstops;                  
  char       id[k_svg_grad_id];       
  float      x1;                      
  float      y1;                      
  float      x2;                      
  float      y2;                      
  svg_stop_t stops[k_svg_grad_stops]; 
} svg_grad_t;

struct svg_grads {
  int32_t    n;                 
  svg_grad_t g[k_svg_grad_max]; 
};
 
/* ===========================================================================
 * Cross-TU helper prototypes (defined `static`-free in one TU, called in others)
 * ===========================================================================
 */

RA8_PRIV bool priv_ra8_svgp_ws(char c);

RA8_PRIV char priv_ra8_svgp_lc(char c);

RA8_PRIV bool priv_ra8_svgp_starts_ci(const uint8_t* s, size_t len, size_t at, const char* lit);

RA8_PRIV size_t priv_ra8_svgp_find_ci(const uint8_t* s, size_t len, size_t from, const char* lit);

RA8_PRIV int32_t priv_ra8_svgp_num(const uint8_t* s, size_t len, size_t* i);

RA8_PRIV bool
priv_ra8_svgp_attr(const uint8_t* s, size_t len, const char* name, size_t* voff, size_t* vlen);

RA8_PRIV int32_t priv_ra8_svgp_attr_num(const uint8_t* s,
                                        size_t         len,
                                        const char*    name,
                                        int32_t        def);

RA8_PRIV uint32_t priv_ra8_svgp_paint(const uint8_t* s, size_t len);

RA8_PRIV uint32_t priv_ra8_svgp_attr_paint(const uint8_t* s,
                                           size_t         len,
                                           const char*    name,
                                           uint32_t       def);

RA8_PRIV uint32_t priv_ra8_svgp_resolve_fill(const uint8_t*     s,
                                             size_t             len,
                                             const svg_xform_t* t,
                                             uint32_t           def,
                                             int32_t*           gi);

RA8_PRIV float priv_ra8_svgp_numf(const uint8_t* s, size_t len, size_t* i);

RA8_PRIV bool priv_ra8_svgp_has_rot(const svg_xform_t* t);

RA8_PRIV void
priv_ra8_svgp_map_point(const svg_xform_t* t, int32_t ux, int32_t uy, int32_t* fx, int32_t* fy);

RA8_PRIV int32_t priv_ra8_svgp_mx(const svg_xform_t* t, int32_t sx);

RA8_PRIV int32_t priv_ra8_svgp_my(const svg_xform_t* t, int32_t sy);

RA8_PRIV int32_t priv_ra8_svgp_sx(const svg_xform_t* t, int32_t sw);

RA8_PRIV void priv_ra8_svgp_apply_xform(svg_xform_t* t, const uint8_t* tag, size_t tlen);

RA8_PRIV void
priv_ra8_svgp_fill_poly(const int32_t* xs, const int32_t* ys, int32_t n, uint32_t color);

RA8_PRIV void
priv_ra8_svgp_fill_poly_grad(const int32_t* xs, const int32_t* ys, int32_t n, const svg_grad_t* g);

RA8_PRIV int32_t priv_match_grad(const svg_grads_t* grads, const uint8_t* val, size_t vlen);

RA8_PRIV 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);

RA8_PRIV void priv_ra8_svgp_draw_rect(const uint8_t* s, size_t len, const svg_xform_t* t);

RA8_PRIV void priv_ra8_svgp_draw_circle(const uint8_t* s, size_t len, const svg_xform_t* t);

RA8_PRIV void priv_ra8_svgp_draw_line(const uint8_t* s, size_t len, const svg_xform_t* t);

RA8_PRIV void priv_ra8_svgp_draw_polygon(const uint8_t* s, size_t len, const svg_xform_t* t);

RA8_PRIV void priv_ra8_svgp_draw_polyline(const uint8_t* s, size_t len, const svg_xform_t* t);

RA8_PRIV void priv_ra8_svgp_draw_path(const uint8_t* s, size_t len, const svg_xform_t* t);