rays 0.1.48 → 0.1.49

data/src/painter.cpp

@@ -59,6 +59,8 @@ namespace Rays
 
 		uint nsegment;
 
+		coord line_height;
+
 		BlendMode blend_mode;
 
 		Bounds clip;
@@ -84,6 +86,7 @@ namespace Rays
 			stroke_join    = JOIN_DEFAULT;
 			miter_limit    = JOIN_DEFAULT_MITER_LIMIT;
 			nsegment       = 0;
+			line_height    = -1;
 			blend_mode     = BLEND_NORMAL;
 			clip           .reset(-1);
 			font           = get_default_font();
@@ -723,7 +726,13 @@ namespace Rays
 		set_blend_mode(self->state.blend_mode);
 
 		FrameBuffer& fb = self->frame_buffer;
-		if (fb) FrameBuffer_bind(fb.id());
+		if (fb)
+		{
+			FrameBuffer_bind(fb.id());
+
+			Texture& tex = fb.texture();
+			if (tex) tex.set_modified();
+		}
 
 		const Bounds& vp = self->viewport;
 		float density    = self->pixel_density;
@@ -773,12 +782,7 @@ namespace Rays
 		glFinish();
 
 		if (self->frame_buffer)
-		{
 			FrameBuffer_unbind();
-
-			Texture& tex = self->frame_buffer.texture();
-			if (tex) tex.set_modified();
-		}
 	}
 
 	bool
@@ -893,6 +897,24 @@ namespace Rays
 			this, polygon, bounds.x, bounds.y, bounds.width, bounds.height, true);
 	}
 
+	void
+	Painter::point (coord x, coord y)
+	{
+		polygon(create_point(x, y));
+	}
+
+	void
+	Painter::point (const Point& point)
+	{
+		polygon(create_point(point));
+	}
+
+	void
+	Painter::points (const Point* points, size_t size)
+	{
+		polygon(create_points(points, size));
+	}
+
 	void
 	Painter::line (coord x1, coord y1, coord x2, coord y2)
 	{
@@ -990,7 +1012,7 @@ namespace Rays
 		coord x3, coord y3, coord x4, coord y4,
 		bool loop)
 	{
-		polygon(create_curve(x1, y1, x2, y2, x3, y3, x4, y4, loop));
+		polygon(create_curve(x1, y1, x2, y2, x3, y3, x4, y4, loop, nsegment()));
 	}
 
 	void
@@ -998,13 +1020,13 @@ namespace Rays
 		const Point& p1, const Point& p2, const Point& p3, const Point& p4,
 		bool loop)
 	{
-		polygon(create_curve(p1, p2, p3, p4, loop));
+		polygon(create_curve(p1, p2, p3, p4, loop, nsegment()));
 	}
 
 	void
 	Painter::curve (const Point* points, size_t size, bool loop)
 	{
-		polygon(create_curve(points, size, loop));
+		polygon(create_curve(points, size, loop, nsegment()));
 	}
 
 	void
@@ -1013,7 +1035,7 @@ namespace Rays
 		coord x3, coord y3, coord x4, coord y4,
 		bool loop)
 	{
-		polygon(create_bezier(x1, y1, x2, y2, x3, y3, x4, y4, loop));
+		polygon(create_bezier(x1, y1, x2, y2, x3, y3, x4, y4, loop, nsegment()));
 	}
 
 	void
@@ -1021,13 +1043,13 @@ namespace Rays
 		const Point& p1, const Point& p2, const Point& p3, const Point& p4,
 		bool loop)
 	{
-		polygon(create_bezier(p1, p2, p3, p4, loop));
+		polygon(create_bezier(p1, p2, p3, p4, loop, nsegment()));
 	}
 
 	void
 	Painter::bezier (const Point* points, size_t size, bool loop)
 	{
-		polygon(create_bezier(points, size, loop));
+		polygon(create_bezier(points, size, loop, nsegment()));
 	}
 
 	static void
@@ -1176,7 +1198,7 @@ namespace Rays
 	}
 
 	static inline void
