rays 0.1.6 → 0.1.7

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

@@ -12,44 +12,11 @@ using Rays::coord;
 
 static Class cPoint;
 
+RUCY_DEFINE_VALUE_FROM_TO(Rays::Point, cPoint)
 
-namespace Rays
-{
-
-
-	Class
-	point_class ()
-	{
-		return cPoint;
-	}
-
-
-}// Rays
+#define THIS  to<Rays::Point*>(self)
 
-
-namespace Rucy
-{
-
-
-	Value
-	value (const Rays::Point& obj)
-	{
-		return new_type(cPoint, new Rays::Point(obj));
-	}
-
-	Value
-	value (const Rays::Point* obj)
-	{
-		return obj ? value(*obj) : nil();
-	}
-
-
-}// Rucy
-
-
-#define THIS to<Rays::Point*>(self)
-
-#define CHECK RUCY_CHECK_OBJ(self, Rays::Point, cPoint)
+#define CHECK RUCY_CHECK_OBJ(Rays::Point, cPoint, self)
 
 
 static
@@ -61,12 +28,8 @@ VALUE alloc(VALUE klass)
 static
 VALUE initialize(VALUE self)
 {
-	RUCY_CHECK_OBJ(self, Rays::Point, cPoint);
-
-	if (argc != 0 && argc != 1 && argc != 2 && argc != 3)
-		arg_count_error("Point#initialize", argc, 0, 1, 2, 3);
-
-	if (argc == 0) return self;
+	CHECK;
+	check_arg_count(__FILE__, __LINE__, "Point#initialize", argc, 0, 1, 2, 3);
 
 	switch (argc)
 	{
@@ -90,20 +53,54 @@ VALUE initialize(VALUE self)
 static
 VALUE initialize_copy(VALUE self, VALUE obj)
 {
-	RUCY_CHECK_OBJ(self, Rays::Point, cPoint);
+	CHECK;
+	*THIS = to<Rays::Point&>(obj);
+	return self;
+}
+
+static
+VALUE move_to(VALUE self)
+{
+	CHECK;
+	check_arg_count(__FILE__, __LINE__, "Point#move_to", argc, 1, 2, 3);
 
-	Rays::Point* point = to<Rays::Point*>(obj);
-	if (!point) argument_error();
+	if (argv[0].is_kind_of(Rays::point_class()))
+		THIS->move_to(to<Rays::Point&>(argv[0]));
+	else
+	{
+		const Rays::Point& p = *THIS;
+		coord x = (argc >= 1 && argv[0]) ? to<coord>(argv[0]) : p.x;
+		coord y = (argc >= 2 && argv[1]) ? to<coord>(argv[1]) : p.y;
+		coord z = (argc >= 3 && argv[2]) ? to<coord>(argv[2]) : p.z;
+		THIS->move_to(x, y, z);
+	}
 
-	*THIS = *point;
 	return self;
 }
 
 static
-VALUE set_x(VALUE self, VALUE x)
+VALUE move_by(VALUE self)
 {
 	CHECK;
+	check_arg_count(__FILE__, __LINE__, "Point#move_by", argc, 1, 2, 3);
+
+	if (argv[0].is_kind_of(Rays::point_class()))
+		THIS->move_by(to<Rays::Point&>(argv[0]));
+	else
+	{
+		coord x = (argc >= 1 && argv[0]) ? to<coord>(argv[0]) : 0;
+		coord y = (argc >= 2 && argv[1]) ? to<coord>(argv[1]) : 0;
+		coord z = (argc >= 3 && argv[2]) ? to<coord>(argv[2]) : 0;
+		THIS->move_by(x, y, z);
+	}
+
+	return self;
+}
 
+static
+VALUE set_x(VALUE self, VALUE x)
+{
+	CHECK;
 	return value(THIS->x = to<coord>(x));
 }
 
@@ -111,7 +108,6 @@ static
 VALUE get_x(VALUE self)
 {
 	CHECK;
-
 	return value(THIS->x);
 }
 
@@ -119,7 +115,6 @@ static
 VALUE set_y(VALUE self, VALUE y)
 {
 	CHECK;
-
 	return value(THIS->y = to<coord>(y));
 }
 
@@ -127,7 +122,6 @@ static
 VALUE get_y(VALUE self)
 {
 	CHECK;
-
 	return value(THIS->y);
 }
 
@@ -135,7 +129,6 @@ static
 VALUE set_z(VALUE self, VALUE z)
 {
 	CHECK;
-
 	return value(THIS->z = to<coord>(z));
 }
 
@@ -143,10 +136,80 @@ static
 VALUE get_z(VALUE self)
 {
 	CHECK;
-
 	return value(THIS->z);
 }
 
+static
+VALUE add(VALUE self, VALUE point)
+{
+	CHECK;
+
+	Rays::Point p = *THIS;
+	p += to<Rays::Point&>(point);
+	return value(p);
+}
+
+static
+VALUE sub(VALUE self, VALUE point)
+{
+	CHECK;
+
+	Rays::Point p = *THIS;
+	p -= to<Rays::Point&>(point);
+	return value(p);
+}
+
+static
+VALUE mult(VALUE self, VALUE point)
+{
+	CHECK;
+
+	Rays::Point p = *THIS;
+	p *= to<Rays::Point&>(point);
+	return value(p);
+}
+
+static
+VALUE div(VALUE self, VALUE point)
+{
+	CHECK;
+
+	Rays::Point p = *THIS;
+	p /= to<Rays::Point&>(point);
+	return value(p);
+}
+
+static
+VALUE array_get(VALUE self, VALUE index)
+{
+	CHECK;
+
+	int i = index.as_i();
+	if (i < 0 || 2 < i)
+		index_error(__FILE__, __LINE__);
+
+	return value((*THIS)[i]);
+}
+
+static
+VALUE array_set(VALUE self, VALUE index, VALUE value)
+{
+	CHECK;
+
+	int i = index.as_i();
+	if (i < 0 || 2 < i)
+		index_error(__FILE__, __LINE__);
+
+	(*THIS)[i] = to<coord>(value);
+	return value;
+}
+
+static
+VALUE inspect(VALUE self)
+{
+	CHECK;
+	return value(Xot::stringf("#<Rays::Point %s>", THIS->inspect().c_str()));
+}
 
 void
 Init_point ()
@@ -157,10 +220,81 @@ Init_point ()
 	rb_define_alloc_func(cPoint, alloc);
 	rb_define_private_method(cPoint, "initialize", RUBY_METHOD_FUNC(initialize), -1);
 	rb_define_private_method(cPoint, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
+	cPoint.define_method("move_to!", move_to);
+	cPoint.define_method("move_by!", move_by);
 	rb_define_method(cPoint, "x=", RUBY_METHOD_FUNC(set_x), 1);
 	rb_define_method(cPoint, "x", RUBY_METHOD_FUNC(get_x), 0);
 	rb_define_method(cPoint, "y=", RUBY_METHOD_FUNC(set_y), 1);
 	rb_define_method(cPoint, "y", RUBY_METHOD_FUNC(get_y), 0);
 	rb_define_method(cPoint, "z=", RUBY_METHOD_FUNC(set_z), 1);
 	rb_define_method(cPoint, "z", RUBY_METHOD_FUNC(get_z), 0);
+	rb_define_method(cPoint, "op_add", RUBY_METHOD_FUNC(add), 1);
+	rb_define_method(cPoint, "op_sub", RUBY_METHOD_FUNC(sub), 1);
+	rb_define_method(cPoint, "op_mult", RUBY_METHOD_FUNC(mult), 1);
+	rb_define_method(cPoint, "op_div", RUBY_METHOD_FUNC(div), 1);
+	cPoint.define_method("[]",  array_get);
+	cPoint.define_method("[]=", array_set);
+	rb_define_method(cPoint, "inspect", RUBY_METHOD_FUNC(inspect), 0);
 }
+
+
+namespace Rucy
+{
+
+
+	template <> Rays::Point
+	value_to<Rays::Point> (Value value, bool convert)
+	{
+		if (convert)
+		{
+			size_t argc = 0;
+			Value* argv = NULL;
+			if (value.is_array())
+			{
+				argc = value.size();
+				argv = value.as_array();
+			}
+			else
+			{
+				argc = 1;
+				argv = &value;
+			}
+
+			if (argc < 1)
+				Rucy::argument_error(__FILE__, __LINE__);
+
+			if (argv[0].is_kind_of(Rays::point_class()))
+				value = argv[0];
+			else if (argv[0].is_i() || argv[0].is_f())
+			{
+				switch (argc)
+				{
+					#define V(i) argv[i].as_f(true)
+					case 1: return Rays::Point(V(0));
+					case 2: return Rays::Point(V(0), V(1));
+					case 3: return Rays::Point(V(0), V(1), V(2));
+					#undef V
+					default: Rucy::argument_error(__FILE__, __LINE__);
+				}
+			}
+		}
+
+		return value_to<Rays::Point&>(value, convert);
+	}
+
+
+}// Rucy
+
+
+namespace Rays
+{
+
+
+	Class
+	point_class ()
+	{
+		return cPoint;
+	}
+
+
+}// Rays

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

@@ -1,5 +1,6 @@
 #include <rucy.h>
-#include <rays/rays.h>
+#include "rays/rays.h"
+#include "rays/opengl.h"
 #include "defs.h"
 
 
@@ -9,35 +10,24 @@ using namespace Rucy;
 static Module mRays;
 
 
-namespace Rays
-{
-
-
-	Module
-	rays_module ()
-	{
-		return mRays;
-	}
-
-
-}// Rays
-
-
 static
 VALUE init(VALUE self)
 {
-	if (!Rays::init())
-		rays_error("Rays::init() failed.");
-
+	Rays::init();
 	return self;
 }
 
 static
 VALUE fin(VALUE self)
 {
-	if (!Rays::fin())
-		rays_error("Rays::fin() failed.");
+	Rays::fin();
+	return self;
+}
 
+static
+VALUE init_offscreen_context(VALUE self)
+{
+	Rays::init_offscreen_context();
 	return self;
 }
 
@@ -48,4 +38,19 @@ Init_rays ()
 	mRays = rb_define_module("Rays");
 	mRays.define_singleton_method("init!", init);
 	mRays.define_singleton_method("fin!", fin);
+	rb_define_singleton_method(mRays, "init_offscreen_context", RUBY_METHOD_FUNC(init_offscreen_context), 0);
 }
+
+
+namespace Rays
+{
+
+
+	Module
+	rays_module ()
+	{
+		return mRays;
+	}
+
+
+}// Rays

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

@@ -0,0 +1,61 @@
+#include "rays/ruby/shader.h"
+
+
+#include <rucy.h>
+#include "defs.h"
+
+
+using namespace Rucy;
+
+
+static Class cShader;
+
+RUCY_DEFINE_VALUE_FROM_TO(Rays::Shader, cShader)
+
+#define THIS  to<Rays::Shader*>(self)
+
+#define CHECK RUCY_CHECK_OBJECT(Rays::Shader, cShader, self)
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	return new_type<Rays::Shader>(klass);
+}
+
+static
+VALUE initialize(VALUE self, VALUE source)
+{
+	RUCY_CHECK_OBJ(Rays::Shader, cShader, self);
+
+	if (!source.is_s())
+		argument_error(__FILE__, __LINE__);
+
+	*THIS = Rays::Shader(source.c_str());
+	return self;
+}
+
+
+void
+Init_shader ()
+{
+	Module mRays = rb_define_module("Rays");
+
+	cShader = rb_define_class_under(mRays, "Shader", rb_cObject);
+	rb_define_alloc_func(cShader, alloc);
+	rb_define_private_method(cShader, "initialize", RUBY_METHOD_FUNC(initialize), 1);
+}
+
+
+namespace Rays
+{
+
+
+	Class
+	shader_class ()
+	{
+		return cShader;
+	}
+
+
+}// Rays

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

