skia 0.1.0

data/lib/skia/native/types.rb

@@ -0,0 +1,284 @@
+# frozen_string_literal: true
+
+module Skia
+  module Native
+    typedef :uint32, :sk_color_t
+    typedef :uint32, :sk_pmcolor_t
+    typedef :pointer, :sk_surface_t
+    typedef :pointer, :sk_canvas_t
+    typedef :pointer, :sk_paint_t
+    typedef :pointer, :sk_path_t
+    typedef :pointer, :sk_image_t
+    typedef :pointer, :sk_data_t
+    typedef :pointer, :sk_shader_t
+    typedef :pointer, :sk_typeface_t
+    typedef :pointer, :sk_font_t
+    typedef :pointer, :sk_mask_filter_t
+    typedef :pointer, :sk_color_filter_t
+    typedef :pointer, :sk_image_filter_t
+    typedef :pointer, :sk_path_effect_t
+    typedef :pointer, :sk_pixmap_t
+    typedef :pointer, :sk_document_t
+    typedef :pointer, :sk_picture_t
+    typedef :pointer, :sk_picture_recorder_t
+    typedef :pointer, :sk_drawable_t
+
+    enum :sk_colortype_t, [
+      :unknown,      0,
+      :alpha_8,      1,
+      :rgb_565,      2,
+      :argb_4444,    3,
+      :rgba_8888,    4,
+      :rgb_888x,     5,
+      :bgra_8888,    6,
+      :rgba_1010102, 7,
+      :rgb_101010x,  8,
+      :gray_8,       9,
+      :rgba_f16,    10,
+      :rgba_f32,    11
+    ]
+
+    enum :sk_alphatype_t, [
+      :unknown,   0,
+      :opaque,    1,
+      :premul,    2,
+      :unpremul,  3
+    ]
+
+    enum :sk_paint_style_t, [
+      :fill,           0,
+      :stroke,         1,
+      :stroke_and_fill, 2
+    ]
+
+    enum :sk_stroke_cap_t, [
+      :butt,   0,
+      :round,  1,
+      :square, 2
+    ]
+
+    enum :sk_stroke_join_t, [
+      :miter, 0,
+      :round, 1,
+      :bevel, 2
+    ]
+
+    enum :sk_blend_mode_t, [
+      :clear,       0,
+      :src,         1,
+      :dst,         2,
+      :src_over,    3,
+      :dst_over,    4,
+      :src_in,      5,
+      :dst_in,      6,
+      :src_out,     7,
+      :dst_out,     8,
+      :src_atop,    9,
+      :dst_atop,   10,
+      :xor,        11,
+      :plus,       12,
+      :modulate,   13,
+      :screen,     14,
+      :overlay,    15,
+      :darken,     16,
+      :lighten,    17,
+      :color_dodge, 18,
+      :color_burn, 19,
+      :hard_light, 20,
+      :soft_light, 21,
+      :difference, 22,
+      :exclusion,  23,
+      :multiply,   24,
+      :hue,        25,
+      :saturation, 26,
+      :color,      27,
+      :luminosity, 28
+    ]
+
+    enum :sk_path_filltype_t, [
+      :winding,          0,
+      :even_odd,         1,
+      :inverse_winding,  2,
+      :inverse_even_odd, 3
+    ]
+
+    enum :sk_path_direction_t, [
+      :cw,  0,
+      :ccw, 1
+    ]
+
+    enum :sk_clipop_t, [
+      :difference, 0,
+      :intersect,  1
+    ]
+
+    enum :sk_encoded_image_format_t, [
+      :bmp,  0,
+      :gif,  1,
+      :ico,  2,
+      :jpeg, 3,
+      :png,  4,
+      :wbmp, 5,
+      :webp, 6,
+      :pkm,  7,
+      :ktx,  8,
+      :astc, 9,
+      :dng, 10,
+      :heif, 11
+    ]
+
+    enum :sk_shader_tilemode_t, [
+      :clamp,  0,
+      :repeat, 1,
+      :mirror, 2,
+      :decal,  3
+    ]
+
+    enum :sk_font_style_slant_t, [
+      :upright, 0,
+      :italic,  1,
+      :oblique, 2
+    ]
+
+    enum :sk_text_encoding_t, [
+      :utf8,     0,
+      :utf16,    1,
+      :utf32,    2,
+      :glyph_id, 3
+    ]
+
+    class SKPoint < FFI::Struct
+      layout :x, :float,
+             :y, :float
+    end
+
+    class SKIPoint < FFI::Struct
+      layout :x, :int32,
+             :y, :int32
+    end
+
+    class SKRect < FFI::Struct
+      layout :left,   :float,
+             :top,    :float,
+             :right,  :float,
+             :bottom, :float
+    end
+
+    class SKIRect < FFI::Struct
+      layout :left,   :int32,
+             :top,    :int32,
+             :right,  :int32,
+             :bottom, :int32
+    end
+
+    class SKSize < FFI::Struct
+      layout :width,  :float,
+             :height, :float
+    end
+
+    class SKISize < FFI::Struct
+      layout :width,  :int32,
+             :height, :int32
+    end
+
+    class SKMatrix < FFI::Struct
+      layout :scaleX,  :float,
+             :skewX,   :float,
+             :transX,  :float,
+             :skewY,   :float,
+             :scaleY,  :float,
+             :transY,  :float,
+             :persp0,  :float,
+             :persp1,  :float,
+             :persp2,  :float
+    end
+
+    # 4x4 matrix (row major order)
+    class SKMatrix44 < FFI::Struct
+      layout :m00, :float, :m01, :float, :m02, :float, :m03, :float,
+             :m10, :float, :m11, :float, :m12, :float, :m13, :float,
+             :m20, :float, :m21, :float, :m22, :float, :m23, :float,
+             :m30, :float, :m31, :float, :m32, :float, :m33, :float
+    end
+
+    class SKImageInfo < FFI::Struct
+      layout :colorspace, :pointer,
+             :width,      :int32,
+             :height,     :int32,
+             :colorType,  :sk_colortype_t,
+             :alphaType,  :sk_alphatype_t
+    end
+
+    class SKFontMetrics < FFI::Struct
+      layout :flags,              :uint32,
+             :top,                :float,
+             :ascent,             :float,
+             :descent,            :float,
+             :bottom,             :float,
+             :leading,            :float,
+             :avgCharWidth,       :float,
+             :maxCharWidth,       :float,
+             :xMin,               :float,
+             :xMax,               :float,
+             :xHeight,            :float,
+             :capHeight,          :float,
+             :underlineThickness, :float,
+             :underlinePosition,  :float,
+             :strikeoutThickness, :float,
+             :strikeoutPosition,  :float
+    end
+
+    # PNG Encoder
+    enum :sk_pngencoder_filterflags_t, [
+      :zero,  0x00,
+      :none,  0x08,
+      :sub,   0x10,
+      :up,    0x20,
+      :avg,   0x40,
+      :paeth, 0x80,
+      :all,   0xF8
+    ]
+
+    class SKPngEncoderOptions < FFI::Struct
+      layout :fFilterFlags, :sk_pngencoder_filterflags_t,
+             :fZLibLevel,             :int,
+             :fComments,              :pointer,
+             :fICCProfile,            :pointer,
+             :fICCProfileDescription, :pointer
+    end
+
+    # JPEG Encoder
+    enum :sk_jpegencoder_downsample_t, [
+      :downsample_420, 0,
+      :downsample_422, 1,
+      :downsample_444, 2
+    ]
+
+    enum :sk_jpegencoder_alphaoption_t, [
+      :ignore, 0,
+      :blend_on_black, 1
+    ]
+
+    class SKJpegEncoderOptions < FFI::Struct
+      layout :fQuality,               :int,
+             :fDownsample,            :sk_jpegencoder_downsample_t,
+             :fAlphaOption,           :sk_jpegencoder_alphaoption_t,
+             :xmpMetadata,            :pointer,
+             :fICCProfile,            :pointer,
+             :fICCProfileDescription, :pointer
+    end
+
+    # WebP Encoder
+    enum :sk_webpencoder_compression_t, [
+      :lossy,    0,
+      :lossless, 1
+    ]
+
+    class SKWebpEncoderOptions < FFI::Struct
+      layout :fCompression,           :sk_webpencoder_compression_t,
+             :fQuality,               :float,
+             :fICCProfile,            :pointer,
+             :fICCProfileDescription, :pointer
+    end
+  end
+end

