skia 0.1.0

data/examples/picture_recording.rb

@@ -0,0 +1,62 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative '../lib/skia'
+
+bounds = Skia::Rect.from_xywh(0, 0, 200, 200)
+picture = Skia::Picture.record(bounds) do |canvas|
+  paint = Skia::Paint.new
+  paint.antialias = true
+
+  paint.color = Skia::Color::RED
+  paint.style = :fill
+  canvas.draw_circle(100, 100, 80, paint)
+
+  paint.color = Skia::Color::BLUE
+  paint.style = :stroke
+  paint.stroke_width = 5
+  canvas.draw_circle(100, 100, 80, paint)
+end
+
+puts 'Recorded picture:'
+puts "  Unique ID: #{picture.unique_id}"
+puts "  Cull rect: #{picture.cull_rect.inspect}"
+puts "  Approximate op count: #{picture.approximate_op_count}"
+puts "  Approximate bytes used: #{picture.approximate_bytes_used}"
+
+data = picture.serialize
+puts "  Serialized size: #{data.size} bytes"
+
+loaded_picture = Skia::Picture.from_data(data)
+puts "  Loaded picture unique ID: #{loaded_picture.unique_id}"
+
+surface = Skia::Surface.make_raster(640, 480)
+surface.draw do |canvas|
+  canvas.clear(Skia::Color::WHITE)
+
+  canvas.with_save do
+    canvas.translate(50, 50)
+    picture.playback(canvas)
+  end
+
+  canvas.with_save do
+    canvas.translate(300, 50)
+    canvas.scale(0.5, 0.5)
+    picture.playback(canvas)
+  end
+
+  canvas.with_save do
+    canvas.translate(50, 280)
+    canvas.scale(1.5, 1.5)
+    picture.playback(canvas)
+  end
+
+  canvas.with_save do
+    canvas.translate(400, 280)
+    canvas.rotate(45, 100, 100)
+    picture.playback(canvas)
+  end
+end
+
+surface.save_png('picture_output.png')
+puts 'Saved to picture_output.png'

data/examples/progress_gauge.rb

@@ -0,0 +1,103 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative '../lib/skia'
+
+def draw_circular_progress(canvas, cx, cy, radius, progress, label, color)
+  paint = Skia::Paint.new
+  paint.antialias = true
+  paint.style = :stroke
+  paint.stroke_width = 12
+  paint.stroke_cap = :round
+
+  paint.color = Skia::Color.rgb(230, 230, 230)
+  canvas.draw_circle(cx, cy, radius, paint)
+
+  paint.color = color
+  rect = Skia::Rect.from_xywh(cx - radius, cy - radius, radius * 2, radius * 2)
+
+  path = Skia::Path.new
+  start_angle = -90
+  sweep_angle = progress * 360 / 100.0
+  path.arc_to_with_oval(rect, start_angle, sweep_angle, true)
+  canvas.draw_path(path, paint)
+
+  paint.style = :fill
+  paint.color = Skia::Color.rgb(50, 50, 50)
+  font_value = Skia::Font.new(nil, radius * 0.5)
+  value_text = "#{progress.to_i}%"
+  text_width, = font_value.measure_text(value_text)
+  canvas.draw_text(value_text, cx - text_width / 2, cy + radius * 0.15, font_value, paint)
+
+  font_label = Skia::Font.new(nil, radius * 0.25)
+  paint.color = Skia::Color.rgb(120, 120, 120)
+  label_width, = font_label.measure_text(label)
+  canvas.draw_text(label, cx - label_width / 2, cy + radius + 25, font_label, paint)
+end
+
+def draw_linear_progress(canvas, x, y, width, height, progress, label, color)
+  paint = Skia::Paint.new
+  paint.antialias = true
+
+  font = Skia::Font.new(nil, 14.0)
+  paint.color = Skia::Color.rgb(80, 80, 80)
+  canvas.draw_text(label, x, y - 10, font, paint)
+
+  percent_text = "#{progress.to_i}%"
+  text_width, = font.measure_text(percent_text)
+  canvas.draw_text(percent_text, x + width - text_width, y - 10, font, paint)
+
+  paint.color = Skia::Color.rgb(230, 230, 230)
+  bg_rect = Skia::Rect.from_xywh(x, y, width, height)
+  canvas.draw_round_rect(bg_rect, height / 2, paint)
+
+  paint.color = color
+  progress_width = width * progress / 100.0
+  return unless progress_width > height
+
+  progress_rect = Skia::Rect.from_xywh(x, y, progress_width, height)
+  canvas.draw_round_rect(progress_rect, height / 2, paint)
+end
+
+WIDTH = 800
+HEIGHT = 500
+
+surface = Skia::Surface.make_raster(WIDTH, HEIGHT)
+
+surface.draw do |canvas|
+  canvas.clear(Skia::Color.rgb(245, 247, 250))
+
+  paint = Skia::Paint.new
+  paint.antialias = true
+
+  font_title = Skia::Font.new(nil, 28.0)
+  paint.color = Skia::Color.rgb(50, 50, 50)
+  canvas.draw_text('System Dashboard', 30, 45, font_title, paint)
+
+  draw_circular_progress(canvas, 130, 180, 70, 78, 'CPU Usage', Skia::Color.rgb(59, 130, 246))
+  draw_circular_progress(canvas, 310, 180, 70, 45, 'Memory', Skia::Color.rgb(16, 185, 129))
+  draw_circular_progress(canvas, 490, 180, 70, 92, 'Disk', Skia::Color.rgb(245, 158, 11))
+  draw_circular_progress(canvas, 670, 180, 70, 23, 'Network', Skia::Color.rgb(139, 92, 246))
+
+  y_start = 320
+  bar_height = 16
+  bar_spacing = 55
+
+  tasks = [
+    { label: 'Project Alpha', progress: 85, color: Skia::Color.rgb(59, 130, 246) },
+    { label: 'Project Beta', progress: 60, color: Skia::Color.rgb(16, 185, 129) },
+    { label: 'Project Gamma', progress: 35, color: Skia::Color.rgb(245, 158, 11) }
+  ]
+
+  tasks.each_with_index do |task, i|
+    draw_linear_progress(
+      canvas,
+      50, y_start + (i * bar_spacing),
+      WIDTH - 100, bar_height,
+      task[:progress], task[:label], task[:color]
+    )
+  end
+end
+
+surface.save_png('dashboard.png')
+puts 'Saved to dashboard.png'

