skia 0.1.0

data/lib/skia/document.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Skia
+  class Document < Base
+    def initialize(ptr, stream)
+      super(ptr, :sk_document_unref)
+      @stream = stream
+      @closed = false
+    end
+
+    def self.create_pdf(path)
+      stream = Native.sk_filewstream_new(path)
+      raise Error, "Failed to create file stream for: #{path}" if stream.nil? || stream.null?
+
+      ptr = Native.sk_document_create_pdf_from_stream(stream)
+      if ptr.nil? || ptr.null?
+        Native.sk_filewstream_destroy(stream)
+        raise Error, 'Failed to create PDF document'
+      end
+
+      doc = new(ptr, stream)
+
+      if block_given?
+        begin
+          yield doc
+        ensure
+          doc.close
+        end
+      else
+        doc
+      end
+    end
+
+    def begin_page(width, height, content_rect = nil)
+      content_ptr = content_rect&.to_struct
+      canvas_ptr = Native.sk_document_begin_page(@ptr, width.to_f, height.to_f, content_ptr)
+      raise Error, 'Failed to begin page' if canvas_ptr.nil? || canvas_ptr.null?
+
+      canvas = Canvas.new(canvas_ptr)
+
+      if block_given?
+        begin
+          yield canvas
+        ensure
+          end_page
+        end
+      else
+        canvas
+      end
+    end
+
+    def end_page
+      Native.sk_document_end_page(@ptr)
+    end
+
+    def close
+      return if @closed
+
+      Native.sk_document_close(@ptr)
+      Native.sk_filewstream_destroy(@stream) if @stream
+      @closed = true
+    end
+
+    def abort
+      return if @closed
+
+      Native.sk_document_abort(@ptr)
+      Native.sk_filewstream_destroy(@stream) if @stream
+      @closed = true
+    end
+
+    def closed?
+      @closed
+    end
+  end
+end

data/lib/skia/font.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Skia
+  class Font < Base
+    def initialize(typeface = nil, size = 12.0, scale_x = 1.0, skew_x = 0.0)
+      ptr = if typeface
+              Native.sk_font_new_with_values(typeface.ptr, size.to_f, scale_x.to_f, skew_x.to_f)
+            else
+              Native.sk_font_new
+            end
+      raise Error, 'Failed to create font' if ptr.nil? || ptr.null?
+
+      super(ptr, :sk_font_delete)
+
+      # Set size explicitly when no typeface is provided (sk_font_new uses default size)
+      self.size = size unless typeface
+    end
+
+    def typeface
+      ptr = Native.sk_font_get_typeface(@ptr)
+      return nil if ptr.nil? || ptr.null?
+
+      Typeface.new(ptr)
+    end
+
+    def typeface=(value)
+      Native.sk_font_set_typeface(@ptr, value&.ptr)
+    end
+
+    def size
+      Native.sk_font_get_size(@ptr)
+    end
+
+    def size=(value)
+      Native.sk_font_set_size(@ptr, value.to_f)
+    end
+
+    def metrics
+      metrics_struct = Native::SKFontMetrics.new
+      Native.sk_font_get_metrics(@ptr, metrics_struct)
+      FontMetrics.new(metrics_struct)
+    end
+
+    def measure_text(text, paint = nil)
+      text_bytes = text.encode('UTF-8')
+      bounds = Native::SKRect.new
+      width = Native.sk_font_measure_text(@ptr, text_bytes, text_bytes.bytesize, :utf8, bounds, paint&.ptr)
+      [width, Rect.from_struct(bounds)]
+    end
+  end
+
+  class FontMetrics
+    attr_reader :top, :ascent, :descent, :bottom, :leading, :avg_char_width, :max_char_width, :x_min, :x_max,
+                :x_height, :cap_height, :underline_thickness, :underline_position, :strikeout_thickness, :strikeout_position
+
+    def initialize(struct)
+      @top = struct[:top]
+      @ascent = struct[:ascent]
+      @descent = struct[:descent]
+      @bottom = struct[:bottom]
+      @leading = struct[:leading]
+      @avg_char_width = struct[:avgCharWidth]
+      @max_char_width = struct[:maxCharWidth]
+      @x_min = struct[:xMin]
+      @x_max = struct[:xMax]
+      @x_height = struct[:xHeight]
+      @cap_height = struct[:capHeight]
+      @underline_thickness = struct[:underlineThickness]
+      @underline_position = struct[:underlinePosition]
+      @strikeout_thickness = struct[:strikeoutThickness]
+      @strikeout_position = struct[:strikeoutPosition]
+    end
+  end
+end