data/lib/skia/native.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Skia
+  module Native
+    extend FFI::Library
+
+    class << self
+      def find_library
+        lib_name, fallbacks = case RUBY_PLATFORM
+                              when /darwin/
+                                ['libSkiaSharp.dylib', ['libskia.dylib']]
+                              when /linux/
+                                ['libSkiaSharp.so', ['libskia.so']]
+                              when /mingw|mswin/
+                                ['libSkiaSharp.dll', ['skia.dll']]
+                              else
+                                raise "Unsupported platform: #{RUBY_PLATFORM}"
+                              end
+
+        gem_root = File.expand_path('../..', __dir__)
+        search_paths = [
+          File.join(gem_root, lib_name),
+          File.join(Dir.pwd, lib_name),
+          ENV['SKIA_LIBRARY_PATH'],
+          lib_name
+        ].compact
+
+        found = search_paths.find { |p| File.exist?(p) }
+        return found if found
+
+        [lib_name] + fallbacks
+      end
+    end
+
+    ffi_lib_flags :now, :global
+
+    begin
+      lib_path = find_library
+      ffi_lib Array(lib_path).first
+    rescue LoadError => e
+      warn 'Failed to load Skia library. Please ensure libSkiaSharp is installed.'
+      warn 'Download from: https://www.nuget.org/packages/SkiaSharp.NativeAssets.macOS'
+      raise e
+    end
+
+    require_relative 'native/types'
+    require_relative 'native/functions'
+    require_relative 'native/callbacks'
+  end
+end