data/examples/social_card.rb

@@ -0,0 +1,121 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative '../lib/skia'
+
+def generate_social_card(
+  title:,
+  author: nil,
+  site_name: nil,
+  tags: [],
+  output: 'social_card.png'
+)
+  width = 1200
+  height = 630
+
+  surface = Skia::Surface.make_raster(width, height)
+
+  surface.draw do |canvas|
+    paint = Skia::Paint.new
+    paint.antialias = true
+
+    gradient = Skia::Shader.linear_gradient(
+      Skia::Point.new(0, 0),
+      Skia::Point.new(width, height),
+      [
+        Skia::Color.rgb(102, 126, 234),
+        Skia::Color.rgb(118, 75, 162)
+      ]
+    )
+    paint.shader = gradient
+    canvas.draw_rect(Skia::Rect.from_xywh(0, 0, width, height), paint)
+    paint.shader = nil
+
+    paint.color = Skia::Color.argb(30, 255, 255, 255)
+    canvas.draw_circle(100, 100, 200, paint)
+    canvas.draw_circle(1100, 500, 250, paint)
+    canvas.draw_circle(900, 50, 100, paint)
+
+    paint.color = Skia::Color::WHITE
+    content_rect = Skia::Rect.from_xywh(60, 60, width - 120, height - 120)
+    canvas.draw_round_rect(content_rect, 20, paint)
+
+    paint.color = Skia::Color.rgb(30, 30, 30)
+    font_title = Skia::Font.new(nil, 52.0)
+
+    max_chars_per_line = 28
+    title_lines = []
+    words = title.split
+    current_line = ''
+
+    words.each do |word|
+      test_line = current_line.empty? ? word : "#{current_line} #{word}"
+      if test_line.length > max_chars_per_line && !current_line.empty?
+        title_lines << current_line
+        current_line = word
+      else
+        current_line = test_line
+      end
+    end
+    title_lines << current_line unless current_line.empty?
+
+    title_y = 160
+    title_lines.each_with_index do |line, i|
+      canvas.draw_text(line, 100, title_y + (i * 70), font_title, paint)
+    end
+
+    if tags.any?
+      font_tag = Skia::Font.new(nil, 24.0)
+      tag_y = height - 180
+      tag_x = 100
+
+      tags.each do |tag|
+        tag_text = "##{tag}"
+        text_width, = font_tag.measure_text(tag_text)
+
+        paint.color = Skia::Color.rgb(102, 126, 234)
+        tag_rect = Skia::Rect.from_xywh(tag_x - 10, tag_y - 25, text_width + 20, 35)
+        canvas.draw_round_rect(tag_rect, 17, paint)
+
+        paint.color = Skia::Color::WHITE
+        canvas.draw_text(tag_text, tag_x, tag_y, font_tag, paint)
+
+        tag_x += text_width + 30
+      end
+    end
+
+    if author
+      font_author = Skia::Font.new(nil, 28.0)
+      paint.color = Skia::Color.rgb(100, 100, 100)
+      canvas.draw_text(author, 100, height - 100, font_author, paint)
+    end
+
+    if site_name
+      font_site = Skia::Font.new(nil, 24.0)
+      paint.color = Skia::Color.rgb(150, 150, 150)
+      text_width, = font_site.measure_text(site_name)
+      canvas.draw_text(site_name, width - 100 - text_width, height - 100, font_site, paint)
+    end
+  end
+
+  surface.save_png(output)
+  puts "Saved to #{output}"
+end
+
+generate_social_card(
+  title: 'Building Ruby Bindings for Skia Graphics Library with FFI',
+  author: '@ruby_dev',
+  site_name: 'tech.blog',
+  tags: %w[Ruby FFI Graphics],
+  output: 'social_card_blog.png'
+)
+
+generate_social_card(
+  title: 'Conference Session: High Performance 2D Graphics in Ruby',
+  author: 'Speaker Name',
+  site_name: 'RubyKaigi',
+  tags: %w[RubyKaigi Conference],
+  output: 'social_card_event.png'
+)
+
+puts "\nSocial cards generated!"

