rays 0.1.3 → 0.1.4

data/ext/rays/defs.h

@@ -7,24 +7,7 @@
 #include <rays/exception.h>
 
 
-using Rays::error;
-
-
-#define CHECK_OBJ(obj, type, klass) \
-	do \
-	{ \
-		type* p = Rucy::get_type<type>(obj, klass); \
-		if (!p) Rucy::invalid_object_error(); \
-	} \
-	while(0)
-
-#define CHECK_OBJECT(obj, type, klass) \
-	do \
-	{ \
-		type* p = Rucy::get_type<type>(obj, klass); \
-		if (!p || !*p) Rucy::invalid_object_error(); \
-	} \
-	while(0)
+using Rays::rays_error;
 
 
 #endif//EOH

data/ext/rays/extconf.rb

@@ -1,11 +1,7 @@
 # -*- coding: utf-8 -*-
 
 
-%w[. xot rucy].map {|s| "../../#{s}/lib"}.each do |path|
-  $: << File.expand_path(File.join File.dirname(__FILE__), *path.split('/'))
-end
-
-require 'rubygems'
+require 'bundler/setup'
 require 'mkmf'
 require 'xot/rake/helpers'
 require 'xot/module'
@@ -15,7 +11,8 @@ require 'rays/module'
 include Xot::Rake
 
 