@@ -2,7 +2,8 @@
 
 
 #include <rucy.h>
-#include <rays/ruby/bitmap.h>
+#include "rays/ruby/color_space.h"
+#include "rays/ruby/bitmap.h"
 #include "defs.h"
 
 
@@ -13,44 +14,11 @@ using Rays::coord;
 
 static Class cTexture;
 
+RUCY_DEFINE_VALUE_FROM_TO(Rays::Texture, cTexture)
 
-namespace Rays
-{
-
-
-	Class
-	texture_class ()
-	{
-		return cTexture;
-	}
-
-
-}// Rays
-
-
-namespace Rucy
-{
+#define THIS  to<Rays::Texture*>(self)
 
-
-	Value
-	value (const Rays::Texture& obj)
-	{
-		return new_type(cTexture, new Rays::Texture(obj));
-	}
-
-	Value
-	value (const Rays::Texture* obj)
-	{
-		return obj ? value(*obj) : nil();
-	}
-
-
-}// Rucy
-
-
-#define THIS to<Rays::Texture*>(self)
-
-#define CHECK RUCY_CHECK_OBJECT(self, Rays::Texture, cTexture)
+#define CHECK RUCY_CHECK_OBJECT(Rays::Texture, cTexture, self)
 
 
 static
@@ -60,20 +28,15 @@ VALUE alloc(VALUE klass)
 }
 
 static
