rays 0.1.6 → 0.1.7

data/ext/rays/color.cpp

@@ -10,60 +10,25 @@ using namespace Rucy;
 
 static Class cColor;
 
+RUCY_DEFINE_VALUE_FROM_TO(Rays::Color, cColor)
 
-namespace Rays
-{
+#define THIS  to<Rays::Color*>(self)
 
-
-	Class
-	color_class ()
-	{
-		return cColor;
-	}
-
-
-}// Rays
-
-
-namespace Rucy
-{
-
-
-	Value
-	value (const Rays::Color& obj)
-	{
-		return new_type(cColor, new Rays::Color(obj));
-	}
-
-	Value
-	value (const Rays::Color* obj)
-	{
-		return obj ? value(*obj) : nil();
-	}
-
-
-}// Rucy
-
-
-#define THIS to<Rays::Color*>(self)
-
-#define CHECK RUCY_CHECK_OBJ(self, Rays::Color, cColor)
+#define CHECK RUCY_CHECK_OBJ(Rays::Color, cColor, self)
 
 
 static
-RUBY_DEF_ALLOC(alloc, klass)
+RUCY_DEF_ALLOC(alloc, klass)
 {
 	return new_type<Rays::Color>(klass);
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEFN(initialize)
+RUCY_DEFN(setup)
 {
-	RUCY_CHECK_OBJ(self, Rays::Color, cColor);
-
-	if (argc < 0 || 4 < argc)
-		arg_count_error("Color#initialize", argc, 0, 1, 2, 3, 4);
+	CHECK;
+	check_arg_count(__FILE__, __LINE__, "Color#initialize", argc, 0, 1, 2, 3, 4);
 
 	if (argc == 0) return self;
 
@@ -91,92 +56,88 @@ RUBY_DEFN(initialize)
 
 	return self;
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF1(initialize_copy, obj)
+RUCY_DEF1(initialize_copy, obj)
 {
-	RUCY_CHECK_OBJ(self, Rays::Color, cColor);
-
-	Rays::Color* color = to<Rays::Color*>(obj);
-	if (!color) argument_error();
-
-	*THIS = *color;
+	CHECK;
+	*THIS = to<Rays::Color&>(obj);
 	return self;
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF1(set_red, red)
+RUCY_DEF1(set_red, red)
 {
 	CHECK;
 
 	return value(THIS->red = to<float>(red));
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF0(get_red)
+RUCY_DEF0(get_red)
 {
 	CHECK;
 
 	return value(THIS->red);
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF1(set_green, green)
+RUCY_DEF1(set_green, green)
 {
 	CHECK;
 
 	return value(THIS->green = to<float>(green));
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF0(get_green)
+RUCY_DEF0(get_green)
 {
 	CHECK;
 
 	return value(THIS->green);
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF1(set_blue, blue)
+RUCY_DEF1(set_blue, blue)
 {
 	CHECK;
 
 	return value(THIS->blue = to<float>(blue));
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF0(get_blue)
+RUCY_DEF0(get_blue)
 {
 	CHECK;
 
 	return value(THIS->blue);
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF1(set_alpha, alpha)
+RUCY_DEF1(set_alpha, alpha)
 {
 	CHECK;
 
 	return value(THIS->alpha = to<float>(alpha));
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF0(get_alpha)
+RUCY_DEF0(get_alpha)
 {
 	CHECK;
 
 	return value(THIS->alpha);
 }
-RUBY_END
+RUCY_END
 
 
 void
@@ -186,7 +147,7 @@ Init_color ()
 
 	cColor = mRays.define_class("Color");
 	cColor.define_alloc_func(alloc);
-	cColor.define_private_method("initialize", initialize);
+	cColor.define_private_method("setup", setup);
 	cColor.define_private_method("initialize_copy", initialize_copy);
 	cColor.define_method("red=", set_red);
 	cColor.define_method("red", get_red);
@@ -197,3 +158,52 @@ Init_color ()
 	cColor.define_method("alpha=", set_alpha);
 	cColor.define_method("alpha", get_alpha);
 }
+
+
+namespace Rucy
+{
+
+
+	template <> Rays::Color
+	value_to<Rays::Color> (Value value, bool convert)
+	{
+		if (convert)
+		{
+			if (value.is_i() || value.is_f())
+				return Rays::Color(value.as_f(true));
+			else if (value.is_array())
+			{
+				int size = value.size();
+				if (size <= 0 || 4 < size)
+					Rucy::argument_error(__FILE__, __LINE__);
+
+				Value* a = value.as_array();
+				switch (size)
+				{
+					case 1: return Rays::Color(a[0].as_f(true));
+					case 2: return Rays::Color(a[0].as_f(true), a[1].as_f(true));
+					case 3: return Rays::Color(a[0].as_f(true), a[1].as_f(true), a[2].as_f(true));
+					case 4: return Rays::Color(a[0].as_f(true), a[1].as_f(true), a[2].as_f(true), a[3].as_f(true));
+				}
+			}
+		}
+
+		return value_to<Rays::Color&>(value, convert);
+	}
+
+
+}// Rucy
+
+
+namespace Rays
+{
+
+
+	Class
+	color_class ()
+	{
+		return cColor;
+	}
+
+
+}// Rays

data/ext/rays/color_space.cpp

@@ -0,0 +1,185 @@
+#include "rays/ruby/color_space.h"
+
+
+#include <rucy.h>
+#include "defs.h"
+
+
+using namespace Rucy;
+
+
+static Class cColorSpace;
+
+RUCY_DEFINE_VALUE_FROM_TO(Rays::ColorSpace, cColorSpace)
+
+#define THIS  to<Rays::ColorSpace*>(self)
+
+#define CHECK RUCY_CHECK_OBJ(Rays::ColorSpace, cColorSpace, self)
+
+
+static
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	return new_type<Rays::ColorSpace>(klass);
+}
+RUCY_END
+
+static
+RUCY_DEF2(setup, type, premultiplied)
+{
+	CHECK;
+
+	*THIS = Rays::ColorSpace(
+		(Rays::ColorSpaceType) to<uint>(type),
+		to<bool>(premultiplied));
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF1(initialize_copy, obj)
+{
+	CHECK;
+	*THIS = to<Rays::ColorSpace&>(obj);
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF0(type)
+{
+	CHECK;
+
+	return value(THIS->type());
+}
+RUCY_END
+
+static
+RUCY_DEF0(is_gray)
+{
+	CHECK;
+
+	return value(THIS->is_gray());
+}
+RUCY_END
+
+static
+RUCY_DEF0(is_rgb)
+{
+	CHECK;
+
+	return value(THIS->is_rgb());
+}
+RUCY_END
+
+static
+RUCY_DEF0(is_bgr)
+{
+	CHECK;
+
+	return value(THIS->is_bgr());
+}
+RUCY_END
+
+static
+RUCY_DEF0(is_float)
+{
+	CHECK;
+
+	return value(THIS->is_float());
+}
+RUCY_END
+
+static
+RUCY_DEF0(has_alpha)
+{
+	CHECK;
+
+	return value(THIS->has_alpha());
+}
+RUCY_END
+
+static
+RUCY_DEF0(has_skip)
+{
+	CHECK;
+
+	return value(THIS->has_skip());
+}
+RUCY_END
+
+static
+RUCY_DEF0(is_premult)
+{
+	CHECK;
+
+	return value(THIS->is_premult());
+}
+RUCY_END
+
+
+void
+Init_color_space ()
+{
+	Module mRays = define_module("Rays");
+
+	cColorSpace = mRays.define_class("ColorSpace");
+	cColorSpace.define_alloc_func(alloc);
+	cColorSpace.define_private_method("initialize_copy", initialize_copy);
+	cColorSpace.define_private_method("setup", setup);
+	cColorSpace.define_method("type",     type);
+	cColorSpace.define_method("gray?",    is_gray);
+	cColorSpace.define_method("rgb?",     is_rgb);
+	cColorSpace.define_method("bgr?",     is_bgr);
+	cColorSpace.define_method("float?",   is_float);
+	cColorSpace.define_method("alpha?",   has_alpha);
+	cColorSpace.define_method("skip?",    has_skip);
+	cColorSpace.define_method("premult?", is_premult);
+
+	cColorSpace.define_const("GRAY_8",     Rays::GRAY_8);
+	cColorSpace.define_const("GRAY_16",    Rays::GRAY_16);
+	cColorSpace.define_const("GRAY_24",    Rays::GRAY_24);
+	cColorSpace.define_const("GRAY_32",    Rays::GRAY_32);
+	cColorSpace.define_const("GRAY_float", Rays::GRAY_float);
+	cColorSpace.define_const("RGB_888",    Rays:: RGB_888);
+	cColorSpace.define_const("RGBA_8888",  Rays:: RGBA_8888);
+	cColorSpace.define_const("RGBX_8888",  Rays:: RGBX_8888);
+	cColorSpace.define_const("ARGB_8888",  Rays::ARGB_8888);
+	cColorSpace.define_const("XRGB_8888",  Rays::XRGB_8888);
+	cColorSpace.define_const("BGR_888",    Rays:: BGR_888);
+	cColorSpace.define_const("BGRA_8888",  Rays:: BGRA_8888);
+	cColorSpace.define_const("BGRX_8888",  Rays:: BGRX_8888);
+	cColorSpace.define_const("ABGR_8888",  Rays::ABGR_8888);
+	cColorSpace.define_const("XBGR_8888",  Rays::XBGR_8888);
+	cColorSpace.define_const("RGB_float",  Rays:: RGB_float);
+	cColorSpace.define_const("RGBA_float", Rays:: RGBA_float);
+	cColorSpace.define_const("ARGB_float", Rays::ARGB_float);
+	cColorSpace.define_const("BGR_float",  Rays:: BGR_float);
+	cColorSpace.define_const("BGRA_float", Rays:: BGRA_float);
+	cColorSpace.define_const("ABGR_float", Rays::ABGR_float);
+	cColorSpace.define_const("GRAY",       Rays::GRAY);
+	cColorSpace.define_const("RGB",        Rays:: RGB);
+	cColorSpace.define_const("BGR",        Rays:: BGR);
+	cColorSpace.define_const("RGBA",       Rays:: RGBA);
+	cColorSpace.define_const("RGBX",       Rays:: RGBX);
+	cColorSpace.define_const("ARGB",       Rays::ARGB);
+	cColorSpace.define_const("XRGB",       Rays::XRGB);
+	cColorSpace.define_const("BGRA",       Rays:: BGRA);
+	cColorSpace.define_const("BGRX",       Rays:: BGRX);
+	cColorSpace.define_const("ABGR",       Rays::ABGR);
+	cColorSpace.define_const("XBGR",       Rays::XBGR);
+}
+
+
+namespace Rays
+{
+
+
+	Class
+	color_space_class ()
+	{
+		return cColorSpace;
+	}
+
+
+}// Rays

data/ext/rays/extconf.rb

@@ -1,75 +1,26 @@
 # -*- 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 'mkmf'
-require 'xot/rake'
+require 'xot/extconf'
 require 'xot/module'
 require 'rucy/module'
 require 'rays/module'
 
-include Xot::Rake
 
+Xot::ExtConf.new Xot, Rucy, Rays do
+  setup do
+    headers    << 'boost/noncopyable.hpp' << 'ruby.h'
+    local_libs << 'rucy'
+    libs.unshift 'gdi21', 'opengl32' if win32?
+    frameworks << 'AppKit' << 'OpenGL' if osx?
+    $LDFLAGS   << ' -Wl,--out-implib=native.dll.a' if cygwin?
+  end
 
-debug = env :DEBUG, false
-
-
-DEFS    = []
-INCDIRS = %w[
-  /opt/local/include
-  /opt/include
-]
-LIBDIRS = []
-
-HEADERS = %w[
-  boost/shared_ptr.hpp
-  ruby.h
-  xot.h
-  rucy.h
-  rays.h
-]
-LIBS = %w[
-  stdc++
-  xot
-  rucy
-  rays
-]
-FRAMEWORKS = []
-
-
-DEFS << '_DEBUG' if debug
-DEFS << 'NDEBUG' unless debug
-DEFS << $~[0].upcase if RUBY_PLATFORM =~ /mswin|ming|cygwin|darwin/i
-if win32?
-  DEFS << 'WINDOWS' << 'WIN32'
-  LIBS.unshift 'gdi32', 'opengl32'
-elsif cocoa?
-  DEFS << 'COCOA'
-  FRAMEWORKS << 'AppKit' << 'OpenGL'
+  dir_config 'boost'
+  create_makefile 'rays/native'
 end
-
-$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'
-
-RbConfig::CONFIG.each do |key, val|
-  {'gcc' => 'g++', 'clang' => 'clang++'}.each {|from, to| val.gsub! from, to}
-end
-
-
-dir_config 'boost'
-dir_config 'xot',  Xot.root_dir
-dir_config 'rucy', Rucy.root_dir
-dir_config 'rays', Rays.root_dir
-
-exit 1 unless HEADERS.all? {|s| have_header(s)}
-exit 1 unless LIBS.all?    {|s| have_library(s)}
-
-
-create_makefile 'rays/native'

data/ext/rays/font.cpp

@@ -12,59 +12,25 @@ using Rays::coord;
 
 static Class cFont;
 
+RUCY_DEFINE_VALUE_FROM_TO(Rays::Font, cFont)
 
-namespace Rays
-{
-
-
-	Class
-	font_class ()
-	{
-		return cFont;
-	}
-
-
-}// Rays
-
-
-namespace Rucy
-{
-
-
-	Value
-	value (const Rays::Font& obj)
-	{
-		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 RUCY_CHECK_OBJECT(self, Rays::Font, cFont)
+#define CHECK RUCY_CHECK_OBJECT(Rays::Font, cFont, self)
 
 
 static
-RUBY_DEF_ALLOC(alloc, klass)
+RUCY_DEF_ALLOC(alloc, klass)
 {
 	return new_type<Rays::Font>(klass);
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEFN(initialize)
+RUCY_DEFN(initialize)
 {
-	RUCY_CHECK_OBJ(self, Rays::Font, cFont);
-	if (argc < 0 || 2 < argc)
-		arg_count_error("Font#initialize", argc, 0, 1, 2);
+	RUCY_CHECK_OBJ(Rays::Font, cFont, self);
+	check_arg_count(__FILE__, __LINE__, "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;
@@ -72,51 +38,49 @@ RUBY_DEFN(initialize)
 
 	return self;
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF0(name)
+RUCY_DEF1(initialize_copy, obj)
 {
-	CHECK;
+	RUCY_CHECK_OBJ(Rays::Font, cFont, self);
 
-	return value(THIS->name().c_str());
+	*THIS = to<Rays::Font&>(obj).copy();
+	return self;
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF0(size)
+RUCY_DEF0(name)
 {
 	CHECK;
+	return value(THIS->name().c_str());
+}
+RUCY_END
 
+static
+RUCY_DEF0(size)
+{
+	CHECK;
 	return value(THIS->size());
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF1(width, str)
+RUCY_DEF1(width, str)
 {
 	CHECK;
-
-	coord width = 0;
-	if (!THIS->get_width(&width, str.c_str()))
-		rays_error("Font#width(%s) failed.", str.inspect().c_str());
-
-	return value(width);
+	return value(THIS->get_width(str.c_str()));
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF0(height)
+RUCY_DEF0(height)
 {
 	CHECK;
-
-	coord height = 0;
-	if (!THIS->get_height(&height))
-		rays_error("Font#height() failed.");
-
-	return value(height);
+	return value(THIS->get_height());
 }
-RUBY_END
+RUCY_END
 
 
 void
@@ -127,8 +91,23 @@ Init_font ()
 	cFont = mRays.define_class("Font");
 	cFont.define_alloc_func(alloc);
 	cFont.define_private_method("initialize", initialize);
+	cFont.define_private_method("initialize_copy", initialize_copy);
 	cFont.define_method("name", name);
 	cFont.define_method("size", size);
 	cFont.define_method("width", width);
 	cFont.define_method("height", height);
 }
+
+
+namespace Rays
+{
+
+
+	Class
+	font_class ()
+	{
+		return cFont;
+	}
+
+
+}// Rays