rays 0.3.11 → 0.3.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9ccc3b9eda8d2da41df31850e7ab6a6e480936ad80dfff07adaf35e5d12c8eee
-  data.tar.gz: 46785a8507b11be71d877a87fb8f7a42478d19190086701e748978e040a16ad3
+  metadata.gz: be106158650d37c835a8396c0ce079a3bc829f6fdd10fed78153f5bba6e0246d
+  data.tar.gz: 833c9b8cd83d1e484d8424991cffd89af1a4af0a31eead4cfe8ea52db0dacead
 SHA512:
-  metadata.gz: 505a1f2e9a2e3a1aea29b4e69528c4741ce0ad956f9c2e7fafa67bf528b6b25c51e6d7371624d52f3a4a8e0e8fa8aab1388d76775b03445f4882af49dd3b18d0
-  data.tar.gz: 51d70c57b927a3b8564718170962d41d36ca7f9a5b209f71c6d72e23bcd6278b8bbf73181909084bb973d2fb72aa4d7172e8ee218407ebf7236c74bb46530e6f
+  metadata.gz: ff626e5099d975fa64f4990d3c4ee12265612dde05b56103354f1cbbbbba6653770c183b262b757d103bf3e1c31824813d1afe66b3445c33090448587c81441a
+  data.tar.gz: 590f20a70dc9505ab609482ce98ff7fbcc9eddbdf03271597869dfadbec55a307f775327c41ffa7f630eef5d7dc7c0c6344d78070e9c5888f2c3bdef0f1de7cf

data/.doc/ext/rays/image.cpp

@@ -122,6 +122,15 @@ VALUE get_smooth(VALUE self)
 	return value(THIS->smooth());
 }
 
+static
+VALUE compare(VALUE self, VALUE other)
+{
+	CHECK;
+	auto* a = THIS->self.get();
+	auto* b = to<const Rays::Image*>(other)->self.get();
+	return value(a < b ? -1 : a > b ? 1 : 0);
+}
+
 static
 VALUE load(VALUE self, VALUE path)
 {
@@ -149,6 +158,7 @@ Init_rays_image ()
 	rb_define_private_method(cImage, "get_bitmap", RUBY_METHOD_FUNC(get_bitmap), 1);
 	rb_define_method(cImage, "smooth=", RUBY_METHOD_FUNC(set_smooth), 1);
 	rb_define_method(cImage, "smooth", RUBY_METHOD_FUNC(get_smooth), 0);
+	cImage.define_method("<=>", compare);
 	cImage.define_module_function("load!", load);
 }
 

data/.doc/ext/rays/painter.cpp

@@ -250,7 +250,17 @@ VALUE image(VALUE self)
 	CHECK;
 	check_arg_count(__FILE__, __LINE__, "Painter#image", argc, 1, 3, 5, 7, 9);
 
-	const Rays::Image* image = to<Rays::Image*>(argv[0]);
+	RUCY_SYM(to_image);
+	std::unique_ptr<Rays::Image> pimage;
+
+	const Rays::Image* image = NULL;
+	if (argv[0].is_a(Rays::image_class()))
+		image = to<Rays::Image*>(argv[0]);
+	else if (argv[0].respond_to(to_image))
+	{
+		pimage.reset(new Rays::Image(to<const Rays::Image&>(argv[0].call(to_image))));
+		image = pimage.get();
+	}
 	if (!image)
 		argument_error(__FILE__, __LINE__, "%s is not an image.", argv[0].inspect().c_str());
 
@@ -742,6 +752,38 @@ VALUE pop_matrix(VALUE self)
 }
 
 