data/examples/text_drawing.rb

@@ -0,0 +1,40 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../lib/skia"
+
+surface = Skia::Surface.make_raster(640, 480)
+
+surface.draw do |canvas|
+  canvas.clear(Skia::Color::WHITE)
+
+  font = Skia::Font.new(nil, 48.0)
+
+  paint = Skia::Paint.new
+  paint.antialias = true
+  paint.color = Skia::Color::BLACK
+
+  canvas.draw_text("Hello, Skia!", 50, 100, font, paint)
+
+  paint.color = Skia::Color::RED
+  canvas.draw_text("Red Text", 50, 180, font, paint)
+
+  paint.color = Skia::Color::BLUE
+  canvas.draw_text("Blue Text", 50, 260, font, paint)
+
+  small_font = Skia::Font.new(nil, 24.0)
+  paint.color = Skia::Color::GREEN
+  canvas.draw_text("Smaller green text", 50, 320, small_font, paint)
+
+  width, bounds = font.measure_text("Measured Text")
+  paint.color = Skia::Color.argb(100, 255, 200, 0)
+  paint.style = :fill
+  measured_rect = Skia::Rect.from_xywh(50, 380 + bounds.top, width, bounds.height)
+  canvas.draw_rect(measured_rect, paint)
+
+  paint.color = Skia::Color::BLACK
+  canvas.draw_text("Measured Text", 50, 380, font, paint)
+end
+
+surface.save_png("text_output.png")
+puts "Saved to text_output.png"

data/lib/skia/base.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Skia
+  class Base
+    attr_reader :ptr
+
+    def initialize(ptr, release_method = nil)
+      raise NullPointerError, 'Pointer cannot be nil' if ptr.nil? || ptr.null?
+
+      @ptr = ptr
+      @release_method = release_method
+      setup_release if @release_method
+    end
+
+    def to_ptr
+      @ptr
+    end
+
+    def null?
+      @ptr.nil? || @ptr.null?
+    end
+
+    def self.release_callback(release_method, ptr)
+      proc { Native.send(release_method, ptr) unless ptr.null? }
+    end
+
+    protected
+
+    def setup_release
+      ObjectSpace.define_finalizer(self, self.class.release_callback(@release_method, @ptr))
+    end
+
+    def release!
+      return unless @release_method && @ptr && !@ptr.null?
+
+      Native.send(@release_method, @ptr)
+      @ptr = nil
+    end
+  end
+end

