rays 0.1.46 → 0.1.47

data/lib/rays/polygon.rb

@@ -24,29 +24,58 @@ module Rays
       !(self & obj).empty?
     end
 
-    def self.line(*args, loop: false)
-      new(*args, loop: loop)
+    def self.points(*args)
+      points! args
+    end
+
+    def self.lines(*args)
+      lines! args
+    end
+
+    def self.line_strip(*args, loop: false)
+      line_strip! args, loop
     end
 
     def self.rect(
-      *args, round: nil, lt: nil, rt: nil, lb: nil, rb: nil, nsegment: nil)
+      *args, round: nil, lt: nil, rt: nil, lb: nil, rb: nil,
+      nsegment: nil)
 
-      create_rect args, round, lt, rt, lb, rb, nsegment
+      rect! args, round, lt, rt, lb, rb, nsegment
     end
 
     def self.ellipse(
       *args, center: nil, radius: nil, hole: nil, from: nil, to: nil,
       nsegment: nil)
 
-      create_ellipse args, center, radius, hole, from, to, nsegment
+      ellipse! args, center, radius, hole, from, to, nsegment
+    end
+
+    def self.triangles(*args, loop: true)
+      triangles! args, loop
+    end
+
+    def self.triangle_strip(*args)
+      triangle_strip! args
+    end
+
+    def self.triangle_fan(*args)
+      triangle_fan! args
+    end
+
+    def self.quads(*args, loop: true)
+      quads! args, loop
+    end
+
+    def self.quad_strip(*args)
+      quad_strip! args
     end
 
     def self.curve(*args, loop: false)
-      create_curve args, loop
+      curve! args, loop
     end
 
     def self.bezier(*args, loop: false)
-      create_bezier args, loop
+      bezier! args, loop
     end
 
   end# Polygon

data/rays.gemspec

@@ -25,8 +25,8 @@ Gem::Specification.new do |s|
   s.platform              = Gem::Platform::RUBY
   s.required_ruby_version = '>= 3.0.0'
 
-  s.add_runtime_dependency 'xot',  '~> 0.1.40'
-  s.add_runtime_dependency 'rucy', '~> 0.1.41'
+  s.add_runtime_dependency 'xot',  '~> 0.1.41'
+  s.add_runtime_dependency 'rucy', '~> 0.1.42'
 
   s.files            = `git ls-files`.split $/
   s.executables      = s.files.grep(%r{^bin/}) {|f| File.basename f}

data/src/color_space.cpp

@@ -70,8 +70,8 @@ namespace Rays
 		static const int BPPS[] =
 		{
 			0,                     // UNKNOWN
-			8,  16, 24,  32,  32,  // GRAY
-			8,  16, 24,  32,  32,  // ALPHA
+			8,  16,  24,  32,  32, // GRAY
+			8,  16,  24,  32,  32, // ALPHA
 			24, 32,  32,  32,  32, // RGB(A)
 			24, 32,  32,  32,  32, // BGR(A)
 			96, 128, 128,          // RGB(A) float

data/src/matrix.cpp

@@ -32,6 +32,14 @@ namespace Rays
 		reset(elements, size);
 	}
 
+	Matrix::Matrix (void* null)
+	{
+		if (null != NULL)
+			argument_error(__FILE__, __LINE__);
+
+		// do nothing to avoid initialization
+	}
+
 	Matrix
 	Matrix::dup () const
 	{

data/src/painter.cpp

@@ -49,6 +49,8 @@ namespace Rays
 
 		coord stroke_width;
 
+		float stroke_outset;
+
 		CapType stroke_cap;
 
 		JoinType stroke_join;
@@ -71,6 +73,7 @@ namespace Rays
 			colors[FILL]   .reset(1, 1);
 			colors[STROKE] .reset(1, 0);
 			stroke_width   = 0;
+			stroke_outset  = 0;
 			stroke_cap     = CAP_DEFAULT;
 			stroke_join    = JOIN_DEFAULT;
 			miter_limit    = JOIN_DEFAULT_MITER_LIMIT;
@@ -797,25 +800,77 @@ namespace Rays
 #endif
 	}
 
-	void
-	Painter::polygon (const Polygon& polygon)
+	static void
+	draw_polygon (
+		Painter* painter, const Polygon& polygon,
+		coord x, coord y, coord width = 0, coord height = 0, bool resize = false)
 	{
+		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;
 
+		bool translate = x != 0 || y != 0;
+		Matrix matrix(nullptr);
+		bool backup = false;
+
+		if (translate || resize)
+		{
+			matrix = self->position_matrix;
+			backup = true;
+
+			if (translate)
+				self->position_matrix.translate(x, y);
+
+			if (resize)
+			{
+				const Bounds& b = polygon.bounds();
+				self->position_matrix.scale(width / b.width, height / b.height);
+			}
+		}
+
 		Color color;
 
 		if (self->get_color(&color, FILL))
 		{
-			Polygon_fill(polygon, this, color);
-			debug_draw_triangulation(this, polygon, color);
+			Polygon_fill(polygon, painter, color);
+			debug_draw_triangulation(painter, polygon, color);
 		}
 
 		if (self->get_color(&color, STROKE))
-			Polygon_stroke(polygon, this, color);
+			Polygon_stroke(polygon, painter, color);
+
+		if (backup)
+			self->position_matrix = matrix;
+	}
+
+	void
+	Painter::polygon (const Polygon& polygon, const coord x, coord y)
+	{
+		draw_polygon(this, polygon, x, y);
+	}
+
+	void
+	Painter::polygon (const Polygon& polygon, const Point& position)
+	{
+		draw_polygon(this, polygon, position.x, position.y);
+	}
+
+	void
+	Painter::polygon (
+		const Polygon& polygon, coord x, coord y, coord width, coord height)
+	{
+		draw_polygon(this, polygon, x, y, width, height, true);
+	}
+
+	void
+	Painter::polygon (const Polygon& polygon, const Bounds& bounds)
+	{
+		draw_polygon(
+			this, polygon, bounds.x, bounds.y, bounds.width, bounds.height, true);
 	}
 
 	void
@@ -1310,6 +1365,18 @@ namespace Rays
 		return self->state.stroke_width;
 	}
 
+	void
+	Painter::set_stroke_outset (float outset)
+	{
+		self->state.stroke_outset = outset;
+	}
+
+	float
+	Painter::stroke_outset () const
+	{
+		return self->state.stroke_outset;
+	}
+
 	void
 	Painter::set_stroke_cap (CapType cap)
 	{