skrift 0.1.0 → 0.4.0

data/lib/skrift/font_set.rb

@@ -0,0 +1,58 @@
+require "shellwords"
+
+module Skrift
+  # An ordered set of fonts with per-codepoint fallback. Entries may be Font
+  # objects, or font file paths / fontconfig names that are loaded lazily and
+  # resolved via (in order) an explicit path, ~/.local/share/fonts, then
+  # `fc-match`. A single Font is just a one-element set.
+  class FontSet
+    def initialize(fonts)
+      @entries = Array(fonts)
+      @loaded  = {}
+    end
+
+    def size = @entries.length
+
+    # The i-th font, lazily loaded/resolved. Returns nil if unresolvable.
+    def [](index)
+      return @loaded[index] if @loaded.key?(index)
+      @loaded[index] = resolve(@entries[index])
+    end
+
+    # Yields each resolvable font in order.
+    def each
+      return enum_for(:each) unless block_given?
+      @entries.each_index { |i| (f = self[i]) && yield(f) }
+    end
+
+    # The first [font, glyph_id] whose font maps +codepoint+, or nil if no font
+    # in the set has a cmap entry for it. (A font that maps the codepoint to the
+    # missing glyph, gid 0, still counts as a match — matching the prior
+    # behaviour; skipping .notdef to keep searching is a deliberate non-goal
+    # here.)
+    def lookup(codepoint)
+      @entries.each_index do |i|
+        font = self[i]
+        next unless font
+        gid = font.glyph_id(codepoint)
+        return [font, gid] unless gid.nil?
+      end
+      nil
+    end
+
+    private
+
+    def resolve(entry)
+      return entry if entry.is_a?(Font)
+      return Font.load(entry) if File.exist?(entry)
+
+      local = File.expand_path("~/.local/share/fonts/#{entry}")
+      return Font.load(local) if File.exist?(local)
+
+      matched = `fc-match --format='%{file}' #{Shellwords.escape(entry)}`.strip
+      return Font.load(matched) if !matched.empty? && File.exist?(matched)
+
+      nil
+    end
+  end
+end

data/lib/skrift/glyph_cache.rb