-	debug_draw_text (
+	debug_draw_line (
 		Painter* painter, const Font& font,
 		coord x, coord y, coord str_width, coord str_height)
 	{
@@ -1210,25 +1232,20 @@ namespace Rays
 	}
 
 	static void
-	draw_text (
+	draw_line (
 		Painter* painter, const Font& font,
-		const char* str, coord x, coord y, coord width = 0, coord height = 0)
+		const char* line, coord x, coord y, coord width = 0, coord height = 0)
 	{
 		assert(painter && font && str && *str != '\0');
 
 		Painter::Data* self = painter->self.get();
 
-		if (!self->painting)
-			invalid_state_error(__FILE__, __LINE__, "painting flag should be true.");
-
-		if (!self->state.has_color())
-			return;
-
-		float density = self->pixel_density;
-		coord str_w = Font_get_width(font, density, str);
-		coord str_h = Font_get_height(font, density);
-		int tex_w   = ceil(str_w);
-		int tex_h   = ceil(str_h);
+		float density          = self->pixel_density;
+		const RawFont& rawfont = Font_get_raw(font, density);
+		coord str_w            = rawfont.get_width(line);
+		coord str_h            = rawfont.get_height();
+		int tex_w              = ceil(str_w);
+		int tex_h              = ceil(str_h);
 		const Texture& texture = Image_get_texture(self->text_image);
 		if (
 			texture.width()  < tex_w ||
@@ -1245,8 +1262,7 @@ namespace Rays
 
 		assert(self->text_image.pixel_density() == density);
 
-		Bitmap_draw_string(
-			&self->text_image.bitmap(), Font_get_raw(font, density), str, 0, 0);
+		Bitmap_draw_string(&self->text_image.bitmap(), rawfont, line, 0, 0);
 
 		str_w /= density;
 		str_h /= density;
@@ -1259,7 +1275,38 @@ namespace Rays
 			x, y, str_w, str_h,
 			false, true, &Shader_get_shader_for_text());
 
-		debug_draw_text(painter, font, x, y, str_w / density, str_h / density);
+		debug_draw_line(painter, font, x, y, str_w / density, str_h / density);
+	}
+
+	static void
+	draw_text (
+		Painter* painter, const Font& font,
+		const char* str, coord x, coord y, coord width = 0, coord height = 0)
+	{
+		assert(painter && font && str && *str != '\0');
+
+		Painter::Data* self = painter->self.get();
+
+		if (!self->painting)
+			invalid_state_error(__FILE__, __LINE__, "painting flag should be true.");
+
+		if (!self->state.has_color())
+			return;
+
+		if (!strchr(str, '\n'))
+			draw_line(painter, font, str, x, y, width, height);
+		else
+		{
+			coord line_height = painter->line_height();
+
+			Xot::StringList lines;
+			split(&lines, str, '\n');
+			for (const auto& line : lines)
+			{
+				draw_line(painter, font, line.c_str(), x, y, width, height);
+				y += line_height;
+			}
+		}
 	}
 
 	void
@@ -1454,6 +1501,21 @@ namespace Rays
 		return self->state.nsegment;
 	}
 
