fontisan 0.4.3 → 0.4.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5b68479ccaac604474e929d9dc4b3de24ec1c79f53e187fd7394cafdf3e02a11
-  data.tar.gz: 27c7dd8fd5afed7656aaaba9a57ea52c78144d66a4346bd4d4b0285c6327c176
+  metadata.gz: 999173c7fe3caa0568c7bc29b87184b1f167c5885b5e66c9c7c7f0f884d2523e
+  data.tar.gz: a9bf5e401b1b08672ced56f71b7ff5d6ab6b60e83b4ba1932ef43582c5d3a528
 SHA512:
-  metadata.gz: 55d3133ec31fb397c671039a8181c5182b62a9cac0108df9a45d551b5def47475d2edbef7e9d921727ad812734351234da82f71c7b8fd1314a16dab83261aa6a
-  data.tar.gz: 4a59af9b12d398575f45018511eeeaea0e49b827efd223f3052ff48f12053087f0e0749498a6be3049f5adb8c880e8461c28167ae7601a7d3dbcaa403e7380e1
+  metadata.gz: 9b770784dbac538d4d3998b1e908eedd5cb010f72897a0dc94b28e32f1150c6fdb99d384703760360dd1b01855de725ef786c34b173854ca8fd869b23ad6a8d6
+  data.tar.gz: 5b64092d77f6c19fc2e40fe40114722652000c49a36b22ae0dacccb86236d5529fe7d9c183bc4bd3141998d44a59b44ae2d5954bf675bb86fb489ff380a7b490

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

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      # Builds the OpenType `fvar` (Font Variations) table from a
+      # list of axis definitions and named instances.
+      #
+      # @see https://learn.microsoft.com/en-us/typography/opentype/spec/fvar
+      module Fvar
+        VERSION_MAJOR = 1
+        VERSION_MINOR = 0
+        AXIS_SIZE = 20
+        INSTANCE_SIZE = 4 # + 4 per axis
+        FIXED_SHIFT = 16
+        FIXED_ONE = 1 << FIXED_SHIFT
+
+        # @param font [Fontisan::Ufo::Font]
+        # @param axes [Array<Hash>] axis definitions
+        # @param instances [Array<Hash>] named instance definitions
+        # @return [String, nil] fvar table bytes, or nil if no axes
+        def self.build(font, axes: nil, instances: nil)
+          axes ||= font.info.respond_to?(:axes) ? font.info.axes : nil
+          instances ||= font.info.respond_to?(:named_instances) ? font.info.named_instances : nil
+
+          axes ||= []
+          return nil if axes.empty?
+
+          axes_bytes = build_axes(axes)
+          instances_bytes = build_instances(instances || [], axes.size)
+          header = build_header(axes.size, axes_bytes, instances_bytes, instances)
+          header + axes_bytes + instances_bytes
+        end
+
+        # ---------- header ----------
+
+        # Header is 16 bytes:
+        #   majorVersion (2) + minorVersion (2) + axesArrayOffset (2)
+        #   + reserved (2) + axisCount (2) + axisSize (2)
+        #   + instanceCount (2) + instanceSize (2)
+        def self.build_header(axis_count, axes_bytes, _instances_bytes, instances)
+          axes_offset = 16
+          axes_offset + axes_bytes.bytesize
+
+          [
+            VERSION_MAJOR,
+            VERSION_MINOR,
+            axes_offset,
+            0, # reserved
+            axis_count,
+            AXIS_SIZE,
+            instances&.size || 0,
+            (instances&.size || 0).zero? ? 0 : (INSTANCE_SIZE + axis_count * 4),
+          ].pack("nnnnnnnn")
+        end
+
+        # ---------- axes ----------
+
+        # Each axis record is 20 bytes:
+        #   axisTag (4) + minValue (4) + defaultValue (4) + maxValue (4)
+        #   + flags (2) + axisNameID (2)
+        def self.build_axes(axes)
+          io = +""
+          axes.each do |axis|
+            tag = (axis[:tag] || axis["tag"] || "wght").to_s.ljust(4, " ")[0, 4]
+            min = fixed_value(axis[:min] || axis["min"] || 100)
+            default = fixed_value(axis[:default] || axis["default"] || 400)
+            max = fixed_value(axis[:max] || axis["max"] || 900)
+            flags = axis[:flags] || axis["flags"] || 0
+            name_id = axis[:name_id] || axis["name_id"] || 0
+
+            io << tag
+            io << [min, default, max, flags, name_id].pack("NNNnn")
+          end
+          io
+        end
+
+        # ---------- instances ----------
+
+        # Each instance record: subfamilyNameID (2) + flags (2) + per-axis coords
+        def self.build_instances(instances, axis_count)
+          return +"" if instances.empty?
+
+          io = +""
+          instances.each do |inst|
+            name_id = inst[:name_id] || inst["name_id"] || 0
+            flags = inst[:flags] || inst["flags"] || 0
+            coords = inst[:coords] || inst["coords"] || []
+            padded = coords.first(axis_count) + Array.new([axis_count - coords.size, 0].max, 0)
+            padded = padded.first(axis_count).map { |c| fixed_value(c) }
+
+            io << [name_id, flags].pack("nn")
+            io << padded.pack("N*")
+          end
+          io
+        end
+
+        # ---------- helpers ----------
+
+        # Convert a float to OpenType Fixed 16.16 (int32).
+        def self.fixed_value(value)
+          (value.to_f * FIXED_ONE).to_i
+        end
+        private_class_method :build_header, :build_axes, :build_instances,
+                             :fixed_value
+      end
+    end
+  end
+end

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