data/lib/skia/image.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module Skia
+  class Image < Base
+    def initialize(ptr)
+      super(ptr, :sk_image_unref)
+    end
+
+    def self.from_file(path)
+      data = Data.from_file(path)
+      ptr = Native.sk_image_new_from_encoded(data.ptr)
+      raise DecodingError, "Failed to decode image: #{path}" if ptr.nil? || ptr.null?
+
+      new(ptr)
+    end
+
+    def self.from_data(data)
+      data_obj = data.is_a?(Data) ? data : Data.new(data)
+      ptr = Native.sk_image_new_from_encoded(data_obj.ptr)
+      raise DecodingError, 'Failed to decode image data' if ptr.nil? || ptr.null?
+
+      new(ptr)
+    end
+
+    def width
+      Native.sk_image_get_width(@ptr)
+    end
+
+    def height
+      Native.sk_image_get_height(@ptr)
+    end
+
+    def unique_id
+      Native.sk_image_get_unique_id(@ptr)
+    end
+
+    def encode(format = :png, quality = 100)
+      # Create a pixmap to hold the image pixels
+      pixmap = Native.sk_pixmap_new
+      raise EncodingError, 'Failed to create pixmap' if pixmap.nil? || pixmap.null?
+
+      begin
+        # Peek pixels from the image into the pixmap
+        raise EncodingError, 'Failed to peek pixels from image' unless Native.sk_image_peek_pixels(@ptr, pixmap)
+
+        stream = Native.sk_dynamicmemorywstream_new
+        raise EncodingError, 'Failed to create stream' if stream.nil? || stream.null?
+
+        begin
+          success = case format
+                    when :png
+                      options = Native::SKPngEncoderOptions.new
+                      options[:fFilterFlags] = :all
+                      options[:fZLibLevel] = 6
+                      options[:fComments] = nil
+                      options[:fICCProfile] = nil
+                      options[:fICCProfileDescription] = nil
+                      Native.sk_pngencoder_encode(stream, pixmap, options)
+                    when :jpeg, :jpg
+                      options = Native::SKJpegEncoderOptions.new
+                      options[:fQuality] = quality
+                      options[:fDownsample] = :downsample_420
+                      options[:fAlphaOption] = :ignore
+                      options[:xmpMetadata] = nil
+                      options[:fICCProfile] = nil
+                      options[:fICCProfileDescription] = nil
+                      Native.sk_jpegencoder_encode(stream, pixmap, options)
+                    when :webp
+                      options = Native::SKWebpEncoderOptions.new
+                      options[:fCompression] = :lossy
+                      options[:fQuality] = quality.to_f
+                      options[:fICCProfile] = nil
+                      options[:fICCProfileDescription] = nil
+                      Native.sk_webpencoder_encode(stream, pixmap, options)
+                    else
+                      options = Native::SKPngEncoderOptions.new
+                      options[:fFilterFlags] = :all
+                      options[:fZLibLevel] = 6
+                      options[:fComments] = nil
+                      options[:fICCProfile] = nil
+                      options[:fICCProfileDescription] = nil
+                      Native.sk_pngencoder_encode(stream, pixmap, options)
+                    end
+
+          raise EncodingError, "Failed to encode image as #{format}" unless success
+
+          data_ptr = Native.sk_dynamicmemorywstream_detach_as_data(stream)
+          raise EncodingError, 'Failed to get encoded data' if data_ptr.nil? || data_ptr.null?
+
+          Data.new(data_ptr)
+        ensure
+          Native.sk_dynamicmemorywstream_destroy(stream)
+        end
+      ensure
+        Native.sk_pixmap_destructor(pixmap)
+      end
+    end
+
+    def save(path, format: nil, quality: 100)
+      format ||= detect_format_from_path(path)
+      data = encode(format, quality)
+      File.binwrite(path, data.to_s)
+      self
+    end
+
+    def save_png(path, quality = 100)
+      save(path, format: :png, quality: quality)
+    end
+
+    def save_jpeg(path, quality = 80)
+      save(path, format: :jpeg, quality: quality)
+    end
+
+    def save_webp(path, quality = 80)
+      save(path, format: :webp, quality: quality)
+    end
+
+    private
+
+    def detect_format_from_path(path)
+      case File.extname(path).downcase
+      when '.png'
+        :png
+      when '.jpg', '.jpeg'
+        :jpeg
+      when '.webp'
+        :webp
+      when '.gif'
+        :gif
+      when '.bmp'
+        :bmp
+      else
+        :png
+      end
+    end
+  end
+end

