rays 0.1.6 → 0.1.7

data/src/texture.cpp

@@ -1,7 +1,10 @@
 #include "rays/texture.h"
 
 
-#include <rays/bitmap.h>
+#include "rays/exception.h"
+#include "rays/bitmap.h"
+#include "rays/opengl.h"
+#include "frame_buffer.h"
 
 
 namespace Rays
@@ -11,13 +14,16 @@ namespace Rays
 	struct Texture::Data
 	{
 
-		Bitmap bitmap;
+		int id, width, height, width_pow2, height_pow2;
 
-		int id, width, height;
+		ColorSpace color_space;
+
+		bool alpha_only, dirty;
 
 		Data ()
-		:	id(-1), width(0), height(0)
+		:	id(-1)
 		{
+			clear();
 		}
 
 		~Data ()
@@ -33,58 +39,40 @@ namespace Rays
 				glDeleteTextures(1, &id_);
 			}
 
-			bitmap = Bitmap();
 			id = -1;
-			width = height = 0;
+			width = height = width_pow2 = height_pow2 = 0;
+			color_space = COLORSPACE_UNKNOWN;
+			alpha_only = dirty = false;
 		}
 
 	};// Texture::Data
 
 
-	static bool
-	get_component_type (GLenum* result, ColorSpace cs)
+	static void
+	create_texture (
+		Texture::Data* self, const Bitmap* bitmap, GLenum format, GLenum type)
 	{
-		if (!result || !cs) return false;
-
-		if (cs.is_float())
-			*result = GL_FLOAT;
-		else
-		{
-			switch (cs.bpc())
-			{
-				case 8:  *result = GL_UNSIGNED_BYTE; break;
-				case 16: *result = GL_UNSIGNED_SHORT; break;
-				case 32: *result = GL_UNSIGNED_INT; break;
-				default: return false;
-			}
-		}
-		return true;
-	}
-
-	static bool
-	create_texture (Texture::Data* self, GLenum format)
-	{
-		if (!self || !self->bitmap) return false;
-
-		GLenum type;
-		if (!get_component_type(&type, self->bitmap.color_space()))
-			return false;
+		if (!self || (bitmap && !*bitmap))
+			argument_error(__FILE__, __LINE__);
 
 		GLuint id = 0;
 		glGenTextures(1, &id);
 		glBindTexture(GL_TEXTURE_2D, id);
 		if (glIsTexture(id) == GL_FALSE)
-			return false;
+			opengl_error(__FILE__, __LINE__, "failed to create texture.");
 
 		self->id = id;
 
-		glTexImage2D(
-			GL_TEXTURE_2D, 0, format, self->bitmap.width(), self->bitmap.height(), 0,
-			format, type, self->bitmap.data());
+		//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_MIN_FILTER, GL_NEAREST);//GL_LINEAR);
 		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);//GL_LINEAR);
 
-		return true;
+		glTexImage2D(
+			GL_TEXTURE_2D, 0, format, self->width_pow2, self->height_pow2, 0,
+			format, type, bitmap ? bitmap->pixels() : NULL);
+
+		check_error(__FILE__, __LINE__);
 	}
 
 	static int
@@ -95,10 +83,11 @@ namespace Rays
 		return n;
 	}
 
-	static bool
+	static void
 	colorspace_for_alphabitmap (ColorSpace* result, ColorSpace cs)
 	{
-		if (!result || !cs) return false;
+		if (!result || !cs)
+			argument_error(__FILE__, __LINE__);
 
 		*result = COLORSPACE_UNKNOWN;
 
@@ -112,11 +101,9 @@ namespace Rays
 				case 16: *result = GRAY_16; break;
 				case 24: *result = GRAY_24; break;
 				case 32: *result = GRAY_32; break;
-				default: return false;
+				default: rays_error(__FILE__, __LINE__, "invalid bpc.");
 			}
 		}
-
-		return true;
 	}
 
 	template <int BytesPerPixel>
@@ -146,8 +133,8 @@ namespace Rays
 	inline void
 	copy_pixel<4> (uchar* dest, const uchar* src)
 	{
-		assert(sizeof(ulong) == 4);
-		*(ulong*) dest = *(ulong*) src;
+		assert(sizeof(uint) == 4);
+		*(uint*) dest = *(uint*) src;
 	}
 
 	template <int BytesPerPixel>