data/lib/skia/paint.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Skia
+  class Paint < Base
+    def initialize(ptr = nil)
+      super(ptr || Native.sk_paint_new, :sk_paint_delete)
+    end
+
+    def antialias?
+      Native.sk_paint_is_antialias(@ptr)
+    end
+
+    def antialias=(value)
+      Native.sk_paint_set_antialias(@ptr, value)
+    end
+
+    def color
+      Color.new(Native.sk_paint_get_color(@ptr))
+    end
+
+    def color=(value)
+      color_value = value.is_a?(Color) ? value.to_i : value
+      Native.sk_paint_set_color(@ptr, color_value)
+    end
+
+    def style
+      Native.sk_paint_get_style(@ptr)
+    end
+
+    def style=(value)
+      Native.sk_paint_set_style(@ptr, value)
+    end
+
+    def stroke_width
+      Native.sk_paint_get_stroke_width(@ptr)
+    end
+
+    def stroke_width=(value)
+      Native.sk_paint_set_stroke_width(@ptr, value.to_f)
+    end
+
+    def stroke_cap
+      Native.sk_paint_get_stroke_cap(@ptr)
+    end
+
+    def stroke_cap=(value)
+      Native.sk_paint_set_stroke_cap(@ptr, value)
+    end
+
+    def stroke_join
+      Native.sk_paint_get_stroke_join(@ptr)
+    end
+
+    def stroke_join=(value)
+      Native.sk_paint_set_stroke_join(@ptr, value)
+    end
+
+    def stroke_miter
+      Native.sk_paint_get_stroke_miter(@ptr)
+    end
+
+    def stroke_miter=(value)
+      Native.sk_paint_set_stroke_miter(@ptr, value.to_f)
+    end
+
+    def blend_mode
+      Native.sk_paint_get_blendmode(@ptr)
+    end
+
+    def blend_mode=(value)
+      Native.sk_paint_set_blendmode(@ptr, value)
+    end
+
+    def shader
+      ptr = Native.sk_paint_get_shader(@ptr)
+      return nil if ptr.nil? || ptr.null?
+
+      Shader.wrap(ptr)
+    end
+
+    def shader=(value)
+      Native.sk_paint_set_shader(@ptr, value&.ptr)
+    end
+
+    def clone
+      self.class.new(Native.sk_paint_clone(@ptr))
+    end
+
+    def reset
+      Native.sk_paint_reset(@ptr)
+      self
+    end
+
+    def with(**options)
+      cloned = clone
+      options.each { |k, v| cloned.send(:"#{k}=", v) }
+      cloned
+    end
+  end
+end

