code wiki / (root) / nx_glyph_stroke.nx
`nx_glyph_stroke.nx` source

↩ module page · 286 lines · 13384 B
1// nx_glyph_stroke.nx -- RUNG 1 of the sovereign FONT BUILDER: the STROKE PEN. A glyph stroke is a centerline
2// polyline + a width; this renders it as a filled thick outline (perpendicular-offset segment quads + round
3// joins/caps as discs), all wound the SAME way so the AA rasterizer's nonzero fill UNIONS them into one smooth
4// shape. Curves are just a curved centerline -> the hard letters (s, arches) become easy, and it's the natural
5// unit for CJK strokes/radicals (the path to kanji). No floats: integer isqrt for the perpendicular. ORIGINAL.
6import "nx_syscalls.nx"
7import "nx_vecmath.nx"
8const K_MAGIC_250000: i64 = 250000
9
10// integer square root (Newton).
11func gs_isqrt(n: i64) -> i64 { return vm_isqrt(n) }
12
13// emit one thick segment quad p0->p1 of width w, wound CCW (consistent with gs_disc) so nonzero UNIONS.
14func gs_seg(xs: *i64, ys: *i64, cstart: *i64, clen: *i64, np: *i64, nc: *i64, x0: i64, y0: i64, x1: i64, y1: i64, w: i64) -> i64 {
  let dx: i64 = x1 - x0
  let dy: i64 = y1 - y0
  let len: i64 = gs_isqrt(dx*dx + dy*dy)
  if len == 0 { return 0 }
  let hw: i64 = w / 2
  let nx: i64 = ((0 - dy) * hw) / len          // left-normal * half-width
  let ny: i64 = (dx * hw) / len
  let p: i64 = np[0]
  xs[p+0]=x0+nx; ys[p+0]=y0+ny
  xs[p+1]=x0-nx; ys[p+1]=y0-ny
  xs[p+2]=x1-nx; ys[p+2]=y1-ny
  xs[p+3]=x1+nx; ys[p+3]=y1+ny
  cstart[nc[0]]=p; clen[nc[0]]=4
  np[0]=p+4; nc[0]=nc[0]+1
  return 0
30}
31
32// emit a 16-gon disc (round join/cap) of radius r at (cx,cy), wound CCW. rev=1 -> reverse (a hole).
33// symmetric round-to-nearest for the /1000 vertex scale -- truncation collapsed small discs
34// (r<=2: every non-axis vertex floored to 0 => zero-area 16-gon => invisible punctuation dots).
35func _gs_rnd1000(v: i64) -> i64 { if v >= 0 { return (v + 500) / 1000 } return 0 - ((500 - v) / 1000) }
36func gs_disc(xs: *i64, ys: *i64, cstart: *i64, clen: *i64, np: *i64, nc: *i64, cs: *i64, sn: *i64, cx: i64, cy: i64, r: i64, rev: i64) -> i64 {
  let p: i64 = np[0]
  var k: i64 = 0
  while k < 16 {
      var kk: i64 = k
      if rev == 1 { kk = 15 - k }
      xs[p+k] = cx + _gs_rnd1000(r * cs[kk])
      ys[p+k] = cy + _gs_rnd1000(r * sn[kk])
      k = k + 1
  }
  cstart[nc[0]]=p; clen[nc[0]]=16
  np[0]=p+16; nc[0]=nc[0]+1
  return 0
49}
50
51// stroke a polyline (n points) at width w: segment quads + a disc at every INTERIOR vertex (round joins).
52// ★TERMINALS: OPEN strokes get FLAT (butt) caps -- no end disc, the perpendicular segment quad ends the
53// stroke square. That is the professional grotesque/geometric look (Helvetica/Arial), vs round blobs that
54// read as a casual marker font. CLOSED loops (o/e/O/0 bowls, first==last) keep all discs (every point is a
55// join, not a terminal) so the ring stays continuous.
56func gs_stroke(xs: *i64, ys: *i64, cstart: *i64, clen: *i64, np: *i64, nc: *i64, cs: *i64, sn: *i64, ptsx: *i64, ptsy: *i64, n: i64, w: i64) -> i64 {
  var closed: i64 = 0
  if ptsx[0] == ptsx[n-1] { if ptsy[0] == ptsy[n-1] { closed = 1 } }
  var i: i64 = 0
  while i < n - 1 {
      gs_seg(xs, ys, cstart, clen, np, nc, ptsx[i], ptsy[i], ptsx[i+1], ptsy[i+1], w)
      i = i + 1
  }
  i = 0
  while i < n {
      var put: i64 = 1
      if closed == 0 {                              // open stroke: butt caps -> skip the two endpoints
          if i == 0 { put = 0 }
          if i == n-1 { put = 0 }
      }
      if put == 1 { gs_disc(xs, ys, cstart, clen, np, nc, cs, sn, ptsx[i], ptsy[i], w / 2, 0) }
      i = i + 1
  }
  return 0
75}
76
77// ★ROLE-AWARE MODULATED stroke (the Metafont nib): per-segment width from stroke DIRECTION -- vertical
78// segments get wv (or wsw when tagged as interior CURVE walls: grotesques swell round walls over stems to
79// compensate the optical thinning of curves), horizontal get wh, linear blend by |dy|/len between. Join
80// discs take the LOCAL max of adjacent segment widths so joints stay covered. Open strokes keep butt ends;
81// closed loops disc every vertex. tags==0 -> no swelling. gs_stroke (uniform) stays for existing callers.
82func gs_stroke_mod2(xs: *i64, ys: *i64, cstart: *i64, clen: *i64, np: *i64, nc: *i64, cs: *i64, sn: *i64,
                  ptsx: *i64, ptsy: *i64, n: i64, wv: i64, wh: i64, wsw: i64, tags: *i64) -> i64 {
  if n < 2 { return 0 }
  let segw: *i64 = sys_mmap(8*(n+2)) as *i64
  var i: i64 = 0
  while i < n - 1 {
      let dx: i64 = ptsx[i+1]-ptsx[i]
      var ady: i64 = ptsy[i+1]-ptsy[i]
      if ady < 0 { ady = 0 - ady }
      let len: i64 = gs_isqrt(dx*dx + ady*ady)
      var wtop: i64 = wv
      if (tags as i64) != 0 { if tags[i] == 1 { wtop = wsw } }
      var w: i64 = wtop
      if len > 0 { w = wh + ((wtop - wh) * ady) / len }
      segw[i] = w
      gs_seg(xs, ys, cstart, clen, np, nc, ptsx[i], ptsy[i], ptsx[i+1], ptsy[i+1], w)
      i = i + 1
  }
  var closed: i64 = 0
  if ptsx[0] == ptsx[n-1] { if ptsy[0] == ptsy[n-1] { closed = 1 } }
  i = 0
  while i < n {
      var put: i64 = 1
      if closed == 0 { if i == 0 { put = 0 } ; if i == n-1 { put = 0 } }   // butt ends on open strokes
      if put == 1 {
          var wp: i64 = 0
          var wn: i64 = 0
          if i > 0 { wp = segw[i-1] }
          if i < n-1 { wn = segw[i] }
          if closed == 1 { if i == 0 { wp = segw[n-2] } ; if i == n-1 { wn = segw[0] } }
          var r: i64 = wp
          if wn > r { r = wn }
          gs_disc(xs, ys, cstart, clen, np, nc, cs, sn, ptsx[i], ptsy[i], r / 2, 0)
      }
      i = i + 1
  }
  return 0
119}
120
121// signed shoelace area x2 of a polygon (this convention: clockwise-on-screen/y-down = NEGATIVE -- the same
122// orientation gs_disc traces, so "solid" outlines must be NEGATIVE to add with discs under nonzero fill).
123func gs_area2(px: *i64, py: *i64, n: i64) -> i64 {
  var a: i64 = 0
  var i: i64 = 0
  var j: i64 = n - 1
  while i < n { a = a + (px[j] + px[i]) * (py[j] - py[i]); j = i; i = i + 1 }
  return a
129}
130// emit polygon with the requested orientation: want_pos=1 -> positive shoelace area, else negative.
131func gs_emit_oriented(xs: *i64, ys: *i64, cstart: *i64, clen: *i64, np: *i64, nc: *i64,
                    px: *i64, py: *i64, n: i64, want_pos: i64) -> i64 {
  let a: i64 = gs_area2(px, py, n)
  var fwd: i64 = 1
  if want_pos == 1 { if a < 0 { fwd = 0 } }
  if want_pos == 0 { if a > 0 { fwd = 0 } }
  let p: i64 = np[0]
  var k: i64 = 0
  while k < n {
      var src: i64 = k
      if fwd == 0 { src = n-1-k }
      xs[p+k]=px[src]; ys[p+k]=py[src]
      k = k + 1
  }
  cstart[nc[0]]=p; clen[nc[0]]=n
  np[0]=p+n; nc[0]=nc[0]+1
  return 0
148}
149
150// ★VARIABLE-WIDTH OUTLINE stroke: the professional construction for a MODULATED pen. Instead of segment
151// quads + join discs (whose radius-mismatch BULGES wherever adjacent segments differ in width -- the ragged
152// edges the swelled nib exposed), emit ONE smooth outline: per-point width = mean of adjacent segment
153// widths, per-point MITER offset along the angle bisector (clamped 2.5x), left side forward + right side
154// back = a single closed polygon (butt ends fall out flat). Closed loops emit outer + reversed inner ring
155// (nonzero winding -> clean annulus). Width now interpolates CONTINUOUSLY along curves -- no lumps.
156func gs_stroke_var(xs: *i64, ys: *i64, cstart: *i64, clen: *i64, np: *i64, nc: *i64,
                 ptsx: *i64, ptsy: *i64, n: i64, segw: *i64, closed: i64) -> i64 {
  if n < 2 { return 0 }
  var m: i64 = n
  if closed == 1 { m = n - 1 }                          // drop the duplicated closing point
  if m < 2 { return 0 }
  let lxo: *i64 = sys_mmap(8*(m+2)) as *i64
  let lyo: *i64 = sys_mmap(8*(m+2)) as *i64
  let rxo: *i64 = sys_mmap(8*(m+2)) as *i64
  let ryo: *i64 = sys_mmap(8*(m+2)) as *i64
  var i: i64 = 0
  while i < m {
      // adjacent segment indices (wrap when closed; clamp when open)
      var sp: i64 = i - 1
      var sn2: i64 = i
      if closed == 1 { if sp < 0 { sp = m - 1 } ; if sn2 > m-1 { sn2 = 0 } }
      else { if sp < 0 { sp = 0 } ; if sn2 > n-2 { sn2 = n-2 } }
      // unit normals (x1000) of the two adjacent segments
      var p0: i64 = i - 1
      if p0 < 0 { if closed == 1 { p0 = m - 1 } else { p0 = 0 } }
      var p2: i64 = i + 1
      if p2 > m-1 { if closed == 1 { p2 = 0 } else { p2 = m-1 } }
      var d1x: i64 = ptsx[i]-ptsx[p0]
      var d1y: i64 = ptsy[i]-ptsy[p0]
      var d2x: i64 = ptsx[p2]-ptsx[i]
      var d2y: i64 = ptsy[p2]-ptsy[i]
      if p0 == i { d1x = d2x; d1y = d2y }               // open start: use the forward segment
      if p2 == i { d2x = d1x; d2y = d1y }               // open end: use the backward segment
      let l1: i64 = gs_isqrt(d1x*d1x+d1y*d1y)
      let l2: i64 = gs_isqrt(d2x*d2x+d2y*d2y)
      var n1x: i64 = 0
      var n1y: i64 = 0
      var n2x: i64 = 0
      var n2y: i64 = 0
      if l1 > 0 { n1x = (0-d1y)*1000/l1; n1y = d1x*1000/l1 }
      if l2 > 0 { n2x = (0-d2y)*1000/l2; n2y = d2x*1000/l2 }
      var nmx: i64 = n1x + n2x
      var nmy: i64 = n1y + n2y
      var LL: i64 = nmx*nmx + nmy*nmy
      // per-point width = mean of adjacent segment widths
      let w: i64 = (segw[sp] + segw[sn2]) / 2
      var vx: i64 = 0
      var vy: i64 = 0
      if LL >= K_MAGIC_250000 {                                 // miter: v = nm * w * 1000 / |nm|^2 (exact w/2 when straight)
          vx = (nmx * w * 1000) / LL
          vy = (nmy * w * 1000) / LL
      } else {                                          // near-reversal: clamp 2x half-width along the bisector
          let ln: i64 = gs_isqrt(LL)
          if ln > 0 { vx = (nmx * w) / ln; vy = (nmy * w) / ln }
      }
      // ★ASYMMETRIC SHARP CORNERS (what real grotesques do): the INNER side keeps the EXACT miter (an
      // under-length inner miter makes the sides cross = a bowtie that CANCELS the apex -- the truncated-V
      // bug's second act), while the OUTER side is BEVELLED at 1.15x half-width (Helvetica flat-cuts its
      // V apex) so pointed apexes don't spear far past the metric lines. Inner = the side toward the
      // neighbours' chord midpoint (the concave side).
      var vxL: i64 = vx
      var vyL: i64 = vy
      var vxR: i64 = 0 - vx
      var vyR: i64 = 0 - vy
      let lex: i64 = gs_isqrt(vx*vx + vy*vy)
      let cl: i64 = (w * 115) / 200
      if lex > cl {
          let cmx: i64 = (ptsx[p0] + ptsx[p2]) / 2 - ptsx[i]
          let cmy: i64 = (ptsy[p0] + ptsy[p2]) / 2 - ptsy[i]
          let side: i64 = vx*cmx + vy*cmy               // >0: +v points toward the chord = inner
          if side > 0 {                                 // L(+v) inner-exact; R(-v) outer-bevel
              vxR = (vxR * cl) / lex
              vyR = (vyR * cl) / lex
          } else {                                      // R(-v) inner-exact; L(+v) outer-bevel
              vxL = (vxL * cl) / lex
              vyL = (vyL * cl) / lex
          }
      }
      lxo[i] = ptsx[i] + vxL
      lyo[i] = ptsy[i] + vyL
      rxo[i] = ptsx[i] + vxR
      ryo[i] = ptsy[i] + vyR
      i = i + 1
  }
  // ★WINDING NORMALIZATION: every solid outline must wind the SAME way as gs_disc (NEGATIVE shoelace in
  // this y-down convention) or nonzero-fill CANCELS where strokes/discs overlap (bowl-stem junction
  // notches; cap discs punching holes -- the eyeballed "candy-cane" bug). A closed ring's INNER contour
  // is the one exception: it winds OPPOSITE (positive) = the counter.
  if closed == 0 {
      // one polygon: left side forward, right side backward (butt ends flat)
      let tpx: *i64 = sys_mmap(8*(2*m+2)) as *i64
      let tpy: *i64 = sys_mmap(8*(2*m+2)) as *i64
      var k: i64 = 0
      while k < m { tpx[k]=lxo[k]; tpy[k]=lyo[k]; k=k+1 }
      k = 0
      while k < m { tpx[m+k]=rxo[m-1-k]; tpy[m+k]=ryo[m-1-k]; k=k+1 }
      gs_emit_oriented(xs, ys, cstart, clen, np, nc, tpx, tpy, 2*m, 0)
  } else {
      // annulus: OUTER ring disc-winding (negative), INNER ring positive (the counter/hole)
      var aL: i64 = gs_area2(lxo, lyo, m)
      var aR: i64 = gs_area2(rxo, ryo, m)
      var absL: i64 = aL
      if absL < 0 { absL = 0 - absL }
      var absR: i64 = aR
      if absR < 0 { absR = 0 - absR }
      if absL >= absR {
          gs_emit_oriented(xs, ys, cstart, clen, np, nc, lxo, lyo, m, 0)
          gs_emit_oriented(xs, ys, cstart, clen, np, nc, rxo, ryo, m, 1)
      } else {
          gs_emit_oriented(xs, ys, cstart, clen, np, nc, rxo, ryo, m, 0)
          gs_emit_oriented(xs, ys, cstart, clen, np, nc, lxo, lyo, m, 1)
      }
  }
  return 0
265}
266
267// fill a 16-entry cos/sin table (x1000) into cs/sn (angles 0,22.5,...,337.5).
268func gs_init_trig(cs: *i64, sn: *i64) -> i64 {
  cs[0]=1000;  sn[0]=0
  cs[1]=924;   sn[1]=383
  cs[2]=707;   sn[2]=707
  cs[3]=383;   sn[3]=924
  cs[4]=0;     sn[4]=1000
  cs[5]=0-383; sn[5]=924
  cs[6]=0-707; sn[6]=707
  cs[7]=0-924; sn[7]=383
  cs[8]=0-1000;sn[8]=0
  cs[9]=0-924; sn[9]=0-383
  cs[10]=0-707;sn[10]=0-707
  cs[11]=0-383;sn[11]=0-924
  cs[12]=0;    sn[12]=0-1000
  cs[13]=383;  sn[13]=0-924
  cs[14]=707;  sn[14]=0-707
  cs[15]=924;  sn[15]=0-383
  return 0
286}
nx_glyph_stroke.nx source

`nx_glyph_stroke.nx` source