@@ -157,7 +144,7 @@ namespace Rays
 		uchar* dest, size_t dest_offset, const uchar* src, size_t src_offset)
 	{
 		if (!dest || !src || dest_offset <= 0 || src_offset <= 0)
-			return;
+			argument_error(__FILE__, __LINE__);
 
 		while (width--)
 		{
@@ -181,18 +168,18 @@ namespace Rays
 		}
 	}
 
-	static bool
+	static void
 	copy_bitmap (Bitmap* dest, const Bitmap& src, int src_offset = 0)
 	{
 		if (!dest || !src || src_offset < 0)
-			return false;
+			argument_error(__FILE__, __LINE__);
 
 		int src_Bpp  = src.color_space().Bpp();
 		int src_Bpc  = src.color_space().Bpc();
 		int dest_Bpp = dest->color_space().Bpp();
 
 		if (src_offset >= (src_Bpp / src_Bpc))
-			return false;
+			rays_error(__FILE__, __LINE__, "invalid src_offset.");
 
 		int width  = std::min(src.width(),  dest->width());
 		int height = std::min(src.height(), dest->height());
@@ -203,108 +190,73 @@ namespace Rays
 			      uchar* d = dest->at<uchar>(0, y);
 			copy_pixels(src_Bpp, width, d, dest_Bpp, s, src_Bpp);
 		}
-
-		return true;
 	}
 
-	static bool
-	create_alpha_texture (Texture::Data* self)
+	static void
+	setup_texture (
+		Texture::Data* self, int width, int height, const ColorSpace& cs,
+		const Bitmap* bitmap, bool alpha_only)
 	{
-		if (!self || !self->bitmap) return false;
-
-		ColorSpace cs = self->bitmap.color_space();
-		int width_pow2  = min_pow2(self->width);
-		int height_pow2 = min_pow2(self->height);
+		if (!self || width <= 0 || height <= 0 || !cs || (bitmap && !*bitmap))
+			argument_error(__FILE__, __LINE__);
 
-		if (
-			width_pow2  != self->width  ||
-			height_pow2 != self->height ||
-			cs.is_rgb() ||
-			cs.is_bgr())
-		{
-			ColorSpace newcs;
-			if (!colorspace_for_alphabitmap(&newcs, cs))
-				return false;
+		GLenum format, type;
+		cs.get_gl_enums(&format, &type, alpha_only);
 
-			Bitmap bmp(width_pow2, height_pow2, newcs);
-			if (!bmp) return false;
+		self->clear();
 
-			if (!copy_bitmap(&bmp, self->bitmap, cs.alpha_pos()))
-				return false;
+		self->width       = width;
+		self->height      = height;
+		self->width_pow2  = min_pow2(width);
+		self->height_pow2 = min_pow2(height);
+		self->color_space = cs;
+		self->alpha_only  = alpha_only;
+		self->dirty       = true;
 
-			self->bitmap = bmp;
-			cs = self->bitmap.color_space();
+		if (alpha_only)
+		{
+			colorspace_for_alphabitmap(&self->color_space, cs);
+			if (!self->color_space.is_gray())
+				rays_error(__FILE__, __LINE__, "alpha_only takes only gray color-space.");
 		}
 
-		if (!self->bitmap.color_space().is_gray())
-			return false;
-
-		return create_texture(self, GL_ALPHA);
-	}
-
-	static bool
-	create_color_texture (Texture::Data* self)
-	{
-		if (!self || !self->bitmap) return false;
-
-		int width_pow2  = min_pow2(self->width);
-		int height_pow2 = min_pow2(self->height);
-
-		if (
-			width_pow2  != self->width ||
-			height_pow2 != self->height)
+		Bitmap bmp;
+		if (bitmap)
 		{
-			Bitmap bmp(
-				width_pow2, height_pow2, self->bitmap.color_space());
-			if (!bmp) return false;
-
-			if (!copy_bitmap(&bmp, self->bitmap))
-				return false;
+			if (
+				self->color_space != cs ||
+				self->width_pow2  != self->width ||
+				self->height_pow2 != self->height)
+			{
+				bmp = Bitmap(self->width_pow2, self->height_pow2, self->color_space);
+				if (!bmp)
+					rays_error(__FILE__, __LINE__, "creating bitmap failed.");
 
-			self->bitmap = bmp;
+				copy_bitmap(&bmp, *bitmap, alpha_only ? self->color_space.alpha_pos() : 0);
+				bitmap = &bmp;
+			}
 		}
 
-		ColorSpace cs = self->bitmap.color_space();
-
-		bool alpha = cs.has_alpha();
-		if (cs.is_rgb())
-			return create_texture(self, alpha ? GL_RGBA : GL_RGB);
-		else if (cs.is_bgr())
-			return create_texture(self, alpha ? GL_BGRA : GL_BGR);
-		else if (cs.is_gray())
-			return create_texture(self, GL_LUMINANCE);
-		else
-			return false;
+		create_texture(self, bitmap, format, type);
 	}
 
-	static bool
-	setup_texture (
-		Texture::Data* self, const Bitmap& bitmap, bool alphaonly = false)
-	{
-		if (!self || !bitmap) return false;
-
-		self->clear();
-
-		self->bitmap = bitmap;
-		if (!self->bitmap) return false;
 
-		self->width  = self->bitmap.width();
-		self->height = self->bitmap.height();
-
-		if (alphaonly)
-			return create_alpha_texture(self);
-		else
-			return create_color_texture(self);
+	Texture::Texture ()
+	{
 	}
 
-
-	Texture::Texture ()
+	Texture::Texture (int width, int height, const ColorSpace& cs, bool alpha_only)
 	{
+		setup_texture(
+			self.get(), width, height, cs,
+			NULL, alpha_only);
 	}
 
-	Texture::Texture (const Bitmap& bitmap, bool alphaonly)
+	Texture::Texture (const Bitmap& bitmap, bool alpha_only)
 	{
-		setup_texture(self.get(), bitmap, alphaonly);
+		setup_texture(
+			self.get(), bitmap.width(), bitmap.height(), bitmap.color_space(),
+			&bitmap, alpha_only);
 	}
 
 	Texture::~Texture ()
@@ -329,16 +281,28 @@ namespace Rays
 		return self->height;
 	}
 
+	const ColorSpace&
+	Texture::color_space () const
+	{
+		return self->color_space;
+	}
+
+	bool
+	Texture::alpha_only () const
+	{
+		return self->alpha_only;
+	}
+
 	float
 	Texture::s (float x) const
 	{
-		return x / (float) self->bitmap.width();
+		return x / (float) self->width_pow2;
 	}
 
 	float
 	Texture::t (float y) const
 	{
-		return y / (float) self->bitmap.height();
+		return y / (float) self->height_pow2;
 	}
 
 	float
@@ -353,10 +317,16 @@ namespace Rays
 		return t(self->height);
 	}
 