data/lib/skia/path.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module Skia
+  class Path < Base
+    def initialize(ptr = nil)
+      super(ptr || Native.sk_path_new, :sk_path_delete)
+    end
+
+    def self.build(&block)
+      path = new
+      path.instance_eval(&block) if block
+      path
+    end
+
+    def move_to(x, y)
+      Native.sk_path_move_to(@ptr, x.to_f, y.to_f)
+      self
+    end
+
+    def line_to(x, y)
+      Native.sk_path_line_to(@ptr, x.to_f, y.to_f)
+      self
+    end
+
+    def quad_to(x1, y1, x2, y2)
+      Native.sk_path_quad_to(@ptr, x1.to_f, y1.to_f, x2.to_f, y2.to_f)
+      self
+    end
+
+    def conic_to(x1, y1, x2, y2, weight)
+      Native.sk_path_conic_to(@ptr, x1.to_f, y1.to_f, x2.to_f, y2.to_f, weight.to_f)
+      self
+    end
+
+    def cubic_to(x1, y1, x2, y2, x3, y3)
+      Native.sk_path_cubic_to(@ptr, x1.to_f, y1.to_f, x2.to_f, y2.to_f, x3.to_f, y3.to_f)
+      self
+    end
+
+    def arc_to(rx, ry, x_axis_rotate, x, y)
+      Native.sk_path_arc_to(@ptr, rx.to_f, ry.to_f, x_axis_rotate.to_f, x.to_f, y.to_f)
+      self
+    end
+
+    def arc_to_with_oval(oval, start_angle, sweep_angle, force_move_to = false)
+      rect_struct = oval.to_struct
+      Native.sk_path_arc_to_with_oval(@ptr, rect_struct, start_angle.to_f, sweep_angle.to_f, force_move_to)
+      self
+    end
+
+    def close
+      Native.sk_path_close(@ptr)
+      self
+    end
+
+    def add_rect(rect, direction = :cw)
+      rect_struct = rect.to_struct
+      Native.sk_path_add_rect(@ptr, rect_struct, direction)
+      self
+    end
+
+    def add_oval(rect, direction = :cw)
+      rect_struct = rect.to_struct
+      Native.sk_path_add_oval(@ptr, rect_struct, direction)
+      self
+    end
+
+    def add_circle(cx, cy, radius, direction = :cw)
+      Native.sk_path_add_circle(@ptr, cx.to_f, cy.to_f, radius.to_f, direction)
+      self
+    end
+
+    def add_arc(rect, start_angle, sweep_angle)
+      rect_struct = rect.to_struct
+      Native.sk_path_add_arc(@ptr, rect_struct, start_angle.to_f, sweep_angle.to_f)
+      self
+    end
+
+    def add_path(other, extend_path: false)
+      mode = extend_path ? 1 : 0
+      Native.sk_path_add_path(@ptr, other.ptr, mode, 0)
+      self
+    end
+
+    def add_path_offset(other, dx, dy, extend_path: false)
+      mode = extend_path ? 1 : 0
+      Native.sk_path_add_path_offset(@ptr, other.ptr, dx.to_f, dy.to_f, mode)
+      self
+    end
+
+    def add_path_matrix(other, matrix, extend_path: false)
+      mode = extend_path ? 1 : 0
+      matrix_struct = matrix.to_struct
+      Native.sk_path_add_path_matrix(@ptr, other.ptr, matrix_struct, mode)
+      self
+    end
+
+    def fill_type
+      Native.sk_path_get_filltype(@ptr)
+    end
+
+    def fill_type=(value)
+      Native.sk_path_set_filltype(@ptr, value)
+    end
+
+    def bounds
+      rect_struct = Native::SKRect.new
+      Native.sk_path_get_bounds(@ptr, rect_struct)
+      Rect.from_struct(rect_struct)
+    end
+
+    def empty?
+      Native.sk_path_count_verbs(@ptr) == 0
+    end
+
+    def contains?(x, y)
+      Native.sk_path_contains(@ptr, x.to_f, y.to_f)
+    end
+
+    def transform(matrix)
+      matrix_struct = matrix.to_struct
+      Native.sk_path_transform(@ptr, matrix_struct)
+      self
+    end
+
+    def clone
+      self.class.new(Native.sk_path_clone(@ptr))
+    end
+
+    def reset
+      Native.sk_path_reset(@ptr)
+      self
+    end
+  end
+end

