skia 1.0.0

data/lib/skia/path.rb

@@ -0,0 +1,166 @@
+# 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_rrect(rrect, direction = :cw)
+      Native.sk_path_add_rrect(@ptr, rrect.ptr, 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_reverse(other)
+      Native.sk_path_add_path_reverse(@ptr, other.ptr)
+      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 count_points
+      Native.sk_path_count_points(@ptr)
+    end
+
+    def approximate_length(force_closed: false, res_scale: 1.0)
+      measure = Native.sk_pathmeasure_new_with_path(@ptr, force_closed, res_scale.to_f)
+      raise Error, 'Failed to create path measure' if measure.nil? || measure.null?
+
+      begin
+        Native.sk_pathmeasure_get_length(measure)
+      ensure
+        Native.sk_pathmeasure_destroy(measure)
+      end
+    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 reverse
+      reversed = self.class.new
+      Native.sk_path_add_path_reverse(reversed.ptr, @ptr)
+      reversed
+    end
+
+    def reset
+      Native.sk_path_reset(@ptr)
+      self
+    end
+  end
+end

data/lib/skia/path_effect.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Skia
+  class PathEffect < Base
+    def initialize(ptr)
+      super(ptr, :sk_path_effect_unref)
+    end
+
+    def self.wrap(ptr)
+      return nil if ptr.nil? || ptr.null?
+
+      new(ptr)
+    end
+
+    def self.dash(intervals, phase: 0.0)
+      unless intervals.is_a?(Array) && intervals.length >= 2
+        raise ArgumentError, 'intervals must be an array with at least 2 elements'
+      end
+
+      interval_values = intervals.map(&:to_f)
+      intervals_ptr = FFI::MemoryPointer.new(:float, interval_values.length)
+      intervals_ptr.write_array_of_float(interval_values)
+
+      ptr = Native.sk_path_effect_create_dash(intervals_ptr, interval_values.length, phase.to_f)
+      raise Error, 'Failed to create dash path effect' if ptr.nil? || ptr.null?
+
+      new(ptr)
+    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

data/lib/skia/pixmap.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Skia
+  class Pixmap < Base
+    def initialize(ptr = nil)
+      super(ptr || Native.sk_pixmap_new, :sk_pixmap_destructor)
+      @pixel_storage = nil
+    end
+
+    def self.from_pixels(image_info, pixels, row_bytes: nil)
+      info = coerce_image_info(image_info)
+      bytes = pixels.is_a?(String) ? pixels.dup : pixels.pack('C*')
+      row_bytes ||= info.min_row_bytes
+
+      if bytes.bytesize < row_bytes * info.height
+        raise ArgumentError, "pixel buffer is too small: #{bytes.bytesize} bytes"
+      end
+
+      storage = FFI::MemoryPointer.new(:uint8, bytes.bytesize)
+      storage.write_bytes(bytes)
+
+      ptr = Native.sk_pixmap_new_with_params(info.to_struct, storage, row_bytes)
+      raise Error, 'Failed to create pixmap from pixels' if ptr.nil? || ptr.null?
+
+      pixmap = new(ptr)
+      pixmap.instance_variable_set(:@pixel_storage, storage)
+      pixmap
+    end
+
+    def info
+      info_struct = Native::SKImageInfo.new
+      Native.sk_pixmap_get_info(@ptr, info_struct)
+      ImageInfo.from_struct(info_struct)
+    end
+
+    def row_bytes
+      Native.sk_pixmap_get_row_bytes(@ptr)
+    end
+
+    def color_space
+      ColorSpace.wrap(Native.sk_pixmap_get_colorspace(@ptr), retain: true)
+    end
+
+    def color_space=(value)
+      unless value.nil? || value.is_a?(ColorSpace)
+        raise ArgumentError, 'color_space must be a Skia::ColorSpace or nil'
+      end
+
+      Native.sk_pixmap_set_colorspace(@ptr, value&.ptr)
+    end
+
+    def pixel_color(x, y)
+      Color.new(Native.sk_pixmap_get_pixel_color(@ptr, x.to_i, y.to_i))
+    end
+
+    def opaque?
+      Native.sk_pixmap_compute_is_opaque(@ptr)
+    end
+
+    def writable_addr(x = nil, y = nil)
+      if x.nil? || y.nil?
+        Native.sk_pixmap_get_writable_addr(@ptr)
+      else
+        Native.sk_pixmap_get_writeable_addr_with_xy(@ptr, x.to_i, y.to_i)
+      end
+    end
+
+    def read_pixels(dst_info, src_x: 0, src_y: 0, row_bytes: nil)
+      info = self.class.coerce_image_info(dst_info)
+      row_bytes ||= info.min_row_bytes
+      byte_size = row_bytes * info.height
+      pixels = FFI::MemoryPointer.new(:uint8, byte_size)
+
+      ok = Native.sk_pixmap_read_pixels(@ptr, info.to_struct, pixels, row_bytes, src_x.to_i, src_y.to_i)
+      raise Error, 'Failed to read pixels from pixmap' unless ok
+
+      pixels.read_bytes(byte_size)
+    end
+
+    def extract_subset(rect)
+      irect = coerce_irect(rect)
+      subset = self.class.new
+      success = Native.sk_pixmap_extract_subset(@ptr, subset.ptr, irect.to_struct)
+      return nil unless success
+
+      subset
+    end
+
+    def reset
+      Native.sk_pixmap_reset(@ptr)
+      @pixel_storage = nil
+      self
+    end
+
+    private
+
+    def self.coerce_image_info(image_info)
+      return image_info if image_info.is_a?(ImageInfo)
+
+      raise ArgumentError, 'image_info must be a Skia::ImageInfo'
+    end
+
+    def coerce_irect(rect)
+      return rect if rect.is_a?(IRect)
+
+      raise ArgumentError, 'rect must be a Skia::IRect'
+    end
+  end
+end

data/lib/skia/point.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Skia
+  class Point
+    attr_accessor :x, :y
+
+    def initialize(x = 0.0, y = 0.0)
+      @x = x.to_f
+      @y = y.to_f
+    end
+
+    def self.from_struct(struct)
+      new(struct[:x], struct[:y])
+    end
+
+    def to_struct
+      struct = Native::SKPoint.new
+      struct[:x] = @x
+      struct[:y] = @y
+      struct
+    end
+
+    def +(other)
+      self.class.new(@x + other.x, @y + other.y)
+    end
+
+    def -(other)
+      self.class.new(@x - other.x, @y - other.y)
+    end
+
+    def *(other)
+      self.class.new(@x * other, @y * other)
+    end
+
+    def /(other)
+      self.class.new(@x / other, @y / other)
+    end
+
+    def -@
+      self.class.new(-@x, -@y)
+    end
+
+    def length
+      Math.sqrt(@x * @x + @y * @y)
+    end
+
+    def normalize
+      len = length
+      return self.class.new(0, 0) if len.zero?
+
+      self / len
+    end
+
+    def ==(other)
+      return false unless other.is_a?(Point)
+
+      @x == other.x && @y == other.y
+    end
+
+    def to_a
+      [@x, @y]
+    end
+  end
+
+  class IPoint
+    attr_accessor :x, :y
+
+    def initialize(x = 0, y = 0)
+      @x = x.to_i
+      @y = y.to_i
+    end
+
+    def self.from_struct(struct)
+      new(struct[:x], struct[:y])
+    end
+
+    def to_struct
+      struct = Native::SKIPoint.new
+      struct[:x] = @x
+      struct[:y] = @y
+      struct
+    end
+
+    def ==(other)
+      return false unless other.is_a?(IPoint)
+
+      @x == other.x && @y == other.y
+    end
+
+    def to_a
+      [@x, @y]
+    end
+  end
+end

data/lib/skia/rect.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+module Skia
+  class Rect
+    attr_accessor :left, :top, :right, :bottom
+
+    def initialize(left = 0.0, top = 0.0, right = 0.0, bottom = 0.0)
+      @left = left.to_f
+      @top = top.to_f
+      @right = right.to_f
+      @bottom = bottom.to_f
+    end
+
+    def self.from_xywh(x, y, width, height)
+      new(x, y, x + width, y + height)
+    end
+
+    def self.from_wh(width, height)
+      new(0, 0, width, height)
+    end
+
+    def self.from_struct(struct)
+      new(struct[:left], struct[:top], struct[:right], struct[:bottom])
+    end
+
+    def to_struct
+      struct = Native::SKRect.new
+      struct[:left] = @left
+      struct[:top] = @top
+      struct[:right] = @right
+      struct[:bottom] = @bottom
+      struct
+    end
+
+    def width
+      @right - @left
+    end
+
+    def height
+      @bottom - @top
+    end
+
+    def center_x
+      (@left + @right) / 2.0
+    end
+
+    def center_y
+      (@top + @bottom) / 2.0
+    end
+
+    def center
+      Point.new(center_x, center_y)
+    end
+
+    def empty?
+      @left >= @right || @top >= @bottom
+    end
+
+    def contains?(x, y)
+      x >= @left && x < @right && y >= @top && y < @bottom
+    end
+
+    def contains_rect?(other)
+      @left <= other.left && @top <= other.top &&
+        @right >= other.right && @bottom >= other.bottom
+    end
+
+    def intersects?(other)
+      @left < other.right && other.left < @right &&
+        @top < other.bottom && other.top < @bottom
+    end
+
+    def intersect(other)
+      return nil unless intersects?(other)
+
+      self.class.new(
+        [@left, other.left].max,
+        [@top, other.top].min,
+        [@right, other.right].min,
+        [@bottom, other.bottom].max
+      )
+    end
+
+    def union(other)
+      self.class.new(
+        [@left, other.left].min,
+        [@top, other.top].min,
+        [@right, other.right].max,
+        [@bottom, other.bottom].max
+      )
+    end
+
+    def offset(dx, dy)
+      self.class.new(@left + dx, @top + dy, @right + dx, @bottom + dy)
+    end
+
+    def offset!(dx, dy)
+      @left += dx
+      @top += dy
+      @right += dx
+      @bottom += dy
+      self
+    end
+
+    def inset(dx, dy)
+      self.class.new(@left + dx, @top + dy, @right - dx, @bottom - dy)
+    end
+
+    def ==(other)
+      return false unless other.is_a?(Rect)
+
+      @left == other.left && @top == other.top &&
+        @right == other.right && @bottom == other.bottom
+    end
+
+    def to_a
+      [@left, @top, @right, @bottom]
+    end
+  end
+
+  class IRect
+    attr_accessor :left, :top, :right, :bottom
+
+    def initialize(left = 0, top = 0, right = 0, bottom = 0)
+      @left = left.to_i
+      @top = top.to_i
+      @right = right.to_i
+      @bottom = bottom.to_i
+    end
+
+    def self.from_xywh(x, y, width, height)
+      new(x, y, x + width, y + height)
+    end
+
+    def self.from_wh(width, height)
+      new(0, 0, width, height)
+    end
+
+    def self.from_struct(struct)
+      new(struct[:left], struct[:top], struct[:right], struct[:bottom])
+    end
+
+    def to_struct
+      struct = Native::SKIRect.new
+      struct[:left] = @left
+      struct[:top] = @top
+      struct[:right] = @right
+      struct[:bottom] = @bottom
+      struct
+    end
+
+    def width
+      @right - @left
+    end
+
+    def height
+      @bottom - @top
+    end
+
+    def empty?
+      @left >= @right || @top >= @bottom
+    end
+
+    def ==(other)
+      return false unless other.is_a?(IRect)
+
+      @left == other.left && @top == other.top &&
+        @right == other.right && @bottom == other.bottom
+    end
+
+    def to_a
+      [@left, @top, @right, @bottom]
+    end
+
+    def to_rect
+      Rect.new(@left.to_f, @top.to_f, @right.to_f, @bottom.to_f)
+    end
+  end
+end