rays 0.1.47 → 0.1.48

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

@@ -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);
 

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

@@ -149,4 +149,8 @@ class TestColor < Test::Unit::TestCase
     assert_equal_color color(1, 0, 0, 1),   hsv(1, 1, 1, 1)
   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,7 +15,19 @@ 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()
@@ -27,4 +41,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
 
@@ -52,24 +52,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_point.rb

@@ -179,7 +179,7 @@ class TestPoint < Test::Unit::TestCase
   end
 
   def test_inspect()
-    assert_equal "#<Rays::Point 1.0, 2.0, 3.0>", point(1, 2, 3).inspect
+    assert_equal "#<Rays::Point 1.0 2.0 3.0>", point(1, 2, 3).inspect
   end
 
   def test_dot()

data/test/test_polygon.rb

@@ -13,12 +13,8 @@ class TestPolygon < Test::Unit::TestCase
     Rays::Polygon.new(*args, **kwargs)
   end
 
-  def line(*args)
-    Rays::Polygon::Line.new(*args)
-  end
-
-  def polyline(*args)
-    Rays::Polyline.new(*args)
+  def polyline(*args, **kwargs)
+    Rays::Polyline.new(*args, **kwargs)
   end
 
   def point(*args)
@@ -44,20 +40,23 @@ class TestPolygon < Test::Unit::TestCase
     assert_equal [[[5, 6], [7, 8]]], polygon(  [5, 6],   [7, 8], loop: false).dump
     assert_equal [[[1, 1], [2, 2]]], polygon(     [1],      [2], loop: false).dump
     assert_equal [[[3, 3], [4, 4]]], polygon(point(3), point(4), loop: false).dump
-    assert_nothing_raised       {polygon(                  loop: true)}
-    assert_nothing_raised       {polygon(                  loop: false)}
-    assert_raise(ArgumentError) {polygon(1,                loop: true)}
-    assert_raise(ArgumentError) {polygon(1,                loop: false)}
-    assert_nothing_raised       {polygon(1, 2,             loop: true)}
-    assert_nothing_raised       {polygon(1, 2,             loop: false)}
-    assert_raise(ArgumentError) {polygon(1, 2, 3,          loop: true)}
-    assert_raise(ArgumentError) {polygon(1, 2, 3,          loop: false)}
-    assert_nothing_raised       {polygon(1, 2, 3, 4,       loop: true)}
-    assert_nothing_raised       {polygon(1, 2, 3, 4,       loop: false)}
-    assert_raise(ArgumentError) {polygon(1, 2, 3, 4, 5,    loop: true)}
-    assert_raise(ArgumentError) {polygon(1, 2, 3, 4, 5,    loop: false)}
-    assert_nothing_raised       {polygon(1, 2, 3, 4, 5, 6, loop: true)}
-    assert_nothing_raised       {polygon(1, 2, 3, 4, 5, 6, loop: false)}
+
+    assert_nothing_raised       {polygon(               loop: true)}
+    assert_nothing_raised       {polygon(               loop: false)}
+    assert_raise(ArgumentError) {polygon(1,             loop: true)}
+    assert_raise(ArgumentError) {polygon(1,             loop: false)}
+    assert_nothing_raised       {polygon(1,2,           loop: true)}
+    assert_nothing_raised       {polygon(1,2,           loop: false)}
+    assert_raise(ArgumentError) {polygon(1,2, 3,        loop: true)}
+    assert_raise(ArgumentError) {polygon(1,2, 3,        loop: false)}
+    assert_nothing_raised       {polygon(1,2, 3,4,      loop: true)}
+    assert_nothing_raised       {polygon(1,2, 3,4,      loop: false)}
+    assert_raise(ArgumentError) {polygon(1,2, 3,4, 5,   loop: true)}
+    assert_raise(ArgumentError) {polygon(1,2, 3,4, 5,   loop: false)}
+    assert_nothing_raised       {polygon(1,2, 3,4, 5,6, loop: true)}
+    assert_nothing_raised       {polygon(1,2, 3,4, 5,6, loop: false)}
+
+    assert_raise(ArgumentError) {polygon(polyline(1,2, 3,4, 5,6, loop: true, hole: true))}
   end
 
   def test_expand()
