rays 0.1.47 → 0.1.49

data/lib/rays/polygon.rb

@@ -8,74 +8,83 @@ module Rays
   class Polygon
 
     include Enumerable
+    include Comparable
 
-    def initialize(*args, loop: true)
-      setup args, loop
+    def initialize(*args, loop: true, colors: nil, texcoords: nil)
+      setup args, loop, colors, texcoords
     end
 
-    def transform(matrix = nil, &block)
-      lines = to_a
-      lines = lines.map {|line| line.transform matrix} if matrix
-      lines = block.call lines if block
-      self.class.new(*lines)
+    def transform(&block)
+      polylines = block.call to_a
+      self.class.new(*polylines)
     end
 
     def intersects(obj)
       !(self & obj).empty?
     end
 
-    def self.points(*args)
-      points! args
+    def <=>(o)
+      (size <=> o.size).then {|cmp|                return cmp if cmp != 0}
+      to_a.zip(o.to_a).each {|a, b| cmp = a <=> b; return cmp if cmp != 0}
+      0
     end
 
-    def self.lines(*args)
-      lines! args
+    def inspect()
+      "#<Rays::Polygon [#{map {|polyline| polyline.inspect}.join ', '}]>"
     end
 
-    def self.line_strip(*args, loop: false)
-      line_strip! args, loop
+    def self.points(*points)
+      points! points
     end
 
-    def self.rect(
-      *args, round: nil, lt: nil, rt: nil, lb: nil, rb: nil,
-      nsegment: nil)
+    def self.line(*points, loop: false)
+      line! points, loop
+    end
 
-      rect! args, round, lt, rt, lb, rb, nsegment
+    def self.lines(*points)
+      lines! points
     end
 
-    def self.ellipse(
-      *args, center: nil, radius: nil, hole: nil, from: nil, to: nil,
-      nsegment: nil)
+    def self.triangles(*points, loop: true, colors: nil, texcoords: nil)
+      triangles! points, loop, colors, texcoords
+    end
 
-      ellipse! args, center, radius, hole, from, to, nsegment
+    def self.triangle_strip(*points, colors: nil, texcoords: nil)
+      triangle_strip! points, colors, texcoords
     end
 
-    def self.triangles(*args, loop: true)
-      triangles! args, loop
+    def self.triangle_fan(*points, colors: nil, texcoords: nil)
+      triangle_fan! points, colors, texcoords
     end
 
-    def self.triangle_strip(*args)
-      triangle_strip! args
+    def self.rect(
+      *args, round: nil, lt: nil, rt: nil, lb: nil, rb: nil,
+      nsegment: nil)
+
+      rect! args, round, lt, rt, lb, rb, nsegment
     end
 
-    def self.triangle_fan(*args)
-      triangle_fan! args
+    def self.quads(*points, loop: true, colors: nil, texcoords: nil)
+      quads! points, loop, colors, texcoords
     end
 
-    def self.quads(*args, loop: true)
-      quads! args, loop
+    def self.quad_strip(*points, colors: nil, texcoords: nil)
+      quad_strip! points, colors, texcoords
     end
 
-    def self.quad_strip(*args)
-      quad_strip! args
+    def self.ellipse(
+      *args, center: nil, radius: nil, hole: nil, from: nil, to: nil,
+      nsegment: nil)
+
+      ellipse! args, center, radius, hole, from, to, nsegment
     end
 
-    def self.curve(*args, loop: false)
-      curve! args, loop
+    def self.curve(*points, loop: false, nsegment: nil)
+      curve! points, loop, nsegment
     end
 
-    def self.bezier(*args, loop: false)
-      bezier! args, loop
+    def self.bezier(*points, loop: false, nsegment: nil)
+      bezier! points, loop, nsegment
     end
 
   end# Polygon

data/lib/rays/polyline.rb

@@ -7,20 +7,66 @@ module Rays
   class Polyline
 
     include Enumerable
+    include Comparable
 
