skrift-color 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 641dc02079c341fcc4818ca69128e8f3aae7bba2d11f25098cec8f0c31c1ae69
+  data.tar.gz: 91708a5b2cdaaa52a3731119871df272d1d0e1bec4523633ddea279baf65a057
+SHA512:
+  metadata.gz: 81dc7ecaa7a487fcaba8447527291a78172cad96124c0df83e68e7eafa019730245eb81a09785b7201ff84fd670d4dd6b266d00462230ba628ae251ec97d6e67
+  data.tar.gz: 076e83a3bfc367be5f0d2a25813be9f2f270f5ae3cb377310e661f1cb292b134a518f34836f8ed763210a8b76cd1390154bcd8dae2afbdbdfe307f929af57f99

data/.rspec

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

data/Gemfile

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gemspec
+
+# skrift is developed alongside this plugin. To work against a local checkout,
+# set a per-machine override (stored in ~/.bundle/config, never committed):
+#
+#   bundle config set --local local.skrift /path/to/skrift
+gem "skrift", git: "https://github.com/vidarh/skrift.git", branch: "master"
+
+gem "rake", "~> 13.0"
+gem "rspec", "~> 3.0"

data/LICENSE.txt

@@ -0,0 +1,15 @@
+ISC License
+
+© 2026 Vidar Hokstad
+
+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,64 @@
+# skrift-color
+
+A [Skrift](https://github.com/vidarh/skrift) plugin that renders **colour
+glyphs** (colour emoji) to RGBA, in the two formats that matter in practice:
+
+- **COLR/CPAL (v0)** — layered vector glyphs (Segoe-style emoji, Twemoji-COLR
+  builds). Each layer is an ordinary outline drawn in a flat palette colour;
+  the plugin rasterises each layer with skrift's monochrome renderer and
+  composites them.
+- **CBDT/CBLC** — embedded PNG bitmaps (e.g. **Noto Color Emoji**, the usual
+  colour emoji font on Linux). The plugin extracts the glyph's PNG, decodes it
+  (pure Ruby, via `zlib`), and scales it to the requested size.
+
+`Skrift::Color::Renderer#render` tries COLR first, then CBDT, and returns the
+same RGBA `Skrift::Color::Image` either way (or `nil` to fall back to mono).
+It's pure Ruby with no extra dependencies, and the **core skrift renderer stays
+monochrome** — colour is entirely opt-in.
+
+## Scope
+
+- **Supported:** COLR v0 + CPAL (layered vector), and CBDT/CBLC with image
+  format 17 + index format 1 (PNG bitmaps, as Noto Color Emoji uses).
+- **Not (yet) supported:** COLR v1 (gradients/transforms), `sbix`, OT-SVG, less
+  common CBLC index/image formats, and ZWJ / multi-codepoint emoji sequences.
+
+## Usage
+
+```ruby
+require "skrift"
+require "skrift/color"
+
+font = Skrift::Font.load("emoji.ttf")
+colr = Skrift::Color::Renderer.new(font, x_scale: 64, y_scale: 64)
+
+if (img = colr.render(0x1F600))   # nil if the codepoint has no COLR glyph
+  # img is a Skrift::Color::Image: width, height, and `pixels`, a row-major
+  # array of packed 0xRRGGBBAA integers (straight alpha).
+  img.pixels.each_slice(img.width) { |row| ... }
+else
+  # fall back to skrift's normal monochrome rendering
+end
+```
+
+## Example
+
+`examples/color_preview.rb` renders a colour glyph and previews it as ANSI
+24-bit-colour terminal output (alpha-composited over a checkerboard) plus a
+saved RGBA PNG. With no arguments it uses the bundled synthetic fixture:
+
+```sh
+ruby examples/color_preview.rb                       # the fixture glyph
+ruby examples/color_preview.rb Twemoji.ttf 0x1F600 96 grin.png
+```
+
+## Tests
+
+The specs run against a tiny **synthetic** COLR/CPAL font built with
+[fontTools](https://github.com/fonttools/fonttools) (committed under
+`spec/fixtures/`). Rebuild it with `rake fixtures` (needs `python3` +
+`fonttools`).
+
+## License
+
+ISC. See `LICENSE.txt`.

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+desc "Rebuild the synthetic COLR/CPAL test fixtures (needs fonttools)"
+task :fixtures do
+  sh "python3 spec/support/build_fixture.rb"
+end
+
+task default: :spec

data/examples/color_preview.rb

@@ -0,0 +1,101 @@
+# Renders a colour glyph (COLR/CPAL vector or CBDT PNG emoji) with skrift-color
+# and showcases it two ways:
+#   * an ANSI 24-bit-colour terminal preview, alpha-composited over a
+#     checkerboard so transparency is visible, and
+#   * a saved RGBA PNG (out.png by default).
+#
+# Usage (from the gem root):
+#   ruby examples/color_preview.rb [FONT.ttf] [CODEPOINT] [SCALE] [OUT.png]
+#
+# With no arguments it renders a real grinning-face emoji from Noto Color Emoji
+# (CBDT) if installed, else the bundled synthetic COLR fixture. Examples:
+#   ruby examples/color_preview.rb                                  # 😀 from Noto
+#   ruby examples/color_preview.rb /path/to/Twemoji.ttf 0x1F389 96  # COLR font
+
+# Allow running straight from source checkouts (no bundler needed).
+sibling = File.expand_path("../../skrift/lib", __dir__)
+$LOAD_PATH.unshift(sibling) if File.directory?(sibling)
+$LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
+
+require "skrift"
+require "skrift/color"
+require "zlib"
+
+# By default, render a real grinning-face emoji from Noto Color Emoji (CBDT)
+# if it's installed; otherwise fall back to the bundled synthetic COLR fixture.
+NOTO    = "/usr/share/fonts/truetype/noto/NotoColorEmoji.ttf"
+FIXTURE = File.expand_path("../spec/fixtures/colrtest.ttf", __dir__)
+
+font_path = ARGV[0] || (File.exist?(NOTO) ? NOTO : FIXTURE)
+default_cp = font_path == NOTO ? 0x1F600 : 0x41
+codepoint  = ARGV[1] ? Integer(ARGV[1]) : default_cp # accepts 0x... or decimal
+scale      = (ARGV[2] || 64).to_i
+out_png    = ARGV[3] || "out.png"
+
+font = Skrift::Font.load(font_path)
+colr = Skrift::Color::Renderer.new(font, x_scale: scale, y_scale: scale)
+
+unless colr.color?
+  abort "#{File.basename(font_path)} has no colour data (COLR/CPAL or CBDT)."
+end
+
+img = colr.render(codepoint)
+unless img
+  abort format("U+%04X has no colour glyph in %s.", codepoint, File.basename(font_path))
+end
+
+puts format("Rendered U+%04X from %s at %dpx -> %dx%d RGBA",
+            codepoint, File.basename(font_path), scale, img.width, img.height)
+
+# --- helpers ---------------------------------------------------------------
+
+def unpack(px)
+  [(px >> 24) & 0xff, (px >> 16) & 0xff, (px >> 8) & 0xff, px & 0xff]
+end
+
+# straight-alpha source-over of (r,g,b,a) onto an opaque (br,bg,bb) background
+def over(fg, bg)
+  r, g, b, a = fg
+  br, bgc, bb = bg
+  [(r * a + br * (255 - a)) / 255,
+   (g * a + bgc * (255 - a)) / 255,
+   (b * a + bb * (255 - a)) / 255]
+end
+
+# --- terminal preview ------------------------------------------------------
+
+LIGHT = [120, 120, 120]
+DARK  = [70, 70, 70]
+
+img.height.times do |y|
+  line = +""
+  img.width.times do |x|
+    checker = (x / 2 + y / 2).even? ? LIGHT : DARK
+    r, g, b = over(unpack(img.pixels[y * img.width + x]), checker)
+    line << "\e[48;2;#{r};#{g};#{b}m  "
+  end
+  puts line + "\e[0m"
+end
+
+# --- RGBA PNG --------------------------------------------------------------
+
+def png_chunk(type, data)
+  body = type.b + data.b
+  [data.bytesize].pack("N") + body + [Zlib.crc32(body)].pack("N")
+end
+
+raw = +"".b
+img.height.times do |y|
+  raw << "\0".b # filter: none
+  img.width.times do |x|
+    r, g, b, a = unpack(img.pixels[y * img.width + x])
+    raw << r.chr << g.chr << b.chr << a.chr
+  end
+end
+
+png = +"\x89PNG\r\n\x1a\n".b
+png << png_chunk("IHDR", [img.width, img.height, 8, 6, 0, 0, 0].pack("NNC5")) # 8-bit RGBA
+png << png_chunk("IDAT", Zlib::Deflate.deflate(raw))
+png << png_chunk("IEND", "")
+File.binwrite(out_png, png)
+puts "Wrote #{out_png}"

data/lib/skrift/color/cbdt.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Skrift
+  module Color
+    # Parses CBLC/CBDT colour-bitmap tables and extracts a glyph's embedded PNG.
+    # Handles the common Noto Color Emoji shape: index format 1 (uint32 offset
+    # array) and image format 17 (small metrics + PNG). Returns nil for fonts or
+    # glyphs it can't handle, so callers can fall back.
+    class CBDT
+      Strike   = Struct.new(:ppem_x, :ppem_y, :start_gid, :end_gid, :subtables)
+      SubTable = Struct.new(:first, :last, :index_format, :image_format, :data_offset, :array_offset)
+
+      def self.parse(font)
+        cblc = font.tables["CBLC"]
+        cbdt = font.tables["CBDT"]
+        return nil unless cblc && cbdt
+        new(font, cblc, cbdt)
+      end
+
+      def initialize(font, cblc, cbdt)
+        @font = font
+        @cbdt = cbdt
+        @strikes = parse_strikes(cblc)
+      end
+
+      # [png_bytes, ppem_y] for a glyph id, or nil if it has no colour bitmap.
+      def glyph(gid)
+        @strikes.each do |st|
+          next unless gid.between?(st.start_gid, st.end_gid)
+          sub = st.subtables.find { |s| gid.between?(s.first, s.last) }
+          next unless sub
+          png = extract(sub, gid)
+          return [png, st.ppem_y] if png
+        end
+        nil
+      end
+
+      private
+
+      def f = @font
+
+      def parse_strikes(cblc)
+        f.getu32(cblc + 4).times.map do |i|
+          st      = cblc + 8 + i * 48 # bitmapSizeTable is 48 bytes
+          isa_off = cblc + f.getu32(st)
+          n_sub   = f.getu32(st + 8)
+          subs = n_sub.times.map do |j|
+            e       = isa_off + j * 8
+            sub_off = isa_off + f.getu32(e + 4)
+            SubTable.new(f.getu16(e), f.getu16(e + 2),
+                         f.getu16(sub_off), f.getu16(sub_off + 2),
+                         f.getu32(sub_off + 4), sub_off)
+          end
+          Strike.new(f.getu8(st + 44), f.getu8(st + 45),
+                     f.getu16(st + 40), f.getu16(st + 42), subs)
+        end
+      end
+
+      def extract(sub, gid)
+        return nil unless sub.index_format == 1 && sub.image_format == 17
+
+        arr = sub.array_offset + 8 # uint32 offsetArray follows the 8-byte header
+        idx = gid - sub.first
+        off = f.getu32(arr + idx * 4)
+        nxt = f.getu32(arr + (idx + 1) * 4)
+        return nil if nxt <= off # no bitmap for this glyph
+
+        data = @cbdt + sub.data_offset + off
+        # image format 17: smallGlyphMetrics (5 bytes) + dataLen (uint32) + PNG
+        png_len = f.getu32(data + 5)
+        f.at(data + 9, png_len)
+      end
+    end
+  end
+end

data/lib/skrift/color/colr.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Skrift
+  module Color
+    # Parses a COLR (v0) table into a map of
+    #   base glyph id => [[layer glyph id, palette index], ...]   (bottom to top)
+    # Returns nil if the font has no COLR table or a version we don't support.
+    module COLR
+      module_function
+
+      def parse(font)
+        off = font.tables["COLR"]
+        return nil unless off
+        return nil unless font.getu16(off).zero? # v0 only
+
+        num_base  = font.getu16(off + 2)
+        base_off  = off + font.getu32(off + 4)
+        layer_off = off + font.getu32(off + 8)
+
+        layers = {}
+        num_base.times do |i|
+          rec   = base_off + i * 6
+          gid   = font.getu16(rec)
+          first = font.getu16(rec + 2)
+          count = font.getu16(rec + 4)
+          layers[gid] = count.times.map do |j|
+            lr = layer_off + (first + j) * 4
+            [font.getu16(lr), font.getu16(lr + 2)]
+          end
+        end
+        layers
+      end
+    end
+  end
+end

data/lib/skrift/color/cpal.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Skrift
+  module Color
+    # Parses a CPAL table's first palette into an array of [r, g, b, a]
+    # (0..255). CPAL stores colours as BGRA; we normalise to RGBA. Returns nil
+    # if the font has no CPAL table.
+    module CPAL
+      module_function
+
+      def parse(font)
+        off = font.tables["CPAL"]
+        return nil unless off
+
+        num_entries = font.getu16(off + 2)
+        records_off = off + font.getu32(off + 8)
+        first_index = font.getu16(off + 12) # colorRecordIndices[0]
+
+        num_entries.times.map do |i|
+          rec = records_off + (first_index + i) * 4
+          b = font.getu8(rec)
+          g = font.getu8(rec + 1)
+          r = font.getu8(rec + 2)
+          a = font.getu8(rec + 3)
+          [r, g, b, a]
+        end
+      end
+    end
+  end
+end

data/lib/skrift/color/png.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require "zlib"
+
+module Skrift
+  module Color
+    # A small, dependency-free PNG decoder, just enough for the bitmaps found in
+    # colour-emoji fonts (CBDT/sbix). Supports 8-bit RGB (2) and RGBA (6), and
+    # palette (3, any bit depth) with a tRNS alpha table. Returns
+    # [width, height, pixels] where pixels is a row-major array of packed
+    # 0xRRGGBBAA integers. Raises on anything it doesn't understand.
+    module PNG
+      module_function
+
+      SIGNATURE = "\x89PNG\r\n\x1a\n".b
+
+      def decode(bytes)
+        bytes = bytes.b
+        raise "not a PNG" unless bytes[0, 8] == SIGNATURE
+
+        ihdr = nil
+        idat = +"".b
+        plte = nil
+        trns = nil
+        pos  = 8
+        while pos + 8 <= bytes.bytesize
+          len  = bytes[pos, 4].unpack1("N")
+          type = bytes[pos + 4, 4]
+          data = bytes[pos + 8, len]
+          case type
+          when "IHDR" then ihdr = data
+          when "PLTE" then plte = data
+          when "tRNS" then trns = data
+          when "IDAT" then idat << data
+          when "IEND" then break
+          end
+          pos += 12 + len # length + type + data + CRC
+        end
+
+        width, height, depth, color_type = ihdr.unpack("NNCC")
+        channels = CHANNELS.fetch(color_type) { raise "unsupported PNG colour type #{color_type}" }
+        rows = unfilter(Zlib::Inflate.inflate(idat), width, height, depth, channels)
+        to_rgba(rows, width, height, depth, color_type, plte, trns)
+      end
+
+      CHANNELS = { 0 => 1, 2 => 3, 3 => 1, 4 => 2, 6 => 4 }.freeze
+
+      # Reverse the per-scanline PNG filters, returning one byte string per row.
+      def unfilter(raw, width, height, depth, channels)
+        bpp    = [(depth * channels) / 8, 1].max          # bytes per pixel (>=1)
+        stride = (width * channels * depth + 7) / 8        # bytes per row
+        rows   = []
+        prev   = ("\0" * stride).b
+        pos    = 0
+        height.times do
+          filter = raw.getbyte(pos)
+          line   = raw.byteslice(pos + 1, stride).dup
+          recon  = apply_filter(filter, line, prev, bpp)
+          rows << recon
+          prev = recon
+          pos += 1 + stride
+        end
+        rows
+      end
+
+      def apply_filter(filter, line, prev, bpp)
+        bytes = line.bytes
+        bytes.each_index do |i|
+          a = i >= bpp ? bytes[i - bpp] : 0
+          b = prev.getbyte(i)
+          c = i >= bpp ? prev.getbyte(i - bpp) : 0
+          add =
+            case filter
+            when 0 then 0
+            when 1 then a
+            when 2 then b
+            when 3 then (a + b) / 2
+            when 4 then paeth(a, b, c)
+            else raise "bad PNG filter #{filter}"
+            end
+          bytes[i] = (bytes[i] + add) & 0xff
+        end
+        bytes.pack("C*")
+      end
+
+      def paeth(a, b, c)
+        p = a + b - c
+        pa = (p - a).abs; pb = (p - b).abs; pc = (p - c).abs
+        pa <= pb && pa <= pc ? a : (pb <= pc ? b : c)
+      end
+
+      def to_rgba(rows, width, height, depth, color_type, plte, trns)
+        pixels = Array.new(width * height, 0)
+        height.times do |y|
+          row = rows[y]
+          width.times do |x|
+            r, g, b, a = sample(row, x, depth, color_type, plte, trns)
+            pixels[y * width + x] = (r << 24) | (g << 16) | (b << 8) | a
+          end
+        end
+        [width, height, pixels]
+      end
+
+      def sample(row, x, depth, color_type, plte, trns)
+        case color_type
+        when 6 # RGBA, 8-bit
+          o = x * 4
+          [row.getbyte(o), row.getbyte(o + 1), row.getbyte(o + 2), row.getbyte(o + 3)]
+        when 2 # RGB, 8-bit
+          o = x * 3
+          [row.getbyte(o), row.getbyte(o + 1), row.getbyte(o + 2), 255]
+        when 3 # palette
+          idx = palette_index(row, x, depth)
+          po  = idx * 3
+          a   = trns && idx < trns.bytesize ? trns.getbyte(idx) : 255
+          [plte.getbyte(po), plte.getbyte(po + 1), plte.getbyte(po + 2), a]
+        else
+          raise "unsupported PNG colour type #{color_type}"
+        end
+      end
+
+      # Index into a palette scanline, honouring sub-byte bit depths.
+      def palette_index(row, x, depth)
+        return row.getbyte(x) if depth == 8
+        per_byte = 8 / depth
+        byte = row.getbyte(x / per_byte)
+        shift = (per_byte - 1 - (x % per_byte)) * depth
+        (byte >> shift) & ((1 << depth) - 1)
+      end
+    end
+  end
+end

data/lib/skrift/color/renderer.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+module Skrift
+  module Color
+    # An RGBA colour glyph. +pixels+ is a row-major array of packed 0xRRGGBBAA
+    # integers (straight, non-premultiplied alpha).
+    Image = Struct.new(:width, :height, :pixels)
+
+    # Renders colour glyphs to an RGBA Skrift::Color::Image. Two formats are
+    # supported: COLR/CPAL v0 (layered vector glyphs, composited with skrift's
+    # monochrome rasteriser) and CBDT/CBLC (embedded PNG bitmaps, e.g. Noto
+    # Color Emoji), scaled to the requested size.
+    class Renderer
+      def initialize(font, x_scale:, y_scale:)
+        @font = font
+        @y_scale = y_scale
+        @sft  = Skrift::Renderer.new(font)
+        @sft.x_scale = x_scale
+        @sft.y_scale = y_scale
+        @colr = COLR.parse(font)
+        @cpal = CPAL.parse(font)
+        @cbdt = CBDT.parse(font)
+      end
+
+      # True if the font carries any supported colour data (COLR+CPAL or CBDT).
+      def color? = (!@colr.nil? && !@cpal.nil?) || !@cbdt.nil?
+
+      # A Skrift::Color::Image (RGBA) for +codepoint+, or nil if it has no
+      # colour glyph — in which case the caller should fall back to ordinary
+      # monochrome rendering. Tries vector (COLR) then bitmap (CBDT).
+      def render(codepoint)
+        render_colr(codepoint) || render_cbdt(codepoint)
+      end
+
+      private
+
+      def render_colr(codepoint)
+        return nil unless @colr && @cpal
+        gid = @font.glyph_id(codepoint)
+        return nil unless gid
+        layers = @colr[gid]
+        return nil unless layers && !layers.empty?
+        composite(layers)
+      end
+
+      def render_cbdt(codepoint)
+        return nil unless @cbdt
+        gid = @font.glyph_id(codepoint)
+        return nil if gid.nil? || gid.zero?
+        found = @cbdt.glyph(gid)
+        return nil unless found
+        png, ppem = found
+        w, h, pixels = PNG.decode(png)
+        factor = @y_scale.to_f / ppem
+        dw = [(w * factor).round, 1].max
+        dh = [(h * factor).round, 1].max
+        Image.new(dw, dh, resample(w, h, pixels, dw, dh))
+      end
+
+      # Alpha-weighted area resample (good for the heavy downscale from a
+      # ~128px emoji bitmap to a text-sized cell).
+      def resample(sw, sh, src, dw, dh)
+        out = Array.new(dw * dh, 0)
+        fx = sw.to_f / dw
+        fy = sh.to_f / dh
+        dh.times do |dy|
+          y0 = dy * fy; y1 = y0 + fy
+          dw.times do |dx|
+            x0 = dx * fx; x1 = x0 + fx
+            r = g = b = a = wsum = 0.0
+            iy = y0.floor
+            while iy < y1 && iy < sh
+              wy = [y1, iy + 1].min - [y0, iy].max
+              ix = x0.floor
+              while ix < x1 && ix < sw
+                wx = [x1, ix + 1].min - [x0, ix].max
+                wt = wx * wy
+                p  = src[iy * sw + ix]
+                pa = (p & 0xff) * wt
+                r += ((p >> 24) & 0xff) * pa
+                g += ((p >> 16) & 0xff) * pa
+                b += ((p >> 8) & 0xff) * pa
+                a += (p & 0xff) * wt
+                wsum += wt
+                ix += 1
+              end
+              iy += 1
+            end
+            next if a <= 0.0
+            out[dy * dw + dx] =
+              ((r / a).round.clamp(0, 255) << 24) |
+              ((g / a).round.clamp(0, 255) << 16) |
+              ((b / a).round.clamp(0, 255) << 8) |
+              (wsum.positive? ? (a / wsum).round.clamp(0, 255) : 0)
+          end
+        end
+        out
+      end
+
+      def composite(layers)
+        rendered = layers.filter_map { |gid, pal| render_layer(gid, pal) }
+        return nil if rendered.empty?
+
+        # Align layers by their actual ink bounding box (in the shared em),
+        # not the font's left-side-bearing: a layer's outline carries its
+        # absolute position, so xmin/ymax place it relative to the others.
+        min_x = rendered.map { _1[:xmin] }.min
+        max_y = rendered.map { _1[:ymax] }.max
+        rendered.each do |r|
+          r[:ox] = r[:xmin] - min_x
+          r[:oy] = max_y - r[:ymax]
+        end
+        width  = rendered.map { _1[:ox] + _1[:w] }.max
+        height = rendered.map { _1[:oy] + _1[:h] }.max
+
+        acc = Array.new(width * height) { [0.0, 0.0, 0.0, 0.0] } # premultiplied
+        rendered.each { |r| blend_layer(acc, width, r) }
+        Image.new(width, height, acc.map { |px| pack(px) })
+      end
+
+      def render_layer(gid, pal_index)
+        outline = @font.outline_offset(gid)
+        return nil unless outline
+        bbox = @sft.glyph_bbox(outline) # [xMin, yMin, xMax, yMax] in renderer space
+        w = bbox[2] - bbox[0] + 1
+        h = bbox[3] - bbox[1] + 1
+        img = Skrift::Image.new(w, h)
+        return nil unless @sft.render(gid, img)
+        { alpha: img.pixels, w: img.width, h: img.height,
+          xmin: bbox[0], ymax: bbox[3],
+          color: @cpal[pal_index] || [0, 0, 0, 255] }
+      end
+
+      # Source-over composite of one layer into the premultiplied accumulator.
+      def blend_layer(acc, width, r)
+        pr, pg, pb, pa = r[:color]
+        pr /= 255.0; pg /= 255.0; pb /= 255.0; pa /= 255.0
+        r[:h].times do |row|
+          arow   = row * r[:w]
+          accrow = (r[:oy] + row) * width + r[:ox]
+          r[:w].times do |col|
+            cov = r[:alpha][arow + col]
+            next if cov.zero?
+            sa = (cov / 255.0) * pa
+            next if sa <= 0.0
+            dst = acc[accrow + col]
+            inv = 1.0 - sa
+            dst[0] = pr * sa + dst[0] * inv
+            dst[1] = pg * sa + dst[1] * inv
+            dst[2] = pb * sa + dst[2] * inv
+            dst[3] = sa      + dst[3] * inv
+          end
+        end
+      end
+
+      # Premultiplied float RGBA -> packed straight-alpha 0xRRGGBBAA.
+      def pack((pr, pg, pb, pa))
+        return 0 if pa <= 0.0
+        r = (pr / pa * 255).round.clamp(0, 255)
+        g = (pg / pa * 255).round.clamp(0, 255)
+        b = (pb / pa * 255).round.clamp(0, 255)
+        a = (pa * 255).round.clamp(0, 255)
+        (r << 24) | (g << 16) | (b << 8) | a
+      end
+    end
+  end
+end

data/lib/skrift/color/version.rb

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

data/lib/skrift/color.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "skrift"
+require_relative "color/version"
+require_relative "color/colr"
+require_relative "color/cpal"
+require_relative "color/png"
+require_relative "color/cbdt"
+require_relative "color/renderer"
+
+module Skrift
+  # COLR/CPAL (v0) colour-glyph support for Skrift, as an opt-in plugin. The
+  # core renderer stays monochrome; this composites colour layers into an RGBA
+  # Skrift::Color::Image. See Skrift::Color::Renderer.
+  module Color
+  end
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification
+name: skrift-color
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Vidar Hokstad
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2026-06-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: skrift
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+description: A Skrift plugin that renders COLR/CPAL (v0) colour glyphs - e.g. layered
+  colour emoji - by compositing each layer with skrift's monochrome rasteriser into
+  an RGBA buffer. The core renderer stays monochrome; colour is opt-in.
+email:
+- vidar@hokstad.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- examples/color_preview.rb
+- lib/skrift/color.rb
+- lib/skrift/color/cbdt.rb
+- lib/skrift/color/colr.rb
+- lib/skrift/color/cpal.rb
+- lib/skrift/color/png.rb
+- lib/skrift/color/renderer.rb
+- lib/skrift/color/version.rb
+homepage: https://github.com/vidarh/skrift-color
+licenses:
+- ISC
+metadata:
+  homepage_uri: https://github.com/vidarh/skrift-color
+  source_code_uri: https://github.com/vidarh/skrift-color
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key: 
+specification_version: 4
+summary: COLR/CPAL colour-glyph (emoji) rendering for the Skrift font renderer
+test_files: []