data/lib/skia/matrix.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+module Skia
+  class Matrix
+    attr_accessor :scale_x, :skew_x, :trans_x, :skew_y, :scale_y, :trans_y, :persp0, :persp1, :persp2
+
+    def initialize(scale_x: 1.0, skew_x: 0.0, trans_x: 0.0,
+                   skew_y: 0.0, scale_y: 1.0, trans_y: 0.0,
+                   persp0: 0.0, persp1: 0.0, persp2: 1.0)
+      @scale_x = scale_x.to_f
+      @skew_x = skew_x.to_f
+      @trans_x = trans_x.to_f
+      @skew_y = skew_y.to_f
+      @scale_y = scale_y.to_f
+      @trans_y = trans_y.to_f
+      @persp0 = persp0.to_f
+      @persp1 = persp1.to_f
+      @persp2 = persp2.to_f
+    end
+
+    def self.identity
+      new
+    end
+
+    def self.translate(dx, dy)
+      new(trans_x: dx.to_f, trans_y: dy.to_f)
+    end
+
+    def self.scale(sx, sy = sx)
+      new(scale_x: sx.to_f, scale_y: sy.to_f)
+    end
+
+    def self.rotate(degrees, px = 0.0, py = 0.0)
+      radians = degrees * Math::PI / 180.0
+      cos = Math.cos(radians)
+      sin = Math.sin(radians)
+
+      if px.zero? && py.zero?
+        new(scale_x: cos, skew_x: -sin, skew_y: sin, scale_y: cos)
+      else
+        new(
+          scale_x: cos,
+          skew_x: -sin,
+          trans_x: px - px * cos + py * sin,
+          skew_y: sin,
+          scale_y: cos,
+          trans_y: py - px * sin - py * cos
+        )
+      end
+    end
+
+    def self.skew(sx, sy)
+      new(skew_x: sx.to_f, skew_y: sy.to_f)
+    end
+
+    def self.from_struct(struct)
+      new(
+        scale_x: struct[:scaleX],
+        skew_x: struct[:skewX],
+        trans_x: struct[:transX],
+        skew_y: struct[:skewY],
+        scale_y: struct[:scaleY],
+        trans_y: struct[:transY],
+        persp0: struct[:persp0],
+        persp1: struct[:persp1],
+        persp2: struct[:persp2]
+      )
+    end
+
+    def to_struct
+      struct = Native::SKMatrix.new
+      struct[:scaleX] = @scale_x
+      struct[:skewX] = @skew_x
+      struct[:transX] = @trans_x
+      struct[:skewY] = @skew_y
+      struct[:scaleY] = @scale_y
+      struct[:transY] = @trans_y
+      struct[:persp0] = @persp0
+      struct[:persp1] = @persp1
+      struct[:persp2] = @persp2
+      struct
+    end
+
+    # Convert 3x3 matrix to 4x4 matrix for canvas operations
+    def to_struct44
+      struct = Native::SKMatrix44.new
+      struct[:m00] = @scale_x
+      struct[:m01] = @skew_x
+      struct[:m02] = 0.0
+      struct[:m03] = @trans_x
+      struct[:m10] = @skew_y
+      struct[:m11] = @scale_y
+      struct[:m12] = 0.0
+      struct[:m13] = @trans_y
+      struct[:m20] = 0.0
+      struct[:m21] = 0.0
+      struct[:m22] = 1.0
+      struct[:m23] = 0.0
+      struct[:m30] = @persp0
+      struct[:m31] = @persp1
+      struct[:m32] = 0.0
+      struct[:m33] = @persp2
+      struct
+    end
+
+    # Create Matrix from 4x4 struct
+    def self.from_struct44(struct)
+      new(
+        scale_x: struct[:m00],
+        skew_x: struct[:m01],
+        trans_x: struct[:m03],
+        skew_y: struct[:m10],
+        scale_y: struct[:m11],
+        trans_y: struct[:m13],
+        persp0: struct[:m30],
+        persp1: struct[:m31],
+        persp2: struct[:m33]
+      )
+    end
+
+    def *(other)
+      self.class.new(
+        scale_x: @scale_x * other.scale_x + @skew_x * other.skew_y,
+        skew_x: @scale_x * other.skew_x + @skew_x * other.scale_y,
+        trans_x: @scale_x * other.trans_x + @skew_x * other.trans_y + @trans_x,
+        skew_y: @skew_y * other.scale_x + @scale_y * other.skew_y,
+        scale_y: @skew_y * other.skew_x + @scale_y * other.scale_y,
+        trans_y: @skew_y * other.trans_x + @scale_y * other.trans_y + @trans_y,
+        persp0: @persp0 * other.scale_x + @persp1 * other.skew_y + @persp2 * other.persp0,
+        persp1: @persp0 * other.skew_x + @persp1 * other.scale_y + @persp2 * other.persp1,
+        persp2: @persp0 * other.trans_x + @persp1 * other.trans_y + @persp2 * other.persp2
+      )
+    end
+
+    def transform_point(point)
+      x = point.x * @scale_x + point.y * @skew_x + @trans_x
+      y = point.x * @skew_y + point.y * @scale_y + @trans_y
+      Point.new(x, y)
+    end
+
+    def identity?
+      @scale_x == 1.0 && @skew_x == 0.0 && @trans_x == 0.0 &&
+        @skew_y == 0.0 && @scale_y == 1.0 && @trans_y == 0.0 &&
+        @persp0 == 0.0 && @persp1 == 0.0 && @persp2 == 1.0
+    end
+
+    def ==(other)
+      return false unless other.is_a?(Matrix)
+
+      @scale_x == other.scale_x && @skew_x == other.skew_x && @trans_x == other.trans_x &&
+        @skew_y == other.skew_y && @scale_y == other.scale_y && @trans_y == other.trans_y &&
+        @persp0 == other.persp0 && @persp1 == other.persp1 && @persp2 == other.persp2
+    end
+
+    def to_a
+      [
+        [@scale_x, @skew_x, @trans_x],
+        [@skew_y, @scale_y, @trans_y],
+        [@persp0, @persp1, @persp2]
+      ]
+    end
+  end
+end

