skrift 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: fd0c67b57871e673fb91b56bd67172fc1f588b69d37dd777cd89ac65fc04a056
+  data.tar.gz: b31c46b7d93b1794e72bb894deb73ca54d63bfc641a7c0e3b9f72d390f97a30b
+SHA512:
+  metadata.gz: 87c484791a46b5e82819d12e6c2633bdd12704f92f78e282f1b97cd89931e52827ec4e97e2b2bed52518cda038adad0a77a49105976f6154fa9e85801e04b529
+  data.tar.gz: a21dd2bd6a20d90639da4264b186d8bae76675e2d9ef4d44a1438d40a4df912396dba0bb3c03aadd58c8518f408e99e3d27bb3a5dae4ff1afc8ad38f238ec308

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/Gemfile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in skrift.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+
+gem "rspec", "~> 3.0"

data/LICENSE.txt

@@ -0,0 +1,18 @@
+ISC License
+
+© 2023 Vidar Hokstad
+
+Based on libschrift, which is
+© 2019-2022 Thomas Oltmann and contributors
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

data/README.md

@@ -0,0 +1,150 @@
+
+# Skrift
+
+Vidar Hokstad <vidar@hokstad.com>
+
+This started out as a Ruby port of `libschrift`. If you need
+performance, and don't mind a C dependency, consider that over this.
+
+If you're fine with slower rendering (*cache* glyphs after rendering)
+and want *pure Ruby*, consider this gem, with the caveat that the
+rewrite is *new* and likely buggy.
+
+## Name
+
+"Skrift" is Norwegian for "text", "writing", or "scripture", and so a
+close cognate of "Schrift". Since I'm Norwegian, it seemed like an
+appropriate way to set this apart from `libschrift` and ensure that if
+anyone want to do a gem directly wrapping the C librarly the name remains
+available.
+
+## License
+
+While it's rewritten in Ruby and changed reasonably since, given it owes
+so much to `libschrift`, I decided to stick with the same license (the
+ISC License), since it's very permissive. See `LICENSE.md`
+
+## This code is opinionated
+
+Firstly, the choice to start by rewriting `libschrift` is because that
+library is an excellent demonstration of a minimalist feature set and
+compact code that I wanted.
+
+However, on top of the structure inherited largely from `libschrift`,
+while working on this code, I've formed my own opinions on it which
+applies to *this library*, and which the author of `libschrift` may or
+may not agree with. These are *my responsibility*:
+
+* Small code size is a virtue as long as it improves rather than hinders
+  understanding. Any feature will be weighed against complexity cost.
+
+* Features that add a lot of complexity may be better written as a
+  separate library (I will happily work with you to ensure it's easy for
+  users to combine your library with `Skrift`)
+
+* Hinting is predominantly important with low resolution. With the trend
+  firmly being towards 4K or 8K displays, putting a lot of effort into
+  hinting is pointless. I will *consider* hinting if someone wants to
+  contribute hinting code, but not at the cost of a lot of complexity (
+  unless you build it as a standalone extension)
+  
+* The current algo uses anti-aliasing. I will *consider* adding support
+  for monochrome rendering for the same reason as above, but currently, AA
+  is still *necessary* for best possible results at small sizes, at least
+  on FHD displays, so since it's already here, I'll *keep* the AA
+  support as long as lower resolution displays are still around.
+  
+* Feature "completeness" for the sake of completeness are not of interest.
+  E.g. I have no interest in parsing the parts of the TTF or OTF formats
+  this library won't use (but if you write a *compact*, well written
+  TTF/ OTF parser in pure Ruby, I *might* consider tearing out the
+  font parsing from this gem if using yours simplifies the `Skrift` code)
+  
+* Idiomatic Ruby is favoured over maximising efficiency (but
+  pathologically low performance is not good - I'm open to changes)
+
+* Lowering coupling is favoured (be it for testing, or ease of improving
+  the code), but architecture acrobatics should be avoided. That is,
+  make it *possible* to test or use individual stages of the rendering
+  pipeline, but don't force library users to care - setup should be
+  minimal, and defaults sane. Factories and abstract interfaces should
+  stay in Java or be used to scare small children, not be found in
+  Ruby code.
+
+  
+## Contributions and Potential Improvements
+
+Contributions are welcome, keeping the above in mind. If your
+contributions are potentially unrelated to the specific purpose of this
+library, I might propose you put them in a separate gem instead, and
+might then offer to help create easy integration points so your code can
+safely extent this library if a user chooses to use both.
+
+Some possible areas for extension, and my current thoughts on them
+(*talk to me* if you want to work on something)
+
+### X11 or Wayland (or Windows, or Mac) integration
+
+No.
+
+I will happily ensure there necessary APIs are there so that you can
+*wrap* or integrate with `Skrift`, or so that you can render to something
+that makes it convenient. E.g. the current rendering to 8 bit
+greyscale already makes `Skrift` (thanks to `libschrift` doing this from
+the start) integrate easily with `XRender` for X11 support.
+
+I will not, however, put platform specific code in `Skrift` itself (I
+*will* accept code well-written code to make use of "platform specific"
+data *from the font files*, however, because they can be useful on other
+platforms)
+
+I use this code for rendering to `X11` myself. It does not require
+pushing platform specific code into this library.
+
+
+### Performance
+
+Performance improvements are welcome *but not if they add a lot of
+complexity*. C-extensions or similar will not be accepted - if you
+want a C dependency, just use `libschrift`.
+
+If you have a suggestion that involves using C in a limited way to speed
+up specifics, I'd suggest providing a *separate* gem to replace/extend
+the appropriate code the same way `oily_png` provides code to speed up
+`chunky_png`. I'm happy to discuss specifics.
+
+### Grid snapping
+
+Where I'm *most likely* to consider a hinter is a *limited* hinter
+to dynamically rescale glyphs to allow using a variable spaced font
+snapped to a grid for e.g. terminal use in a somewhat intelligent way (I
+don't expect this is likely to look good, but I'm open to be convinced
+even if it only works on some fonts, though it might well be better as a
+standalone conversion tool unless it works well on a broad range of
+fonts)
+
+### Transformations
+
+The current code already applies linear affine transformations to the
+glyphs. I'd be supportive of *compact* contributions to make it easier to
+apply a broader set of transforms during rendering to allow for more
+flexible layout. Please discuss API first if you want anything merged, or
+if you just want stable extension points to do this in a separate
+library.
+
+### Outlines
+
+You can currently extract outlines, and so can of course replace the
+rendering stage and render unfilled outlines on your own. That said, I'd
+be supportive both of low complexity changes to render the fonts as
+outlines *and* of low complexity changes to "grow" outlines (e.g. to
+be able to render an outline in one colour and a filled version in the
+desired size in another colour - you can't do this by just scaling). The
+code that'd need to change to replace the rasteriser is tiny.
+
+### Text Layout
+
+Specifically, *text layout* is perhaps out of scope of this library, but
+I'm happy to discuss it - if nothing else I'd be supportive of an
+extension in a separate gem and/or ensuring the basics is well
+supported.

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/lib/skrift/font.rb

@@ -0,0 +1,345 @@
+class Font
+  # TrueType, TrueType, OpenType
+  FILE_MAGIC = ["\0\1\0\0", "true", "OTTO"]
+
+  attr_reader :memory, :units_per_em
+
+  def initialize(memory)
+    @memory = memory
+    raise "Unsupported format (magic value: #{at(0,4).inspect})" if !FILE_MAGIC.member?(at(0,4))
+    head = reqtable("head")
+    @units_per_em  = getu16(head + 18)
+    @loca_format   = geti16(head + 50)
+    hhea = reqtable("hhea")
+    @num_long_hmtx = getu16(hhea + 34)
+  end
+
+  def Font.load(filename) # loadfile, 103
+    memory = File.read(filename).force_encoding("ASCII-8BIT")
+    Font.new(memory)
+  end
+
+  def at(offset, len=1)
+    raise "Out of bounds #{offset} / len #{len} (max: #{@memory.size})" if offset.to_i + len.to_i >= @memory.size
+    @memory[offset..(offset+len-1)]
+  end
+
+  def getu8(offset); at(offset).ord; end
+  def geti8(offset); at(offset).unpack1("c"); end
+  def getu16(offset); at(offset,2).unpack1("S>"); end
+  def geti16(offset); at(offset,2).unpack1("s>"); end
+  def getu32(offset); at(offset,4).unpack1("N"); end
+
+  def tables
+    @tables ||= Hash[*
+      getu16(4).times.map {|t| [at(t*16 + 12,4),getu32(t*16 + 20)] }.flatten
+    ]
+  end
+
+  def reqtable(tag); tables[tag] or raise "Unable to get table '#{tag}'"; end
+  def gettable(tag); tables[tag]; end
+
+  def glyph_bbox(outline)
+    box = at(outline+2, 8).unpack("s>*")
+    raise "Broken bbox #{box.inspect}" if box[2] < box[0] || box[3] < box[1]
+    return box
+  end
+
+  # Returns the offset into the font that the glyph's outline is stored at
+  def outline_offset(glyph) # 806
+    loca = reqtable("loca")
+    glyf = reqtable("glyf")
+    if @loca_format == 0
+      base = loca + 2 * glyph
+      this  = 2 * getu16(base)
+      next_ = 2 * getu16(base + 2)
+    else
+      this, next_ = at(loca + 4 * glyph,8).unpack("NN")
+    end
+    return this == next_ ? nil : glyf + this
+  end
+
+  def each_cmap_entry
+    cmap = reqtable("cmap")
+    getu16(cmap + 2).times do |idx|
+      entry  = cmap + 4 + idx * 8
+      type   = getu16(entry) * 0100 + getu16(entry + 2)
+      table  = cmap + getu32(entry + 4)
+      format = getu16(table)
+      yield(type, table, format)
+    end
+  end
+  
+  # Maps unicode code points to glyph indices
+  def glyph_id(char_code)
+    each_cmap_entry do |type, table, format|
+      if (type == 0004 || type == 0312)
+        return cmap_fmt12_13(table, char_code, 12) if format == 12
+        return nil
+      end
+    end
+
+    # If no full repertoire cmap was found, try looking for a Unicode BMP map
+    each_cmap_entry do |type, table, format|
+      if type == 0003 || type == 0301
+        return cmap_fmt4(table + 6, char_code) if format == 4
+        return cmap_fmt6(table + 6, char_code) if format == 6
+        return nil
+      end
+    end
+    return nil
+  end
+
+  def hor_metrics(glyph)
+    hmtx = reqtable("hmtx")
+    return nil if hmtx.nil?
+    if glyph < @num_long_hmtx # In long metrics segment?
+      offset = hmtx + 4 * glyph
+      return getu16(offset), geti16(offset + 2)
+    end
+    # Glyph is inside short metrics segment
+    boundary = hmtx + 4 * @num_long_hmtx
+    return nil if boundary < 4
+    offset = boundary - 4
+    advance_width = getu16(offset)
+    offset = boundary + 2 * (glyph - @num_long_hmtx)
+    return advance_width, geti16(offset)
+  end
+
+
+  def cmap_fmt4(table, char_code) # 572
+    # cmap format 4 only supports the Unicode BMP
+    return nil if char_code > 0xffff
+    seg_count_x2 = getu16(table)
+    raise "Error" if (seg_count_x2 & 1) != 0 or seg_count_x2 == 0
+    # Find starting positions of the relevant arrays
+    end_codes        = table + 8
+    start_codes      = end_codes   + seg_count_x2 + 2
+    id_deltas        = start_codes + seg_count_x2
+    id_range_offsets = id_deltas   + seg_count_x2
+
+    @ecodes ||= at(end_codes,seg_count_x2 -1).unpack("n*")
+    seg_id_x_x2 = @ecodes.bsearch_index {|i| i > char_code } * 2
+
+    # Look up segment info from the arrays & short circuit if the spec requires
+    start_code = getu16(start_codes + seg_id_x_x2)
+    return 0 if start_code > char_code
+    id_delta = getu16(id_deltas + seg_id_x_x2)
+    if (id_range_offset = getu16(id_range_offsets + seg_id_x_x2)) == 0
+      # Intentional integer under- and overflow
+      return (char_code + id_delta) & 0xffff
+    end
+    # Calculate offset into glyph array and determine ultimate value
+    id = getu16(id_range_offsets + seg_id_x_x2 + id_range_offset + 2 * (char_code - start_code))
+    return id ? (id + id_delta) & 0xffff : 0
+  end
+
+  def decode_outline(offset, rec_depth = 0, outl = Outline.new)
+    num_contours = geti16(offset)
+    return nil if num_contours == 0
+    return simple_outline(offset + 10, num_contours, outl) if num_contours > 0
+    return compound_outline(offset + 10, rec_depth, outl)
+  end
+
+  def cmap_fmt6(table, char_code) # 621
+    first_code, entry_count  = at(table,4).unpack("S>*")
+    return nil if !char_code.between?(first_code, 0xffff)
+    char_code -= first_code
+    return nil if (char_code >= entry_count)
+    return getu16(table + 4 + 2 * char_code)
+  end
+
+  def cmap_fmt12_13(table, char_code, which)
+    getu32(table + 12).times do |i|
+      first_code, last_code, glyph_offset = at(table + (i*12) + 16, 12).unpack("N*")
+      next if char_code < first_code || char_code > last_code
+      glyph_offset += char_code-first_code if which == 12
+      return glyph_offset
+    end
+    return nil
+  end
+
+  REPEAT_FLAG          = 0x08
+
+  # For a simple outline, determines each point of the outline with a set of flags
+  def simple_flags(off, num_pts, flags)
+    value  = 0
+    repeat = 0
+    num_pts.times do |i|
+      if repeat > 0
+        repeat -= 1
+      else
+        value = getu8(off)
+        off += 1
+        if value.allbits?(REPEAT_FLAG)
+          repeat = getu8(off)
+          off += 1
+        end
+      end
+      flags[i] = value
+    end
+    return off
+  end
+
+  X_CHANGE_IS_SMALL    = 0x02 # x2 for Y
+  X_CHANGE_IS_ZERO     = 0x10 # x2 for Y
+  X_CHANGE_IS_POSITIVE = 0x10 # x2 for Y
+
+  def simple_points(offset, num_pts, points, base_point)
+    [].tap do |flags|
+      offset = simple_flags(offset, num_pts, flags)
+
+      accum = 0.0
+      accumulate = ->(i, factor) do
+        if flags[i].allbits?(X_CHANGE_IS_SMALL * factor)
+          offset += 1
+          bit = flags[i].allbits?(X_CHANGE_IS_POSITIVE * factor) ? 1 : 0
+          accum -= (getu8(offset-1) ^ -bit) + bit
+        elsif flags[i].nobits?(X_CHANGE_IS_ZERO * factor)
+          offset += 2
+          accum += geti16(offset-2)
+        end
+        accum
+      end
+    
+      num_pts.times {|i| points << Vector[accumulate.call(i,1), 0.0] }
+      accum = 0.0
+      num_pts.times {|i| points[base_point+i][1] = accumulate.call(i,2) }
+    end
+  end
+
+  def simple_outline(offset, num_contours, outl = Outline.new)
+    base_points = outl.points.length
+    num_pts = getu16(offset + (num_contours - 1) *2) + 1
+    end_pts = at(offset, num_contours*2).unpack("S>*")
+    offset += 2*num_contours
+    # Falling end_pts have no sensible interpretation, so treat as error
+    end_pts.each_cons(2) { |a, b| raise if b < a + 1 }
+    offset += 2 + getu16(offset)
+
+    flags = simple_points(offset, num_pts, outl.points, base_points)
+
+    beg = 0
+    num_contours.times do |i|
+      decode_contour(outl, flags, beg, base_points+beg, end_pts[i] - beg + 1)
+      beg = end_pts[i] + 1
+    end
+    outl
+  end
+
+  POINT_IS_ON_CURVE    = 0x01
+
+  def decode_contour(outl, flags, off, base_point, count)
+    return true if count < 2 # Invisible (no area)
+
+    if flags[off].allbits?(POINT_IS_ON_CURVE)
+      loose_end = base_point
+      base_point+= 1
+      off += 1
+      count -= 1
+    elsif flags[off + count - 1].allbits?(POINT_IS_ON_CURVE)
+      count -= 1
+      loose_end = base_point + count
+    else
+      loose_end = outl.points.length
+      outl.points << midpoint(outl.points[base_point], outl.points[base_point + count - 1])
+    end
+    beg  = loose_end
+    ctrl = nil
+    count.times do |i|
+      cur = base_point + i
+      if flags[off+i].allbits?(POINT_IS_ON_CURVE)
+        outl.segments << Outline::Segment.new(beg, cur, ctrl)
+        beg = cur
+        ctrl = nil
+      else
+        if ctrl # 2x control points in a row -> insert midpoint
+          center = outl.points.length
+          outl.points << midpoint(outl.points[ctrl], outl.points[cur])
+          outl.segments << Outline::Segment.new(beg, center, ctrl)
+          beg = center
+        end
+        ctrl = cur
+      end
+    end
+    outl.segments << Outline::Segment.new(beg, loose_end, ctrl)
+    return true
+  end
+
+  OFFSETS_ARE_LARGE         = 0x001
+  ACTUAL_XY_OFFSETS         = 0x002
+  GOT_A_SINGLE_SCALE        = 0x008
+  THERE_ARE_MORE_COMPONENTS = 0x020
+  GOT_AN_X_AND_Y_SCALE      = 0x040
+  GOT_A_SCALE_MATRIX        = 0x080
+
+  def compound_outline(offset, rec_depth, outl) # 1057
+    # Guard against infinite recursion (compound glyphs that have themselves as component).
+    return nil if rec_depth >= 4
+    flags = THERE_ARE_MORE_COMPONENTS
+    while flags.allbits?(THERE_ARE_MORE_COMPONENTS)
+      flags, glyph = at(offset,4).unpack("S>*")
+      p [flags,glyph]
+      offset += 4
+      # We don't implement point matching, and neither does stb truetype
+      return nil if (flags & ACTUAL_XY_OFFSETS) == 0
+      # Read additional X and Y offsets (in FUnits) of this component.
+      if (flags & OFFSETS_ARE_LARGE) != 0
+        local = Matrix[[1.0, 0.0, geti16(offset)], [0.0,1.0, geti16(offset+2)]]
+        offset += 4
+      else
+        local = Matrix[[1.0, 0.0, geti8(offset)], [0.0, 1.0, geti8(offset)+1]]
+        offset += 2
+      end
+
+      if flags.allbits?(GOT_A_SINGLE_SCALE)
+        local[0][0] = local[1][0] = geti16(offset) / 16384.0
+        offset += 2
+      elsif flags.allbits?(GOT_AN_X_AND_Y_SCALE)
+        local[0][0] = geti16(offset + 0) / 16384.0
+        local[1][0] = geti16(offset + 2) / 16384.0
+        offset += 4
+      elsif flags.allbits?(GOT_A_SCALE_MATRIX)
+        local[0][0] = geti16(offset + 0) / 16384.0
+        local[0][1] = geti16(offset + 2) / 16384.0
+        local[1][0] = geti16(offset + 4) / 16384.0
+        local[1][1] = geti16(offset + 6) / 16384.0
+        offset += 8
+      end
+
+      outline = outline_offset(glyph)
+      return nil if outline.nil?
+      base_point = outl.points.length
+      return nil if decode_outline(outline, rec_depth + 1, outl).nil?
+      transform_points(local,outl.points[base_point..-1])
+    end
+    return outl
+  end
+
+  HORIZONTAL_KERNING   = 0x01
+  MINIMUM_KERNING      = 0x02
+  CROSS_STREAM_KERNING = 0x04
+  OVERRIDE_KERNING     = 0x08
+
+  def kerning
+    return @kerning if @kerning
+    offset = gettable("kern")
+    return nil if offset.nil? || getu16(offset) != 0
+    offset += 4
+    @kerning = {}
+    getu16(offset - 2).times do
+      length,format,flags = at(offset+2,6).unpack("S>CC")
+      offset += 6
+      if format == 0 && flags.allbits?(HORIZONTAL_KERNING) && flags.nobits?(MINIMUM_KERNING)
+        offset += 8
+        getu16(offset-8).times do |i|
+          v = geti16(offset+i*6+4)
+          @kerning[at(offset+i*6,4)] =
+            Kerning.new(* flags.allbits?(CROSS_STREAM_KERNING) ? [0,v] : [v,0])
+        end
+      end
+      offset += length
+    end
+    @kerning
+  end
+end

data/lib/skrift/outline.rb

@@ -0,0 +1,56 @@
+def midpoint(a, b); 0.5*(a+b); end
+
+# Applies an affine linear transformation matrix to a set of points
+def transform_points(trf, pts)
+  pts.each {|pt| pt[0],pt[1] = *(trf * Vector[*pt,1]) }
+end
+
+class Outline
+  Segment = Struct.new(:beg, :end, :ctrl)
+  
+  attr_reader :points, :segments
+  
+  def initialize
+    @points, @segments = [], []
+  end
+
+  def clip_points(width, height)
+    @points.each do |pt|
+      pt[0] = pt[0].clamp(0, width.pred)
+      pt[1] = pt[1].clamp(0, height.pred)
+    end
+  end
+
+  def render(transform, image)
+    transform_points(transform, @points)
+    clip_points(image.width, image.height)
+    buf = Raster.new(image.width, image.height)
+    @segments.each do |seg|
+      seg.ctrl ? tesselate_curve(seg) : buf.draw_line(@points[seg.beg], @points[seg.end])
+    end
+    image.pixels = buf.post_process
+    return image
+  end
+
+  def tesselate_curve(curve)
+    if is_flat(curve)
+      @segments << Segment.new(curve.beg, curve.end)
+      return
+    end
+    ctrl0 = @points.length
+    @points << midpoint(@points[curve.beg], @points[curve.ctrl])
+    ctrl1 = @points.length
+    @points << midpoint(@points[curve.ctrl], @points[curve.end])
+    pivot = @points.length
+    @points << midpoint(@points[ctrl0], @points[ctrl1])
+    tesselate_curve(Segment.new(curve.beg, pivot, ctrl0))
+    tesselate_curve(Segment.new(pivot, curve.end, ctrl1))
+  end
+
+  # A heuristic to tell whether a given curve can be approximated closely enough by a line. */
+  def is_flat(curve)
+    g = @points[curve.ctrl] - @points[curve.beg]
+    h = @points[curve.end]  - @points[curve.beg]
+    (g[0]*h[1]-g[1]*h[0]).abs <= 2.0
+  end
+end

data/lib/skrift/raster.rb

@@ -0,0 +1,80 @@
+class Raster
+  Cell = Struct.new(:area, :cover)
+
+  def initialize width, height
+    @width = width
+    @height = height
+    @cells = (0..(width*height-1)).map { Cell.new(0.0,0.0) }
+  end
+
+  # Integrate the values in the buffer to arrive at the final grayscale image.
+  def post_process
+    accum = 0.0
+    (@width*@height).times.collect do |i|
+      cell = @cells[i]
+      value = (accum + cell.area).abs
+      value = [value, 1.0].min * 255.0 + 0.5
+      accum += cell.cover
+      value.to_i & 0xff
+    end
+  end
+
+  # Draws a line into the buffer. Uses a custom 2D raycasting algorithm to do so.
+  def draw_line(origin, goal)
+    prev_distance = 0.0
+    num_steps = 0
+    delta = goal-origin
+    dir_x = delta[0] <=> 0
+    dir_y = delta[1] <=> 0
+    next_crossing = Vector[0.0,0.0]
+    pixel = Vector[0,0]
+    return if dir_y == 0
+
+    crossing_incr_x = dir_x != 0 ? (1.0 / delta[0]).abs : 1.0
+    crossing_incr_y = (1.0 / delta[1]).abs
+
+    if dir_x == 0
+      pixel[0] = origin[0].floor
+      next_crossing[0] = 100.0
+    else
+      if dir_x > 0
+        pixel[0] = origin[0].floor
+        next_crossing[0] = crossing_incr_x - (origin[0] - pixel[0]) * crossing_incr_x
+        num_steps += goal[0].ceil - origin[0].floor - 1
+      else
+        pixel[0] = origin[0].ceil - 1
+        next_crossing[0] = (origin[0] - pixel[0]) * crossing_incr_x
+        num_steps += origin[0].ceil - goal[0].floor - 1
+      end
+    end
+
+    if dir_y > 0
+      pixel[1] = origin[1].floor
+      next_crossing[1] = crossing_incr_y - (origin[1] - pixel[1]) * crossing_incr_y
+      num_steps += goal[1].ceil - origin[1].floor - 1
+    else
+      pixel[1] = origin[1].ceil - 1
+      next_crossing[1] = (origin[1] - pixel[1]) * crossing_incr_y
+      num_steps += origin[1].ceil - goal[1].floor - 1
+    end
+
+    next_distance = next_crossing.min
+    half_delta_x = 0.5 * delta[0]
+    setcell = ->(nd) do
+      x_average = origin[0] + (prev_distance + nd) * half_delta_x - pixel[0]
+      y_difference = (nd - prev_distance).to_f * delta[1]
+      cell = @cells[pixel[1] * @width + pixel[0]]
+      cell.cover += y_difference
+      cell.area  += (1.0 - x_average) * y_difference
+    end
+    num_steps.times do
+      setcell.call(next_distance)
+      prev_distance = next_distance
+      along_x = next_crossing[0] < next_crossing[1]
+      pixel += along_x ? Vector[dir_x,0] : Vector[0,dir_y]
+      next_crossing += along_x ? Vector[crossing_incr_x, 0.0] : Vector[0.0, crossing_incr_y]
+      next_distance = next_crossing.min
+    end
+    setcell.call(1.0)
+  end
+end

data/lib/skrift/sft.rb

@@ -0,0 +1,83 @@
+class SFT
+  DOWNWARD_Y = 0x01
+
+  attr_accessor :font, :x_scale, :y_scale, :x_offset, :y_offset, :flags
+
+  def initialize(font)
+    @font = font
+    @x_scale  = 32
+    @y_scale  = 32
+    @x_offset = 0
+    @y_offset = 0
+    @flags = SFT::DOWNWARD_Y
+  end
+
+  def lookup(codepoint)
+    return font.glyph_id(codepoint)
+  end
+
+  def glyph_bbox(outline)
+    box = @font.glyph_bbox(outline)
+    raise if !box
+    # Transform the bounding box into SFT coordinate space
+    xs = @x_scale.to_f / @font.units_per_em
+    ys = @y_scale.to_f / @font.units_per_em
+    box[0] = (box[0] * xs + @x_offset).floor
+    box[1] = (box[1] * ys + @y_offset).floor
+    box[2] = (box[2] * xs + @x_offset).ceil
+    box[3] = (box[3] * ys + @y_offset).ceil
+    return box
+  end
+
+  def gmetrics(glyph) # 149
+    raise "out of bounds" if glyph < 0
+    xs = @x_scale.to_f / @font.units_per_em
+    adv, lsb = @font.hor_metrics(glyph)
+
+    return nil if adv.nil?
+    metrics = GMetrics.new(adv * xs, lsb * xs + @x_offset)
+
+    outline = @font.outline_offset(glyph)
+    return metrics if outline.nil?
+    bbox = glyph_bbox(outline)
+    return nil if !bbox
+    metrics.min_width = bbox[2] - bbox[0] + 1
+    metrics.min_height= bbox[3] - bbox[1] + 1
+    metrics.y_offset  = @flags & SFT::DOWNWARD_Y != 0 ? bbox[3] : bbox[1]
+    return metrics
+  end
+
+  def lmetrics
+    hhea= font.reqtable("hhea")
+    factor = @y_scale.to_f / @font.units_per_em
+    LMetrics.new(
+      font.geti16(hhea + 4) * factor, # ascender
+      font.geti16(hhea + 6) * factor, # descender
+      font.geti16(hhea + 8) * factor  # line_gap
+    ) 
+  end
+
+  def render(glyph, image) # 239
+    outline = @font.outline_offset(glyph)
+    return false if outline.nil?
+    return true if outline.nil?
+    bbox = glyph_bbox(outline)
+    return false if !bbox
+    # Set up the transformation matrix such that
+    # the transformed bounding boxes min corner lines
+    # up with the (0, 0) point.
+    xr = [@x_scale.to_f / @font.units_per_em, 0.0, @x_offset - bbox[0]]
+    ys = @y_scale.to_f / @font.units_per_em
+    if @flags.allbits?(SFT::DOWNWARD_Y)
+      transform = Matrix.rows([xr, [0.0, -ys, bbox[3] - @y_offset]])
+    else
+      transform = Matrix.rows([xr, [0.0, +ys, @y_offset - bbox[1] ]])
+    end
+    outl = @font.decode_outline(outline)
+    outl.render(transform, image)
+  end
+
+  def kerning(left_glyph, right_glyph) # 176
+    @font.kerning[[left_glyph,right_glyph].pack("n*")]
+  end
+end

data/lib/skrift/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Skrift
+  VERSION = "0.1.0"
+end

data/lib/skrift.rb

@@ -0,0 +1,11 @@
+GMetrics = Struct.new(:advance_width, :left_side_bearing, :y_offset, :min_width, :min_height)
+LMetrics = Struct.new(:ascender, :descender, :line_gap)
+Image = Struct.new(:width, :height, :pixels)
+Kerning = Struct.new(:x_shift, :y_shift)
+
+require_relative './skrift/version'
+require_relative './skrift/sft'
+require_relative './skrift/outline'
+require_relative './skrift/raster'
+require_relative './skrift/font'
+require 'matrix'

data/skrift.gemspec

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative "lib/skrift/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "skrift"
+  spec.version = Skrift::VERSION
+  spec.authors = ["Vidar Hokstad"]
+  spec.email = ["vidar@hokstad.com"]
+
+  spec.summary = "A pure Ruby TruteType font renderer"
+  #spec.description = "TODO: Write a longer description or delete this line."
+  spec.homepage = "https://github.com/vidarh/skrift"
+  spec.license = "ISC"
+  spec.required_ruby_version = ">= 2.7.0"
+
+  #spec.metadata["allowed_push_host"] = "TODO: Set to your gem server 'https://example.com'"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  #spec.metadata["changelog_uri"] = "TODO: Put your gem's CHANGELOG.md URL here."
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|circleci)|appveyor)})
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # Uncomment to register a new dependency of your gem
+  # spec.add_dependency "example-gem", "~> 1.0"
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

