skia 0.1.0

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

data/lib/skia/shader.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Skia
+  class Shader < Base
+    def initialize(ptr)
+      super(ptr, :sk_shader_unref)
+    end
+
+    def self.wrap(ptr)
+      return nil if ptr.nil? || ptr.null?
+
+      new(ptr)
+    end
+
+    def self.linear_gradient(start_point, end_point, colors, positions = nil, tile_mode: :clamp, matrix: nil)
+      points = FFI::MemoryPointer.new(Native::SKPoint, 2)
+      start_struct = start_point.to_struct
+      end_struct = end_point.to_struct
+      points[0].write_bytes(start_struct.to_ptr.read_bytes(Native::SKPoint.size))
+      points[1].write_bytes(end_struct.to_ptr.read_bytes(Native::SKPoint.size))
+
+      color_values = colors.map { |c| c.is_a?(Color) ? c.to_i : c }
+      colors_ptr = FFI::MemoryPointer.new(:uint32, color_values.size)
+      colors_ptr.write_array_of_uint32(color_values)
+
+      positions_ptr = nil
+      if positions
+        positions_ptr = FFI::MemoryPointer.new(:float, positions.size)
+        positions_ptr.write_array_of_float(positions.map(&:to_f))
+      end
+
+      matrix_ptr = matrix&.to_struct
+
+      ptr = Native.sk_shader_new_linear_gradient(
+        points,
+        colors_ptr,
+        positions_ptr,
+        color_values.size,
+        tile_mode,
+        matrix_ptr
+      )
+      raise Error, 'Failed to create linear gradient shader' if ptr.nil? || ptr.null?
+
+      new(ptr)
+    end
+
+    def self.radial_gradient(center, radius, colors, positions = nil, tile_mode: :clamp, matrix: nil)
+      center_struct = center.to_struct
+
+      color_values = colors.map { |c| c.is_a?(Color) ? c.to_i : c }
+      colors_ptr = FFI::MemoryPointer.new(:uint32, color_values.size)
+      colors_ptr.write_array_of_uint32(color_values)
+
+      positions_ptr = nil
+      if positions
+        positions_ptr = FFI::MemoryPointer.new(:float, positions.size)
+        positions_ptr.write_array_of_float(positions.map(&:to_f))
+      end
+
+      matrix_ptr = matrix&.to_struct
+
+      ptr = Native.sk_shader_new_radial_gradient(
+        center_struct,
+        radius.to_f,
+        colors_ptr,
+        positions_ptr,
+        color_values.size,
+        tile_mode,
+        matrix_ptr
+      )
+      raise Error, 'Failed to create radial gradient shader' if ptr.nil? || ptr.null?
+
+      new(ptr)
+    end
+
+    def self.sweep_gradient(center, colors, positions = nil, tile_mode: :clamp, start_angle: 0.0, end_angle: 360.0,
+                            matrix: nil)
+      center_struct = center.to_struct
+
+      color_values = colors.map { |c| c.is_a?(Color) ? c.to_i : c }
+      colors_ptr = FFI::MemoryPointer.new(:uint32, color_values.size)
+      colors_ptr.write_array_of_uint32(color_values)
+
+      positions_ptr = nil
+      if positions
+        positions_ptr = FFI::MemoryPointer.new(:float, positions.size)
+        positions_ptr.write_array_of_float(positions.map(&:to_f))
+      end
+
+      matrix_ptr = matrix&.to_struct
+
+      ptr = Native.sk_shader_new_sweep_gradient(
+        center_struct,
+        colors_ptr,
+        positions_ptr,
+        color_values.size,
+        tile_mode,
+        start_angle.to_f,
+        end_angle.to_f,
+        matrix_ptr
+      )
+      raise Error, 'Failed to create sweep gradient shader' if ptr.nil? || ptr.null?
+
+      new(ptr)
+    end
+  end
+end