data/lib/skia/native/callbacks.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Skia
+  module Native
+  end
+end

data/lib/skia/native/functions.rb

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+
+module Skia
+  module Native
+    # Surface
+    attach_function :sk_surface_new_raster, [SKImageInfo.ptr, :size_t, :pointer], :sk_surface_t
+    attach_function :sk_surface_new_raster_direct,
+                    [SKImageInfo.ptr, :pointer, :size_t, :pointer, :pointer, :pointer], :sk_surface_t
+    attach_function :sk_surface_unref, [:sk_surface_t], :void
+    attach_function :sk_surface_get_canvas, [:sk_surface_t], :sk_canvas_t
+    attach_function :sk_surface_new_image_snapshot, [:sk_surface_t], :sk_image_t
+    attach_function :sk_surface_peek_pixels, %i[sk_surface_t sk_pixmap_t], :bool
+
+    # Canvas - State
+    attach_function :sk_canvas_save, [:sk_canvas_t], :int
+    attach_function :sk_canvas_save_layer, [:sk_canvas_t, SKRect.ptr, :sk_paint_t], :int
+    attach_function :sk_canvas_restore, [:sk_canvas_t], :void
+    attach_function :sk_canvas_restore_to_count, %i[sk_canvas_t int], :void
+    attach_function :sk_canvas_get_save_count, [:sk_canvas_t], :int
+
+    # Canvas - Transform
+    attach_function :sk_canvas_translate, %i[sk_canvas_t float float], :void
+    attach_function :sk_canvas_scale, %i[sk_canvas_t float float], :void
+    attach_function :sk_canvas_rotate_degrees, %i[sk_canvas_t float], :void
+    attach_function :sk_canvas_rotate_radians, %i[sk_canvas_t float], :void
+    attach_function :sk_canvas_skew, %i[sk_canvas_t float float], :void
+    attach_function :sk_canvas_concat, [:sk_canvas_t, SKMatrix44.ptr], :void
+    attach_function :sk_canvas_set_matrix, [:sk_canvas_t, SKMatrix44.ptr], :void
+    attach_function :sk_canvas_get_matrix, [:sk_canvas_t, SKMatrix44.ptr], :void
+    attach_function :sk_canvas_reset_matrix, [:sk_canvas_t], :void
+
+    # Canvas - Clip
+    attach_function :sk_canvas_clip_rect_with_operation,
+                    [:sk_canvas_t, SKRect.ptr, :sk_clipop_t, :bool], :void
+    attach_function :sk_canvas_clip_path_with_operation,
+                    %i[sk_canvas_t sk_path_t sk_clipop_t bool], :void
+    attach_function :sk_canvas_clip_region, %i[sk_canvas_t pointer sk_clipop_t], :void
+
+    # Canvas - Draw
+    attach_function :sk_canvas_draw_paint, %i[sk_canvas_t sk_paint_t], :void
+    attach_function :sk_canvas_draw_rect, [:sk_canvas_t, SKRect.ptr, :sk_paint_t], :void
+    attach_function :sk_canvas_draw_rrect, %i[sk_canvas_t pointer sk_paint_t], :void
+    attach_function :sk_canvas_draw_round_rect,
+                    [:sk_canvas_t, SKRect.ptr, :float, :float, :sk_paint_t], :void
+    attach_function :sk_canvas_draw_circle, %i[sk_canvas_t float float float sk_paint_t], :void
+    attach_function :sk_canvas_draw_oval, [:sk_canvas_t, SKRect.ptr, :sk_paint_t], :void
+    attach_function :sk_canvas_draw_path, %i[sk_canvas_t sk_path_t sk_paint_t], :void
+    attach_function :sk_canvas_draw_image, %i[sk_canvas_t sk_image_t float float sk_paint_t], :void
+    attach_function :sk_canvas_draw_image_rect,
+                    [:sk_canvas_t, :sk_image_t, SKRect.ptr, SKRect.ptr, :sk_paint_t], :void
+    attach_function :sk_canvas_draw_line, %i[sk_canvas_t float float float float sk_paint_t], :void
+    attach_function :sk_canvas_draw_point, %i[sk_canvas_t float float sk_paint_t], :void
+    attach_function :sk_canvas_draw_points, %i[sk_canvas_t int size_t pointer sk_paint_t], :void
+    attach_function :sk_canvas_draw_simple_text,
+                    %i[sk_canvas_t pointer size_t sk_text_encoding_t float float sk_font_t sk_paint_t], :void
+    attach_function :sk_canvas_clear, %i[sk_canvas_t sk_color_t], :void
+    attach_function :sk_canvas_draw_color, %i[sk_canvas_t sk_color_t sk_blend_mode_t], :void
+
+    # Paint
+    attach_function :sk_paint_new, [], :sk_paint_t
+    attach_function :sk_paint_clone, [:sk_paint_t], :sk_paint_t
+    attach_function :sk_paint_delete, [:sk_paint_t], :void
+    attach_function :sk_paint_reset, [:sk_paint_t], :void
+    attach_function :sk_paint_is_antialias, [:sk_paint_t], :bool
+    attach_function :sk_paint_set_antialias, %i[sk_paint_t bool], :void
+    attach_function :sk_paint_get_color, [:sk_paint_t], :sk_color_t
+    attach_function :sk_paint_set_color, %i[sk_paint_t sk_color_t], :void
+    attach_function :sk_paint_get_style, [:sk_paint_t], :sk_paint_style_t
+    attach_function :sk_paint_set_style, %i[sk_paint_t sk_paint_style_t], :void
+    attach_function :sk_paint_get_stroke_width, [:sk_paint_t], :float
+    attach_function :sk_paint_set_stroke_width, %i[sk_paint_t float], :void
+    attach_function :sk_paint_get_stroke_miter, [:sk_paint_t], :float
+    attach_function :sk_paint_set_stroke_miter, %i[sk_paint_t float], :void
+    attach_function :sk_paint_get_stroke_cap, [:sk_paint_t], :sk_stroke_cap_t
+    attach_function :sk_paint_set_stroke_cap, %i[sk_paint_t sk_stroke_cap_t], :void
+    attach_function :sk_paint_get_stroke_join, [:sk_paint_t], :sk_stroke_join_t
+    attach_function :sk_paint_set_stroke_join, %i[sk_paint_t sk_stroke_join_t], :void
+    attach_function :sk_paint_get_blendmode, [:sk_paint_t], :sk_blend_mode_t
+    attach_function :sk_paint_set_blendmode, %i[sk_paint_t sk_blend_mode_t], :void
+    attach_function :sk_paint_get_shader, [:sk_paint_t], :sk_shader_t
+    attach_function :sk_paint_set_shader, %i[sk_paint_t sk_shader_t], :void
+    attach_function :sk_paint_get_maskfilter, [:sk_paint_t], :sk_mask_filter_t
+    attach_function :sk_paint_set_maskfilter, %i[sk_paint_t sk_mask_filter_t], :void
+    attach_function :sk_paint_get_colorfilter, [:sk_paint_t], :sk_color_filter_t
+    attach_function :sk_paint_set_colorfilter, %i[sk_paint_t sk_color_filter_t], :void
+    attach_function :sk_paint_get_imagefilter, [:sk_paint_t], :sk_image_filter_t
+    attach_function :sk_paint_set_imagefilter, %i[sk_paint_t sk_image_filter_t], :void
+    attach_function :sk_paint_get_path_effect, [:sk_paint_t], :sk_path_effect_t
+    attach_function :sk_paint_set_path_effect, %i[sk_paint_t sk_path_effect_t], :void
+
+    # Path
+    attach_function :sk_path_new, [], :sk_path_t
+    attach_function :sk_path_clone, [:sk_path_t], :sk_path_t
+    attach_function :sk_path_delete, [:sk_path_t], :void
+    attach_function :sk_path_reset, [:sk_path_t], :void
+    attach_function :sk_path_move_to, %i[sk_path_t float float], :void
+    attach_function :sk_path_line_to, %i[sk_path_t float float], :void
+    attach_function :sk_path_quad_to, %i[sk_path_t float float float float], :void
+    attach_function :sk_path_conic_to, %i[sk_path_t float float float float float], :void
+    attach_function :sk_path_cubic_to, %i[sk_path_t float float float float float float], :void
+    attach_function :sk_path_arc_to, %i[sk_path_t float float float float float], :void
+    attach_function :sk_path_arc_to_with_oval, [:sk_path_t, SKRect.ptr, :float, :float, :bool], :void
+    attach_function :sk_path_close, [:sk_path_t], :void
+    attach_function :sk_path_add_rect, [:sk_path_t, SKRect.ptr, :sk_path_direction_t], :void
+    attach_function :sk_path_add_rrect, %i[sk_path_t pointer sk_path_direction_t], :void
+    attach_function :sk_path_add_oval, [:sk_path_t, SKRect.ptr, :sk_path_direction_t], :void
+    attach_function :sk_path_add_circle, %i[sk_path_t float float float sk_path_direction_t], :void
+    attach_function :sk_path_add_arc, [:sk_path_t, SKRect.ptr, :float, :float], :void
+    attach_function :sk_path_add_path, %i[sk_path_t sk_path_t int int], :void
+    attach_function :sk_path_add_path_offset, %i[sk_path_t sk_path_t float float int], :void
+    attach_function :sk_path_add_path_matrix, [:sk_path_t, :sk_path_t, SKMatrix.ptr, :int], :void
+    attach_function :sk_path_get_filltype, [:sk_path_t], :sk_path_filltype_t
+    attach_function :sk_path_set_filltype, %i[sk_path_t sk_path_filltype_t], :void
+    attach_function :sk_path_get_bounds, [:sk_path_t, SKRect.ptr], :void
+    attach_function :sk_path_contains, %i[sk_path_t float float], :bool
+    attach_function :sk_path_transform, [:sk_path_t, SKMatrix.ptr], :void
+    attach_function :sk_path_count_points, [:sk_path_t], :int
+    attach_function :sk_path_count_verbs, [:sk_path_t], :int
+
+    # Image
+    attach_function :sk_image_ref, [:sk_image_t], :void
+    attach_function :sk_image_unref, [:sk_image_t], :void
+    attach_function :sk_image_get_width, [:sk_image_t], :int32
+    attach_function :sk_image_get_height, [:sk_image_t], :int32
+    attach_function :sk_image_get_unique_id, [:sk_image_t], :uint32
+    attach_function :sk_image_new_from_encoded, [:sk_data_t], :sk_image_t
+    attach_function :sk_image_ref_encoded, [:sk_image_t], :sk_data_t
+
+    # Pixmap
+    attach_function :sk_pixmap_new, [], :sk_pixmap_t
+    attach_function :sk_pixmap_destructor, [:sk_pixmap_t], :void
+    attach_function :sk_pixmap_get_info, [:sk_pixmap_t, SKImageInfo.ptr], :void
+
+    # Image - Pixmap operations
+    attach_function :sk_image_peek_pixels, %i[sk_image_t sk_pixmap_t], :bool
+
+    # Encoders (take sk_pixmap_t, not sk_image_t)
+    attach_function :sk_pngencoder_encode, [:pointer, :sk_pixmap_t, SKPngEncoderOptions.ptr], :bool
+    attach_function :sk_jpegencoder_encode, [:pointer, :sk_pixmap_t, SKJpegEncoderOptions.ptr], :bool
+    attach_function :sk_webpencoder_encode, [:pointer, :sk_pixmap_t, SKWebpEncoderOptions.ptr], :bool
+
+    # Data
+    attach_function :sk_data_new_with_copy, %i[pointer size_t], :sk_data_t
+    attach_function :sk_data_new_from_file, [:string], :sk_data_t
+    attach_function :sk_data_ref, [:sk_data_t], :void
+    attach_function :sk_data_unref, [:sk_data_t], :void
+    attach_function :sk_data_get_size, [:sk_data_t], :size_t
+    attach_function :sk_data_get_data, [:sk_data_t], :pointer
+
+    # Stream
+    attach_function :sk_dynamicmemorywstream_new, [], :pointer
+    attach_function :sk_dynamicmemorywstream_destroy, [:pointer], :void
+    attach_function :sk_dynamicmemorywstream_detach_as_data, [:pointer], :sk_data_t
+
+    # Typeface
+    attach_function :sk_typeface_create_from_name, %i[string pointer], :sk_typeface_t
+    attach_function :sk_typeface_create_from_file, %i[string int], :sk_typeface_t
+    attach_function :sk_typeface_create_default, [], :sk_typeface_t
+    attach_function :sk_typeface_unref, [:sk_typeface_t], :void
+
+    # FontStyle
+    attach_function :sk_fontstyle_new, %i[int int sk_font_style_slant_t], :pointer
+    attach_function :sk_fontstyle_delete, [:pointer], :void
+
+    # Font
+    attach_function :sk_font_new, [], :sk_font_t
+    attach_function :sk_font_new_with_values, %i[sk_typeface_t float float float], :sk_font_t
+    attach_function :sk_font_delete, [:sk_font_t], :void
+    attach_function :sk_font_set_typeface, %i[sk_font_t sk_typeface_t], :void
+    attach_function :sk_font_get_typeface, [:sk_font_t], :sk_typeface_t
+    attach_function :sk_font_set_size, %i[sk_font_t float], :void
+    attach_function :sk_font_get_size, [:sk_font_t], :float
+    attach_function :sk_font_get_metrics, [:sk_font_t, SKFontMetrics.ptr], :float
+    attach_function :sk_font_measure_text,
+                    [:sk_font_t, :pointer, :size_t, :sk_text_encoding_t, SKRect.ptr, :sk_paint_t], :float
+
+    # Shader
+    attach_function :sk_shader_unref, [:sk_shader_t], :void
+    attach_function :sk_shader_new_linear_gradient,
+                    [:pointer, :pointer, :pointer, :int, :sk_shader_tilemode_t, SKMatrix.ptr], :sk_shader_t
+    attach_function :sk_shader_new_radial_gradient,
+                    [SKPoint.ptr, :float, :pointer, :pointer, :int, :sk_shader_tilemode_t, SKMatrix.ptr], :sk_shader_t
+    attach_function :sk_shader_new_sweep_gradient,
+                    [SKPoint.ptr, :pointer, :pointer, :int, :sk_shader_tilemode_t, :float, :float, SKMatrix.ptr], :sk_shader_t
+
+    # MaskFilter
+    attach_function :sk_maskfilter_new_blur, %i[int float], :sk_mask_filter_t
+    attach_function :sk_maskfilter_unref, [:sk_mask_filter_t], :void
+
+    # Color
+    attach_function :sk_colortype_get_default_8888, [], :sk_colortype_t
+
+    # Document (PDF)
+    attach_function :sk_document_unref, [:sk_document_t], :void
+    attach_function :sk_document_create_pdf_from_stream, [:pointer], :sk_document_t
+    attach_function :sk_document_begin_page, [:sk_document_t, :float, :float, SKRect.ptr], :sk_canvas_t
+    attach_function :sk_document_end_page, [:sk_document_t], :void
+    attach_function :sk_document_close, [:sk_document_t], :void
+    attach_function :sk_document_abort, [:sk_document_t], :void
+
+    # FileWStream (for PDF output)
+    attach_function :sk_filewstream_new, [:string], :pointer
+    attach_function :sk_filewstream_destroy, [:pointer], :void
+
+    # Picture Recorder
+    attach_function :sk_picture_recorder_new, [], :sk_picture_recorder_t
+    attach_function :sk_picture_recorder_delete, [:sk_picture_recorder_t], :void
+    attach_function :sk_picture_recorder_begin_recording, [:sk_picture_recorder_t, SKRect.ptr], :sk_canvas_t
+    attach_function :sk_picture_recorder_end_recording, [:sk_picture_recorder_t], :sk_picture_t
+    attach_function :sk_picture_get_recording_canvas, [:sk_picture_recorder_t], :sk_canvas_t
+
+    # Picture
+    attach_function :sk_picture_ref, [:sk_picture_t], :void
+    attach_function :sk_picture_unref, [:sk_picture_t], :void
+    attach_function :sk_picture_get_unique_id, [:sk_picture_t], :uint32
+    attach_function :sk_picture_get_cull_rect, [:sk_picture_t, SKRect.ptr], :void
+    attach_function :sk_picture_playback, %i[sk_picture_t sk_canvas_t], :void
+    attach_function :sk_picture_serialize_to_data, [:sk_picture_t], :sk_data_t
+    attach_function :sk_picture_deserialize_from_data, [:sk_data_t], :sk_picture_t
+    attach_function :sk_picture_approximate_op_count, %i[sk_picture_t bool], :int
+    attach_function :sk_picture_approximate_bytes_used, [:sk_picture_t], :size_t
+  end
+end