-	const Bitmap&
-	Texture::bitmap () const
+	bool
+	Texture::dirty () const
+	{
+		return self->dirty;
+	}
+
+	void
+	Texture::set_dirty (bool b)
 	{
-		return self->bitmap;
+		self->dirty = b;
 	}
 
 	Texture::operator bool () const

data/test/helper.rb

@@ -1,13 +1,20 @@
 # -*- coding: utf-8 -*-
 
 
-require 'xot/load_path'
-Xot::LoadPath.unshift File.expand_path('../../lib', __FILE__)
+%w[../xot ../rucy .]
+  .map  {|s| File.expand_path "../../#{s}/lib", __FILE__}
+  .each {|s| $:.unshift s if !$:.include?(s) && File.directory?(s)}
 
 require 'test/unit'
+require 'xot/test'
 require 'rays'
 
+include Xot::Test
+
 
 unless $RAYS_NOAUTOINIT
-  def Rays.fin! (); end
+  def Rays.fin! () end
 end
+
+
+Rays.init_offscreen_context

data/test/test_bitmap.rb

@@ -6,4 +6,22 @@ require_relative 'helper'
 
 class TestBitmap < Test::Unit::TestCase
 
+  W = 32
+  H = 16
+
+  def bmp (w = W, h = H)
+    Rays::Bitmap.new w, h
+  end
+
+  def test_initialize ()
+    assert_equal W, bmp.width
+    assert_equal H, bmp.height
+  end
+
+  def test_to_texture ()
+    assert_equal Rays::Texture, bmp.to_texture.class
+    assert_equal W, bmp.to_texture.width
+    assert_equal H, bmp.to_texture.height
+  end
+
 end# TestBitmap

