rays 0.1.47 → 0.1.49

data/src/polyline.cpp

@@ -1,7 +1,8 @@
 #include "polyline.h"
 
 
-#include <assert.h>
+#include <memory>
+#include "rays/color.h"
 #include "rays/debug.h"
 
 
@@ -15,43 +16,122 @@ namespace Rays
 	struct Polyline::Data
 	{
 
+		typedef std::vector<Color>  ColorList;
+
+		typedef std::vector<Coord3> TexCoordList;
+
 		PointList points;
 
-		bool loop = false, fill = false;
+		std::unique_ptr<ColorList>    pcolors;
+
+		std::unique_ptr<TexCoordList> ptexcoords;
 
-		template <typename I, typename FUN>
-		void reset (I begin, I end, bool loop_, bool fill_, FUN to_point_fun)
+		bool loop = false, fill = false, hole = false;
+
+		void reset (
+			const auto* points_, const Color* colors_, const Coord3* texcoords_,
+			size_t size_, bool loop_, bool fill_, bool hole_,
+			auto to_point_fun)
 		{
-			if (begin > end)
-				argument_error(__FILE__, __LINE__);
+			ColorList* colors       = colors_    ? &this->colors()    : NULL;
+			TexCoordList* texcoords = texcoords_ ? &this->texcoords() : NULL;
+			int size                = (int) size_;
 
-			points.clear();
 			loop = loop_;
 			fill = fill_;
+			hole = hole_;
+			if (!is_valid())
+				argument_error(__FILE__, __LINE__, "hole polyline must be looped");
 
-			size_t size = end - begin;
-			if (size <= 0) return;
-
+			points.clear();
 			points.reserve(size);
-			for (auto it = begin; it != end; ++it)
-				points.emplace_back(to_point_fun(*it));
+			if (hole)
+			{
+				for (int i = size - 1; i >= 0; --i)
+					points.emplace_back(to_point_fun(points_[i]));
+			}
+			else
+			{
+				for (int i = 0; i < size; ++i)
+					points.emplace_back(to_point_fun(points_[i]));
+			}
+
+			if (colors)
+			{
+				colors->clear();
+				colors->reserve(size);
+				if (hole)
+				{
+					for (int i = size - 1; i >= 0; --i)
+						colors->emplace_back(colors_[i]);
+				}
+				else
+				{
+					for (int i = 0; i < size; ++i)
+						colors->emplace_back(colors_[i]);
+				}
+			}
+
+			if (texcoords)
+			{
+				texcoords->clear();
+				texcoords->reserve(size);
+				if (hole)
+				{
+					for (int i = size - 1; i >= 0; --i)
+						texcoords->emplace_back(texcoords_[i]);
+				}
+				else
+				{
+					for (int i = 0; i < size; ++i)
+						texcoords->emplace_back(texcoords_[i]);
+				}
+			}
 		}
 
+		ColorList& colors ()
+		{
+			if (!pcolors) pcolors.reset(new ColorList());
+			return *pcolors;
+		}
+
+		TexCoordList& texcoords ()
+		{
+			if (!ptexcoords) ptexcoords.reset(new TexCoordList());
+			return *ptexcoords;
+		}
+
+		bool is_valid () const
+		{
+			return loop || !hole;
+		}
+
+		private:
+#if 0
+			void reset_values (size_t size_, bool hole, auto fun)
+			{
+				int size = (int) size_;
+
+				if (hole)
+					for (int i = size - 1; i >= 0;   --i) fun((size_t) i);
+				else
+					for (int i = 0;        i < size; ++i) fun((size_t) i);
+			}
+#endif
 	};// Polyline::Data
 
 