@@ -0,0 +1,142 @@
+module Skrift
+  # A rasterised, cached glyph. A monochrome glyph carries +alpha+ (a row-major
+  # 0..255 coverage array, stride padded to a multiple of 4), or nil for a
+  # glyph with no outline (e.g. space). A colour glyph (from a colour delegate,
+  # see GlyphCache) instead carries +rgba+, a row-major array of packed
+  # 0xRRGGBBAA pixels; for those +alpha+ is nil. Placement fields are shared.
+  RenderedGlyph = Struct.new(:alpha, :width, :height, :left_side_bearing, :y_offset, :advance_width, :rgba) do
+    def color? = !rgba.nil?
+  end
+
+  # The platform-independent glyph pipeline shared by every backend: resolve a
+  # codepoint through a FontSet, rasterise it (with optional fit-to-cell
+  # scaling), and cache the result. Backends (XRender glyphsets, software RGB
+  # blending, ...) consume the RenderedGlyph and place it however they like.
+  class GlyphCache
+    attr_reader :fontset, :ascent, :descent, :line_gap, :cell_width
+
+    # +special+ is an optional callable codepoint -> Skrift::Image (alpha) used
+    # to override font rasterisation (e.g. a box-drawing plugin); return nil to
+    # fall through to the font.
+    #
+    # +color+ is an optional colour delegate: any object responding to
+    # #render(codepoint) and returning an RGBA colour image (with #width,
+    # #height and #pixels of packed 0xRRGGBBAA), or nil to fall through to
+    # monochrome. skrift core knows nothing about colour formats — all of that
+    # lives in the delegate (e.g. the skrift-color gem).
+    def initialize(fontset, x_scale:, y_scale:, fixed: nil, maxheight: nil, fit: false, special: nil, color: nil)
+      @fontset   = fontset.is_a?(FontSet) ? fontset : FontSet.new(fontset)
+      @x_scale   = x_scale
+      @y_scale   = y_scale
+      @fixed     = fixed
+      @maxheight = maxheight
+      @fit       = fit
+      @special   = special
+      @color     = color
+      @cache     = {}
+
+      @sft = Renderer.new(@fontset[0])
+      @sft.x_scale = x_scale
+      @sft.y_scale = y_scale
+      lm = @sft.lmetrics
+      @ascent, @descent, @line_gap = lm.ascender, lm.descender, lm.line_gap
+
+      # +fixed+ enables monospace cells: pass a Numeric cell width, or true to
+      # derive it from the 'M' advance. Either way @fixed stays truthy so glyphs
+      # render at the cell width.
+      g = @sft.gmetrics(@sft.lookup("M".ord)) || @sft.gmetrics(0)
+      @cell_width = (fixed if fixed.is_a?(Numeric)) || (g ? g.advance_width.ceil : x_scale)
+    end
+
+    def baseline = @ascent.round
+
+    # Cell height unified on ascent - descent (line gap excluded), clamped to
+    # maxheight when given.
+    def cell_height
+      @cell_height ||= [@maxheight, @ascent.ceil - @descent.ceil].compact.min
+    end
+
+    # RenderedGlyph for +codepoint+, or nil if no font in the set maps it.
+    def glyph(codepoint)
+      return @cache[codepoint] if @cache.key?(codepoint)
+      @cache[codepoint] = build(codepoint)
+    end
+
+    # Total advance for +str+: the fixed cell width per character in fixed mode,
+    # otherwise the sum of per-glyph advances.
+    def text_width(str)
+      str.to_s.each_char.sum do |ch|
+        next @cell_width if @fixed
+        (g = glyph(ch.ord)) ? g.advance_width : 0
+      end
+    end
+
+    private
+
+    def build(codepoint)
+      if @special && (img = @special.call(codepoint))
+        # y_offset == baseline places the bitmap at the cell top under the
+        # standard `baseline - y_offset` formula (box drawing fills the cell).
+        return RenderedGlyph.new(img.pixels, img.width, img.height, 0, baseline, @cell_width)
+      end
+
+      # Delegate to the colour renderer if it has this codepoint. We only place
+      # its RGBA image in the cell (generic geometry) — the colour rendering
+      # itself lives entirely in the delegate.
+      if @color && (cimg = @color.render(codepoint))
+        return color_glyph(cimg)
+      end
+
+      font, gid = @fontset.lookup(codepoint)
+      return nil unless font
+      @sft.font = font
+      mtx = @sft.gmetrics(gid)
+      return nil unless mtx
+
+      # No outline (e.g. space): advance only, no alpha.
+      if mtx.min_width.nil? || mtx.min_height.nil?
+        return RenderedGlyph.new(nil, 0, 0, (mtx.left_side_bearing || 0).round, mtx.y_offset, mtx.advance_width)
+      end
+
+      saved = nil
+      # Oversized glyph in a fixed cell: re-render smaller so it fits rather
+      # than being clamped (and distorted) at the cell edge. Only clear
+      # overshoots are scaled; marginal ones are left to the clamp.
+      if @fit && @fixed
+        sx = mtx.min_width  > @cell_width  * 1.1 ? @cell_width.to_f  / mtx.min_width  : 1.0
+        sy = mtx.min_height > cell_height * 1.1 ? cell_height.to_f / mtx.min_height : 1.0
+        s  = [sx, sy].min
+        if s < 1.0
+          saved = [@sft.x_scale, @sft.y_scale]
+          @sft.x_scale *= s
+          @sft.y_scale *= s
+          mtx = @sft.gmetrics(gid)
+        end
+      end
+
+      w = @fixed ? @cell_width : mtx.min_width
+      h = [mtx.min_height, @maxheight].compact.min
+      img = Image.new((w + 3) & ~3, h)
+      alpha = @sft.render(gid, img) ? img.pixels : Array.new(img.width * img.height, 0)
+      RenderedGlyph.new(alpha, img.width, img.height,
+                        mtx.left_side_bearing.round, mtx.y_offset || baseline, mtx.advance_width)
+    ensure
+      @sft.x_scale, @sft.y_scale = saved if saved
+    end
+
+    # Wrap a colour delegate's RGBA image as a RenderedGlyph, centred in its
+    # cell span. The span (in cells) is inferred from the image width — a colour
+    # emoji rendered at the cell size is naturally about two cells wide — so the
+    # advance and centring span two cells for emoji without the cache needing a
+    # Unicode width table.
+    def color_glyph(cimg)
+      w, h = cimg.width, cimg.height
+      span = [(w.to_f / @cell_width).round, 1].max
+      advance = span * @cell_width
+      RenderedGlyph.new(nil, w, h,
+                        ((advance - w) / 2.0).round,
+                        (baseline - (cell_height - h) / 2.0).round,
+                        advance, cimg.pixels)
+    end
+  end
+end