-DEBUG = env :DEBUG, false
+debug = env :DEBUG, false
+
 
 DEFS    = []
 INCDIRS = %w[
@@ -40,7 +37,8 @@ LIBS = %w[
 FRAMEWORKS = []
 
 
-DEFS << '_DEBUG' if DEBUG
+DEFS << '_DEBUG' if debug
+DEFS << 'NDEBUG' unless debug
 DEFS << $~[0].upcase if RUBY_PLATFORM =~ /mswin|ming|cygwin|darwin/i
 if win32?
   DEFS << 'WINDOWS' << 'WIN32'
@@ -54,9 +52,13 @@ $CPPFLAGS   << DEFS.map       {|s| " -D#{s}"}.join
 $CPPFLAGS   << INCDIRS.map    {|s| " -I#{s}"}.join
 $LDFLAGS    << LIBDIRS.map    {|s| " -L#{s}"}.join
 $LDFLAGS    << FRAMEWORKS.map {|s| " -framework #{s}"}.join
+$LDFLAGS    << ' -Wl,--out-implib=native.dll.a' if cygwin?
+$CFLAGS     << ' --stdlib=libc++' if clang?
 $LOCAL_LIBS << ' -lrucy'
 
-Config::CONFIG.each {|key, val| val.gsub!(/gcc/, 'g++')}
+RbConfig::CONFIG.each do |key, val|
+  {'gcc' => 'g++', 'clang' => 'clang++'}.each {|from, to| val.gsub! from, to}
+end
 
 
 dir_config 'boost'

data/ext/rays/font.cpp

@@ -10,12 +10,13 @@ using namespace Rucy;
 using Rays::coord;
 
 
+static Class cFont;
+
+
 namespace Rays
 {
 
 
-	static Class cFont;
-
 	Class
 	font_class ()
 	{
@@ -31,38 +32,43 @@ namespace Rucy
 
 
 	Value
-	value (const Rays::Font& font)
+	value (const Rays::Font& obj)
 	{
-		return new_type<Rays::Font>(
-			Rays::font_class(), new Rays::Font(font));
+		return new_type(cFont, new Rays::Font(obj));
+	}
+
+	Value
+	value (const Rays::Font* obj)
+	{
+		return obj ? value(*obj) : nil();
 	}
 
 
 }// Rucy
 
 
-#define this to<Rays::Font*>(self)
+#define THIS to<Rays::Font*>(self)
 
-#define CHECK CHECK_OBJECT(self, Rays::Font, Rays::font_class())
+#define CHECK RUCY_CHECK_OBJECT(self, Rays::Font, cFont)
 
 
 static
 RUBY_DEF_ALLOC(alloc, klass)
 {
-	return new_type<Rays::Font>(klass, new Rays::Font);
+	return new_type<Rays::Font>(klass);
 }
 RUBY_END
 
 static
 RUBY_DEFN(initialize)
 {
-	CHECK_OBJ(self, Rays::Font, Rays::font_class());
+	RUCY_CHECK_OBJ(self, Rays::Font, cFont);
 	if (argc < 0 || 2 < argc)
 		arg_count_error("Font#initialize", argc, 0, 1, 2);
 
 	const char* name = (argc >= 1) ? argv[0].c_str()    : NULL;
 	float size       = (argc >= 2) ? to<float>(argv[1]) : 0;
-	*this = Rays::Font(name, size);
+	*THIS = Rays::Font(name, size);
 
 	return self;
 }
@@ -73,7 +79,7 @@ RUBY_DEF0(name)
 {
 	CHECK;
 
-	return value(this->name().c_str());
+	return value(THIS->name().c_str());
 }
 RUBY_END
 
@@ -82,7 +88,7 @@ RUBY_DEF0(size)
 {
 	CHECK;
 
-	return value(this->size());
+	return value(THIS->size());
 }
 RUBY_END
 
@@ -92,8 +98,8 @@ RUBY_DEF1(width, str)
 	CHECK;
 
 	coord width = 0;
-	if (!this->get_extent(&width, NULL, str.c_str()))
-		error("Font#width(%s) failed.", str.inspect().c_str());
+	if (!THIS->get_width(&width, str.c_str()))
+		rays_error("Font#width(%s) failed.", str.inspect().c_str());
 
 	return value(width);
 }
@@ -105,8 +111,8 @@ RUBY_DEF0(height)
 	CHECK;
 
 	coord height = 0;
-	if (!this->get_extent(NULL, &height, NULL))
-		error("Font#height() failed.");
+	if (!THIS->get_height(&height))
+		rays_error("Font#height() failed.");
 
 	return value(height);
 }
@@ -116,15 +122,13 @@ RUBY_END
 void
 Init_font ()
 {
-	Module m = define_module("Rays");
-
-	Class c = m.define_class("Font");
-	Rays::cFont = c;
-
-	c.define_alloc_func(alloc);
-	c.define_method("initialize", initialize);
-	c.define_method("name", name);
-	c.define_method("size", size);
-	c.define_method("width", width);
-	c.define_method("height", height);
+	Module mRays = define_module("Rays");
+
+	cFont = mRays.define_class("Font");
+	cFont.define_alloc_func(alloc);
+	cFont.define_private_method("initialize", initialize);
+	cFont.define_method("name", name);
+	cFont.define_method("size", size);
+	cFont.define_method("width", width);
+	cFont.define_method("height", height);
 }

data/ext/rays/image.cpp

@@ -12,12 +12,13 @@ using namespace Rucy;
 using Rays::coord;
 
 
+static Class cImage;
+
+
 namespace Rays
 {
 
 
-	static Class cImage;
-
 	Class
 	image_class ()
 	{
@@ -33,52 +34,60 @@ namespace Rucy
 
 
 	Value
-	value (const Rays::Image& image)
+	value (const Rays::Image& obj)
 	{
-		return new_type<Rays::Image>(
-			Rays::image_class(), new Rays::Image(image));
+		return new_type(cImage, new Rays::Image(obj));
+	}
+
+	Value
+	value (const Rays::Image* obj)
+	{
+		return obj ? value(*obj) : nil();
 	}
 
 
 }// Rucy
 
 
-#define this to<Rays::Image*>(self)
+#define THIS to<Rays::Image*>(self)
 
-#define CHECK CHECK_OBJECT(self, Rays::Image, Rays::image_class())
+#define CHECK RUCY_CHECK_OBJECT(self, Rays::Image, cImage)
 
 
 static
 RUBY_DEF_ALLOC(alloc, klass)
 {
-	return new_type<Rays::Image>(klass, new Rays::Image);
+	return new_type<Rays::Image>(klass);
 }
 RUBY_END
 
 static
 RUBY_DEFN(initialize)
 {
-	CHECK_OBJ(self, Rays::Image, Rays::image_class());
-	if (argc != 0 && argc != 1 && argc != 2 && argc != 3)
-		arg_count_error("Image#initialize", argc, 0, 1, 2, 3);
+	RUCY_CHECK_OBJ(self, Rays::Image, cImage);
+
+	if (argc < 1 || 3 < argc)
+		arg_count_error("Image#initialize", argc, 1, 2, 3);
 
 	if (argc == 0) return self;
 
-	if (argv[1].is_kind_of(Rays::bitmap_class()))
+	if (argv[0].is_kind_of(Rays::bitmap_class()))
 	{
-		if (argc != 1 && argc != 2)
-			arg_count_error("Image#initialize", argc, 0, 1, 2, 3);
+		if (argc < 1 || 2 < argc)
+			arg_count_error("Image#initialize", argc, 1, 2);
+
+		const Rays::Bitmap* bitmap = to<Rays::Bitmap*>(argv[0]);
+		if (!bitmap) argument_error();
 
-		const Rays::Bitmap& bitmap = *to<Rays::Bitmap*>(argv[1]);
-		bool alphaonly = (argc == 2) ? to<bool>(argv[2]) : false;
-		*this = Rays::Image(bitmap, alphaonly);
+		bool alphaonly = (argc == 2) ? to<bool>(argv[1]) : false;
+		*THIS = Rays::Image(*bitmap, alphaonly);
 	}
 	else
 	{
 		int width  = to<int>(argv[0]);
 		int height = to<int>(argv[1]);
 		uint colorspace = (argc == 3) ? to<uint>(argv[2]) : (uint) Rays::RGBA;
-		*this = Rays::Image(width, height, (Rays::ColorSpaceType) colorspace);
+		*THIS = Rays::Image(width, height, (Rays::ColorSpaceType) colorspace);
 	}
 
 	return self;
@@ -90,7 +99,7 @@ RUBY_DEF0(width)
 {
 	CHECK;
 
-	return value(this->width());
+	return value(THIS->width());
 }
 RUBY_END
 
@@ -99,7 +108,7 @@ RUBY_DEF0(height)
 {
 	CHECK;
 
-	return value(this->height());
+	return value(THIS->height());
 }
 RUBY_END
 
@@ -108,7 +117,7 @@ RUBY_DEF0(color_space)
 {
 	CHECK;
 
-	return value(this->color_space().type());
+	return value(THIS->color_space().type());
 }
 RUBY_END
 
@@ -117,7 +126,7 @@ RUBY_DEF0(bitmap)
 {
 	CHECK;
 
-	return value(this->bitmap());
+	return value(THIS->bitmap());
 }
 RUBY_END
 
@@ -126,7 +135,7 @@ RUBY_DEF0(texture)
 {
 	CHECK;
 
-	return value(this->texture());
+	return value(THIS->texture());
 }
 RUBY_END
 
@@ -142,7 +151,7 @@ RUBY_DEFN(load)
 	Rays::Image img;
 	if (!Rays::load_image(&img, path.c_str(), alphaonly))
 	{
-		error(
+		rays_error(
 			"Image.load('%s', %s) failed.",
 			path.c_str(), alphaonly ? "true" : "false");
 	}
@@ -155,17 +164,15 @@ RUBY_END
 void
 Init_image ()
 {
-	Module m = define_module("Rays");
-
-	Class c = m.define_class("Image");
-	Rays::cImage = c;
-
-	c.define_alloc_func(alloc);
-	c.define_method("initialize", initialize);
-	c.define_method("width", width);
-	c.define_method("height", height);
-	c.define_method("color_space", color_space);
-	c.define_method("bitmap", bitmap);
-	c.define_method("texture", texture);
-	c.define_function("load", load);
+	Module mRays = define_module("Rays");
+
+	cImage = mRays.define_class("Image");
+	cImage.define_alloc_func(alloc);
+	cImage.define_private_method("initialize", initialize);
+	cImage.define_method("width", width);
+	cImage.define_method("height", height);
+	cImage.define_method("color_space", color_space);
+	cImage.define_method("bitmap", bitmap);
+	cImage.define_method("texture", texture);
+	cImage.define_function("load", load);
 }

data/ext/rays/matrix.cpp

@@ -0,0 +1,154 @@
+#include "rays/ruby/matrix.h"
+
+
+#include <rucy.h>
+#include "defs.h"
+
+
+using namespace Rucy;
+
+
+static Class cMatrix;
+
+
+namespace Rays
+{
+
+
+	Class
+	matrix_class ()
+	{
+		return cMatrix;
+	}
+
+
+}// Rays
+
+
+namespace Rucy
+{
+
+
+	Value
+	value (const Rays::Matrix& obj)
+	{
+		return new_type(cMatrix, new Rays::Matrix(obj));
+	}
+
+	Value
+	value (const Rays::Matrix* obj)
+	{
+		return obj ? value(*obj) : nil();
+	}
+
+
+}// Rucy
+
+
+#define THIS to<Rays::Matrix*>(self)
+
+#define CHECK RUCY_CHECK_OBJ(self, Rays::Matrix, cMatrix)
+
+
+static
+RUBY_DEF_ALLOC(alloc, klass)
+{
+	return new_type<Rays::Matrix>(klass);
+}
+RUBY_END
+
+static
+RUBY_DEFN(initialize)
+{
+	RUCY_CHECK_OBJ(self, Rays::Matrix, cMatrix);
+
+	if (argc != 0 && argc != 1 && argc != 16)
+		arg_count_error("Matrix#initialize", argc, 0, 1, 16);
+
+	if (argc == 0) return self;
+
+	switch (argc)
+	{
+		case 1:
+			*THIS = Rays::Matrix(to<float>(argv[0]));
+			break;
+
+		case 16:
+			*THIS = Rays::Matrix(
+				to<float>(argv[0]),  to<float>(argv[1]),  to<float>(argv[2]),  to<float>(argv[3]),
+				to<float>(argv[4]),  to<float>(argv[5]),  to<float>(argv[6]),  to<float>(argv[7]),
+				to<float>(argv[8]),  to<float>(argv[9]),  to<float>(argv[10]), to<float>(argv[11]),
+				to<float>(argv[12]), to<float>(argv[13]), to<float>(argv[14]), to<float>(argv[15]));
+			break;
+	}
+
+	return self;
+}
+RUBY_END
+
+static
+RUBY_DEF1(initialize_copy, obj)
+{
+	RUCY_CHECK_OBJ(self, Rays::Matrix, cMatrix);
+
+	Rays::Matrix* matrix = to<Rays::Matrix*>(obj);
+	if (!matrix) argument_error();
+
+	*THIS = *matrix;
+	return self;
+}
+RUBY_END
+
+static
+RUBY_DEFN(set)
+{
+	CHECK;
+
+	if (argc != 0 && argc != 1 && argc != 16)
+		arg_count_error("Matrix#initialize", argc, 0, 1, 16);
+
+	switch (argc)
+	{
+		case 0:
+			*THIS = Rays::Matrix();
+			break;
+
+		case 1:
+			*THIS = Rays::Matrix(to<float>(argv[0]));
+			break;
+
+		case 16:
+			*THIS = Rays::Matrix(
+				to<float>(argv[0]),  to<float>(argv[1]),  to<float>(argv[2]),  to<float>(argv[3]),
+				to<float>(argv[4]),  to<float>(argv[5]),  to<float>(argv[6]),  to<float>(argv[7]),
+				to<float>(argv[8]),  to<float>(argv[9]),  to<float>(argv[10]), to<float>(argv[11]),
+				to<float>(argv[12]), to<float>(argv[13]), to<float>(argv[14]), to<float>(argv[15]));
+			break;
+	}
+
+	return self;
+}
+RUBY_END
+
+static
+RUBY_DEF2(at, row, column)
+{
+	CHECK;
+
+	return value(THIS->at(row.as_i(), column.as_i()));
+}
+RUBY_END
+
+
+void
+Init_matrix ()
+{
+	Module mRays = define_module("Rays");
+
+	cMatrix = mRays.define_class("Matrix");
+	cMatrix.define_alloc_func(alloc);
+	cMatrix.define_private_method("initialize", initialize);
+	cMatrix.define_private_method("initialize_copy", initialize_copy);
+	cMatrix.define_method("set", set);
+	cMatrix.define_method("at", at);
+}