data/test.rb

@@ -0,0 +1,77 @@
+
+require 'pp'
+require_relative './lib/skrift'
+
+f = Font.load("resources/Ubuntu-Regular.ttf")
+#f = Font.load("resources/FiraGO-Regular_extended_with_NotoSansEgyptianHieroglyphs-Regular.ttf")
+#f = Font.load("/usr/share/fonts/truetype/tlwg/Umpush-BoldOblique.ttf")
+#f = Font.load("/usr/share/fonts/truetype/tlwg/Garuda.ttf")
+#f = Font.load("resources/FiraGO-Regular.ttf")
+#f = Font.load("/usr/share/fonts/opentype/cantarell/Cantarell-Regular.otf")
+p f.tables
+#p f.kerning
+
+sft = SFT.new(f)
+sft.x_scale =  20
+sft.y_scale =  20
+sft.x_offset = 0
+sft.y_offset = 0
+
+PP.pp sft.lmetrics
+
+if ARGV[0] == "gid"
+  gid = ARGV[1].to_i
+elsif ARGV[0]
+  gid = sft.lookup(ARGV[0][0].ord)
+  p gid
+  if ARGV[0][1]
+    f.reqtable("kern")
+    #PP.pp f.kerning.map {|k,v|
+    #  [k.unpack("n*"), v]
+    #}
+    
+    gid2 = sft.lookup(ARGV[0][1].ord)
+    PP.pp sft.kerning(gid,gid2)
+    exit
+  end
+end
+
+#gid = 12
+
+def test_glyph(sft, gid)
+  puts "TESTING GLYPH #{gid}"
+  mtx = sft.gmetrics(gid)
+p mtx
+
+#p sft.gmetrics(sft.lookup(0x43))
+
+
+img = Image.new(mtx.min_width, mtx.min_height)
+if sft.render(gid, img)
+#r = Raster.new(img.width, img.height)
+#
+#r.draw_line(Point.new(0,0), Point.new(img.width-1, 0))
+#r.draw_line(Point.new(10,10), Point.new(20, 10))
+#r.draw_line(Point.new(10,10), Point.new(20, 20))
+#r.draw_line(Point.new(20,10), Point.new(30, 20))
+#r.draw_line(Point.new(0,0), Point.new(img.width-1, img.height-1))
+#p r
+#img.pixels = r.post_process
+
+img.height.times do |row|
+  img.pixels[row*img.width .. (row+1)*img.width-1].map do |s|
+    print "\033[32;48;2;#{s};#{s};#{s}m%02x " % s
+  end
+  puts "\033[39;49m"
+end
+end
+end
+
+if gid
+  test_glyph(sft,gid)
+else
+  (0..10000).each do |gid|
+    test_glyph(sft,gid)
+  end
+end
+

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification
+name: skrift
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Vidar Hokstad
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2023-08-18 00:00:00.000000000 Z
+dependencies: []
+description: 
+email:
+- vidar@hokstad.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/skrift.rb
+- lib/skrift/font.rb
+- lib/skrift/outline.rb
+- lib/skrift/raster.rb
+- lib/skrift/sft.rb
+- lib/skrift/version.rb
+- resources/Ubuntu-Regular.ttf
+- skrift.gemspec
+- test.rb
+homepage: https://github.com/vidarh/skrift
+licenses:
+- ISC
+metadata:
+  homepage_uri: https://github.com/vidarh/skrift
+  source_code_uri: https://github.com/vidarh/skrift
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.4
+signing_key: 
+specification_version: 4
+summary: A pure Ruby TruteType font renderer
+test_files: []