-	void
-	Polyline_create (
-		Polyline* polyline, const Path& path, bool loop, bool hole)
+	Polyline
+	Polyline_create (const Path& path, bool loop, bool hole)
 	{
 		Path cleaned;
 		ClipperLib::CleanPolygon(path, cleaned);
 
-		auto fun = [](const IntPoint& point) {return from_clipper(point);};
-		if (hole)
-			polyline->self->reset(cleaned.rbegin(), cleaned.rend(), loop, loop, fun);
-		else
-			polyline->self->reset(cleaned. begin(), cleaned. end(), loop, loop, fun);
+		Polyline pl;
+		pl.self->reset(
+			&cleaned[0], NULL, NULL, cleaned.size(), loop, loop, hole,
+			[](const IntPoint& point) {return from_clipper(point);});
+		return pl;
 	}
 
 	template <typename I>
@@ -66,8 +146,6 @@ namespace Rays
 	void
 	Polyline_get_path (Path* path, const Polyline& polyline, bool hole)
 	{
-		assert(path);
-
 		const auto& points = polyline.self->points;
 		if (hole)
 			reset_path(path, points.rbegin(), points.rend());
@@ -80,17 +158,23 @@ namespace Rays
 	{
 	}
 
-	Polyline::Polyline (const Point* points, size_t size, bool loop)
+	Polyline::Polyline (
+		const Point* points, size_t size, bool loop,
+		const Color* colors, const Coord3* texcoords,
+		bool hole)
 	{
 		self->reset(
-			points, points + size, loop, loop,
+			points, colors, texcoords, size, loop, loop, hole,
 			[](const Point& p) {return p;});
 	}
 
-	Polyline::Polyline (const Point* points, size_t size, bool loop, bool fill)
+	Polyline::Polyline (
+		const Point* points, size_t size, bool loop, bool fill,
+		const Color* colors, const Coord3* texcoords,
+		bool hole)
 	{
 		self->reset(
-			points, points + size, loop, fill,
+			points, colors, texcoords, size, loop, fill, hole,
 			[](const Point& p) {return p;});
 	}
 
@@ -130,6 +214,33 @@ namespace Rays
 		return self->fill;
 	}
 
+	bool
+	Polyline::hole () const
+	{
+		return self->hole;
+	}
+
+	const Point*
+	Polyline::points () const
+	{
+		const auto& v = self->points;
+		return !v.empty() ? &v[0] : NULL;
+	}
+
+	const Color*
+	Polyline::colors () const
+	{
+		const auto& pv = self->pcolors;
+		return pv && !pv->empty() ? &(*pv)[0] : NULL;
+	}
+
+	const Coord3*
+	Polyline::texcoords () const
+	{
+		const auto& pv = self->ptexcoords;
+		return pv && !pv->empty() ? &(*pv)[0] : NULL;
+	}
+
 	size_t
 	Polyline::size () const
 	{
@@ -162,7 +273,7 @@ namespace Rays
 
 	Polyline::operator bool () const
 	{
-		return true;
+		return self->is_valid();
 	}
 
 	bool

data/src/polyline.h

@@ -50,13 +50,11 @@ namespace Rays
 	}
 
 
-	void Polyline_create (
-		Polyline* polyline, const ClipperLib::Path& path, bool loop,
-		bool hole = false);
+	Polyline Polyline_create (
+		const ClipperLib::Path& path, bool loop, bool hole = false);
 
 	void Polyline_get_path (
-		ClipperLib::Path* path, const Polyline& polyline,
-		bool hole = false);
+		ClipperLib::Path* path, const Polyline& polyline, bool hole = false);
 
 	bool Polyline_expand (
 		Polygon* result, const Polyline& polyline,

data/src/shader.cpp

@@ -97,7 +97,30 @@ namespace Rays
 	}
 
 	static Shader