+static
+VALUE set_debug(VALUE self, VALUE debug)
+{
+	CHECK;
+	if (debug)
+		THIS->remove_flag(Rays::Painter::FLAG_BATCHING);
+	else
+		THIS->   add_flag(Rays::Painter::FLAG_BATCHING);
+	return debug;
+}
+
+static
+VALUE get_debug(VALUE self)
+{
+	CHECK;
+	return value(!THIS->has_flag(Rays::Painter::FLAG_BATCHING));
+}
+
+static
+VALUE set_global_debug(VALUE self, VALUE debug)
+{
+	Rays::Painter::set_debug(debug);
+	return debug;
+}
+
+static
+VALUE get_global_debug(VALUE self)
+{
+	return value(Rays::Painter::debug());
+}
+
+
 static Class cPainter;
 
 void
@@ -822,6 +864,12 @@ Init_rays_painter ()
 	rb_define_method(cPainter, "matrix", RUBY_METHOD_FUNC(get_matrix), 0);
 	rb_define_method(cPainter, "push_matrix", RUBY_METHOD_FUNC(push_matrix), 0);
 	rb_define_method(cPainter, "pop_matrix", RUBY_METHOD_FUNC(pop_matrix), 0);
+
+	rb_define_method(cPainter, "debug=", RUBY_METHOD_FUNC(set_debug), 1);
+	cPainter.define_method("debug?", get_debug);
+
+	rb_define_singleton_method(cPainter, "debug=", RUBY_METHOD_FUNC(set_global_debug), 1);
+	cPainter.define_singleton_method("debug?", get_global_debug);
 }
 
 

data/.doc/ext/rays/shader.cpp

@@ -66,15 +66,17 @@ make_env (const Value& names, const Value& ignore_no_uniform_location_error)
 		to_name_list(names, 0),
 		to_name_list(names, 1),
 		to_name_list(names, 2),
-		to_name(     names, 3),
-		to_name(     names, 4),
+		to_name_list(names, 3),
+		to_name_list(names, 4),
 		to_name(     names, 5),
-		to_name_list(names, 6),
-		to_name_list(names, 7),
-		to_name_list(names, 8),
-		to_name_list(names, 9),
+		to_name(     names, 6),
+		to_name(     names, 7),
+		to_name(     names, 8),
+		to_name(     names, 9),
 		to_name_list(names, 10),
 		to_name_list(names, 11),
+		to_name_list(names, 12),
+		to_name_list(names, 13),
 		flags);
 }
 

data/.github/workflows/release-gem.yml

@@ -4,6 +4,9 @@ on:
   push:
     tags: ['v[0-9]*']
 
+permissions:
+  contents: write
+
 jobs:
   release:
     runs-on: macos-latest
@@ -33,23 +36,9 @@ jobs:
           echo path=$(ruby -e 'print Dir.glob("*.gem").first') >> $GITHUB_OUTPUT
 
       - name: create github release
-        id: release
-        uses: actions/create-release@v1
         env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          tag_name: ${{ github.ref }}
-          release_name: ${{ github.ref }}
-
-      - name: upload to github release
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ steps.release.outputs.upload_url }}
-          asset_path: ./${{ steps.gem.outputs.path }}
-          asset_name:   ${{ steps.gem.outputs.path }}
-          asset_content_type: application/zip
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: ruby -I.github/workflows -rutils -e 'release(*ARGV)' ./${{ steps.gem.outputs.path }}
 
       - name: upload to rubygems
         env:

data/.github/workflows/utils.rb

@@ -1,3 +1,9 @@
+require 'shellwords'
+
+ALL_REPO        = 'xord/all'
+ALL_DIR         = '../all'
+ALL_FETCH_DEPTH = 100
+
 RENAMES = {reflex: 'reflexion'}
 
 def sh(cmd)
@@ -5,7 +11,7 @@ def sh(cmd)
   system cmd
 end
 
-def setup_dependencies(build: true, only: nil)
+def setup_dependencies(only: nil)
   gemspec_path = `git ls-files`.lines(chomp: true).find {|l| l =~ /\.gemspec$/}
   return unless gemspec_path
 