@@ -0,0 +1,222 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      # Builds the OpenType `gvar` (Glyph Variation Data) table from
+      # per-glyph deltas computed between a default master and one or
+      # more extreme masters.
+      #
+      # This is the hardest table in the variable-font specification.
+      # It stores, for every glyph, how each outline point moves
+      # between the default master and each extreme master.
+      #
+      # This builder produces a minimal-but-valid gvar:
+      #   - One tuple per master (no shared tuples)
+      #   - Explicit per-point deltas (no IUP compression)
+      #   - Delta values encoded as int8 when possible, int16 otherwise
+      #
+      # @see https://learn.microsoft.com/en-us/typography/opentype/spec/gvar
+      module Gvar
+        VERSION_MAJOR = 1
+        VERSION_MINOR = 0
+
+        # TupleIndex flags
+        TUPLE_SHARED          = 0x8000
+        TUPLE_PRIVATE         = 0x4000
+        TUPLE_AXIS_COUNT_MASK = 0x0FFF
+
+        # Delta encoding flags (in the delta data header)
+        DELTAS_ARE_ZERO    = 0x80
+        DELTAS_ARE_INT8    = 0x40
+        POINT_COUNT_MASK   = 0x3FFF
+
+        # @param default_glyphs [Array<Fontisan::Ufo::Glyph>] default master
+        # @param masters [Array<Hash>] extreme masters
+        #   Each hash: { axes: { tag: peak_value }, glyphs: [Glyph, ...] }
+        # @param axis_count [Integer] number of axes
+        # @return [String] gvar table bytes
+        def self.build(default_glyphs:, masters:, axis_count:)
+          glyph_count = default_glyphs.size
+          return build_empty(glyph_count) if masters.empty? || glyph_count.zero?
+
+          # Compute per-glyph variation data
+          glyph_data = Array.new(glyph_count) do |gid|
+            build_glyph_variation(default_glyphs[gid], masters, gid, axis_count)
+          end
+
+          assemble(glyph_count, axis_count, glyph_data)
+        end
+
+        # ---------- per-glyph variation ----------
+
+        # Build the tuple variation data for a single glyph.
+        # Returns the serialized bytes (tuple headers + delta data).
+        # Returns empty string if the glyph has no variation.
+        def self.build_glyph_variation(default_glyph, masters, gid, axis_count)
+          return +"" unless default_glyph
+
+          tuples = []
+          masters.each do |master|
+            master_glyph = master[:glyphs]&.dig(gid)
+            next unless master_glyph
+
+            deltas = compute_deltas(default_glyph, master_glyph)
+            next if deltas.all? { |d| d[0].zero? && d[1].zero? }
+
+            tuples << {
+              peak: master[:axes] || {},
+              deltas: deltas,
+            }
+          end
+
+          return +"" if tuples.empty?
+
+          serialize_tuples(tuples, axis_count)
+        end
+
+        # Compute per-point deltas (dx, dy) between default and master.
+        # @return [Array<[Integer, Integer]>] deltas for each point
+        def self.compute_deltas(default_glyph, master_glyph)
+          default_points = default_glyph.contours.flat_map(&:points)
+          master_points = master_glyph.contours.flat_map(&:points)
+
+          count = [default_points.size, master_points.size].min
+          Array.new(count) do |i|
+            dx = master_points[i].x.to_i - default_points[i].x.to_i
+            dy = master_points[i].y.to_i - default_points[i].y.to_i
+            [dx, dy]
+          end
+        end
+
+        # ---------- tuple serialization ----------
+
+        def self.serialize_tuples(tuples, axis_count)
+          tuple_entries = tuples.map { |t| serialize_tuple(t, axis_count) }
+          tuple_count = tuple_entries.size
+
+          io = +""
+          io << [tuple_count].pack("n") # tupleVariationCount
+          io << [4 + tuple_count * 4].pack("n") # dataOffset (after header + tuple headers)
+          # Wait — dataOffset is from start of per-glyph data to the delta data area.
+          # The tuple headers come first, then the delta data.
+          # Let me recalculate:
+          tuple_headers_size = tuple_entries.sum { |e| e[:header].bytesize }
+          data_offset = 4 + tuple_headers_size
+
+          io = +""
+          io << [tuple_count].pack("n")
+          io << [data_offset].pack("n")
+
+          tuple_entries.each do |e|
+            io << e[:header]
+            io << e[:data]
+          end
+
+          io
+        end
+
+        def self.serialize_tuple(tuple, axis_count)
+          peak = tuple[:peak]
+          deltas = tuple[:deltas]
+
+          # Encode delta data
+          all_fit_int8 = deltas.all? { |dx, dy| dx.between?(-127, 127) && dy.between?(-127, 127) }
+
+          point_count = deltas.size
+          flags = point_count & POINT_COUNT_MASK
+          flags |= DELTAS_ARE_INT8 if all_fit_int8
+
+          data = +""
+          data << [flags].pack("n")
+
+          if all_fit_int8
+            deltas.each do |dx, dy|
+              data << [dx & 0xFF, dy & 0xFF].pack("CC")
+            end
+          else
+            deltas.each do |dx, dy|
+              data << [dx & 0xFFFF, dy & 0xFFFF].pack("nn")
+            end
+          end
+
+          # Encode tuple header
+          tuple_index = TUPLE_PRIVATE | (axis_count & TUPLE_AXIS_COUNT_MASK)
+
+          header = +""
+          header << [data.bytesize].pack("n") # variationDataSize
+          header << [tuple_index].pack("n") # tupleIndex
+
+          # Peak axis coordinates (F2DOT14 per axis)
+          axis_tags = peak.keys.sort
+          axis_tags.first(axis_count).each do |tag|
+            header << [f2dot14(peak[tag] || 0)].pack("n")
+          end
+
+          { header: header, data: data }
+        end
+
+        # ---------- gvar table assembly ----------
+
+        def self.assemble(glyph_count, axis_count, glyph_data)
+          # Build the glyph variation data offset array
+          offsets = [0]
+          current = 0
+          glyph_data.each do |data|
+            current += data.bytesize
+            offsets << current
+          end
+
+          # Offset size: uint16 (flags bit 0 = 0) or uint32 (bit 0 = 1)
+          use_long = offsets.last > 0xFFFF
+          flags = use_long ? 1 : 0
+
+          # Build header (20 bytes for v1)
+          header = +""
+          header << [VERSION_MAJOR, VERSION_MINOR].pack("nn") # version
+          header << [axis_count].pack("n") # axisCount
+          header << [0].pack("n") # sharedTupleCount
+          header << [0].pack("N") # offsetToSharedTuples
+          header << [glyph_count].pack("n") # glyphCount
+          header << [flags].pack("n") # flags (bit 0 = offset size)
+
+          header_size = header.bytesize
+          offset_entry_size = use_long ? 4 : 2
+          offset_array_size = (glyph_count + 1) * offset_entry_size
+          header_size + offset_array_size
+
+          # Offset array (relative to data_start)
+          if use_long
+            header + offsets.pack("N*") + glyph_data.join
+          else
+            header + offsets.pack("n*") + glyph_data.join
+          end
+        end
+
+        def self.build_empty(glyph_count)
+          # Minimal gvar with no variation data
+          header = [VERSION_MAJOR, VERSION_MINOR, 0, 0, 0, glyph_count, 1, glyph_count * 1 + 16].pack("nnnnnnNN")
+          offsets = Array.new(glyph_count + 1, 0).pack("C*")
+          header + offsets
+        end
+
+        # ---------- helpers ----------
+
+        def self.f2dot14(value)
+          (value.to_f * 16384).to_i
+        end
+
+        def self.byte_size_for(max_value)
+          return 1 if max_value <= 0xFF
+          return 2 if max_value <= 0xFFFF
+          return 3 if max_value <= 0xFFFFFF
+
+          4
+        end
+        private_class_method :build_glyph_variation, :compute_deltas,
+                             :serialize_tuples, :serialize_tuple,
+                             :assemble, :build_empty, :f2dot14, :byte_size_for
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/compile.rb