data/lib/skia/surface.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+module Skia
+  class Surface < Base
+    attr_reader :width, :height
+
+    def initialize(ptr, width, height)
+      super(ptr, :sk_surface_unref)
+      @width = width
+      @height = height
+    end
+
+    def self.make_raster(width, height, color_type: :rgba_8888, alpha_type: :premul)
+      info = Native::SKImageInfo.new
+      info[:width] = width
+      info[:height] = height
+      info[:colorType] = color_type
+      info[:alphaType] = alpha_type
+      info[:colorspace] = nil
+
+      ptr = Native.sk_surface_new_raster(info, 0, nil)
+      raise Error, 'Failed to create raster surface' if ptr.nil? || ptr.null?
+
+      new(ptr, width, height)
+    end
+
+    def self.make_raster_direct(width, height, pixels, row_bytes, color_type: :rgba_8888, alpha_type: :premul)
+      info = Native::SKImageInfo.new
+      info[:width] = width
+      info[:height] = height
+      info[:colorType] = color_type
+      info[:alphaType] = alpha_type
+      info[:colorspace] = nil
+
+      ptr = Native.sk_surface_new_raster_direct(info, pixels, row_bytes, nil, nil, nil)
+      raise Error, 'Failed to create direct raster surface' if ptr.nil? || ptr.null?
+
+      new(ptr, width, height)
+    end
+
+    def canvas
+      @canvas ||= Canvas.new(Native.sk_surface_get_canvas(@ptr))
+    end
+
+    def snapshot
+      ptr = Native.sk_surface_new_image_snapshot(@ptr)
+      raise Error, 'Failed to create image snapshot' if ptr.nil? || ptr.null?
+
+      Image.new(ptr)
+    end
+
+    def draw
+      yield canvas
+      self
+    end
+
+    def encode(format = :png, quality = 100)
+      pixmap = Native.sk_pixmap_new
+      raise Error, 'Failed to create pixmap' if pixmap.nil? || pixmap.null?
+
+      begin
+        raise Error, 'Failed to peek pixels from surface' unless Native.sk_surface_peek_pixels(@ptr, pixmap)
+
+        stream = Native.sk_dynamicmemorywstream_new
+        raise Error, '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 Error, "Failed to encode surface as #{format}" unless success
+
+          data_ptr = Native.sk_dynamicmemorywstream_detach_as_data(stream)
+          raise Error, '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
+      else
+        :png
+      end
+    end
+  end
+end

data/lib/skia/typeface.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Skia
+  class Typeface < Base
+    WEIGHT_NORMAL = 400
+    WEIGHT_BOLD = 700
+    WIDTH_NORMAL = 5
+
+    def initialize(ptr)
+      super(ptr, :sk_typeface_unref)
+    end
+
+    def self.from_name(name, weight: WEIGHT_NORMAL, width: WIDTH_NORMAL, slant: :upright)
+      style = Native.sk_fontstyle_new(weight, width, slant)
+      begin
+        ptr = Native.sk_typeface_create_from_name(name, style)
+        return nil if ptr.nil? || ptr.null?
+
+        new(ptr)
+      ensure
+        Native.sk_fontstyle_delete(style) if style && !style.null?
+      end
+    end
+
+    def self.from_file(path, index = 0)
+      ptr = Native.sk_typeface_create_from_file(path, index)
+      raise FileNotFoundError, "Failed to load typeface: #{path}" if ptr.nil? || ptr.null?
+
+      new(ptr)
+    end
+
+    def self.default
+      ptr = Native.sk_typeface_create_default
+      return nil if ptr.nil? || ptr.null?
+
+      new(ptr)
+    end
+  end
+end

data/lib/skia/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Skia
+  VERSION = '0.1.0'
+end

data/lib/skia.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'ffi'
+
+require_relative 'skia/version'
+require_relative 'skia/native'
+require_relative 'skia/base'
+require_relative 'skia/color'
+require_relative 'skia/point'
+require_relative 'skia/rect'
+require_relative 'skia/matrix'
+require_relative 'skia/paint'
+require_relative 'skia/path'
+require_relative 'skia/data'
+require_relative 'skia/image'
+require_relative 'skia/surface'
+require_relative 'skia/canvas'
+require_relative 'skia/typeface'
+require_relative 'skia/font'
+require_relative 'skia/shader'
+require_relative 'skia/document'
+require_relative 'skia/picture'
+
+module Skia
+  class Error < StandardError; end
+  class NullPointerError < Error; end
+  class EncodingError < Error; end
+  class DecodingError < Error; end
+  class FileNotFoundError < Error; end
+  class UnsupportedOperationError < Error; end
+end

data/skia-ruby.gemspec

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative 'lib/skia/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'skia'
+  spec.version = Skia::VERSION
+  spec.authors = ['Yudai Takada']
+  spec.email = ['t.yudai92@gmail.com']
+
+  spec.summary = 'Ruby bindings for Google Skia 2D graphics library'
+  spec.description = 'Ruby bindings for Skia, providing high-performance 2D graphics capabilities'
+  spec.homepage = 'https://github.com/ydah/skia-ruby'
+  spec.license = 'MIT'
+  spec.required_ruby_version = '>= 3.0.0'
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = "#{spec.homepage}/tree/v#{spec.version}"
+  spec.metadata['changelog_uri'] = "#{spec.homepage}/blob/v#{spec.version}/CHANGELOG.md"
+
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) ||
+        f.start_with?(*%w[bin/ test/ spec/ features/ .git .github appveyor Gemfile Dockerfile])
+    end
+  end
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'ffi', '~> 1.15'
+end