@@ -13,44 +19,109 @@ def setup_dependencies(build: true, only: nil)
   name    = File.basename gemspec_path, '.gemspec'
 
   exts = File.readlines('Rakefile')
-    .map {|l| l[%r|^\s*require\W+(\w+)/extension\W+$|, 1]}
+    .map {|l| l[%r|^\s*require\W+([\w\-\_]+)/extension\W+$|, 1]}
     .compact
     .reject {|ext| ext == name}
   exts = exts & [only].flatten.map(&:to_s) if only
+  return if exts.empty?
+
+  unless setup_dependencies_via_monorepo(exts)
+    setup_dependencies_via_each_repo_by_version(gemspec, exts)
+  end
+
+  exts.each {|ext| sh %( cd ../#{ext} && rake ext )}
+end
+
+def setup_dependencies_via_monorepo(exts)
+  return false unless checkout_monorepo
+  exts.each {|ext| sh %( ln -snf all/#{ext} ../#{ext} )}
+  true
+end
+
+def checkout_monorepo()
+  uuid = `git log -1 --format=%B`[/^\[\[([0-9a-fA-F-]+)\]\]$/, 1]
+  return false unless uuid
+
+  commit = setup_monorepo uuid
+  return false unless commit
+
+  Dir.chdir(ALL_DIR) {sh %( git checkout -q #{commit} )}
+  true
+end
+
+def setup_monorepo(uuid)
+  unless File.directory? ALL_DIR
+    url = "https://github.com/#{ALL_REPO}.git"
+    sh %( git clone --no-tags --depth #{ALL_FETCH_DEPTH} #{url} #{ALL_DIR} )
+  end
+  loop do
+    commit = find_monorepo_commit uuid
+    return commit if commit
+
+    deepened = Dir.chdir ALL_DIR do
+      before = `git rev-list --count HEAD`.to_i
+      sh %( git fetch --deepen #{ALL_FETCH_DEPTH} )
+      `git rev-list --count HEAD`.to_i > before
+    end
+    return nil unless deepened
+  end
+end
+
+def find_monorepo_commit(uuid)
+  Dir.chdir ALL_DIR do
+    out = `git log origin/HEAD -F --grep="[[#{uuid}]]" --format=%H -1`.strip
+    out.empty? ? nil : out
+  end
+end
 
+def setup_dependencies_via_each_repo_by_version(gemspec, exts)
   exts.each do |ext|
     gem   = RENAMES[ext.to_sym].then {|s| s || ext}
-    ver   = gemspec[/add_dependency.*['"]#{gem}['"].*['"]\s*>=\s*([\d\.]+)\s*['"]/, 1]
+    ver   = gemspec[/add_dependency.*['"]#{gem}['"].*['"]\s*~>\s*([\d\.]+)\s*['"]/, 1]
     opts  = '-c advice.detachedHead=false --depth 1'
     clone = "git clone #{opts} https://github.com/xord/#{ext}.git ../#{ext}"
 
     # 'rake subtree:push' pushes all subrepos, so cloning by new tag
     # often fails before tagging each new tag
     sh %( #{clone} --branch v#{ver} || #{clone} )
-    sh %( cd ../#{ext} && rake ext )
   end
 end
 
 def tag_versions()
-  tags = `git tag`.lines chomp: true
-  vers = `git log --oneline ./VERSION`
+  changes = changelogs
+  tags    = `git tag`.lines chomp: true
+  vers    = `git log --oneline ./VERSION`
     .lines(chomp: true)
     .map {|line| line.split.first[/^\w+$/]}
-    .map {|hash| [`git cat-file -p #{hash}:./VERSION 2>/dev/null`[/[\d\.]+/], hash]}
-    .select {|ver, hash| ver && hash}
+    .map {|sha| [`git cat-file -p #{sha}:./VERSION 2>/dev/null`[/[\d\.]+/], sha]}
+    .select {|ver, sha| ver && sha}
     .reverse
     .to_h
 
-  changes = File.read('ChangeLog.md')
-    .split(/^\s*##\s*\[\s*v([\d\.]+)\s*\].*$/)
-    .slice(1..-1)
-    .each_slice(2)
-    .to_h
-    .transform_values(&:strip!)
-
-  vers.to_a.reverse.each do |ver, hash|
+  vers.to_a.reverse.each do |ver, sha|
     tag = "v#{ver}"
     break if tags.include?(tag)
-    sh %( git tag -a -m \"#{changes[ver]&.gsub '"', '\\"'}\" #{tag} #{hash} )
+    sh %( git tag -a -m \"#{changes[tag]&.gsub '"', '\\"'}\" #{tag} #{sha} )
   end
 end
+
+def release(*paths)
+  tag   = ENV['GITHUB_REF']&.sub(%r|^refs/tags/|, '') || raise('GITHUB_REF tag not set')
+  notes = (changelogs[tag] || '').shellescape
+  paths = paths.flatten.join ' '
+
+  sh(%( gh release create #{tag} #{paths} --notes #{notes} )) ||
+    sh(%( gh release upload #{tag} #{paths} --clobber )) ||
+    raise('failed to upload to releases')
+end
+
+def changelogs()
+  File.read('ChangeLog.md')
+    .split(/^\s*##\s*\[\s*(v[\d\.]+)\s*\].*$/)
+    .slice(1..)
+    .each_slice(2)
+    .to_h
+    .transform_values(&:strip!)
+rescue Errno::ENOENT
+  raise 'failed to get changelogs'
+end

data/ChangeLog.md

@@ -1,6 +1,32 @@
 # rays ChangeLog
 
 
+## [v0.3.13] - 2026-05-17
+
+- Improve batch rendering: defer flush until state actually changes
+- Rewrite README.md
+- CI: Migrate release-gem.yml from actions/create-release to gh release create
+
+- Fix text rendering corruption when batching is enabled
+
+
+## [v0.3.12] - 2026-05-10
+
+- Support WebAssembly
+- Implement batch rendering
+- Implement WASM font rendering via HTMLCanvasElement
+- Implement SDL_ttf font rendering for SDL backend
+- Use GL_DEPTH_COMPONENT16 on WASM builds
+- Rename texcoord_offset to texcoord_pixel
+- Pin external library versions
+- Add Image and Texture comparison operators
+- Add Painter::set_debug / debug singleton API
+- Pin position attribute to location 0 on macOS
+- Simplify Painter_draw_image to fill-only
+- Add libsdl2-ttf-dev to CI apt packages
+- Remove deprecated has_rdoc= from gemspecs
+
+
 ## [v0.3.11] - 2026-04-17
 
 - Move OpenGL code into src/opengl/ and introduce Renderer abstraction

data/README.md

@@ -1,4 +1,4 @@
-# Rays - A Drawing Engine using OpenGL.
+# Rays - A 2D drawing engine on OpenGL
 
 [![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/xord/rays)
 ![License](https://img.shields.io/github/license/xord/rays)
@@ -21,18 +21,39 @@ Thanks for your support! 🙌
 
 ## 🚀 About
 
-**Rays** is a drawing engine that utilizes OpenGL for 2D rendering.
+**Rays** is a hardware-accelerated 2D drawing engine for Ruby. It is built on OpenGL and exposes a retained-mode-friendly API: build `Polygon`, `Polyline`, `Image`, `Shader`, and `Font` objects, then paint them into an off-screen `Image` (or a window provided by [Reflex](https://github.com/xord/reflex)) through a `Painter`.
 
-It is designed to provide efficient graphics capabilities, making it ideal for creating complex visualizations and graphics applications.
+It is the rendering layer used by [Reflex](https://github.com/xord/reflex), [Processing](https://github.com/xord/processing), [RubySketch](https://github.com/xord/rubysketch), and [Reight](https://github.com/xord/reight). Like the rest of the `xord/*` family, it is primarily developed for our own use, but it also works as a standalone drawing gem.
+
+## 📋 Requirements
+
+- Ruby **3.0.0** or later
+- A C++ compiler with C++20 support
+- [Xot](https://rubygems.org/gems/xot) and [Rucy](https://rubygems.org/gems/rucy) (declared as runtime dependencies)
+- Platform graphics backend:
+  - **macOS** — AppKit, OpenGL, AVFoundation (bundled with the OS)
+  - **iOS** — UIKit, OpenGL ES, AVFoundation (bundled with the OS)
+  - **Windows** — GDI32, OpenGL32, GLEW (`MINGW_PACKAGE_PREFIX-glew`)
+  - **Linux** — `libsdl2-dev`, `libsdl2-ttf-dev`, `libglew-dev`
+
+The following third-party libraries are cloned from GitHub and statically linked while the native extension is being built, so you do not need to install them separately:
+
+| Library                                                       | Role                                              |
+| ------------------------------------------------------------- | ------------------------------------------------- |
+| [GLM](https://github.com/g-truc/glm)                          | Vector / matrix math used internally              |
+| [Clipper](https://github.com/skyrpex/clipper)                 | Polygon Boolean operations (`+`, `-`, `&`, `\|`, `^`) |
+| [earcut.hpp](https://github.com/mapbox/earcut.hpp)            | Polygon triangulation                             |
+| [splines-lib](https://github.com/andrewwillmott/splines-lib)  | Curve / spline math                               |
+| [stb](https://github.com/nothings/stb) (Windows / Linux only) | Image file loading                                |
 
 ## 📦 Installation
 
 Add this line to your Gemfile:
 ```ruby
-$ gem 'rays'
+gem 'rays'
 ```
 
-Then, install gem:
+Then install:
 ```bash
 $ bundle install
 ```
@@ -42,7 +63,145 @@ Or install it directly:
 $ gem install rays
 ```
 
+`require 'rays'` automatically calls `Rays.init!` and registers `Rays.fin!` at exit. Set `$RAYS_NOAUTOINIT = true` before requiring if you want to manage the lifetime yourself.
+
+Rays needs a current OpenGL context. When used through [Reflex](https://github.com/xord/reflex), the window creates and binds a context for you. To use Rays standalone for off-screen rendering, it allocates a hidden context automatically.
+
+## 📚 What's Included
+
+### Geometry and color types
+
+| Class                | Purpose                                                          |
+| -------------------- | ---------------------------------------------------------------- |
+| `Rays::Point`        | 2D / 3D point with arithmetic operators                          |
+| `Rays::Bounds`       | Axis-aligned rectangle (position + size)                         |
+| `Rays::Color`        | RGBA color in floating-point components                          |
+| `Rays::ColorSpace`   | Pixel format / color space descriptor (RGBA, ARGB, GRAY, ...)    |
+| `Rays::Matrix`       | 4×4 transformation matrix                                        |
+
+### Drawing primitives
+
+| Class                | Purpose                                                                                      |
+| -------------------- | -------------------------------------------------------------------------------------------- |
+| `Rays::Polyline`     | A single open or closed polyline; expandable into a stroked polygon                          |
+| `Rays::Polygon`      | One or more polylines forming a closed shape; supports Boolean ops via `+`, `-`, `&`, `\|`, `^` |
+| `Rays::Image`        | A renderable texture with an associated `Painter` for off-screen drawing                     |
+| `Rays::Bitmap`       | CPU-side pixel buffer that can be uploaded to / downloaded from an `Image`                   |
+| `Rays::Font`         | Text rendering — created from a system font name and a size                                  |
+| `Rays::Shader`       | GLSL fragment / vertex shader with `set_uniform` / `uniform` for parameters                  |
+| `Rays::Camera`       | Live camera capture (per platform) rendered into an `Image`                                  |
+
+### The `Painter`
+
+`Rays::Painter` is the immediate-mode drawing surface. Obtain one through `Image#painter`, then between `painter.paint do |p| ... end` (or `begin_paint` / `end_paint`) issue draw calls:
+
+- **Shapes** — `point`, `line`, `rect`, `ellipse`, `curve`, `bezier`, `triangle`, `quad`, `polygon`
+- **Bitmaps & text** — `image`, `text`
+- **State** — `fill`, `stroke`, `background`, `stroke_width`, `stroke_cap`, `stroke_join`, `blend_mode`, `clip`, `font`, `texture`, `shader`
+- **Transforms** — `translate`, `scale`, `rotate`, `set_matrix`
+- **Push / pop** — `push(:state, :matrix)` / `pop`, or the block form `push(fill: ..., stroke: ...) { ... }`
+
+`stroke_cap`, `stroke_join`, `blend_mode`, `texcoord_mode`, `texcoord_wrap` accept symbols (e.g. `:round`, `:miter`, `:multiply`).
+
+### Top-level helpers
+
+- `Rays.init!` / `Rays.fin!` — explicit lifecycle (called automatically on `require`)
+- `Rays::Image.load(path)` / `Rays::Image#save(path)` — image file I/O
+- `Rays.renderer_info` — debug info about the current OpenGL context
+
+## 💡 Usage
+
+### Draw to an off-screen image and save it
+
+```ruby
+require 'rays'
+
+image = Rays::Image.new(200, 200)
+image.paint do |p|
+  p.background 0, 0, 0
+  p.fill   1, 0.4, 0.1     # orange-ish
+  p.stroke 1, 1, 1
+  p.stroke_width 4
+
+  p.rect 20, 20, 160, 160, round: 16
+  p.ellipse 100, 100, 60, 60
+end
+
+image.save 'out.png'
+```
+
+### Compose a polygon from Boolean operations
+
+```ruby
+require 'rays'
+
+a = Rays::Polygon.rect(0, 0, 100, 100)
+b = Rays::Polygon.ellipse(50, 50, 80, 80)
+
+union        = a | b   # outer outline of both
+difference   = a - b   # rectangle with circular bite
+intersection = a & b   # lens-shaped overlap
+xor          = a ^ b   # everything except the overlap
+
+Rays::Image.new(140, 140).paint {|p| p.fill 1; p.polygon difference }.save 'diff.png'
+```
+
+(The C++ operator names map to Ruby's `|`, `-`, `&`, `^`.)
+
+### Use a fragment shader
+
+```ruby
+require 'rays'
+
+invert = Rays::Shader.new <<~GLSL
+  uniform sampler2D texture;
+  varying vec4 vTexCoord;
+  void main() {
+    vec4 c = texture2D(texture, vTexCoord.xy);
+    gl_FragColor = vec4(1.0 - c.rgb, c.a);
+  }
+GLSL
+
+src = Rays::Image.load('photo.png')
+out = Rays::Image.new(src.width, src.height)
+out.paint do |p|
+  p.shader = invert
+  p.image src
+end
+out.save 'photo-invert.png'
+```
+
+### Drive `push` / `pop` with attributes
+
+```ruby
+image.paint do |p|
+  p.push(:state, :matrix, fill: [1, 0, 0]) do
+    p.translate 50, 50
+    p.rotate 30
+    p.rect -20, -20, 40, 40
+  end
+  # fill, state, and matrix are restored here
+end
+```
+
+## 🛠️ Development
+
+```bash
+$ rake vendor   # clone the external libraries into vendor/
+$ rake lib      # build the native C++ library (librays)
+$ rake ext      # build the Ruby C extension
+$ rake test     # run the test suite
+$ rake doc      # generate RDoc from C++ sources
+$ rake          # default: builds the extension
+```
+
+The drawing tests render into off-screen images and compare pixels, so they require a working OpenGL context. The `test_rays_init.rb` test must run in its own process and is listed in `TESTS_ALONE`.
+
+In the [`xord/all`](https://github.com/xord/all) monorepo you can scope by module, e.g. `rake rays test`.
+
 ## 📜 License
 
 **Rays** is licensed under the MIT License.
 See the [LICENSE](./LICENSE) file for details.
+
+The third-party libraries listed above retain their own licenses (all MIT-compatible: MIT, ISC, Boost-1.0, dual-licensed MIT/Happy-Bunny for GLM, Unlicense for splines-lib).

data/Rakefile

@@ -16,7 +16,7 @@ TESTS_ALONE = ['test/test_rays_init.rb']
 
 install_packages(
   mingw: %w[MINGW_PACKAGE_PREFIX-glew],
-  apt:   %w[libglew-dev libsdl2-dev])
+  apt:   %w[libglew-dev libsdl2-dev libsdl2-ttf-dev])
 
 use_external_library 'https://github.com/g-truc/glm',
   tag:     '1.0.1',
@@ -29,7 +29,7 @@ use_external_library 'https://github.com/skyrpex/clipper',
   excludes: 'clipper/cpp/cpp_'
 
 use_external_library 'https://github.com/mapbox/earcut.hpp',
-  tag:     'v2.2.4',
+  commit:  '365be263bfed498f9d3d3bf065bcb39b0d0e4ba6',
   incdirs: 'include/mapbox',
   srcdirs: 'NOSRC'
 
@@ -44,7 +44,7 @@ use_external_library 'https://github.com/andrewwillmott/splines-lib',
     end
   }
 
-if win32? || linux?
+if win32? || linux? || wasm?
   use_external_library 'https://github.com/nothings/stb',
     commit:  'ae721c50eaf761660b4f90cc590453cdb0c2acd0',
     srcdirs: 'NOSRC'

data/VERSION

@@ -1 +1 @@
-0.3.11
+0.3.13

data/ext/rays/extconf.rb

@@ -13,11 +13,10 @@ Xot::ExtConf.new Xot, Rucy, Rays do
   setup do
     headers    << 'ruby.h'
     libs.unshift 'gdi32', 'opengl32', 'glew32'           if win32?
-    libs.unshift 'SDL2', 'GLEW', 'GL'                    if linux?
+    libs.unshift 'SDL2', 'SDL2_ttf', 'GLEW', 'GL'        if linux? || wasm?
     frameworks << 'AppKit' << 'OpenGL' << 'AVFoundation' if osx?
-
-    $CPPFLAGS << ' -DRAYS_32BIT_PIXELS_STRING'      if RUBY_PLATFORM == 'x64-mingw-ucrt'
-    $LDFLAGS  << ' -Wl,--out-implib=rays_ext.dll.a' if mingw? || cygwin?
+    $CPPFLAGS << ' -DRAYS_32BIT_PIXELS_STRING'           if RUBY_PLATFORM == 'x64-mingw-ucrt'
+    $LDFLAGS  << ' -Wl,--out-implib=librays.dll.a'       if mingw? || cygwin?
   end
 
   create_makefile 'rays_ext'

data/ext/rays/image.cpp

@@ -134,6 +134,16 @@ RUCY_DEF0(get_smooth)
 }
 RUCY_END
 
+static
+RUCY_DEF1(compare, other)
+{
+	CHECK;
+	auto* a = THIS->self.get();
+	auto* b = to<const Rays::Image*>(other)->self.get();
+	return value(a < b ? -1 : a > b ? 1 : 0);
+}
+RUCY_END
+
 static
 RUCY_DEF1(load, path)
 {
@@ -162,6 +172,7 @@ Init_rays_image ()
 	cImage.define_private_method("get_bitmap", get_bitmap);
 	cImage.define_method("smooth=", set_smooth);
 	cImage.define_method("smooth",  get_smooth);
+	cImage.define_method("<=>", compare);
 	cImage.define_module_function("load!", load);
 }