data/test/test_bounds.rb

@@ -25,6 +25,16 @@ class TestBounds < Test::Unit::TestCase
     assert_raise(ArgumentError) {bounds(1, 2, 3, 4, 5, 6, 7)}
   end
 
+  def test_intersect? ()
+    assert     bounds(10, 20, 30, 100, 100, 100).intersect?(bounds 50, 60, 70, 100, 100, 100)
+    assert_not bounds(10, 20, 30,  10,  10,  10).intersect?(bounds 50, 60, 70, 100, 100, 100)
+  end
+
+  def test_include? ()
+    assert     bounds(10, 20, 30, 100, 100, 100).include?(point 50, 60)
+    assert_not bounds(10, 20, 30,  10,  10,  10).include?(point 50, 60)
+  end
+
   def test_get_xyzwhd ()
     o = bounds 1, 2, 3, 4, 5, 6
     assert_equal 1, o.x
@@ -68,22 +78,36 @@ class TestBounds < Test::Unit::TestCase
     assert_equal 4, o.right
     assert_equal 6, o.bottom
     assert_equal 8, o.front
+    assert_equal [1, 2], o.lt.to_a
+    assert_equal [4, 2], o.rt.to_a
+    assert_equal [1, 6], o.lb.to_a
+    assert_equal [4, 6], o.rb.to_a
   end
 
   def test_set_ltbrbf ()
-    o = bounds
-    o.left   = -1
-    assert_equal [-1,  0,  0,  1,  0,  0], o.to_a(3)
-    o.top    = -2
-    assert_equal [-1, -2,  0,  1,  2,  0], o.to_a(3)
-    o.back   = -3
-    assert_equal [-1, -2, -3,  1,  2,  3], o.to_a(3)
-    o.right  = 11
-    assert_equal [-1, -2, -3, 13,  2,  3], o.to_a(3)
-    o.bottom = 22
-    assert_equal [-1, -2, -3, 13, 25,  3], o.to_a(3)
-    o.front  = 33
-    assert_equal [-1, -2, -3, 13, 25, 37], o.to_a(3)
+    assert_equal [1, 0, 0, -1,  0,  0], bounds.tap {|o| o.left   = 1}.to_a(3)
+    assert_equal [0, 2, 0,  0, -2,  0], bounds.tap {|o| o.top    = 2}.to_a(3)
+    assert_equal [0, 0, 3,  0,  0, -3], bounds.tap {|o| o.back   = 3}.to_a(3)
+    assert_equal [0, 0, 0,  5,  0,  0], bounds.tap {|o| o.right  = 4}.to_a(3)
+    assert_equal [0, 0, 0,  0,  6,  0], bounds.tap {|o| o.bottom = 5}.to_a(3)
+    assert_equal [0, 0, 0,  0,  0,  7], bounds.tap {|o| o.front  = 6}.to_a(3)
+
+    assert_equal [-1,  0,  0,  1,  0,  0], bounds.tap {|o| o.left   = -1}.to_a(3)
+    assert_equal [ 0, -2,  0,  0,  2,  0], bounds.tap {|o| o.top    = -2}.to_a(3)
+    assert_equal [ 0,  0, -3,  0,  0,  3], bounds.tap {|o| o.back   = -3}.to_a(3)
+    assert_equal [ 0,  0,  0, -5,  0,  0], bounds.tap {|o| o.right  = -4}.to_a(3)
+    assert_equal [ 0,  0,  0,  0, -6,  0], bounds.tap {|o| o.bottom = -5}.to_a(3)
+    assert_equal [ 0,  0,  0,  0,  0, -7], bounds.tap {|o| o.front  = -6}.to_a(3)
+
+    assert_equal [20, 30, 0, 20, 30, 0], bounds(10, 20, 30, 40).tap {|o| o.lt = [20, 30]}.to_a(3)
+    assert_equal [10, 30, 0, 11, 30, 0], bounds(10, 20, 30, 40).tap {|o| o.rt = [20, 30]}.to_a(3)
+    assert_equal [20, 20, 0, 20, 11, 0], bounds(10, 20, 30, 40).tap {|o| o.lb = [20, 30]}.to_a(3)
+    assert_equal [10, 20, 0, 11, 11, 0], bounds(10, 20, 30, 40).tap {|o| o.rb = [20, 30]}.to_a(3)
+
+    assert_equal [20, 30, 0, 20, 30, 0], bounds(10, 20, 30, 40).tap {|o| o.lt += 10}.to_a(3)
+    assert_equal [10, 30, 0, 40, 30, 0], bounds(10, 20, 30, 40).tap {|o| o.rt += 10}.to_a(3)
+    assert_equal [20, 20, 0, 20, 50, 0], bounds(10, 20, 30, 40).tap {|o| o.lb += 10}.to_a(3)
+    assert_equal [10, 20, 0, 40, 50, 0], bounds(10, 20, 30, 40).tap {|o| o.rb += 10}.to_a(3)
   end
 
   def test_position ()