-    def initialize(*points, loop: false)
-      setup points, loop
+    def initialize(
+      *points, loop: false, fill: nil, colors: nil, texcoords: nil, hole: false)
+
+      setup points, loop, (fill != nil ? fill : loop), colors, texcoords, hole
+    end
+
+    def with(**kwargs)
+      points_, loop_, fill_, colors_, texcoords_, hole_ =
+        kwargs.values_at :points, :loop, :fill, :colors, :texcoords, :hole
+      self.class.new(
+                 *(points_    || (points?    ? points    : [])),
+        loop:      loop_ != nil ? loop_ : loop?,
+        fill:      fill_ != nil ? fill_ : fill?,
+        colors:    colors_    || (colors?    ? colors    : nil),
+        texcoords: texcoords_ || (texcoords? ? texcoords : nil),
+        hole:      hole_ != nil ? hole_ : hole?)
+    end
+
+    def points()
+      each_point.to_a
+    end
+
+    def colors()
+      each_color.to_a
+    end
+
+    def texcoords()
+      each_texcoord.to_a
+    end
+
+    def each_point(&block)
+      block ? each_point!(&block) : enum_for(:each_point!)
+    end
+
+    def each_color(&block)
+      block ? each_color!(&block) : enum_for(:each_color!)
+    end
+
+    def each_texcoord(&block)
+      block ? each_texcoord!(&block) : enum_for(:each_texcoord!)
     end
 
-    def transform(matrix = nil, loop: loop?, &block)
-      points = to_a
-      points = points.map {|point| matrix * point} if matrix
-      points = block.call points if block
-      self.class.new(*points, loop: loop)
+    alias each each_point
+
+    def <=>(o)
+      (size  <=> o.size) .then {|cmp|                        return cmp if cmp != 0}
+      (loop? <=> o.loop?).then {|cmp|                        return cmp if cmp != 0}
+      (fill? <=> o.fill?).then {|cmp|                        return cmp if cmp != 0}
+      points   .zip(o.points)   .each {|a, b| cmp = a <=> b; return cmp if cmp != 0}
+      colors   .zip(o.colors)   .each {|a, b| cmp = a <=> b; return cmp if cmp != 0}
+      texcoords.zip(o.texcoords).each {|a, b| cmp = a <=> b; return cmp if cmp != 0}
+      0
     end
 
     def inspect()
-      "#<Rays::Polyline #{to_a.join ', '}, loop: #{loop?}>"
+      p    = points.map {|o| o.to_a.join ','}.join ', '
+      c, t = colors.size, texcoords.size
+      "#<Rays::Polyline [#{p}] loop:#{loop?} fill:#{fill?} hole:#{hole?} colors:#{c} texcoords:#{t}>"
     end
 
   end# Polyline

data/lib/rays.rb

@@ -10,7 +10,6 @@ require 'rays/matrix'
 require 'rays/painter'
 require 'rays/polyline'
 require 'rays/polygon'
-require 'rays/polygon_line'
 require 'rays/bitmap'
 require 'rays/image'
 require 'rays/font'

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.41'
-  s.add_runtime_dependency 'rucy', '~> 0.1.42'
+  s.add_runtime_dependency 'xot',  '~> 0.1.42'
+  s.add_runtime_dependency 'rucy', '~> 0.1.44'
 
   s.files            = `git ls-files`.split $/
   s.executables      = s.files.grep(%r{^bin/}) {|f| File.basename f}

data/src/color.cpp

@@ -47,8 +47,17 @@ namespace Rays
 		hue = fmod(hue, 1.f);
 		if (hue < 0) hue += 1.f;
 
-		auto c = glm::rgbColor(Vec3(hue * 360.f, saturation, value));
-		return Color(c[0], c[1], c[2], alpha);
+		auto rgb = glm::rgbColor(Vec3(hue * 360.f, saturation, value));
+		return Color(rgb[0], rgb[1], rgb[2], alpha);
+	}
+
+	void
+	get_hsv (float* hue, float* saturation, float* value, const Color& color)
+	{
+		auto hsv = glm::hsvColor(Vec3(color.r, color.g, color.b));
+		if (hue)        *hue        = hsv[0] / 360.f;
+		if (saturation) *saturation = hsv[1];
+		if (value)      *value      = hsv[2];
 	}
 
 

data/src/font.cpp

@@ -27,7 +27,7 @@ namespace Rays
 			if (pixel_density != for_pixel_density)
 			{
 				rawfont_for_pixel_density =
-					RawFont(rawfont.name(), rawfont.size() * pixel_density);
+					RawFont(rawfont, rawfont.size() * pixel_density);
 				for_pixel_density = pixel_density;
 			}
 
@@ -37,8 +37,16 @@ namespace Rays
 	};// Font::Data
 
 
+	Font
+	load_font (const char* path, coord size)
+	{
+		Font font;
+		font.self->rawfont = RawFont_load(path, size);
+		return font;
+	}
+
 	const Font&