data/lib/skia/canvas.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+module Skia
+  class Canvas < Base
+    def initialize(ptr)
+      super(ptr, nil)
+    end
+
+    def save
+      Native.sk_canvas_save(@ptr)
+    end
+
+    def save_layer(bounds = nil, paint = nil)
+      bounds_ptr = bounds&.to_struct
+      paint_ptr = paint&.ptr
+      Native.sk_canvas_save_layer(@ptr, bounds_ptr, paint_ptr)
+    end
+
+    def restore
+      Native.sk_canvas_restore(@ptr)
+    end
+
+    def restore_to_count(count)
+      Native.sk_canvas_restore_to_count(@ptr, count)
+    end
+
+    def save_count
+      Native.sk_canvas_get_save_count(@ptr)
+    end
+
+    def translate(dx, dy)
+      Native.sk_canvas_translate(@ptr, dx.to_f, dy.to_f)
+      self
+    end
+
+    def scale(sx, sy = sx)
+      Native.sk_canvas_scale(@ptr, sx.to_f, sy.to_f)
+      self
+    end
+
+    def rotate(degrees, px = nil, py = nil)
+      if px && py
+        translate(px, py)
+        Native.sk_canvas_rotate_degrees(@ptr, degrees.to_f)
+        translate(-px, -py)
+      else
+        Native.sk_canvas_rotate_degrees(@ptr, degrees.to_f)
+      end
+      self
+    end
+
+    def rotate_radians(radians)
+      Native.sk_canvas_rotate_radians(@ptr, radians.to_f)
+      self
+    end
+
+    def skew(sx, sy)
+      Native.sk_canvas_skew(@ptr, sx.to_f, sy.to_f)
+      self
+    end
+
+    def concat(matrix)
+      matrix_struct = matrix.to_struct44
+      Native.sk_canvas_concat(@ptr, matrix_struct)
+      self
+    end
+
+    def matrix=(matrix)
+      matrix_struct = matrix.to_struct44
+      Native.sk_canvas_set_matrix(@ptr, matrix_struct)
+    end
+
+    def matrix
+      m = Native::SKMatrix44.new
+      Native.sk_canvas_get_matrix(@ptr, m)
+      Matrix.from_struct44(m)
+    end
+
+    def clip_rect(rect, op = :intersect, antialias: false)
+      rect_struct = rect.to_struct
+      Native.sk_canvas_clip_rect_with_operation(@ptr, rect_struct, op, antialias)
+      self
+    end
+
+    def clip_path(path, op = :intersect, antialias: false)
+      Native.sk_canvas_clip_path_with_operation(@ptr, path.ptr, op, antialias)
+      self
+    end
+
+    def clear(color = Color::TRANSPARENT)
+      color_value = color.is_a?(Color) ? color.to_i : color
+      Native.sk_canvas_clear(@ptr, color_value)
+      self
+    end
+
+    def draw_color(color, blend_mode = :src_over)
+      color_value = color.is_a?(Color) ? color.to_i : color
+      Native.sk_canvas_draw_color(@ptr, color_value, blend_mode)
+      self
+    end
+
+    def draw_paint(paint)
+      Native.sk_canvas_draw_paint(@ptr, paint.ptr)
+      self
+    end
+
+    def draw_rect(rect, paint)
+      rect_struct = rect.to_struct
+      Native.sk_canvas_draw_rect(@ptr, rect_struct, paint.ptr)
+      self
+    end
+
+    def draw_round_rect(rect, radius, paint)
+      rect_struct = rect.to_struct
+      Native.sk_canvas_draw_round_rect(@ptr, rect_struct, radius.to_f, radius.to_f, paint.ptr)
+      self
+    end
+
+    def draw_circle(cx, cy, radius, paint)
+      Native.sk_canvas_draw_circle(@ptr, cx.to_f, cy.to_f, radius.to_f, paint.ptr)
+      self
+    end
+
+    def draw_oval(rect, paint)
+      rect_struct = rect.to_struct
+      Native.sk_canvas_draw_oval(@ptr, rect_struct, paint.ptr)
+      self
+    end
+
+    def draw_path(path, paint)
+      Native.sk_canvas_draw_path(@ptr, path.ptr, paint.ptr)
+      self
+    end
+
+    def draw_line(x1, y1, x2, y2, paint)
+      Native.sk_canvas_draw_line(@ptr, x1.to_f, y1.to_f, x2.to_f, y2.to_f, paint.ptr)
+      self
+    end
+
+    def draw_image(image, x, y, paint = nil)
+      Native.sk_canvas_draw_image(@ptr, image.ptr, x.to_f, y.to_f, paint&.ptr)
+      self
+    end
+
+    def draw_image_rect(image, src_rect, dst_rect, paint = nil)
+      src_struct = src_rect&.to_struct
+      dst_struct = dst_rect.to_struct
+      Native.sk_canvas_draw_image_rect(@ptr, image.ptr, src_struct, dst_struct, paint&.ptr)
+      self
+    end
+
+    def draw_text(text, x, y, font, paint)
+      text_bytes = text.encode('UTF-8')
+      Native.sk_canvas_draw_simple_text(@ptr, text_bytes, text_bytes.bytesize, :utf8, x.to_f, y.to_f, font.ptr,
+                                        paint.ptr)
+      self
+    end
+
+    def with_save
+      count = save
+      begin
+        yield self
+      ensure
+        restore_to_count(count)
+      end
+    end
+
+    def with_save_layer(bounds = nil, paint = nil)
+      count = save_layer(bounds, paint)
+      begin
+        yield self
+      ensure
+        restore_to_count(count)
+      end
+    end
+  end
+end