@@ -105,9 +129,12 @@ class TestBounds < Test::Unit::TestCase
 
   def test_move_to ()
     o = bounds 1, 2, 3, 4, 5, 6
-    assert_equal bounds(7, 7, 3, 4, 5, 6), o.move_to(7)
-    assert_equal bounds(7, 8, 3, 4, 5, 6), o.move_to(7, 8)
-    assert_equal bounds(7, 8, 9, 4, 5, 6), o.move_to(7, 8, 9)
+    assert_equal bounds(7, 2, 3, 4, 5, 6), o.move_to(  7)
+    assert_equal bounds(7, 8, 3, 4, 5, 6), o.move_to(  7,   8)
+    assert_equal bounds(1, 8, 3, 4, 5, 6), o.move_to(nil,   8)
+    assert_equal bounds(7, 8, 9, 4, 5, 6), o.move_to(  7,   8, 9)
+    assert_equal bounds(1, 8, 9, 4, 5, 6), o.move_to(nil,   8, 9)
+    assert_equal bounds(1, 2, 9, 4, 5, 6), o.move_to(nil, nil, 9)
     assert_raise(ArgumentError) {o.move_to()}
     assert_raise(ArgumentError) {o.move_to(7, 8, 9, 10)}
 
@@ -122,10 +149,13 @@ class TestBounds < Test::Unit::TestCase
 
   def test_move_by ()
     o = bounds 1, 2, 3, 4, 5, 6
-    assert_equal bounds( 8,  9,  3, 4, 5, 6), o.move_by(7)
-    assert_equal bounds( 8, 10,  3, 4, 5, 6), o.move_by(7, 8)
-    assert_equal bounds( 8, 10, 12, 4, 5, 6), o.move_by(7, 8, 9)
-    assert_equal bounds(-6, -5,  3, 4, 5, 6), o.move_by(-7)
+    assert_equal bounds( 8,  2,  3, 4, 5, 6), o.move_by(  7)
+    assert_equal bounds( 8, 10,  3, 4, 5, 6), o.move_by(  7,   8)
+    assert_equal bounds( 1, 10,  3, 4, 5, 6), o.move_by(nil,   8)
+    assert_equal bounds( 8, 10, 12, 4, 5, 6), o.move_by(  7,   8, 9)
+    assert_equal bounds( 1, 10, 12, 4, 5, 6), o.move_by(nil,   8, 9)
+    assert_equal bounds( 1,  2, 12, 4, 5, 6), o.move_by(nil, nil, 9)
+    assert_equal bounds(-6,  2,  3, 4, 5, 6), o.move_by(-7)
     assert_equal bounds(-6, -6,  3, 4, 5, 6), o.move_by(-7, -8)
     assert_equal bounds(-6, -6, -6, 4, 5, 6), o.move_by(-7, -8, -9)
     assert_raise(ArgumentError) {o.move_by()}
@@ -142,9 +172,12 @@ class TestBounds < Test::Unit::TestCase
 
   def test_resize_to ()
     o = bounds 1, 2, 3, 4, 5, 6