-	make_default_shader_for_texture ()
+	make_default_shader_for_texture_clamp ()
+	{
+		const ShaderBuiltinVariableNames& names =
+			ShaderEnv_get_builtin_variable_names(DEFAULT_ENV);
+		return Shader(
+			"varying vec4 "      + V_TEXCOORD + ";\n"
+			"varying vec4 "      + V_COLOR + ";\n"
+			"uniform vec3 "      + U_TEXCOORD_MIN + ";\n"
+			"uniform vec3 "      + U_TEXCOORD_MAX + ";\n"
+			"uniform vec3 "      + U_TEXCOORD_OFFSET + ";\n"
+			"uniform sampler2D " + U_TEXTURE + ";\n"
+			"void main ()\n"
+			"{\n"
+			"  vec2 texcoord__ = clamp(" +
+				V_TEXCOORD     + ".xy, " +
+				U_TEXCOORD_MIN + ".xy, " +
+				U_TEXCOORD_MAX + ".xy - " + U_TEXCOORD_OFFSET + ".xy);\n"
+			"  vec4 color__    = texture2D(" + U_TEXTURE + ", texcoord__);\n"
+			"  gl_FragColor    = " + V_COLOR + " * color__;\n"
+			"}\n");
+	}
+
+	static Shader
+	make_default_shader_for_texture_repeat ()
 	{
 		const ShaderBuiltinVariableNames& names =
 			ShaderEnv_get_builtin_variable_names(DEFAULT_ENV);
@@ -160,10 +183,19 @@ namespace Rays
 	}
 
 	const Shader&
-	Shader_get_default_shader_for_texture ()
+	Shader_get_default_shader_for_texture (TexCoordWrap wrap)
 	{
-		static const Shader SHADER = make_default_shader_for_texture();
-		return SHADER;
+		switch (wrap)
+		{
+			case TEXCOORD_REPEAT:
+				static const Shader REPEAT = make_default_shader_for_texture_repeat();
+				return REPEAT;
+
+			case TEXCOORD_CLAMP:
+			default:
+				static const Shader CLAMP = make_default_shader_for_texture_clamp();
+				return CLAMP;
+		}
 	}
 
 	const Shader&

data/src/shader.h

@@ -57,7 +57,7 @@ namespace Rays
 
 	const Shader& Shader_get_default_shader_for_shape ();
 
-	const Shader& Shader_get_default_shader_for_texture ();
+	const Shader& Shader_get_default_shader_for_texture (TexCoordWrap wrap);
 
 	const Shader& Shader_get_shader_for_text ();
 

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;
 	}
 
@@ -197,8 +197,8 @@ namespace Rays
 		if (glIsTexture(self->id) == GL_FALSE)
 			opengl_error(__FILE__, __LINE__, "failed to create texture.");
 
-		//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
-		//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);//GL_LINEAR);
 
@@ -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/src/{noise.cpp → util.cpp}

@@ -1,4 +1,4 @@
-#include "rays/noise.h"
+#include "rays/util.h"
 
 
 #include <glm/gtc/noise.hpp>

data/src/win32/font.cpp

@@ -57,7 +57,7 @@ namespace Rays
 
 
 	const Font&
