fontisan 0.4.6 → 0.4.7

data/lib/fontisan/ufo/compile/cff2.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      # Builds the OpenType CFF2 table from UFO glyphs.
+      #
+      # CFF2 is simpler than CFF1: no Name INDEX, String INDEX, Encoding,
+      # or Charset. The Top DICT references CharStrings and a Font DICT
+      # INDEX (which wraps at least one Font DICT pointing to a Private
+      # DICT).
+      #
+      # Layout (static font, single Font DICT, empty Private DICT):
+      #
+      #   Header (5 bytes)
+      #   Top DICT (variable — offsets to CharStrings + Font DICT INDEX)
+      #   Global Subr INDEX (4 bytes — empty)
+      #   CharStrings INDEX (variable)
+      #   Font DICT INDEX (variable — wraps one Font DICT)
+      #     Font DICT: DICT with Private operator [0, 0] (empty Private)
+      #
+      # The Top DICT offsets depend on the Top DICT's own size — a
+      # circular dependency resolved with fixed-point iteration (the
+      # same pattern as the CFF1 builder).
+      #
+      # @see https://learn.microsoft.com/en-us/typography/opentype/spec/cff2
+      module Cff2
+        # CFF2 Top DICT operator encodings.
+        CHARSTRINGS_OPERATOR = 17 # 0x11
+        VARIATION_STORE_OPERATOR = 24 # 0x18
+        FONT_DICT_INDEX_OPERATOR = [12, 36].freeze # 0x0C24
+        PRIVATE_OPERATOR = 18 # 0x12
+
+        # @param font [Fontisan::Ufo::Font]
+        # @param glyphs [Array<Fontisan::Ufo::Glyph>] in gid order
+        # @param variation_store [String, nil] ItemVariationStore bytes
+        #   for variable CFF2 fonts. When present, embedded between the
+        #   GlobalSubr INDEX and CharStrings INDEX, and referenced from
+        #   the Top DICT via operator 24.
+        # @return [String] CFF2 table bytes
+        def self.build(_font, glyphs:, variation_store: nil)
+          charstrings = glyphs.map { |g| charstring_for(g) }
+          global_subr_index = empty_global_subr_index
+          font_dict = build_font_dict(private_size: 0, private_offset: 0)
+          font_dict_index = Tables::Cff2::IndexBuilder.build([font_dict])
+          vs_bytes = variation_store&.b
+
+          # Fixed-point iteration: encode Top DICT, compute offsets, repeat.
+          top_dict = encode_top_dict(
+            charstrings_offset: 0, font_dict_index_offset: 0,
+            variation_store_offset: vs_bytes ? 0 : nil
+          )
+          layout = compute_layout(top_dict:, charstrings:, global_subr_index:,
+                                  font_dict_index:, variation_store: vs_bytes)
+
+          10.times do
+            top_dict = encode_top_dict(
+              charstrings_offset: layout[:charstrings_offset],
+              font_dict_index_offset: layout[:font_dict_index_offset],
+              variation_store_offset: layout[:variation_store_offset],
+            )
+            next_layout = compute_layout(top_dict:, charstrings:, global_subr_index:,
+                                         font_dict_index:, variation_store: vs_bytes)
+            break if same_offsets?(layout, next_layout)
+
+            layout = next_layout
+          end
+
+          assemble(layout:)
+        end
+
+        # ---------- charstring per-glyph ----------
+
+        def self.charstring_for(glyph)
+          return empty_charstring(glyph.width.to_i) if glyph.contours.empty?
+
+          builder = Tables::Cff::CharStringBuilder.new
+          builder.build(glyph.to_outline, width: glyph.width.to_i)
+        rescue StandardError
+          empty_charstring(glyph.width.to_i)
+        end
+
+        def self.empty_charstring(width)
+          builder = Tables::Cff::CharStringBuilder.new
+          builder.build_empty(width: width.zero? ? nil : width)
+        end
+
+        # ---------- DICT encoding ----------
+
+        # Encode the Top DICT with offsets to CharStrings, Font DICT INDEX,
+        # and optionally VariationStore.
+        def self.encode_top_dict(charstrings_offset:, font_dict_index_offset:,
+                                 variation_store_offset: nil)
+          io = +""
+          io << Tables::Cff2::DictEncoder.encode_entry(
+            [charstrings_offset], CHARSTRINGS_OPERATOR
+          )
+          io << Tables::Cff2::DictEncoder.encode_entry(
+            [font_dict_index_offset], FONT_DICT_INDEX_OPERATOR
+          )
+          if variation_store_offset
+            io << Tables::Cff2::DictEncoder.encode_entry(
+              [variation_store_offset], VARIATION_STORE_OPERATOR
+            )
+          end
+          io
+        end
+
+        # Encode a Font DICT: just the Private operator [size, offset].
+        def self.build_font_dict(private_size:, private_offset:)
+          Tables::Cff2::DictEncoder.encode_entry(
+            [private_size, private_offset], PRIVATE_OPERATOR
+          )
+        end
+
+        # ---------- layout ----------
+
+        # Compute byte offsets for each section. The Top DICT's size
+        # determines where the Global Subr INDEX starts, which cascades
+        # to all subsequent offsets. When a VariationStore is present,
+        # it sits between the GlobalSubr INDEX and the CharStrings INDEX.
+        def self.compute_layout(top_dict:, charstrings:, global_subr_index:,
+                                font_dict_index:, variation_store: nil)
+          charstrings_index = Tables::Cff2::IndexBuilder.build(charstrings)
+
+          header_size = Tables::Cff2::Header::HEADER_SIZE
+          global_subr_offset = header_size + top_dict.bytesize
+          post_global_subr = global_subr_offset + global_subr_index.bytesize
+
+          if variation_store
+            variation_store_offset = post_global_subr
+            charstrings_offset = variation_store_offset + variation_store.bytesize
+          else
+            variation_store_offset = nil
+            charstrings_offset = post_global_subr
+          end
+          font_dict_index_offset = charstrings_offset + charstrings_index.bytesize
+
+          {
+            top_dict: top_dict,
+            charstrings_index: charstrings_index,
+            global_subr_index: global_subr_index,
+            font_dict_index: font_dict_index,
+            variation_store: variation_store,
+            variation_store_offset: variation_store_offset,
+            charstrings_offset: charstrings_offset,
+            font_dict_index_offset: font_dict_index_offset,
+          }
+        end
+
+        def self.same_offsets?(a, b)
+          a[:charstrings_offset] == b[:charstrings_offset] &&
+            a[:font_dict_index_offset] == b[:font_dict_index_offset] &&
+            a[:variation_store_offset] == b[:variation_store_offset]
+        end
+
+        def self.empty_global_subr_index
+          Tables::Cff2::IndexBuilder.build([])
+        end
+
+        # ---------- assembly ----------
+
+        def self.assemble(layout:)
+          io = +""
+          io << Tables::Cff2::Header.build(top_dict_size: layout[:top_dict].bytesize)
+          io << layout[:top_dict]
+          io << layout[:global_subr_index]
+          io << layout[:variation_store] if layout[:variation_store]
+          io << layout[:charstrings_index]
+          io << layout[:font_dict_index]
+          io
+        end
+
+        private_class_method :charstring_for, :empty_charstring,
+                             :encode_top_dict, :build_font_dict,
+                             :compute_layout, :same_offsets?,
+                             :empty_global_subr_index, :assemble
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/compile/cff2_subroutines.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      # CFF2 subroutine utilities — bias calculation and INDEX building.
+      #
+      # Subroutines are shared charstring sequences referenced by index
+      # from the caller. CFF2 supports two kinds:
+      #   - GlobalSubr: shared across all CharStrings
+      #   - LocalSubr: per Font DICT, referenced via operator 19 (0x13)
+      #
+      # The bias for callsubr/callgsubr index lookup is:
+      #   0-1240       → bias 107
+      #   1241-33800   → bias 1131
+      #   33801+       → bias 32768
+      #
+      # @see https://learn.microsoft.com/en-us/typography/opentype/spec/cff2#charstring-operators
+      module Cff2Subrs
+        # Calculate the bias for subroutine index lookup.
+        # @param count [Integer] number of subroutines in the INDEX
+        # @return [Integer] bias
+        def self.bias(count)
+          return 107 if count <= 1240
+          return 1131 if count <= 33800
+
+          32768
+        end
+
+        # Build a Subr INDEX (same structure for Global and Local).
+        # @param subrs [Array<String>] charstring bytes for each subr
+        # @return [String] INDEX binary
+        def self.build_index(subrs)
+          Tables::Cff2::IndexBuilder.build(subrs.map(&:b))
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/compile/colr.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      # Builds the OpenType `COLR` (Color) table (version 0).
+      #
+      # COLR v0 maps glyph IDs to layers. Each layer is a reference
+      # to another glyph painted in a specific color. This produces
+      # multi-color glyphs (e.g., emoji) using simple flat layers.
+      #
+      # Header (14 bytes):
+      #   uint16 version (= 0)
+      #   uint16 numBaseGlyphRecords
+      #   Offset32 baseGlyphRecordsOffset
+      #   Offset32 layerRecordsOffset
+      #   uint16 numLayerRecords
+      #
+      # BaseGlyphRecord (6 bytes):
+      #   uint16 glyphID
+      #   uint16 firstLayerIndex
+      #   uint16 numLayers
+      #
+      # LayerRecord (3 bytes):
+      #   uint16 layerGlyphID
+      #   uint8 paletteIndex
+      #
+      # @see https://learn.microsoft.com/en-us/typography/opentype/spec/colr
+      module Colr
+        VERSION = 0
+        HEADER_SIZE = 14
+        BASE_GLYPH_RECORD_SIZE = 6
+        LAYER_RECORD_SIZE = 3
+
+        # @param base_glyphs [Array<Hash>] each with :gid (Integer) and
+        #   :layers (Array<Hash> with :layer_gid and :palette_index)
+        # @return [String, nil] COLR table bytes, or nil if no base glyphs
+        def self.build(base_glyphs:)
+          return nil if base_glyphs.nil? || base_glyphs.empty?
+
+          base_records = +""
+          layer_records = +""
+          first_layer_index = 0
+
+          base_glyphs.each do |bg|
+            layers = bg[:layers] || []
+            num_layers = layers.size
+
+            base_records << [
+              bg[:gid] || 0,
+              first_layer_index,
+              num_layers,
+            ].pack("nnn")
+
+            layers.each do |layer|
+              layer_records << [
+                layer[:layer_gid] || 0,
+                layer[:palette_index] || 0,
+              ].pack("nC")
+            end
+
+            first_layer_index += num_layers
+          end
+
+          num_base = base_glyphs.size
+          base_offset = HEADER_SIZE
+          layer_offset = base_offset + (num_base * BASE_GLYPH_RECORD_SIZE)
+          num_layer_records = layer_records.bytesize / LAYER_RECORD_SIZE
+
+          io = +""
+          io << [VERSION, num_base, base_offset, layer_offset,
+                 num_layer_records].pack("nnNNn")
+          io << base_records
+          io << layer_records
+          io
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/compile/cpal.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      # Builds the OpenType `CPAL` (Color Palette) table.
+      #
+      # CPAL stores one or more palettes of BGRA color records,
+      # referenced by COLR layers and other color-glyph mechanisms.
+      #
+      # @see https://learn.microsoft.com/en-us/typography/opentype/spec/cpal
+      module Cpal
+        VERSION = 0
+        HEADER_SIZE = 12
+        COLOR_RECORD_SIZE = 4 # BGRA
+
+        # Color value object: BGRA uint8 tuple.
+        Color = Struct.new(:blue, :green, :red, :alpha, keyword_init: true) do
+          def to_bytes
+            [blue || 0, green || 0, red || 0, alpha || 255].pack("C4")
+          end
+        end
+
+        # @param palettes [Array<Array<Color>>] one or more palettes,
+        #   each an array of Color values. All palettes must have the
+        #   same number of entries.
+        # @return [String, nil] CPAL table bytes, or nil if no palettes
+        def self.build(palettes:)
+          return nil if palettes.nil? || palettes.empty?
+
+          num_entries = palettes.first.size
+          num_palettes = palettes.size
+          num_records = num_entries * num_palettes
+
+          indices = Array.new(num_palettes) { |i| i * num_entries }
+          records = palettes.flatten
+
+          offset = HEADER_SIZE + (num_palettes * 2) # header + indices
+
+          io = +""
+          io << [VERSION, num_entries, num_palettes, num_records, offset].pack("nnnnN")
+          indices.each { |idx| io << [idx].pack("n") }
+          records.each { |c| io << color_bytes(c) }
+          io
+        end
+
+        def self.color_bytes(color)
+          return color.to_bytes if color.is_a?(Color)
+
+          b = color[:blue] || color["blue"] || 0
+          g = color[:green] || color["green"] || 0
+          r = color[:red] || color["red"] || 0
+          a = color[:alpha] || color["alpha"] || 255
+          [b, g, r, a].pack("C4")
+        end
+
+        private_class_method :color_bytes
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/compile/math.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      # Builds the OpenType `MATH` table for mathematical formula layout.
+      #
+      # The MATH table provides constants and glyph info for rendering
+      # equations in math-aware environments (Word, LibreOffice, TeX).
+      #
+      # Layout:
+      #   Header (10 bytes):
+      #     uint16 version (= 1)
+      #     Offset32 mathConstantsOffset
+      #     Offset32 mathGlyphInfoOffset
+      #     Offset32 mathVariantsOffset
+      #
+      #   MathConstants: 57 layout constants (int16 + bool each)
+      #   MathGlyphInfo: italic correction, top accent, extension
+      #   MathVariants: glyph assembly for stretched delimiters
+      #
+      # @see https://learn.microsoft.com/en-us/typography/opentype/spec/math
+      module MathTable
+        VERSION = 1
+        HEADER_SIZE = 10
+
+        # @param constants [Hash, nil] math layout constants
+        # @param glyph_info [Hash, nil] per-glyph math data
+        # @param variants [Hash, nil] stretched delimiter data
+        # @return [String, nil] MATH table bytes, or nil if no data
+        def self.build(constants: nil, glyph_info: nil, variants: nil)
+          return nil unless constants || glyph_info || variants
+
+          constants_bytes = constants ? build_constants(constants) : nil
+          glyph_info_bytes = glyph_info ? build_glyph_info(glyph_info) : nil
+          variants_bytes = variants ? build_variants(variants) : nil
+
+          constants_off = constants_bytes ? HEADER_SIZE : 0
+          gi_off = glyph_info_bytes ? constants_off + (constants_bytes&.bytesize || 0) : 0
+          if gi_off.zero? && glyph_info_bytes
+            gi_off = HEADER_SIZE + (constants_bytes&.bytesize || 0)
+          end
+          variants_off = variants_bytes ? gi_off + (glyph_info_bytes&.bytesize || 0) : 0
+          if variants_off.zero? && variants_bytes
+            variants_off = HEADER_SIZE + (constants_bytes&.bytesize || 0) + (glyph_info_bytes&.bytesize || 0)
+          end
+
+          io = +""
+          io << [0x00010000, constants_off, gi_off, variants_off].pack("Nnnn")
+          io << constants_bytes if constants_bytes
+          io << glyph_info_bytes if glyph_info_bytes
+          io << variants_bytes if variants_bytes
+          io
+        end
+
+        # Build the MathConstants subtable (57 constants).
+        # Each constant is int16 (or int32 for larger ranges).
+        def self.build_constants(constants)
+          io = +""
+          # The 57 constants are a fixed sequence. We pack what's
+          # provided and use 0 (default) for missing ones.
+          constant_names.each do |name|
+            value = constants[name] || constants[name.to_s] || 0
+            io << [value.to_i].pack("s>")
+          end
+          io
+        end
+
+        def self.constant_names
+          %i[
+            scriptPercentScaleDown
+            scriptScriptPercentScaleDown
+            delimitedSubFormulaMinHeight
+            displayOperatorMinHeight
+            mathLeading
+            axisHeight
+            accentBaseHeight
+            flattenedAccentBaseHeight
+            subscriptShiftDown
+            subscriptTopMax
+            subscriptBaselineDropMin
+            superscriptShiftUp
+            superscriptShiftUpCramped
+            superscriptBottomMin
+            superscriptBaselineDropMax
+            subSuperscriptGapMin
+            superscriptBottomMaxWithSubscript
+            spaceAfterScript
+            upperLimitGapMin
+            upperLimitBaselineRiseMin
+            lowerLimitGapMin
+            lowerLimitBaselineDropMin
+            stackTopShiftUp
+            stackTopDisplayStyleShiftUp
+            stackBottomShiftDown
+            stackBottomDisplayStyleShiftDown
+            stackGapMin
+            stackDisplayStyleGapMin
+            stretchStackTopShiftUp
+            stretchStackBottomShiftDown
+            fractionNumeratorShiftUp
+            fractionNumeratorDisplayStyleShiftUp
+            fractionDenominatorShiftDown
+            fractionDenominatorDisplayStyleShiftDown
+            fractionNumeratorGapMin
+            fractionNumDisplayStyleGapMin
+            fractionRuleThickness
+            fractionDenominatorGapMin
+            fractionDenomDisplayStyleGapMin
+            skewedFractionHorizontalGap
+            skewedFractionVerticalGap
+            overbarVerticalGap
+            overbarRuleThickness
+            overbarExtraAscender
+            underbarVerticalGap
+            underbarRuleThickness
+            underbarExtraDescender
+            radicalVerticalGap
+            radicalDisplayStyleVerticalGap
+            radicalRuleThickness
+            radicalExtraAscender
+            radicalKernBeforeDegree
+            radicalKernAfterDegree
+            radicalDegreeBottomRaisePercent
+          ].freeze
+        end
+
+        def self.build_glyph_info(_info)
+          # Minimal: just the header with offsets (all empty for now)
+          [0, 0, 0, 0].pack("NNNN")
+        end
+
+        def self.build_variants(_variants)
+          # Minimal: just the header with offset (empty for now)
+          [0, 0, 0, 0].pack("NNNN")
+        end
+
+        private_class_method :build_constants, :constant_names,
+                             :build_glyph_info, :build_variants
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/compile/meta.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      # Builds the OpenType `meta` table.
+      #
+      # The meta table stores font metadata as tagged data — longer-form
+      # strings than the `name` table supports. Common tags:
+      #   "dlng" — design languages (BCP-47 tags)
+      #   "slng" — supported languages
+      #
+      # @see https://learn.microsoft.com/en-us/typography/opentype/spec/meta
+      module Meta
+        VERSION = 1
+        HEADER_SIZE = 16
+        DATA_MAP_SIZE = 12 # tag(4) + offset(4) + length(4)
+
+        # @param data [Hash<String,String>] tag → UTF-8 string value
+        # @return [String, nil] meta table bytes, or nil if no data
+        def self.build(data:)
+          return nil if data.nil? || data.empty?
+
+          count = data.size
+          data_offset = HEADER_SIZE + (count * DATA_MAP_SIZE)
+
+          io = +""
+          io << [VERSION, 0, count, data_offset].pack("NNNN")
+
+          # Two iterations over the same data: the meta table has two
+          # distinct output sections (data map entries then data values)
+          # that cannot be interleaved. The map-entry section records
+          # offsets that depend on the total size of the value section,
+          # so the value section must be produced last.
+          #
+          # rubocop:disable Style/CombinableLoops
+          offset = data_offset
+          data.each do |tag, value|
+            io << tag.ljust(4, " ")[0, 4]
+            io << [offset, value.bytesize].pack("NN")
+            offset += value.bytesize
+          end
+          data.each_value { |value| io << value.b }
+          # rubocop:enable Style/CombinableLoops
+
+          io
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/compile/otf2_compiler.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      # UFO → OTF (CFF2). Uses CFF2 outlines instead of CFF1.
+      #
+      # CFF2 uses the same OTTO sfnt signature as CFF1. The difference
+      # is the table tag: `CFF2` (vs `CFF ` for CFF1). CFF2 enables
+      # variable font support and improved subroutinization.
+      #
+      # Note: CFF2 does NOT bypass the 65,535 glyph cap. The maxp
+      # table's numGlyphs is uint16 in all OpenType versions, and the
+      # CFF2 CharStrings INDEX count must match it. For > 65,535
+      # glyphs, use TTC splitting.
+      class Otf2Compiler < BaseCompiler
+        SFNT_VERSION = SFNT_VERSION_OPEN_TYPE
+
+        def build_outline_tables
+          {
+            "CFF2" => Cff2.build(font, glyphs: font.glyphs.values),
+          }
+        end
+
+        def compile(output_path:)
+          glyphs = font.glyphs.values
+
+          tables = {
+            "head" => Head.build(font, glyphs: glyphs, loca_format: Head::LOCA_FORMAT_LONG),
+            "hhea" => Hhea.build(font, glyphs: glyphs),
+            "maxp" => Maxp.build(font, glyphs: glyphs, version: Maxp::VERSION_OPEN_TYPE),
+            "OS/2" => Os2.build(font, glyphs: glyphs),
+            "name" => Name.build(font),
+            "post" => Post.build(font),
+            "hmtx" => Hmtx.build(font, glyphs: glyphs),
+            "cmap" => Cmap.build(font, glyphs: glyphs),
+            "CFF2" => Cff2.build(font, glyphs: glyphs),
+          }
+
+          write(tables, output_path)
+          output_path
+        end
+      end
+    end
+  end
+end