+	void
+	Painter::set_line_height (coord height)
+	{
+		if (height < 0) height = -1;
+		self->state.line_height = height;
+	}
+
+	coord
+	Painter::line_height (bool raw) const
+	{
+		coord height = self->state.line_height;
+		if (!raw && height < 0) height = self->state.font.get_height();
+		return height;
+	}
+
 	void
 	Painter::set_blend_mode (BlendMode mode)
 	{

data/src/polygon.cpp

@@ -431,7 +431,7 @@ namespace Rays
 #endif
 
 	static uint
-	get_nsegment (
+	get_nsegment_for_angle (
 		uint nsegment, uint nsegment_min, float angle_from, float angle_to)
 	{
 		float angle = angle_to - angle_from;
@@ -700,7 +700,7 @@ namespace Rays
 					left_top    != 0 || right_top    != 0 ||
 					left_bottom != 0 || right_bottom != 0);
 
-				nsegment = get_nsegment(nsegment, 1, 0, 90);
+				nsegment = get_nsegment_for_angle(nsegment, 1, 0, 90);
 
 				fix_rounds(
 					&left_top,    &right_top,
@@ -863,7 +863,7 @@ namespace Rays
 			{
 				assert(width != 0 && height != 0);
 
-				nsegment = get_nsegment(nsegment, 3, 0, 360);
+				nsegment = get_nsegment_for_angle(nsegment, 3, 0, 360);
 
 				bool has_hole     = hole_size != 0;
 				float radian_from = Xot::deg2rad(0);
@@ -904,7 +904,7 @@ namespace Rays
 			{
 				assert(width != 0 && height != 0 && angle_from != angle_to);
 
-				nsegment = get_nsegment(nsegment, 3, angle_from, angle_to);
+				nsegment = get_nsegment_for_angle(nsegment, 3, angle_from, angle_to);
 
 				bool has_hole     = hole_size != 0;
 				float radian_from = Xot::deg2rad(angle_from);
@@ -973,9 +973,17 @@ namespace Rays
 	Polygon
 	create_points (const Point* points, size_t size)
 	{
+		static const coord DELTA = 0.01;
+
 		Polygon p;
 		for (size_t i = 0; i < size; ++i)
-			p.self->append(Polyline(&points[i], 1, false, false));
+		{
+			// Polyline(&points[i], 1, false, false).expand() ignores CapType
+
+			coord x = points[i].x, y = points[i].y;
+			Point array[] = {{x, y}, {x + DELTA, y + DELTA}};
+			p.self->append(Polyline(array, 2, false, false));
+		}
 		return p;
 	}
 
@@ -1353,11 +1361,13 @@ namespace Rays
 	create_spline (
 		SplineType type,
 		const Point* points, size_t size, bool loop,
-		uint nsegment = 16)
+		uint nsegment = 0)
 	{
 		if (size % 4 != 0)
 			argument_error(__FILE__, __LINE__);
 
+		if (nsegment <= 0) nsegment = 16;
+
 		size_t count = size / 4;
 		auto spline_fun = get_spline_fun(type);
 
@@ -1384,7 +1394,7 @@ namespace Rays
 	create_curve (
 		coord x1, coord y1, coord x2, coord y2,
 		coord x3, coord y3, coord x4, coord y4,
-		bool loop)
+		bool loop, uint nsegment)
 	{
 		const Point points[] = {
 			Point(x1, y1),
@@ -1392,29 +1402,29 @@ namespace Rays
 			Point(x3, y3),
 			Point(x4, y4)
 		};
-		return create_spline(CATMULLROM, points, 4, loop);
+		return create_spline(CATMULLROM, points, 4, loop, nsegment);
 	}
 
 	Polygon
 	create_curve (
 		const Point& p1, const Point& p2, const Point& p3, const Point& p4,
-		bool loop)
+		bool loop, uint nsegment)
 	{
 		const Point points[] = {p1, p2, p3, p4};
-		return create_spline(CATMULLROM, points, 4, loop);
+		return create_spline(CATMULLROM, points, 4, loop, nsegment);
 	}
 
 	Polygon
-	create_curve (const Point* points, size_t size, bool loop)
+	create_curve (const Point* points, size_t size, bool loop, uint nsegment)
 	{
-		return create_spline(CATMULLROM, points, size, loop);
+		return create_spline(CATMULLROM, points, size, loop, nsegment);
 	}
 
 	Polygon
 	create_bezier (
 		coord x1, coord y1, coord x2, coord y2,
 		coord x3, coord y3, coord x4, coord y4,
-		bool loop)
+		bool loop, uint nsegment)
 	{
 		const Point points[] = {
 			Point(x1, y1),
@@ -1422,22 +1432,22 @@ namespace Rays
 			Point(x3, y3),
 			Point(x4, y4)
 		};
-		return create_spline(BEZIER, points, 4, loop);
+		return create_spline(BEZIER, points, 4, loop, nsegment);
 	}
 
 	Polygon
 	create_bezier (
 		const Point& p1, const Point& p2, const Point& p3, const Point& p4,
-		bool loop)
+		bool loop, uint nsegment)
 	{
 		const Point points[] = {p1, p2, p3, p4};
-		return create_spline(BEZIER, points, 4, loop);
+		return create_spline(BEZIER, points, 4, loop, nsegment);
 	}
 
 	Polygon
-	create_bezier (const Point* points, size_t size, bool loop)
+	create_bezier (const Point* points, size_t size, bool loop, uint nsegment)
 	{
-		return create_spline(BEZIER, points, size, loop);
+		return create_spline(BEZIER, points, size, loop, nsegment);
 	}
 
 	void

data/src/texture.cpp

@@ -145,7 +145,7 @@ namespace Rays
 	}
 
 	static void
-	copy_bitmap (Bitmap* dest, const Bitmap& src)
+	copy_pixels (Bitmap* dest, const Bitmap& src)
 	{
 		assert(dest);
 
@@ -174,7 +174,7 @@ namespace Rays
 		if (!*bmp)
 			rays_error(__FILE__, __LINE__);
 
-		copy_bitmap(bmp.get(), bitmap);
+		copy_pixels(bmp.get(), bitmap);
 		return bmp;
 	}
 