-	default_font ()
+	get_default_font ()
 	{
 		static const Font FONT(NULL);
 		return FONT;

data/test/test_bitmap.rb

@@ -6,8 +6,8 @@ class TestBitmap < Test::Unit::TestCase
   W = 32
   H = 16
 
-  def bitmap(w = W, h = H)
-    Rays::Bitmap.new w, h
+  def bitmap(w = W, h = H, *args)
+    Rays::Bitmap.new w, h, *args
   end
 
   def color(*args)
@@ -32,10 +32,17 @@ class TestBitmap < Test::Unit::TestCase
   end
 
   def test_pixels()
-    colors = %w[#f00 #0f0 #00f #ff0].map {|s| color s}
-    bmp = bitmap 2, 2
-    bmp[0, 0], bmp[1, 0], bmp[0, 1], bmp[1, 1] = colors
+    bmp = bitmap 2, 2, Rays::RGBA
+    assert_equal [0] * 4, bmp.pixels
+
+    bmp.pixels = [0xffff0000, 0xff00ff00, 0xff0000ff, 0xffffff00]
     assert_equal [0xffff0000, 0xff00ff00, 0xff0000ff, 0xffffff00], bmp.pixels
+
+    bmp = bitmap 2, 2, Rays::RGBA_float
+    assert_equal [0,0,0,0] * 4, bmp.pixels
+
+    bmp.pixels = [1,0,0,1, 0,1,0,1, 0,0,1,1, 1,1,0,1]
+    assert_equal [1,0,0,1, 0,1,0,1, 0,0,1,1, 1,1,0,1], bmp.pixels
   end
 
   def test_at()

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,4 +156,18 @@ 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
+
 end# TestColor

data/test/test_font.rb

@@ -3,8 +3,10 @@ require_relative 'helper'
 
 class TestFont < Test::Unit::TestCase
 
+  R = Rays
+
   def font(*args)
-    Rays::Font.new(*args)
+    R::Font.new(*args)
   end
 
   def test_name()
@@ -13,13 +15,28 @@ class TestFont < Test::Unit::TestCase
 
   def test_size()
     assert_kind_of Numeric, font.size
-    assert_equal 32, font(nil, 32).size
+
+    f = font('Arial', 10)
+    assert_equal 10, f.size
+
+    name   = f.name
+    f.size = 11
+    assert_equal 11,   f.size
+    assert_equal name, f.name
+
+    f11    = f.dup
+    f.size = 12
+    assert_equal 12, f  .size
+    assert_equal 11, f11.size
   end
 
   def test_width()
     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()
@@ -27,4 +44,8 @@ class TestFont < Test::Unit::TestCase
     assert_equal f.height, f.ascent + f.descent + f.leading
   end
 
+  def test_families()
+    assert_not R::Font.families.empty?
+  end
+
 end# TestFont

data/test/test_image.rb

@@ -11,7 +11,7 @@ class TestImage < Test::Unit::TestCase
     Rays::Image.load path
   end
 
-  def color(r = 0, g = 0, b = 0, a = 0)
+  def color(r, g, b, a)
     Rays::Color.new r, g, b, a
   end
 
@@ -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
@@ -52,24 +78,24 @@ class TestImage < Test::Unit::TestCase
   end
 
   def test_paint()
-    def paint(&block)
+    paint  = -> &block {
       Rays::Image.new(10, 10).paint(&block)
-    end
-    def fill(&block)
-      paint {|p| p.fill 1, 0, 0; p.stroke nil; block.call p}
-    end
-    def stroke(&block)
-      paint {|p| p.fill nil; p.stroke 1, 0, 0; block.call p}
-    end
-    def drawn(&block)
-      fill(&block).bitmap.to_a.reject {|o| o.transparent?}.uniq.size > 0
-    end
-
-    assert_equal color(0, 0, 0, 0), fill   {|p| p.rect 1, 1, 8, 8}[0, 0]
-    assert_equal color(1, 0, 0, 1), fill   {|p| p.rect 1, 1, 8, 8}[1, 1]
-    assert_equal color(1, 0, 0, 1), stroke {|p| p.line 0, 0, 1, 1}[0, 0]
-
-    assert drawn {|p| p.text "a"}
+    }
+    fill   = -> &block {
+      paint.call {|p| p.fill 1, 0, 0; p.stroke nil; block.call p}
+    }
+    stroke = -> &block {
+      paint.call {|p| p.fill nil; p.stroke 1, 0, 0; block.call p}
+    }
+    drawn  = -> &block {
+      fill[&block].bitmap.to_a.reject {|o| o.transparent?}.uniq.size > 0
+    }
+
+    assert_equal color(0, 0, 0, 0), fill.call   {|p| p.rect 1, 1, 8, 8}[0, 0]
+    assert_equal color(1, 0, 0, 1), fill.call   {|p| p.rect 1, 1, 8, 8}[1, 1]
+    assert_equal color(1, 0, 0, 1), stroke.call {|p| p.line 0, 0, 1, 1}[0, 0]
+
+    assert drawn.call {|p| p.text "a"}
   end
 
   def test_save_load()

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