@@ -71,43 +70,26 @@ class TestPolygon < Test::Unit::TestCase
     }
   end
 
-  def test_transform_with_matrix()
-    m = Rays::Matrix.translate 10, 10
-    assert_equal_polygon rect(20, 20, 50, 50), rect(10, 10, 50, 50).transform(m)
-
-    m = Rays::Matrix.scale 2
-    assert_equal_polygon rect(20, 20, 40, 40), rect(10, 10, 20, 20).transform(m)
-
-    m = Rays::Matrix.rotate 90
-    assert_equal_polygon rect(-10, 0, 10, 10), rect(0, 0, 10, 10).transform(m)
-  end
-
-  def test_transform_block()
+  def test_transform()
     o = rect(0, 0, 100, 100) - rect(10, 10, 50, 50)
     assert_equal 2, o.size
 
-    o.transform {|lines|
-      lines.map {|l| l.transform Rays::Matrix.translate 10, 10}
+    o.transform {|polylines|
+      m = Rays::Matrix.translate 10, 10
+      polylines.map {|pl| pl.with points: pl.points.map {|p| m * p}}
     }.tap {|x|
       assert_equal_polygon (rect(10, 10, 100, 100) - rect(20, 20, 50, 50)), x
     }
 
-    o.transform {|lines|
-      lines.reject {|l| l.to_a.include? point(10, 10)}
+    o.transform {|polylines|
+      polylines.reject {|pl| pl.to_a.include? point(10, 10)}
     }.tap {|x|
       assert_equal 1, x.size
       assert_equal 2, o.size
     }
 
-    o.transform {|lines|
-      lines.reject {|l| l.to_a.include? point(10, 10)}
-    }.tap {|x|
-      assert_equal 1, x.size
-      assert_equal 2, o.size
-    }
-
-    o.transform {|lines|
-      lines + [line(1, 2, 3, 4, 5, 6)]
+    o.transform {|polylines|
+      polylines + [polyline(1, 2, 3, 4, 5, 6)]
     }.tap {|x|
       assert_equal 3, x.size
       assert_equal 2, o.size
@@ -156,6 +138,31 @@ class TestPolygon < Test::Unit::TestCase
     assert_raise(IndexError) {o[-4]}
   end
 
+  def test_add()
+    assert_equal_polygon(
+      polygon(*rect(0, 0, 10, 10).to_a, *rect(5, 0, 10, 10).to_a),
+               rect(0, 0, 10, 10)      + rect(5, 0, 10, 10))
+
+    assert_equal_polygon(
+      polygon(*rect(0, 0, 10, 10).to_a, *rect(5, 0, 10, 10).to_a, *rect(10, 0, 10, 10).to_a),
+               rect(0, 0, 10, 10)     + [rect(5, 0, 10, 10),       rect(10, 0, 10, 10)])
+
+    o = rect(0, 0, 10, 10)
+    assert_equal_polygon(
+      polygon(*rect(0, 0, 10, 10).to_a, *rect(0, 0, 10, 10).to_a),
+      o + o)
+
+    assert_equal_polygon rect(0, 0, 10, 10), rect(0, 0, 10, 10) + polygon()
+    assert_equal_polygon rect(0, 0, 10, 10), polygon() + rect(0, 0, 10, 10)
+    assert_equal_polygon rect(0, 0, 10, 10), rect(0, 0, 10, 10) + []
+
+    assert_equal(
+      polygon(
+        polyline(0,0, 0,10, 10,10, 10,0, loop: true, fill: true),
+        polyline(1,1, 2,1,   2,2,   1,2, loop: true, fill: true, hole: true)),
+      polygon(0,0, 0,10, 10,10, 10,0) + polyline(1,1, 2,1, 2,2, 1,2, loop: true, hole: true))
+  end
+
   def test_sub()
     rect10 = rect 0, 0, 10, 10