data/lib/skrift/outline.rb

@@ -1,56 +1,53 @@
-def midpoint(a, b); 0.5*(a+b); end
+module Skrift
+  class Outline
+    include Geometry
 
-# 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
+    Segment = Struct.new(:beg, :end, :ctrl)
 
-class Outline
-  Segment = Struct.new(:beg, :end, :ctrl)
-  
-  attr_reader :points, :segments
-  
-  def initialize
-    @points, @segments = [], []
-  end
+    attr_reader :points, :segments
 
-  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)
+    def initialize
+      @points, @segments = [], []
     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])
+    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
-    image.pixels = buf.post_process
-    return image
-  end
 
-  def tesselate_curve(curve)
-    if is_flat(curve)
-      @segments << Segment.new(curve.beg, curve.end)
-      return
+    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[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[curve.beg, pivot, ctrl0])
+      tesselate_curve(Segment[pivot, curve.end, ctrl1])
     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
+    # 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
 end

data/lib/skrift/raster.rb

@@ -1,80 +1,89 @@
-class Raster
-  Cell = Struct.new(:area, :cover)
+module Skrift
+  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
+    Vector = Struct.new(:x,:y) do
+      def*(f) = Vector[x*f,y*f]
+      def+(o) = Vector[x+o[0],y+o[1]]
+      def-(o) = Vector[x-o[0],y-o[1]]
+      def min = (x < y ? x : y)
+    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
+    def initialize width, height
+      @width = width
+      @height = height
+      @cells = (0..(width*height-1)).map { Cell[0.0,0.0] }
     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
+    # 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
+      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
+      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
+        next_crossing[0] = 100.0
       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
+        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
-    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
+      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
+      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] : [0.0, crossing_incr_y]
+        next_distance = next_crossing.min
+      end
+      setcell.call(1.0)
     end
-    setcell.call(1.0)
   end
 end

data/lib/skrift/sft.rb

@@ -1,83 +1,97 @@
-class SFT
-  DOWNWARD_Y = 0x01
+module Skrift
+  # The scaling/rendering façade: set a scale, look up glyphs, measure and
+  # render them. (Formerly named SFT, after libschrift's handle struct.)
+  class Renderer
+    DOWNWARD_Y = 0x01
 
-  attr_accessor :font, :x_scale, :y_scale, :x_offset, :y_offset, :flags
+    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 initialize(font)
+      @font = font
+      @x_scale  = 32
+      @y_scale  = 32
+      @x_offset = 0
+      @y_offset = 0
+      @flags = DOWNWARD_Y
+    end
 
-  def lookup(codepoint)
-    return font.glyph_id(codepoint)
-  end
+    # Glyph id for +codepoint+. With +variation+ (a variation selector such as
+    # Font::VS_EMOJI), resolve the <codepoint, selector> sequence via cmap-14
+    # first, falling back to the plain glyph when the font omits the sequence.
+    def lookup(codepoint, variation: nil)
+      if variation && (g = font.variation_glyph_id(codepoint, variation))
+        return g
+      end
+      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 glyph_bbox(outline)
+      box = @font.glyph_bbox(outline)
+      raise if !box
+      # Transform the bounding box into Renderer 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)
+    def gmetrics(glyph) # 149
+      return nil if glyph.nil?
+      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)
+      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
+      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 & 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 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] ]])
+    # Rasterise +glyph+ into +image+ (mutated in place). Returns true if the
+    # glyph had a renderable outline, false otherwise (e.g. a space).
+    def render(glyph, image) # 239
+      outline = @font.outline_offset(glyph)
+      return false 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?(DOWNWARD_Y)
+        transform = [xr, [0.0, -ys, bbox[3] - @y_offset]]
+      else
+        transform = [xr, [0.0, +ys, @y_offset - bbox[1] ]]
+      end
+      outl = @font.decode_outline(outline)
+      return false unless outl
+      outl.render(transform, image)
+      true
     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*")]
+    def kerning(left_glyph, right_glyph) # 176
+      @font.kerning[[left_glyph,right_glyph].pack("n*")]
+    end
   end
 end

data/lib/skrift/version.rb

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