-VALUE initialize(VALUE self)
+VALUE setup(VALUE self, VALUE width, VALUE height, VALUE color_space, VALUE alpha_only)
 {
-	RUCY_CHECK_OBJ(self, Rays::Texture, cTexture);
-
-	if (argc != 1 && argc != 2)
-		arg_count_error("Texture#initialize", argc, 1, 2);
+	RUCY_CHECK_OBJ(Rays::Texture, cTexture, self);
 
-	Rays::Bitmap* bitmap = to<Rays::Bitmap*>(argv[0]);
-	bool alphaonly = (argc == 2) ? to<bool>(argv[1]) : false;
+	Rays::ColorSpace* cs = to<Rays::ColorSpace*>(color_space);
+	if (!cs) argument_error(__FILE__, __LINE__);
 
-	if (!bitmap)
-		argument_error("%s is not a Bitmap object.", argv[0].inspect().c_str());
-
-	*THIS = Rays::Texture(*bitmap, alphaonly);
+	*THIS = Rays::Texture(
+		to<int>(width), to<int>(height), *cs, to<bool>(alpha_only));
 	return self;
 }
 
@@ -81,7 +44,6 @@ static
 VALUE width(VALUE self)
 {
 	CHECK;
-
 	return value(THIS->width());
 }
 