@@ -258,6 +258,25 @@ namespace Rays
 			&bitmap);
 	}
 
+	Texture&
+	Texture::operator = (const Bitmap& bitmap)
+	{
+		if (!bitmap)
+			argument_error(__FILE__, __LINE__);
+
+		int w = bitmap.width(), h = bitmap.height();
+		if (w != width() || h != height())
+			argument_error(__FILE__, __LINE__, "the size of bitmap does not match");
+
+		GLenum format, type;
+		ColorSpace_get_gl_format_and_type(&format, &type, bitmap.color_space());
+
+		glBindTexture(GL_TEXTURE_2D, self->id);
+		glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, w, h, format, type, bitmap.pixels());
+
+		return *this;
+	}
+
 	Texture::~Texture ()
 	{
 	}

data/src/texture.h

@@ -28,6 +28,8 @@ namespace Rays
 
 			Texture (const Bitmap& bitmap);
 
+			Texture& operator = (const Bitmap& bitmap);
+
 			~Texture ();
 
 			int          width () const;

data/test/test_color.rb

@@ -66,19 +66,18 @@ class TestColor < Test::Unit::TestCase
   def test_set_rgb()
     o = color
     assert_equal [0, 0, 0, 1], o.to_a
-    o.red = 1
+    o.red   = 1
     assert_equal [1, 0, 0, 1], o.to_a
     o.green = 2
     assert_equal [1, 2, 0, 1], o.to_a
-    o.blue = 3
+    o.blue  = 3
     assert_equal [1, 2, 3, 1], o.to_a
     o.alpha = 4
     assert_equal [1, 2, 3, 4], o.to_a
   end
 
   def test_to_a()
-    o = color 1, 2, 3, 4
-    assert_equal [1, 2, 3, 4], o.to_a
+    assert_equal [1, 2, 3, 4], color(1, 2, 3, 4).to_a
   end
 
   def test_index()
@@ -121,6 +120,14 @@ class TestColor < Test::Unit::TestCase
     assert o > color(1, 2, 3, 3)
   end
 
+  def test_to_hsv()
+    h, s, v, a = hsv(0.1, 0.2, 0.3, 0.4).to_hsv
+    assert_in_delta 0.1, h
+    assert_in_delta 0.2, s
+    assert_in_delta 0.3, v
+    assert_in_delta 0.4, a
+  end
+
   def test_hsv_hue()
     assert_equal_color color(0.5, 0, 1), hsv(-0.25, 1, 1)
     assert_equal_color color(1,   0, 0), hsv( 0,    1, 1)
@@ -149,6 +156,16 @@ class TestColor < Test::Unit::TestCase
     assert_equal_color color(1, 0, 0, 1),   hsv(1, 1, 1, 1)
   end
 
+  def test_hsb()
+    assert_equal(
+      Rays::Color.hsv(0.1, 0.2, 0.3, 0.4),
+      Rays::Color.hsb(0.1, 0.2, 0.3, 0.4))
+
+    assert_equal(
+      color(0.1, 0.2, 0.3, 0.4).to_hsv,
+      color(0.1, 0.2, 0.3, 0.4).to_hsb)
+  end
+
   def test_inspect()
     assert_equal "#<Rays::Color 1.0 2.0 3.0 1.0>", color(1, 2, 3).inspect
   end

data/test/test_font.rb

@@ -34,6 +34,9 @@ class TestFont < Test::Unit::TestCase
     assert_equal 0, font.width('')
     w = font.width 'X'
     assert_equal w * 2, font.width('XX')
+    assert_equal w * 2, font.width("XX\nX")
+    assert_equal w * 2, font.width("XX\nXX")
+    assert_equal w * 3, font.width("XX\nXXX")
   end
 
   def test_height()

data/test/test_image.rb

@@ -19,6 +19,10 @@ class TestImage < Test::Unit::TestCase
     Rays::Bounds.new(*args)
   end
 
+  def update_texture(img)
+    image(1, 1).paint {image img}
+  end
+
   def test_initialize()
     assert_equal 10,       image(10, 20).width
     assert_equal 20,       image(10, 20).height
@@ -42,6 +46,28 @@ class TestImage < Test::Unit::TestCase
     assert_equal 10, image(20, 10).bitmap.height
   end
 