data/lib/skia/picture.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Skia
+  class Picture < Base
+    def initialize(ptr)
+      super(ptr, :sk_picture_unref)
+    end
+
+    def self.from_data(data)
+      data_obj = data.is_a?(Data) ? data : Data.new(data)
+      ptr = Native.sk_picture_deserialize_from_data(data_obj.ptr)
+      raise Error, "Failed to deserialize picture" if ptr.nil? || ptr.null?
+
+      new(ptr)
+    end
+
+    def self.record(bounds, &block)
+      recorder = PictureRecorder.new
+      recorder.begin_recording(bounds, &block)
+    end
+
+    def unique_id
+      Native.sk_picture_get_unique_id(@ptr)
+    end
+
+    def cull_rect
+      rect_struct = Native::SKRect.new
+      Native.sk_picture_get_cull_rect(@ptr, rect_struct)
+      Rect.from_struct(rect_struct)
+    end
+
+    def playback(canvas)
+      Native.sk_picture_playback(@ptr, canvas.ptr)
+      self
+    end
+
+    def serialize
+      data_ptr = Native.sk_picture_serialize_to_data(@ptr)
+      raise Error, "Failed to serialize picture" if data_ptr.nil? || data_ptr.null?
+
+      Data.new(data_ptr)
+    end
+
+    def approximate_op_count(nested: true)
+      Native.sk_picture_approximate_op_count(@ptr, nested)
+    end
+
+    def approximate_bytes_used
+      Native.sk_picture_approximate_bytes_used(@ptr)
+    end
+
+    def save(path)
+      data = serialize
+      File.binwrite(path, data.to_s)
+      self
+    end
+
+    def self.load(path)
+      data = Data.from_file(path)
+      from_data(data)
+    end
+  end
+
+  class PictureRecorder
+    def initialize
+      @ptr = Native.sk_picture_recorder_new
+      raise Error, "Failed to create picture recorder" if @ptr.nil? || @ptr.null?
+
+      @recording = false
+    end
+
+    def ptr
+      @ptr
+    end
+
+    def begin_recording(bounds)
+      bounds_struct = bounds.to_struct
+      canvas_ptr = Native.sk_picture_recorder_begin_recording(@ptr, bounds_struct)
+      raise Error, "Failed to begin recording" if canvas_ptr.nil? || canvas_ptr.null?
+
+      @recording = true
+      canvas = Canvas.new(canvas_ptr)
+
+      if block_given?
+        yield canvas
+        end_recording
+      else
+        canvas
+      end
+    end
+
+    def recording_canvas
+      return nil unless @recording
+
+      canvas_ptr = Native.sk_picture_get_recording_canvas(@ptr)
+      return nil if canvas_ptr.nil? || canvas_ptr.null?
+
+      Canvas.new(canvas_ptr)
+    end
+
+    def end_recording
+      return nil unless @recording
+
+      ptr = Native.sk_picture_recorder_end_recording(@ptr)
+      @recording = false
+      raise Error, "Failed to end recording" if ptr.nil? || ptr.null?
+
+      Picture.new(ptr)
+    end
+
+    def recording?
+      @recording
+    end
+
+    def delete
+      Native.sk_picture_recorder_delete(@ptr) if @ptr
+      @ptr = nil
+    end
+  end
+end