-    assert_equal bounds(1, 2, 3, 7, 7, 6), o.resize_to(7)
-    assert_equal bounds(1, 2, 3, 7, 8, 6), o.resize_to(7, 8)
-    assert_equal bounds(1, 2, 3, 7, 8, 9), o.resize_to(7, 8, 9)
+    assert_equal bounds(1, 2, 3, 7, 5, 6), o.resize_to(  7)
+    assert_equal bounds(1, 2, 3, 7, 8, 6), o.resize_to(  7,   8)
+    assert_equal bounds(1, 2, 3, 4, 8, 6), o.resize_to(nil,   8)
+    assert_equal bounds(1, 2, 3, 7, 8, 9), o.resize_to(  7,   8, 9)
+    assert_equal bounds(1, 2, 3, 4, 8, 9), o.resize_to(nil,   8, 9)
+    assert_equal bounds(1, 2, 3, 4, 5, 9), o.resize_to(nil, nil, 9)
     assert_raise(ArgumentError) {o.resize_to()}
     assert_raise(ArgumentError) {o.resize_to(7, 8, 9, 10)}
 
@@ -159,10 +192,13 @@ class TestBounds < Test::Unit::TestCase
 
   def test_resize_by ()
     o = bounds 1, 2, 3, 4, 5, 6
-    assert_equal bounds(1, 2, 3, 11, 12,  6), o.resize_by(7)
-    assert_equal bounds(1, 2, 3, 11, 13,  6), o.resize_by(7, 8)
-    assert_equal bounds(1, 2, 3, 11, 13, 15), o.resize_by(7, 8, 9)
-    assert_equal bounds(1, 2, 3, -3, -2,  6), o.resize_by(-7)
+    assert_equal bounds(1, 2, 3, 11,  5,  6), o.resize_by(  7)
+    assert_equal bounds(1, 2, 3, 11, 13,  6), o.resize_by(  7,   8)
+    assert_equal bounds(1, 2, 3,  4, 13,  6), o.resize_by(nil,   8)
+    assert_equal bounds(1, 2, 3, 11, 13, 15), o.resize_by(  7,   8, 9)
+    assert_equal bounds(1, 2, 3,  4, 13, 15), o.resize_by(nil,   8, 9)
+    assert_equal bounds(1, 2, 3,  4,  5, 15), o.resize_by(nil, nil, 9)
+    assert_equal bounds(1, 2, 3, -3,  5,  6), o.resize_by(-7)
     assert_equal bounds(1, 2, 3, -3, -3,  6), o.resize_by(-7, -8)
     assert_equal bounds(1, 2, 3, -3, -3, -3), o.resize_by(-7, -8, -9)
     assert_raise(ArgumentError) {o.resize_by()}
@@ -179,9 +215,12 @@ class TestBounds < Test::Unit::TestCase
 
   def test_inset_by ()
     o = bounds 1, 2, 3, 20, 30, 40
-    assert_equal bounds(8,  9,  3, 6, 16, 40), o.inset_by(7)
-    assert_equal bounds(8, 10,  3, 6, 14, 40), o.inset_by(7, 8)
-    assert_equal bounds(8, 10, 12, 6, 14, 22), o.inset_by(7, 8, 9)
+    assert_equal bounds(8,  2,  3,  6, 30, 40), o.inset_by(  7)
+    assert_equal bounds(8, 10,  3,  6, 14, 40), o.inset_by(  7,   8)
+    assert_equal bounds(1, 10,  3, 20, 14, 40), o.inset_by(nil,   8)
+    assert_equal bounds(8, 10, 12,  6, 14, 22), o.inset_by(  7,   8, 9)
+    assert_equal bounds(1, 10, 12, 20, 14, 22), o.inset_by(nil,   8, 9)
+    assert_equal bounds(1,  2, 12, 20, 30, 22), o.inset_by(nil, nil, 9)
     assert_raise(ArgumentError) {o.inset_by()}
     assert_raise(ArgumentError) {o.inset_by(7, 8, 9, 10)}
 
@@ -208,7 +247,7 @@ class TestBounds < Test::Unit::TestCase
   def test_index ()
     o = bounds 1, 2, 3, 4, 5, 6
     assert_equal point(1, 2, 3), o[0]
-    assert_equal point(4, 6, 8), o[1]
+    assert_equal point(4, 5, 6), o[1]
     assert_raise(IndexError) {o[-1]}
     assert_raise(IndexError) {o[2]}
   end
@@ -216,17 +255,17 @@ class TestBounds < Test::Unit::TestCase
   def test_index_assign ()
     o = bounds 1, 2, 3, 4, 5, 6
     o[0] = point 7, 8, 9