-	default_font ()
+	get_default_font ()
 	{
 		static const Font FONT(NULL);
 		return FONT;
@@ -50,21 +58,6 @@ namespace Rays
 		return font.self->get_raw(pixel_density);
 	}
 
-	coord
-	Font_get_width (const Font& font, float pixel_density, const char* str)
-	{
-		return Font_get_raw(font, pixel_density).get_width(str);
-	}
-
-	coord
-	Font_get_height (
-		const Font& font, float pixel_density,
-		coord* ascent, coord* descent, coord* leading)
-	{
-		return Font_get_raw(font, pixel_density)
-			.get_height(ascent, descent, leading);
-	}
-
 
 	Font::Font ()
 	{
@@ -79,12 +72,26 @@ namespace Rays
 	{
 	}
 
+	Font
+	Font::dup () const
+	{
+		Font f;
+		f.self->rawfont = RawFont(self->rawfont, self->rawfont.size());
+		return f;
+	}
+
 	String
 	Font::name () const
 	{
 		return self->rawfont.name();
 	}
 
+	void
+	Font::set_size (coord size)
+	{
+		self->rawfont = RawFont(self->rawfont, size);
+	}
+
 	coord
 	Font::size () const
 	{
@@ -94,7 +101,19 @@ namespace Rays
 	coord
 	Font::get_width (const char* str) const
 	{
-		return self->rawfont.get_width(str);
+		if (!strchr(str, '\n'))
+			return self->rawfont.get_width(str);
+
+		Xot::StringList lines;
+		split(&lines, str);
+
+		coord width = 0;
+		for (const auto& line : lines)
+		{
+			coord w = self->rawfont.get_width(line.c_str());
+			if (w > width) width = w;
+		}
+		return width;
 	}
 
 	coord

data/src/font.h

@@ -15,11 +15,15 @@ namespace Rays
 	class RawFont
 	{
 
+		typedef RawFont This;
+
 		public:
 
 			RawFont ();
 
-			RawFont (const char* name, coord size = 0);
+			RawFont (const char* name, coord size);
+
+			RawFont (const This& obj, coord size);
 
 			~RawFont ();
 
@@ -51,11 +55,8 @@ namespace Rays
 
 	const RawFont& Font_get_raw (const Font& font, float pixel_density);
 
-	coord Font_get_width (const Font& font, float pixel_density, const char* str);
 
-	coord Font_get_height (
-		const Font& font, float pixel_density,
-		coord* ascent = NULL, coord* descent = NULL, coord* leading = NULL);
+	RawFont RawFont_load (const char* path, coord size);
 
 
 }// Rays

data/src/image.cpp

@@ -10,6 +10,13 @@
 #include "texture.h"
 
 
+#if 0
+#define PRINT_MODIFIED_FLAGS(message) self->print_modified_flags(message)
+#else
+#define PRINT_MODIFIED_FLAGS(message)
+#endif
+
+
 namespace Rays
 {
 
@@ -27,6 +34,16 @@ namespace Rays
 
 		mutable Texture texture;
 
+		void print_modified_flags (const char* message)
+		{
+			printf("%s: %d %d %d %d \n",
+				message,
+				bitmap ? 1 : 0,
+				Bitmap_get_modified(bitmap) ? 1 : 0,
+				texture ? 1 : 0,
+				texture.modified() ? 1 : 0);
+		}
+
 	};// Image::Data
 
 
@@ -82,18 +99,30 @@ namespace Rays
 		if (!self->bitmap)
 		{
 			if (self->texture)
+			{
+				PRINT_MODIFIED_FLAGS("new bitmap from texture");
 				self->bitmap = Bitmap_from(self->texture);
+			}
 			else
+			{
+				PRINT_MODIFIED_FLAGS("new bitmap");
 				self->bitmap = Bitmap(self->width, self->height, self->color_space);
+			}
 			clear_modified_flags(image);
 		}
-		else if (
-			self->texture &&
-			self->texture.modified() &&
-			!Bitmap_get_modified(self->bitmap))
+		else if (self->texture && self->texture.modified())
 		{
-			self->bitmap = Bitmap_from(self->texture);
-			clear_modified_flags(image);
+			if (Bitmap_get_modified(self->bitmap))
+			{
+				invalid_state_error(
+					__FILE__, __LINE__, "bitmap and texture modifications conflicted");
+			}
+			else
+			{
+				PRINT_MODIFIED_FLAGS("bitmap from texture");
+				self->bitmap = Bitmap_from(self->texture);
+				clear_modified_flags(image);
+			}
 		}
 
 		return self->bitmap;
@@ -115,9 +144,13 @@ namespace Rays
 		if (!self->texture)
 		{
 			if (self->bitmap)
+			{
+				PRINT_MODIFIED_FLAGS("new texture from bitmap");
 				self->texture = Texture(self->bitmap);
+			}
 			else
 			{
+				PRINT_MODIFIED_FLAGS("new texture");
 				self->texture = Texture(self->width, self->height, self->color_space);
 
 				Painter p = image.painter();
@@ -127,13 +160,19 @@ namespace Rays
 			}
 			clear_modified_flags(&image);
 		}
-		else if (
-			self->bitmap &&
-			Bitmap_get_modified(self->bitmap) &&
-			!self->texture.modified())
+		else if (self->bitmap && Bitmap_get_modified(self->bitmap))
 		{
-			self->texture = Texture(self->bitmap);
-			clear_modified_flags(&image);
+			if (self->texture.modified())
+			{
+				invalid_state_error(
+					__FILE__, __LINE__, "texture and bitmap modifications conflicted");
+			}
+			else
+			{
+				PRINT_MODIFIED_FLAGS("texture from bitmap");
+				self->texture = self->bitmap;
+				clear_modified_flags(&image);
+			}
 		}
 
 		return self->texture;
@@ -232,15 +271,20 @@ namespace Rays
 	}
 
 	Bitmap&
-	Image::bitmap ()
+	Image::bitmap (bool modify)
 	{
+		if (modify)
+		{
+			if (!self->bitmap) get_bitmap(this);
+			Bitmap_set_modified(&self->bitmap);
+		}
 		return get_bitmap(this);
 	}
 
 	const Bitmap&
 	Image::bitmap () const
 	{
-		return get_bitmap(const_cast<Image*>(this));
+		return const_cast<Image*>(this)->bitmap();
 	}
 
 	Image::operator bool () const

data/src/ios/font.mm

@@ -2,6 +2,7 @@
 #include "../font.h"
 
 
+#include <memory>
 #import <CoreGraphics/CGContext.h>
 #import <CoreText/CoreText.h>
 #include "rays/exception.h"
@@ -12,15 +13,23 @@ namespace Rays
 {
 
 
+	typedef std::shared_ptr<const __CFDictionary>       CFDictionaryPtr;
+
+	typedef std::shared_ptr<const __CFAttributedString> CFAttributedStringPtr;
+
+	typedef std::shared_ptr<CGDataProvider>             CGDataProviderPtr;
+
+	typedef std::shared_ptr<CGFont>                     CGFontPtr;
+
+	typedef std::shared_ptr<const __CTLine>             CTLinePtr;
+
+
 	struct RawFont::Data
 	{
 
-		CTFontRef font;
+		CTFontRef font = NULL;
 
-		Data ()
-		:	font(NULL)
-		{
-		}
+		String path;
 
 		~Data ()
 		{
@@ -34,7 +43,7 @@ namespace Rays
 	};// RawFont::Data
 
 
-	static CTLineRef
+	static CTLinePtr
 	make_line (CTFontRef font, const char* str)
 	{
 		if (!font || !str || *str == '\0')
@@ -50,18 +59,65 @@ namespace Rays
 		};
 		size_t nkeys = sizeof(keys) / sizeof(keys[0]);
 
-		CFDictionaryRef attr = CFDictionaryCreate(
-			NULL, (const void**) &keys, (const void**) &values, nkeys,
-			&kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
+		CFDictionaryPtr attr(
+			CFDictionaryCreate(
+				NULL, (const void**) &keys, (const void**) &values, nkeys,
+				&kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks),
+			CFRelease);
 
-		CFAttributedStringRef attrstr = CFAttributedStringCreate(
-			NULL, cfstring(str).get(), attr);
-		CFRelease(attr);
+		CFAttributedStringPtr attrstr(
+			CFAttributedStringCreate(NULL, cfstring(str).get(), attr.get()),
+			CFRelease);
 
-		CTLineRef line = CTLineCreateWithAttributedString(attrstr);
-		CFRelease(attrstr);
+		return CTLinePtr(
+			CTLineCreateWithAttributedString(attrstr.get()),
+			CFRelease);
+	}
 
-		return line;
+	const FontFamilyMap&
+	get_font_families ()
+	{
+		static const FontFamilyMap MAP = []() {
+			FontFamilyMap map;
+			for (NSString* family in UIFont.familyNames)
+			{
+				FontFamilyMap::mapped_type array;
+				for (NSString* name in [UIFont fontNamesForFamilyName: family])
+					array.emplace_back(name.UTF8String);
+				map[family.UTF8String] = array;
+			}
+			return map;
+		}();
+		return MAP;
+	}
+
+	RawFont
+	RawFont_load (const char* path, coord size)
+	{
+		if (!path)
+			argument_error(__FILE__, __LINE__);
+
+		CGDataProviderPtr data_provider(
+			CGDataProviderCreateWithFilename(path),
+			CGDataProviderRelease);
+		if (!data_provider)
+			rays_error(__FILE__, __LINE__, "failed to create CGDataProvider");
+
+		CGFontPtr cgfont(
+			CGFontCreateWithDataProvider(data_provider.get()),
+			CGFontRelease);
+		if (!cgfont)
+			rays_error(__FILE__, __LINE__, "failed to create CGFont");
+
+		CTFontRef ctfont = CTFontCreateWithGraphicsFont(
+			cgfont.get(), size, NULL, NULL);
+		if (!ctfont)
+			rays_error(__FILE__, __LINE__, "failed to create CTFont");
+
+		RawFont rawfont;
+		rawfont.self->font = ctfont;
+		rawfont.self->path = path;
+		return rawfont;
 	}
 
 
@@ -76,6 +132,15 @@ namespace Rays
 			:	CTFontCreateUIFontForLanguage(kCTFontSystemFontType, size, NULL);
 	}
 
+	RawFont::RawFont (const This& obj, coord size)
+	{
+		const char* path = obj.self->path.empty() ? NULL : obj.self->path.c_str();
+		if (path)
+			*this = RawFont_load(path, size);
+		else
+			self->font = CTFontCreateWithName(cfstring(obj.name()).get(), size, NULL);
+	}
+
 	RawFont::~RawFont ()
 	{
 	}
@@ -92,15 +157,13 @@ namespace Rays
 
 		if (*str == '\0') return;
 
-		CTLineRef line = make_line(self->font, str);
+		CTLinePtr line = make_line(self->font, str);
 		if (!line)
 			rays_error(__FILE__, __LINE__, "creating CTLineRef failed.");
 
-		coord width = 0, height = 0, ascent = 0;
-		width  = get_width(str);
-		height = get_height(&ascent);
-
-		height = ceil(height);
+		coord width, height, ascent = 0;
+		width  = ceil(get_width(str));
+		height = ceil(get_height(&ascent));
 		ascent = floor(ascent);
 
 		CGRect rect = CGRectMake(x, context_height - height - y, width, height);
@@ -112,10 +175,8 @@ namespace Rays
 		CGContextSaveGState(context);
 		CGContextSetTextMatrix(context, CGAffineTransformIdentity);
 		CGContextSetTextPosition(context, x, context_height - ascent - y);
-		CTLineDraw(line, context);
+		CTLineDraw(line.get(), context);
 		CGContextRestoreGState(context);
-
-		CFRelease(line);
 	}
 
 	String
@@ -123,14 +184,13 @@ namespace Rays
 	{
 		if (!*this) return "";
 
-		CFStringRef str = CTFontCopyFullName(self->font);
+		CFStringPtr str(CTFontCopyFullName(self->font), CFRelease);
 
 		enum {BUFSIZE = 2048};
 		char buf[BUFSIZE + 1];
-		if (!CFStringGetCString(str, buf, BUFSIZE, kCFStringEncodingUTF8))
+		if (!CFStringGetCString(str.get(), buf, BUFSIZE, kCFStringEncodingUTF8))
 			buf[0] = '\0';
 
-		CFRelease(str);
 		return buf;
 	}
 
@@ -152,14 +212,11 @@ namespace Rays
 
 		if (*str == '\0') return 0;
 
-		CTLineRef line = make_line(self->font, str);
+		CTLinePtr line = make_line(self->font, str);
 		if (!line)
 			rays_error(__FILE__, __LINE__, "creating CTLineRef failed.");
 
-		coord w = CTLineGetTypographicBounds(line, NULL, NULL, NULL);
-		CFRelease(line);
-
-		return w;
+		return CTLineGetTypographicBounds(line.get(), NULL, NULL, NULL);
 	}
 
 	coord