rays 0.1.3 → 0.1.4

data/.doc/ext/rays/rays.cpp

@@ -6,12 +6,13 @@
 using namespace Rucy;
 
 
+static Module mRays;
+
+
 namespace Rays
 {
 
 
-	static Module mRays;
-
 	Module
 	rays_module ()
 	{
@@ -26,7 +27,7 @@ static
 VALUE init(VALUE self)
 {
 	if (!Rays::init())
-		error("Rays::init() failed.");
+		rays_error("Rays::init() failed.");
 
 	return self;
 }
@@ -35,7 +36,7 @@ static
 VALUE fin(VALUE self)
 {
 	if (!Rays::fin())
-		error("Rays::fin() failed.");
+		rays_error("Rays::fin() failed.");
 
 	return self;
 }
@@ -44,9 +45,7 @@ VALUE fin(VALUE self)
 void
 Init_rays ()
 {
-	Module m = rb_define_module("Rays");
-	Rays::mRays = m;
-
-	m.define_singleton_method("init!", init);
-	m.define_singleton_method("fin!", fin);
+	mRays = rb_define_module("Rays");
+	mRays.define_singleton_method("init!", init);
+	mRays.define_singleton_method("fin!", fin);
 }

data/.doc/ext/rays/texture.cpp

@@ -11,12 +11,13 @@ using namespace Rucy;
 using Rays::coord;
 
 
+static Class cTexture;
+
+
 namespace Rays
 {
 
 
-	static Class cTexture;
-
 	Class
 	texture_class ()
 	{
@@ -32,32 +33,39 @@ namespace Rucy
 
 
 	Value
-	value (const Rays::Texture& texture)
+	value (const Rays::Texture& obj)
+	{
+		return new_type(cTexture, new Rays::Texture(obj));
+	}
+
+	Value
+	value (const Rays::Texture* obj)
 	{
-		return new_type<Rays::Texture>(
-			Rays::texture_class(), new Rays::Texture(texture));
+		return obj ? value(*obj) : nil();
 	}
 
 
 }// Rucy
 
 
-#define this to<Rays::Texture*>(self)
+#define THIS to<Rays::Texture*>(self)
 
-#define CHECK CHECK_OBJECT(self, Rays::Texture, Rays::texture_class())
+#define CHECK RUCY_CHECK_OBJECT(self, Rays::Texture, cTexture)
 
 
 static
 VALUE alloc(VALUE klass)
 {
-	return new_type<Rays::Texture>(klass, new Rays::Texture);
+	return new_type<Rays::Texture>(klass);
 }
 
 static
 VALUE initialize(VALUE self)
 {
-	CHECK_OBJ(self, Rays::Texture, Rays::texture_class());
-	if (argc != 1 && argc != 2) arg_count_error("Texture#initialize", argc, 1, 2);
+	RUCY_CHECK_OBJ(self, Rays::Texture, cTexture);
+
+	if (argc != 1 && argc != 2)
+		arg_count_error("Texture#initialize", argc, 1, 2);
 
 	Rays::Bitmap* bitmap = to<Rays::Bitmap*>(argv[0]);
 	bool alphaonly = (argc == 2) ? to<bool>(argv[1]) : false;
@@ -65,7 +73,7 @@ VALUE initialize(VALUE self)
 	if (!bitmap)
 		argument_error("%s is not a Bitmap object.", argv[0].inspect().c_str());
 
-	*this = Rays::Texture(*bitmap, alphaonly);
+	*THIS = Rays::Texture(*bitmap, alphaonly);
 	return self;
 }
 
@@ -74,7 +82,7 @@ VALUE width(VALUE self)
 {
 	CHECK;
 
-	return value(this->width());
+	return value(THIS->width());
 }
 
 static
@@ -82,7 +90,23 @@ VALUE height(VALUE self)
 {
 	CHECK;
 
-	return value(this->height());
+	return value(THIS->height());
+}
+
+static
+VALUE s(VALUE self, VALUE x)
+{
+	CHECK;
+
+	return value(THIS->s(x.as_f(true)));
+}
+
+static
+VALUE t(VALUE self, VALUE y)
+{
+	CHECK;
+
+	return value(THIS->t(y.as_f(true)));
 }
 
 static
@@ -90,7 +114,7 @@ VALUE s_max(VALUE self)
 {
 	CHECK;
 
-	return value(this->s_max());
+	return value(THIS->s_max());
 }
 
 static
@@ -98,7 +122,7 @@ VALUE t_max(VALUE self)
 {
 	CHECK;
 
-	return value(this->t_max());
+	return value(THIS->t_max());
 }
 
 static
@@ -106,23 +130,21 @@ VALUE bitmap(VALUE self)
 {
 	CHECK;
 
-	return value(this->bitmap());
+	return value(THIS->bitmap());
 }
 
 
 void
 Init_texture ()
 {
-	Module m = rb_define_module("Rays");
-
-	Class c = rb_define_class_under(m, "Texture", rb_cObject);
-	Rays::cTexture = c;
-
-	rb_define_alloc_func(c, alloc);
-	rb_define_method(c, "initialize", RUBY_METHOD_FUNC(initialize), -1);
-	rb_define_method(c, "width", RUBY_METHOD_FUNC(width), 0);
-	rb_define_method(c, "height", RUBY_METHOD_FUNC(height), 0);
-	rb_define_method(c, "s_max", RUBY_METHOD_FUNC(s_max), 0);
-	rb_define_method(c, "t_max", RUBY_METHOD_FUNC(t_max), 0);
-	rb_define_method(c, "bitmap", RUBY_METHOD_FUNC(bitmap), 0);
+	Module mRays = rb_define_module("Rays");
+
+	cTexture = rb_define_class_under(mRays, "Texture", rb_cObject);
+	rb_define_alloc_func(cTexture, alloc);
+	rb_define_private_method(cTexture, "initialize", RUBY_METHOD_FUNC(initialize), -1);
+	rb_define_method(cTexture, "width", RUBY_METHOD_FUNC(width), 0);
+	rb_define_method(cTexture, "height", RUBY_METHOD_FUNC(height), 0);
+	rb_define_method(cTexture, "s_max", RUBY_METHOD_FUNC(s_max), 0);
+	rb_define_method(cTexture, "t_max", RUBY_METHOD_FUNC(t_max), 0);
+	rb_define_method(cTexture, "bitmap", RUBY_METHOD_FUNC(bitmap), 0);
 }

data/.gitignore

@@ -0,0 +1,14 @@
+*.o
+*.so
+*.bundle
+*.dll.a
+*.gem
+*.log
+*.rdoc.cpp
+*~
+lib/*.a
+.doc
+.yardoc
+.DS_Store
+Makefile
+depend.mf

data/Rakefile

@@ -1,12 +1,8 @@
 # -*- mode: ruby; 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 'xot/rake/helpers'
+require 'bundler/setup'
+require 'xot/rake'
 require 'xot/module'
 require 'rucy/module'
 require 'rays/module'
@@ -14,35 +10,14 @@ require 'rays/module'
 include Xot::Rake
 
 
-MODULE  = Rays
-INCDIRS = [Rays, Rucy].map {|m| m.include_dirs}.flatten
+MODULE      = Rays
+INCDIRS     = [Rays, Rucy, Xot].map {|m| m.include_dirs}.flatten
+TESTS_ALONE = ['test/test_rays.rb']
 
 
 task :default => :build
 
 task :build => :ext
 
-task :rebuild => [:clean, :build]
-
-task :lib => 'lib:build'
-
-task :ext => 'ext:build'
-
-task :doc => 'ext:doc'
-
-task :gem => 'gem:build'
-
-task :install => 'gem:install'
-
-task :uninstall => 'gem:uninstall'
-
-task :clean => ['lib:clean', 'ext:clean', 'gem:clean']
-
-task :test => :ext do
-  Dir['test/**/test_*.rb'].each do |rb|
-    sh %( ruby #{rb} )
-  end
-end
-
 
 [Xot, Rucy, Rays].each {|m| m.load_tasks}

data/VERSION

@@ -1 +1 @@
-0.1.3
+0.1.4

data/ext/rays/bitmap.cpp

@@ -2,6 +2,7 @@
 
 
 #include <rucy.h>
+#include "rays/ruby/font.h"
 #include "defs.h"
 
 
@@ -13,12 +14,13 @@ using Rays::ulong;
 using Rays::coord;
 
 
+static Class cBitmap;
+
+
 namespace Rays
 {
 
 
-	static Class cBitmap;
-
 	Class
 	bitmap_class ()
 	{
@@ -34,42 +36,64 @@ namespace Rucy
 
 
 	Value
-	value (const Rays::Bitmap& bitmap)
+	value (const Rays::Bitmap& obj)
+	{
+		return new_type(cBitmap, new Rays::Bitmap(obj));
+	}
+
+	Value
+	value (const Rays::Bitmap* obj)
 	{
-		return new_type<Rays::Bitmap>(
-			Rays::bitmap_class(), new Rays::Bitmap(bitmap));
+		return obj ? value(*obj) : nil();
 	}
 
 
 }// Rucy
 
 
-#define this to<Rays::Bitmap*>(self)
+#define THIS to<Rays::Bitmap*>(self)
 
-#define CHECK CHECK_OBJECT(self, Rays::Bitmap, Rays::bitmap_class())
+#define CHECK RUCY_CHECK_OBJECT(self, Rays::Bitmap, cBitmap)
 
 
 static
 RUBY_DEF_ALLOC(alloc, klass)
 {
-	return new_type<Rays::Bitmap>(klass, new Rays::Bitmap);
+	return new_type<Rays::Bitmap>(klass);
+}
+RUBY_END
+
+static
+RUBY_DEF3(setup, width, height, colorspace)
+{
+	RUCY_CHECK_OBJ(self, Rays::Bitmap, cBitmap);
+	*THIS = Rays::Bitmap(
+		to<int>(width), to<int>(height),
+		(Rays::ColorSpaceType) to<uint>(colorspace));
+	return self;
 }
 RUBY_END
 
 static
-RUBY_DEFN(initialize)
+RUBY_DEFN(draw_string)
 {
-	CHECK_OBJ(self, Rays::Bitmap, Rays::bitmap_class());
-	if (argc != 0 && argc != 2 && argc != 3)
-		arg_count_error("Bitmap#initialize", argc, 0, 2, 3);
+	CHECK;
+	if (argc < 1 || 4 < argc)
+		arg_count_error("Bitmap#draw_string", argc, 1, 2, 3, 4);
 
-	if (argc == 0) return self;
+	const char* str        = to<const char*>(argv[0]);
+	coord x                = argc >= 2 ? to<coord>(argv[1]) : 0;
+	coord y                = argc >= 3 ? to<coord>(argv[2]) : 0;
+	const Rays::Font* font = argc >= 4
+		? to<Rays::Font*>(argv[3]) : &Rays::default_font();
 
-	int width  = to<int>(argv[0]);
-	int height = to<int>(argv[1]);
-	uint colorspace = (argc == 3) ? to<uint>(argv[2]) : (uint) Rays::RGBA;
+	if (!Rays::draw_string(THIS, str, x, y, *font))
+	{
+		rays_error(
+			"Bitmap#draw_string('%s', %f, %f, %s) failed.",
+			str, x, y, font->name().c_str());
+	}
 
-	*this = Rays::Bitmap(width, height, (Rays::ColorSpaceType) colorspace);
 	return self;
 }
 RUBY_END
@@ -79,7 +103,7 @@ RUBY_DEF0(width)
 {
 	CHECK;
 
-	return value(this->width());
+	return value(THIS->width());
 }
 RUBY_END
 
@@ -88,7 +112,7 @@ RUBY_DEF0(height)
 {
 	CHECK;
 
-	return value(this->height());
+	return value(THIS->height());
 }
 RUBY_END
 
@@ -97,7 +121,7 @@ RUBY_DEF0(color_space)
 {
 	CHECK;
 
-	return value(this->color_space().type());
+	return value(THIS->color_space().type());
 }
 RUBY_END
 
@@ -107,14 +131,14 @@ RUBY_DEF2(at, x, y)
 	CHECK;
 
 	int xx = x.as_i(), yy = y.as_i();
-	void* pixel = this->at<void*>(xx, yy);
-	if (!pixel) error("Bitmap#at(%d, %d) failed.", xx, yy);
+	void* pixel = THIS->at<void*>(xx, yy);
+	if (!pixel) rays_error("Bitmap#at(%d, %d) failed.", xx, yy);
 
-	Value array(this->color_space().Bpp() / this->color_space().Bpc(), NULL);
-	if (this->color_space().is_float())
+	Value array(THIS->color_space().Bpp() / THIS->color_space().Bpc(), NULL);
+	if (THIS->color_space().is_float())
 	{
 		float* p = (float*) pixel;
-		switch (this->color_space().type())
+		switch (THIS->color_space().type())
 		{
 			case Rays::GRAY_float:
 				array.push(p[0]);
@@ -138,13 +162,13 @@ RUBY_DEF2(at, x, y)
 				array.push(p[3]).push(p[2]).push(p[1]).push(p[0]);
 				break;
 			default:
-				error("Bitmap#at: unknown color space");
+				rays_error("Bitmap#at: unknown color space");
 		}
 	}
 	else
 	{
 		uchar* p = (uchar*) pixel;
-		switch (this->color_space().type())
+		switch (THIS->color_space().type())
 		{
 			case Rays::GRAY_8:
 				array.push(*(uchar*) pixel);
@@ -186,7 +210,7 @@ RUBY_DEF2(at, x, y)
 				array.push(p[3]).push(p[2]).push(p[1]);
 				break;
 			default:
-				error("Bitmap#at: unknown color space");
+				rays_error("Bitmap#at: unknown color space");
 		}
 	}
 
@@ -200,14 +224,14 @@ RUBY_DEF3(assign_at, x, y, color)
 	CHECK;
 
 	int xx = x.as_i(), yy = y.as_i();
-	void* pixel = this->at<void*>(xx, yy);
-	if (!pixel) error("Bitmap#assign_at(%d, %d) failed.", xx, yy);
+	void* pixel = THIS->at<void*>(xx, yy);
+	if (!pixel) rays_error("Bitmap#assign_at(%d, %d) failed.", xx, yy);
 
-	Value array(this->color_space().Bpp() / this->color_space().Bpc(), NULL);
-	if (this->color_space().is_float())
+	Value array(THIS->color_space().Bpp() / THIS->color_space().Bpc(), NULL);
+	if (THIS->color_space().is_float())
 	{
 		float* p = (float*) pixel;
-		switch (this->color_space().type())
+		switch (THIS->color_space().type())
 		{
 			#define C(n) ((float) color[n].as_f())
 			case Rays::GRAY_float:
@@ -233,13 +257,13 @@ RUBY_DEF3(assign_at, x, y, color)
 				break;
 			#undef C
 			default:
-				error("Bitmap#at: unknown color space");
+				rays_error("Bitmap#at: unknown color space");
 		}
 	}
 	else
 	{
 		uchar* p = (uchar*) pixel;
-		switch (this->color_space().type())
+		switch (THIS->color_space().type())
 		{
 			#define C(n) ((uchar) color[n].as_i())
 			case Rays::GRAY_8:
@@ -283,7 +307,7 @@ RUBY_DEF3(assign_at, x, y, color)
 				break;
 			#undef C
 			default:
-				error("Bitmap#at: unknown color space");
+				rays_error("Bitmap#at: unknown color space");
 		}
 	}
 
@@ -297,7 +321,7 @@ RUBY_DEF1(load, path)
 {
 	Rays::Bitmap bmp;
 	if (!Rays::load_bitmap(&bmp, path.c_str()))
-		error("Bitmap.load('%s') failed.", path.c_str());
+		rays_error("Bitmap.load('%s') failed.", path.c_str());
 
 	return value(bmp);
 }
@@ -307,20 +331,20 @@ RUBY_END
 void
 Init_bitmap ()
 {
-	Module m = define_module("Rays");
-
-	m.define_const("RGB", Rays::RGB);
-	m.define_const("RGBA", Rays::RGBA);
-
-	Class c = m.define_class("Bitmap");
-	Rays::cBitmap = 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("[]", at);
-	c.define_method("[]=", assign_at);
-	c.define_function("load", load);
+	Module mRays = define_module("Rays");
+
+	mRays.define_const("GRAY", Rays::GRAY);
+	mRays.define_const("RGB",  Rays::RGB);
+	mRays.define_const("RGBA", Rays::RGBA);
+
+	cBitmap = mRays.define_class("Bitmap");
+	cBitmap.define_alloc_func(alloc);
+	cBitmap.define_private_method("setup", setup);
+	cBitmap.define_method("draw_string", draw_string);
+	cBitmap.define_method("width", width);
+	cBitmap.define_method("height", height);
+	cBitmap.define_method("color_space", color_space);
+	cBitmap.define_method("[]", at);
+	cBitmap.define_method("[]=", assign_at);
+	cBitmap.define_function("load", load);
 }