+  def test_bitmap_with_modify_flag()
+    img1 = image 1, 1
+    update_texture img1
+    img1.bitmap(false).tap {|bmp| bmp[0, 0] = color 1, 0, 0, 1}
+
+    img2 = image 1, 1
+    update_texture img2
+    img2.bitmap(true) .tap {|bmp| bmp[0, 0] = color 0, 1, 0, 1}
+
+    assert_equal [0x00000000], image(1, 1).paint {image img1}.pixels
+    assert_equal [0xff00ff00], image(1, 1).paint {image img2}.pixels
+  end
+
+  def test_pixels()
+    img        = image 2, 1
+    assert_equal [0x00000000, 0x00000000], img.pixels
+
+    img.pixels = [0xffff0000, 0xff00ff00]
+    assert_equal [0xffff0000, 0xff00ff00], img.pixels
+    assert_equal [0xffff0000, 0xff00ff00], image(2, 1).paint {image img}.pixels
+  end
+
   def test_painter()
     pa = image(10, 10).painter
     assert_equal color(0, 0, 0, 0), pa.background

data/test/test_matrix.rb

@@ -87,6 +87,10 @@ class TestMatrix < Test::Unit::TestCase
     assert o > matrix(0)
   end
 
+  def test_transpose()
+    assert_equal mat_str('1594 2615 3726 4837'), mat_str('1234 5678 9123 4567').transpose
+  end
+
   def test_transform()
     assert_equal mat_str('1001 0102 0013 0001'), translate(1, 2, 3)
     assert_equal mat_str('2000 0300 0040 0001'), scale(2, 3, 4)
@@ -100,4 +104,22 @@ class TestMatrix < Test::Unit::TestCase
     assert (rotate(90, 1, 0, 0) * point(0, 1, 0)).z > 0.99
   end
 
+  def test_ortho()
+    m = Rays::Matrix
+    assert_equal m, m.ortho(1, 2, 3, 4)      .class
+    assert_equal m, m.ortho(1, 2, 3, 4, 5, 6).class
+  end
+
+  def test_projection()
+    m = Rays::Matrix
+    assert_equal m, m.ortho(1, 2, 3, 4).class
+  end
+
+  def test_look_at()
+    m = Rays::Matrix
+    assert_equal m, m.look_at(1, 2, 3, 4, 5, 6)                              .class
+    assert_equal m, m.look_at(1, 2, 3, 4, 5, 6, 7, 8, 9)                     .class
+    assert_equal m, m.look_at(point(1, 2, 3), point(4, 5, 6), point(7, 8, 9)).class
+  end
+
 end# TestMatrix

data/test/test_painter.rb

@@ -152,6 +152,33 @@ class TestPainter < Test::Unit::TestCase
     assert_equal         4, pa.miter_limit
   end
 
+  def test_line_height_accessor()
+    pa = painter
+
+    h = pa.line_height
+    assert              h > 0
+    assert_not_equal 1, h
+
+    assert_equal        [h, -1], [pa.line_height, pa.line_height!]
+    pa.line_height =     1
+    assert_equal        [1,  1], [pa.line_height, pa.line_height!]
+    pa.line_height       2
+    assert_equal        [2,  2], [pa.line_height, pa.line_height!]
+    pa.push line_height: 9 do |_|
+      assert_equal      [9,  9], [pa.line_height, pa.line_height!]
+    end
+    assert_equal        [2,  2], [pa.line_height, pa.line_height!]
+    pa.line_height =    -1
+    assert_equal        [h, -1], [pa.line_height, pa.line_height!]
+    pa.line_height       0
+    assert_equal        [0,  0], [pa.line_height, pa.line_height!]
+    pa.line_height =     nil
+    assert_equal        [h, -1], [pa.line_height, pa.line_height!]
+
+    pa.font "Menlo", 100
+    assert_equal pa.font.height, pa.line_height
+  end
+
   def test_blend_mode_accessor()
     pa = painter
     assert_equal        :normal,   pa.blend_mode

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rays
 version: !ruby/object:Gem::Version
-  version: 0.1.48
+  version: 0.1.49
 platform: ruby
 authors:
 - xordog
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-01-07 00:00:00.000000000 Z
+date: 2024-02-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: xot
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.41
+        version: 0.1.42
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.41
+        version: 0.1.42
 - !ruby/object:Gem::Dependency
   name: rucy
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.43
+        version: 0.1.44
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.43
+        version: 0.1.44
 description: This library helps you to develop graphics application with OpenGL.
 email: xordog@gmail.com
 executables: []
@@ -260,7 +260,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
+rubygems_version: 3.4.19
 signing_key:
 specification_version: 4
 summary: A Drawing Engine using OpenGL.