skia 1.0.0

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/runtime_effect.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative '../lib/skia'
+
+sksl = <<~SKSL
+  half4 main(float2 coord) {
+    half r = coord.x / 640.0;
+    half g = coord.y / 360.0;
+    return half4(r, g, 0.35, 1.0);
+  }
+SKSL
+
+effect = Skia::RuntimeEffect.make_for_shader(sksl)
+shader = effect.make_shader
+
+surface = Skia::Surface.make_raster(640, 360)
+paint = Skia::Paint.new
+paint.shader = shader
+
+surface.draw do |canvas|
+  canvas.draw_rect(Skia::Rect.from_wh(640, 360), paint)
+end
+
+surface.save_png('runtime_effect.png')
+puts 'Saved runtime_effect.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/bitmap.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module Skia
+  class Bitmap < Base
+    def initialize(ptr = nil)
+      super(ptr || Native.sk_bitmap_new, nil)
+      @pixel_storage = nil
+    end
+
+    def info
+      info_struct = Native::SKImageInfo.new
+      Native.sk_bitmap_get_info(@ptr, info_struct)
+      ImageInfo.from_struct(info_struct)
+    end
+
+    def width
+      info.width
+    end
+
+    def height
+      info.height
+    end
+
+    def row_bytes
+      Native.sk_bitmap_get_row_bytes(@ptr)
+    end
+
+    def byte_count
+      Native.sk_bitmap_get_byte_count(@ptr)
+    end
+
+    def pixels_ptr
+      Native.sk_bitmap_get_pixels(@ptr, nil)
+    end
+
+    def pixels
+      ptr = pixels_ptr
+      return nil if ptr.nil? || ptr.null?
+
+      ptr.read_bytes(byte_count)
+    end
+
+    def allocated?
+      !Native.sk_bitmap_is_null(@ptr)
+    end
+
+    def immutable?
+      Native.sk_bitmap_is_immutable(@ptr)
+    end
+
+    def immutable=(value)
+      return unless value
+
+      Native.sk_bitmap_set_immutable(@ptr)
+    end
+
+    def alloc_pixels(image_info, flags: nil)
+      info = coerce_image_info(image_info)
+      row_bytes = info.min_row_bytes
+      @pixel_storage = nil
+      return Native.sk_bitmap_try_alloc_pixels_with_flags(@ptr, info.to_struct, flags.to_i) if flags
+
+      Native.sk_bitmap_try_alloc_pixels(@ptr, info.to_struct, row_bytes)
+    end
+
+    def erase(color, rect: nil)
+      color_value = color.is_a?(Color) ? color.to_i : color
+      if rect
+        irect = coerce_irect(rect)
+        Native.sk_bitmap_erase_rect(@ptr, color_value, irect.to_struct)
+      else
+        Native.sk_bitmap_erase(@ptr, color_value)
+      end
+      self
+    end
+
+    def pixel_color(x, y)
+      Color.new(Native.sk_bitmap_get_pixel_color(@ptr, x.to_i, y.to_i))
+    end
+
+    def peek_pixels
+      pixmap = Pixmap.new
+      return nil unless Native.sk_bitmap_peek_pixels(@ptr, pixmap.ptr)
+
+      pixmap
+    end
+
+    def extract_subset(rect)
+      irect = coerce_irect(rect)
+      subset = self.class.new
+      success = Native.sk_bitmap_extract_subset(subset.ptr, @ptr, irect.to_struct)
+      return nil unless success
+
+      subset
+    end
+
+    def make_shader(tile_x: :clamp, tile_y: :clamp, matrix: nil)
+      matrix_struct = matrix&.to_struct
+      sampling = Native::SKSamplingOptions.new
+      sampling[:fMaxAniso] = 0
+      sampling[:fUseCubic] = 0
+      sampling[:fCubicB] = 0.0
+      sampling[:fCubicC] = 0.0
+      sampling[:fFilter] = :nearest
+      sampling[:fMipmap] = :none
+
+      ptr = Native.sk_bitmap_make_shader(@ptr, tile_x, tile_y, sampling, matrix_struct)
+      raise Error, 'Failed to create shader from bitmap' if ptr.nil? || ptr.null?
+
+      Shader.new(ptr)
+    end
+
+    def to_image
+      ptr = Native.sk_image_new_from_bitmap(@ptr)
+      raise Error, 'Failed to create image from bitmap' if ptr.nil? || ptr.null?
+
+      Image.new(ptr)
+    end
+
+    def reset
+      Native.sk_bitmap_reset(@ptr)
+      @pixel_storage = nil
+      self
+    end
+
+    private
+
+    def 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/canvas.rb

@@ -0,0 +1,239 @@
+# 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 reset_matrix
+      Native.sk_canvas_reset_matrix(@ptr)
+      self
+    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 clip_rrect(rrect, op = :intersect, antialias: false)
+      Native.sk_canvas_clip_rrect_with_operation(@ptr, rrect.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_rrect(rrect, paint)
+      Native.sk_canvas_draw_rrect(@ptr, rrect.ptr, 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_arc(oval, start_angle, sweep_angle, use_center, paint)
+      oval_struct = oval.to_struct
+      Native.sk_canvas_draw_arc(@ptr, oval_struct, start_angle.to_f, sweep_angle.to_f, use_center, 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_picture(picture, matrix = nil, paint = nil)
+      matrix_struct = matrix&.to_struct
+      Native.sk_canvas_draw_picture(@ptr, picture.ptr, matrix_struct, 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_point(x, y, paint)
+      Native.sk_canvas_draw_point(@ptr, x.to_f, y.to_f, paint.ptr)
+      self
+    end
+
+    def draw_points(points, paint, mode: :points)
+      return self if points.empty?
+
+      point_structs = points.map { |point| coerce_point(point).to_struct }
+      points_ptr = FFI::MemoryPointer.new(Native::SKPoint, point_structs.length)
+
+      point_structs.each_with_index do |point_struct, index|
+        destination = Native::SKPoint.new(points_ptr + (index * Native::SKPoint.size))
+        destination[:x] = point_struct[:x]
+        destination[:y] = point_struct[:y]
+      end
+
+      Native.sk_canvas_draw_points(@ptr, mode, point_structs.length, points_ptr, 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 draw_text_blob(blob, x, y, paint)
+      Native.sk_canvas_draw_text_blob(@ptr, blob.ptr, x.to_f, y.to_f, 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
+
+    private
+
+    def coerce_point(point)
+      return point if point.is_a?(Point)
+      return Point.new(point[0], point[1]) if point.is_a?(Array) && point.length == 2
+
+      raise ArgumentError, 'point must be Skia::Point or [x, y]'
+    end
+  end
+end