-    assert_equal bounds(7, 8, 9, -2, -1, 0), o
+    assert_equal bounds(7, 8, 9, 4, 5, 6), o
     o[1] = point 10, 11, 12
-    assert_equal bounds(7, 8, 9, 4, 4, 4), o
+    assert_equal bounds(7, 8, 9, 10, 11, 12), o
     assert_raise(IndexError) {o[-1]}
     assert_raise(IndexError) {o[2]}
   end
 
   def test_compare ()
     o = bounds 1, 2, 3, 4, 5, 6
-    assert o == bounds(1, 2, 3, 4, 5, 6)
-    assert !(o != bounds(1, 2, 3, 4, 5, 6))
+    assert     o == bounds(1, 2, 3, 4, 5, 6)
+    assert_not o != bounds(1, 2, 3, 4, 5, 6)
 
     assert o < bounds(2, 2, 3, 4, 5, 6)
     assert o < bounds(1, 3, 3, 4, 5, 6)
@@ -243,4 +282,11 @@ class TestBounds < Test::Unit::TestCase
     assert o > bounds(1, 2, 3, 4, 5, 5)
   end
 
+  def test_operators ()
+    assert_equal bounds(50, 60, 70,  60,  60,  60), bounds(10, 20, 30, 100, 100, 100) & bounds(50, 60, 70, 100, 100, 100)
+    assert_equal bounds(10, 20, 30, 140, 140, 140), bounds(10, 20, 30, 100, 100, 100) | bounds(50, 60, 70, 100, 100, 100)
+
+    assert_equal point(0), (bounds(10, 20, 30, 10, 10, 10) & bounds(50, 60, 70, 10, 10, 10)).size
+  end
+
 end# TestBounds

data/test/test_color.rb

@@ -10,15 +10,42 @@ class TestColor < Test::Unit::TestCase
     Rays::Color.new *args
   end
 
+  def color8 (r, g, b, a, div = 255)
+    color *[r, g, b, a].map {|n| n / div.to_f}
+  end
+
+  def parse (*args)
+    Rays::Color.parse *args
+  end
+
   def test_initialize ()
     assert_equal color(0, 0, 0, 1), color()
     assert_equal color(1, 1, 1, 1), color(1)
     assert_equal color(1, 1, 1, 2), color(1, 2)
     assert_equal color(1, 2, 3, 1), color(1, 2, 3)
     assert_equal color(1, 2, 3, 4), color(1, 2, 3, 4)
+    assert_equal color8(1, 2, 3, 4), color('#01020304')
     assert_raise(ArgumentError) {color(1, 2, 3, 4, 5)}
   end
 
+  def test_parse ()
+    assert_equal color(0, 0, 0, 1), parse('#000')
+    assert_equal color(0, 0, 0, 1), parse('#000000')
+    assert_equal color(0, 0, 0, 0), parse('#0000')
+    assert_equal color(0, 0, 0, 0), parse('#00000000')
+    assert_equal color8(0x01, 0x23, 0x45, 0x67), parse('#01234567')
+    assert_equal color8(0x89, 0xab, 0xcd, 0xef), parse('#89abcdef')
+    assert_equal color8(0x0, 0x2, 0x4, 0x6, 15), parse('#0246')
+    assert_equal color8(0x9, 0xb, 0xd, 0xf, 15), parse('#9bdf')
+    assert_equal color(0, 0, 0, 1), parse(' #000 ')
+    assert_raise(ArgumentError) {parse '#'}
+    assert_raise(ArgumentError) {parse '000'}
+    assert_raise(ArgumentError) {parse '#0'}
+    assert_raise(ArgumentError) {parse '#00'}
+    assert_raise(ArgumentError) {parse '#00000'}
+    assert_raise(ArgumentError) {parse '#0000000'}
+  end
+
   def test_get_rgb ()
     o = color 1, 2, 3, 4
     assert_equal 1, o.red
@@ -71,8 +98,8 @@ class TestColor < Test::Unit::TestCase
 
   def test_compare ()
     o = color 1, 2, 3, 4
-    assert o == color(1, 2, 3, 4)
-    assert !(o != color(1, 2, 3, 4))
+    assert     o == color(1, 2, 3, 4)
+    assert_not o != color(1, 2, 3, 4)
 
     assert o < color(2, 2, 3, 4)
     assert o < color(1, 3, 3, 4)