rays 0.3.11 → 0.3.12

data/src/sdl/rays.cpp

@@ -2,6 +2,7 @@
 
 
 #include <SDL.h>
+#include <SDL_ttf.h>
 #include "rays/exception.h"
 #include "rays/debug.h"
 #include "../renderer.h"
@@ -28,6 +29,9 @@ namespace Rays
 		if (SDL_Init(SDL_INIT_VIDEO) < 0)
 			rays_error(__FILE__, __LINE__, SDL_GetError());
 
+		if (TTF_Init() < 0)
+			rays_error(__FILE__, __LINE__, "TTF_Init failed: %s", TTF_GetError());
+
 		Renderer_init();
 
 		global::initialized = true;
@@ -41,6 +45,7 @@ namespace Rays
 
 		Renderer_fin();
 
+		//TTF_Quit();
 		SDL_Quit();
 
 		global::initialized = false;

data/src/texture.h

@@ -19,6 +19,8 @@ namespace Rays
 	class Texture
 	{
 
+		typedef Texture This;
+
 		public:
 
 			Texture ();
@@ -53,6 +55,10 @@ namespace Rays
 
 			bool operator ! () const;
 
+			friend bool operator == (const This& lhs, const This& rhs);
+
+			friend bool operator != (const This& lhs, const This& rhs);
+
 			struct Data;
 
 			Xot::PSharedImpl<Data> self;

data/test/test_painter.rb

@@ -193,43 +193,54 @@ class TestPainter < Test::Unit::TestCase
   end
 
   def test_clip_accessor()
-    pa = painter
-    pa.clip = [1, 2, 3, 4]
-    assert_equal [1, 2, 3, 4], pa.clip.to_a
-    pa.clip = [5, 6, 7, 8]
-    assert_equal [5, 6, 7, 8], pa.clip.to_a
-    pa.clip    1, 2, 3, 4
-    assert_equal [1, 2, 3, 4], pa.clip.to_a
-    pa.push clip: [5, 6, 7, 8] do |_|
+    pa      = painter
+    pa.clip =      [1, 2, 3, 4]
+    assert_equal   [1, 2, 3, 4], pa.clip.to_a
+    pa.clip =      [5, 6, 7, 8]
+    assert_equal   [5, 6, 7, 8], pa.clip.to_a
+    pa.clip         1, 2, 3, 4
+    assert_equal   [1, 2, 3, 4], pa.clip.to_a
+    pa.push clip:  [5, 6, 7, 8] do |_|
       assert_equal [5, 6, 7, 8], pa.clip.to_a
     end
-    assert_equal [1, 2, 3, 4], pa.clip.to_a
+    assert_equal   [1, 2, 3, 4], pa.clip.to_a
   end
 
   def test_font_accessor()
-    pa = painter
+    pa       = painter
     f10, f20 = font(nil, 10), font(nil, 20)
-    pa.font = f10
-    assert_equal f10, pa.font
-    pa.font = f20
-    assert_equal f20, pa.font
-    pa.font   f10
-    assert_equal f10, pa.font
-    pa.push font: f20 do |_|
+    pa.font  =     f10
+    assert_equal   f10, pa.font
+    pa.font  =     f20
+    assert_equal   f20, pa.font
+    pa.font        f10
+    assert_equal   f10, pa.font
+    pa.push font:  f20 do |_|
       assert_equal f20, pa.font
     end
-    assert_equal f10, pa.font
+    assert_equal   f10, pa.font
   end
 
   def test_font_name_size()
     pa = painter
-    pa.font "Arial", 10
-    assert_equal "Arial", pa.font.name
-    assert_equal 10, pa.font.size
-    pa.font nil
-    assert_not_equal "Arial", pa.font.name
-    pa.font nil, 20
-    assert_equal 20, pa.font.size
+    pa.font          "Arial", 10
+    assert_equal     "Arial",     pa.font.name
+    assert_equal              10, pa.font.size
+    pa.font          nil
+    assert_not_equal "Arial",     pa.font.name
+    assert_not_equal          10, pa.font.size
+    pa.font          nil,     20
+    assert_not_equal "Arial",     pa.font.name
+    assert_equal              20, pa.font.size
+  end
+
+  def test_debug_accessor()
+    pa       = painter
+    assert_false pa.debug?
+    pa.debug = true
+    assert_true  pa.debug?
+    pa.debug = false
+    assert_false pa.debug?
   end
 
   def test_color_by_name()

data/test/test_painter_batch.rb

@@ -0,0 +1,254 @@
+require_relative 'helper'
+
+
+class TestPainterBatch < Test::Unit::TestCase
+
+  def image(w = 16, h = 16, bg: 0, &block)
+    Rays::Image.new(w, h)
+      .paint {background bg}
+      .tap {|img| img.paint {stroke nil; instance_eval(&block)} if block}
+  end
+
+  def assert_gray(expected, actual, message = nil)
+    assert_in_epsilon expected, actual, 0.02, message
+  end
+
+  def assert_rgb(expected, actual)
+    (0..2).each do |i|
+      assert_gray expected[i], actual[i], "Expected: #{expected}, Actual: #{actual}"
+    end
+  end
+
+  def assert_equal_batched_and_unbatched(w, h, &block)
+    batched   = image(w, h, bg: 0, &block)
+    unbatched = image(w, h, bg: 0) {|p| p.debug = true; p.instance_eval(&block)}
+    assert_equal unbatched.bitmap.pixels, batched.bitmap.pixels, "Pixel mismatch"
+  end
+
+  def test_match_fill_rects()
+    assert_equal_batched_and_unbatched(16, 16) do
+      fill 1, 0, 0
+      rect 0, 0, 8, 16
+      fill 0, 1, 0
+      rect 8, 0, 8, 16
+    end
+  end
+
+  def test_match_stroke_rects()
+    assert_equal_batched_and_unbatched(16, 16) do
+      no_fill
+      stroke 1, 0, 0
+      rect 0, 0, 8, 16
+      stroke 0, 1, 0
+      rect 8, 0, 8, 16
+    end
+  end
+
+  def test_match_translated_rects()
+    assert_equal_batched_and_unbatched(16, 16) do
+      fill 1, 0, 0
+      rect 0, 0, 8, 16
+      translate 8, 0
+      fill 0, 1, 0
+      rect 0, 0, 8, 16
+    end
+  end
+
+  def test_match_scaled_rects()
+    assert_equal_batched_and_unbatched(16, 16) do
+      scale 2, 1
+      fill 1, 0, 0
+      rect 0, 0, 4, 16
+      fill 0, 1, 0
+      rect 4, 0, 4, 16
+    end
+  end
+
+  def test_match_rotated_rects()
+    assert_equal_batched_and_unbatched(16, 16) do
+      fill 1, 0, 0
+      rect 0, 0, 16, 8
+      translate 8, 8
+      rotate 180
+      translate(-8, -8)
+      fill 0, 1, 0
+      rect 0, 0, 16, 8
+    end
+  end
+
+  def test_match_many_rects()
+    assert_equal_batched_and_unbatched(16, 16) do
+      8.times do |x|
+        fill x / 7.0, 0, 0
+        rect x * 2, 0, 2, 16
+      end
+    end
+  end
+
+  def test_match_image_draw()
+    img = image(4, 4) {fill 1, 0, 0; rect 0, 0, 4, 4}
+    assert_equal_batched_and_unbatched(8, 8) do
+      fill 1
+      image img, 2, 2, 4, 4
+    end
+  end
+
+  def test_match_image_partial_draw()
+    img = image(4, 4) {
+      fill 1, 0, 0; rect 0, 0, 2, 4
+      fill 0, 1, 0; rect 2, 0, 2, 4
+    }
+    assert_equal_batched_and_unbatched(2, 4) do
+      fill 1
+      image img, 0, 0, 2, 4, 0, 0, 2, 4
+    end
+  end
+
+  def test_match_image_multiple()
+    r = image(4, 4) {fill 1, 0, 0; rect 0, 0, 4, 4}
+    g = image(4, 4) {fill 0, 1, 0; rect 0, 0, 4, 4}
+    assert_equal_batched_and_unbatched(8, 4) do
+      fill 1
+      image r, 0, 0
+      image g, 4, 0
+    end
+  end
+
+  def test_match_image_translated()
+    img = image(4, 4) {fill 1, 0, 0; rect 0, 0, 4, 4}
+    assert_equal_batched_and_unbatched(8, 8) do
+      fill 1
+      translate 4, 0
+      image img, 0, 0
+    end
+  end
+
+  def test_match_atlas_sub_regions()
+    atlas = image(8, 4) do
+      fill 1, 0, 0; rect 0, 0, 4, 4
+      fill 0, 1, 0; rect 4, 0, 4, 4
+    end
+    assert_equal_batched_and_unbatched(8, 4) do
+      fill 1
+      image atlas, 0, 0, 4, 4, 0, 0, 4, 4
+      image atlas, 4, 0, 4, 4, 4, 0, 4, 4
+    end
+  end
+
+  def test_match_atlas_sub_regions_reversed_order()
+    atlas = image(8, 4) do
+      fill 1, 0, 0; rect 0, 0, 4, 4
+      fill 0, 1, 0; rect 4, 0, 4, 4
+    end
+    assert_equal_batched_and_unbatched(8, 4) do
+      fill 1
+      image atlas, 4, 0, 4, 4, 0, 0, 4, 4
+      image atlas, 0, 0, 4, 4, 4, 0, 4, 4
+    end
+  end
+
+  def test_match_atlas_four_regions()
+    atlas = image(4, 4) do
+      fill 1, 0, 0; rect 0, 0, 2, 2
+      fill 0, 1, 0; rect 2, 0, 2, 2
+      fill 0, 0, 1; rect 0, 2, 2, 2
+      fill 1, 1, 0; rect 2, 2, 2, 2
+    end
+    assert_equal_batched_and_unbatched(8, 8) do
+      fill 1
+      image atlas, 0, 0, 2, 2, 0, 0, 4, 4
+      image atlas, 2, 0, 2, 2, 4, 0, 4, 4
+      image atlas, 0, 2, 2, 2, 0, 4, 4, 4
+      image atlas, 2, 2, 2, 2, 4, 4, 4, 4
+    end
+  end
+
+  def test_match_atlas_scaled_draw()
+    atlas = image(4, 4) do
+      fill 1, 0, 0; rect 0, 0, 2, 4
+      fill 0, 1, 0; rect 2, 0, 2, 4
+    end
+    assert_equal_batched_and_unbatched(16, 8) do
+      fill 1
+      image atlas, 0, 0, 2, 4, 0, 0, 8, 8
+      image atlas, 2, 0, 2, 4, 8, 0, 8, 8
+    end
+  end
+
+  def test_match_atlas_with_translate()
+    atlas = image(8, 4) do
+      fill 1, 0, 0; rect 0, 0, 4, 4
+      fill 0, 1, 0; rect 4, 0, 4, 4
+    end
+    assert_equal_batched_and_unbatched(8, 4) do
+      fill 1
+      translate 4, 0
+      image atlas, 0, 0, 4, 4, 0, 0, 4, 4
+    end
+  end
+
+  def test_match_rects_and_images_interleaved()
+    img = image(4, 4) {fill 0, 0, 1; rect 0, 0, 4, 4}
+    assert_equal_batched_and_unbatched(16, 4) do
+      fill 1, 0, 0
+      rect 0, 0, 4, 4
+      fill 1
+      image img, 4, 0
+      fill 0, 1, 0
+      rect 8, 0, 4, 4
+    end
+  end
+
+  def test_match_blend_mode()
+    assert_equal_batched_and_unbatched(16, 16) do
+      fill 0.5
+      rect 0, 0, 16, 16
+      blend_mode :add
+      fill 0.2
+      rect 0, 0, 8, 16
+    end
+  end
+
+  def test_match_clip()
+    assert_equal_batched_and_unbatched(16, 16) do
+      fill 1, 0, 0
+      clip 0, 0, 8, 16
+      rect 0, 0, 16, 16
+    end
+  end
+
+  def test_match_push_pop_state()
+    assert_equal_batched_and_unbatched(16, 16) do
+      fill 1, 0, 0
+      rect 0, 0, 8, 16
+      push fill: [0, 1, 0] do
+        rect 8, 0, 8, 16
+      end
+    end
+  end
+
+  def test_match_shader()
+    assert_equal_batched_and_unbatched(16, 16) do
+      fill 1, 0, 0
+      rect 0, 0, 8, 16
+      shader "void main() {gl_FragColor = vec4(0.0, 0.0, 1.0, 1.0);}"
+      fill 1
+      rect 8, 0, 8, 16
+    end
+  end
+
+  def test_atlas_no_bleed()
+    atlas = image(4, 2) do
+      fill 1, 0, 0; rect 0, 0, 2, 2
+      fill 0, 0, 1; rect 2, 0, 2, 2
+    end
+    img = image(8, 8, bg: 0) do
+      fill 1
+      image atlas, 0, 0, 2, 2, 0, 0, 8, 8
+    end
+    assert_rgb [1, 0, 0], img[1, 1]
+    assert_rgb [1, 0, 0], img[6, 4]
+    assert_rgb [1, 0, 0], img[7, 7]
+  end
+
+end# TestPainterBatch

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rays
 version: !ruby/object:Gem::Version
-  version: 0.3.11
+  version: 0.3.12
 platform: ruby
 authors:
 - xordog
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-04-17 00:00:00.000000000 Z
+date: 2026-05-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: xot
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.3.11
+        version: 0.3.12
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.3.11
+        version: 0.3.12
 - !ruby/object:Gem::Dependency
   name: rucy
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.3.11
+        version: 0.3.12
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.3.11
+        version: 0.3.12
 description: This library helps you to develop graphics application with OpenGL.
 email: xordog@gmail.com
 executables: []
@@ -245,6 +245,7 @@ files:
 - test/test_image.rb
 - test/test_matrix.rb
 - test/test_painter.rb
+- test/test_painter_batch.rb
 - test/test_painter_shape.rb
 - test/test_point.rb
 - test/test_polygon.rb
@@ -285,6 +286,7 @@ test_files:
 - test/test_image.rb
 - test/test_matrix.rb
 - test/test_painter.rb
+- test/test_painter_batch.rb
 - test/test_painter_shape.rb
 - test/test_point.rb
 - test/test_polygon.rb