@@ -89,15 +51,27 @@ static
 VALUE height(VALUE self)
 {
 	CHECK;
-
 	return value(THIS->height());
 }
 
 static
-VALUE s(VALUE self, VALUE x)
+VALUE color_space(VALUE self)
+{
+	CHECK;
+	return value(THIS->color_space());
+}
+
+static
+VALUE alpha_only(VALUE self)
 {
 	CHECK;
+	return value(THIS->alpha_only());
+}
 
+static
+VALUE s(VALUE self, VALUE x)
+{
+	CHECK;
 	return value(THIS->s(x.as_f(true)));
 }
 
@@ -105,7 +79,6 @@ static
 VALUE t(VALUE self, VALUE y)
 {
 	CHECK;
-
 	return value(THIS->t(y.as_f(true)));
 }
 
@@ -113,7 +86,6 @@ static
 VALUE s_max(VALUE self)
 {
 	CHECK;
-
 	return value(THIS->s_max());
 }
 
@@ -121,16 +93,14 @@ static
 VALUE t_max(VALUE self)
 {
 	CHECK;
-
 	return value(THIS->t_max());
 }
 
 static
-VALUE bitmap(VALUE self)
+VALUE to_bitmap(VALUE self)
 {
 	CHECK;
-
-	return value(THIS->bitmap());
+	return value(Rays::Bitmap(*THIS));
 }
 
 
@@ -141,10 +111,28 @@ Init_texture ()
 
 	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_private_method(cTexture, "setup", RUBY_METHOD_FUNC(setup), 4);
 	rb_define_method(cTexture, "width", RUBY_METHOD_FUNC(width), 0);
 	rb_define_method(cTexture, "height", RUBY_METHOD_FUNC(height), 0);
+	rb_define_method(cTexture, "color_space", RUBY_METHOD_FUNC(color_space), 0);
+	rb_define_method(cTexture, "alpha_only", RUBY_METHOD_FUNC(alpha_only), 0);
+	rb_define_method(cTexture, "s", RUBY_METHOD_FUNC(s), 1);
+	rb_define_method(cTexture, "t", RUBY_METHOD_FUNC(t), 1);
 	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);
+	rb_define_method(cTexture, "to_bitmap", RUBY_METHOD_FUNC(to_bitmap), 0);
 }
+
+
+namespace Rays
+{
+
+
+	Class
+	texture_class ()
+	{
+		return cTexture;
+	}
+
+
+}// Rays

data/Rakefile

@@ -1,8 +1,9 @@
 # -*- mode: ruby; 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 'xot/rake'
 require 'xot/module'
@@ -12,8 +13,8 @@ require 'rays/module'
 include Xot::Rake
 
 
-MODULE      = Rays
-INCDIRS     = [Rays, Rucy, Xot].map {|m| m.include_dirs}.flatten
+MODULES     = [Xot, Rucy, Rays].map {|m| m.const_get :Module}
+MODULE      = MODULES.last
 TESTS_ALONE = ['test/test_rays.rb']
 
 
@@ -22,4 +23,4 @@ task :default => :build
 task :build => :ext
 
 
-[Xot, Rucy, Rays].each {|m| m.load_tasks}
+MODULES.each {|m| m.load_tasks :lib, :ext, :test, :doc, :gem}

data/VERSION

@@ -1 +1 @@
-0.1.6
+0.1.7