data/lib/skia/color.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Skia
+  class Color
+    attr_reader :value
+
+    def initialize(r_or_value = 0, g = nil, b = nil, a = 255)
+      @value = if g.nil? && b.nil?
+                 r_or_value.is_a?(Integer) ? r_or_value : 0xFF000000
+               else
+                 ((a & 0xFF) << 24) | ((r_or_value & 0xFF) << 16) | ((g & 0xFF) << 8) | (b & 0xFF)
+               end
+    end
+
+    def self.argb(a, r, g, b)
+      new(r, g, b, a)
+    end
+
+    def self.rgb(r, g, b)
+      new(r, g, b, 255)
+    end
+
+    def self.from_hex(hex_string)
+      hex = hex_string.delete_prefix('#')
+      case hex.length
+      when 6
+        new(hex.to_i(16) | 0xFF000000)
+      when 8
+        new(hex.to_i(16))
+      else
+        raise ArgumentError, "Invalid hex color format: #{hex_string}"
+      end
+    end
+
+    def alpha
+      (@value >> 24) & 0xFF
+    end
+
+    def red
+      (@value >> 16) & 0xFF
+    end
+
+    def green
+      (@value >> 8) & 0xFF
+    end
+
+    def blue
+      @value & 0xFF
+    end
+
+    def to_i
+      @value
+    end
+
+    def to_hex
+      format('#%08X', @value)
+    end
+
+    def with_alpha(a)
+      self.class.new(red, green, blue, a)
+    end
+
+    def ==(other)
+      return false unless other.is_a?(Color)
+
+      @value == other.value
+    end
+
+    TRANSPARENT = new(0x00000000)
+    BLACK = new(0xFF000000)
+    WHITE = new(0xFFFFFFFF)
+    RED = new(0xFFFF0000)
+    GREEN = new(0xFF00FF00)
+    BLUE = new(0xFF0000FF)
+    YELLOW = new(0xFFFFFF00)
+    CYAN = new(0xFF00FFFF)
+    MAGENTA = new(0xFFFF00FF)
+    GRAY = new(0xFF808080)
+    LIGHT_GRAY = new(0xFFC0C0C0)
+    DARK_GRAY = new(0xFF404040)
+  end
+end

data/lib/skia/data.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Skia
+  class Data < Base
+    def initialize(ptr_or_bytes = nil)
+      case ptr_or_bytes
+      when FFI::Pointer
+        super(ptr_or_bytes, :sk_data_unref)
+      when String
+        ptr = Native.sk_data_new_with_copy(ptr_or_bytes, ptr_or_bytes.bytesize)
+        raise Error, 'Failed to create data from bytes' if ptr.nil? || ptr.null?
+
+        super(ptr, :sk_data_unref)
+      when nil
+        raise ArgumentError, 'Data requires bytes or pointer'
+      else
+        raise ArgumentError, "Invalid argument type: #{ptr_or_bytes.class}"
+      end
+    end
+
+    def self.from_file(path)
+      ptr = Native.sk_data_new_from_file(path)
+      raise FileNotFoundError, "Failed to load file: #{path}" if ptr.nil? || ptr.null?
+
+      new(ptr)
+    end
+
+    def self.from_bytes(bytes)
+      new(bytes)
+    end
+
+    def size
+      Native.sk_data_get_size(@ptr)
+    end
+
+    def empty?
+      size == 0
+    end
+
+    def to_s
+      data_ptr = Native.sk_data_get_data(@ptr)
+      data_ptr.read_bytes(size)
+    end
+
+    alias to_bytes to_s
+  end
+end