@@ -33,7 +33,9 @@ module Fontisan
       autoload :TtfCompiler,  "fontisan/ufo/compile/ttf_compiler"
       autoload :OtfCompiler,  "fontisan/ufo/compile/otf_compiler"
       autoload :Filters,      "fontisan/ufo/compile/filters"
+      autoload :Fvar,         "fontisan/ufo/compile/fvar"
       autoload :Gpos,         "fontisan/ufo/compile/gpos"
+      autoload :Gvar,         "fontisan/ufo/compile/gvar"
       autoload :Head,         "fontisan/ufo/compile/head"
       autoload :Hhea,         "fontisan/ufo/compile/hhea"
       autoload :Maxp,         "fontisan/ufo/compile/maxp"

data/lib/fontisan/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Fontisan
-  VERSION = "0.4.3"
+  VERSION = "0.4.5"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fontisan
 version: !ruby/object:Gem::Version
-  version: 0.4.3
+  version: 0.4.5
 platform: ruby
 authors:
 - Ribose Inc.
@@ -563,8 +563,10 @@ files:
 - lib/fontisan/ufo/compile/filters/decompose_components.rb
 - lib/fontisan/ufo/compile/filters/flatten_components.rb
 - lib/fontisan/ufo/compile/filters/reverse_contour_direction.rb
+- lib/fontisan/ufo/compile/fvar.rb
 - lib/fontisan/ufo/compile/glyf_loca.rb
 - lib/fontisan/ufo/compile/gpos.rb
+- lib/fontisan/ufo/compile/gvar.rb
 - lib/fontisan/ufo/compile/head.rb
 - lib/fontisan/ufo/compile/hhea.rb
 - lib/fontisan/ufo/compile/hmtx.rb