rays 0.1.6 → 0.1.7

data/ext/rays/point.cpp

@@ -12,62 +12,25 @@ 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
-RUBY_DEF_ALLOC(alloc, klass)
+RUCY_DEF_ALLOC(alloc, klass)
 {
 	return new_type<Rays::Point>(klass);
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEFN(initialize)
+RUCY_DEFN(initialize)
 {
-	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)
 	{
@@ -87,75 +50,184 @@ 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::Point, cPoint);
+	CHECK;
+	*THIS = to<Rays::Point&>(obj);
+	return self;
+}
+RUCY_END
 
-	Rays::Point* point = to<Rays::Point*>(obj);
-	if (!point) argument_error();
+static
+RUCY_DEFN(move_to)
+{
+	CHECK;
+	check_arg_count(__FILE__, __LINE__, "Point#move_to", argc, 1, 2, 3);
+
+	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;
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF1(set_x, x)
+RUCY_DEFN(move_by)
 {
 	CHECK;
+	check_arg_count(__FILE__, __LINE__, "Point#move_by", argc, 1, 2, 3);
 
-	return value(THIS->x = to<coord>(x));
+	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;
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF0(get_x)
+RUCY_DEF1(set_x, x)
 {
 	CHECK;
+	return value(THIS->x = to<coord>(x));
+}
+RUCY_END
 
+static
+RUCY_DEF0(get_x)
+{
+	CHECK;
 	return value(THIS->x);
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF1(set_y, y)
+RUCY_DEF1(set_y, y)
 {
 	CHECK;
-
 	return value(THIS->y = to<coord>(y));
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF0(get_y)
+RUCY_DEF0(get_y)
 {
 	CHECK;
-
 	return value(THIS->y);
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF1(set_z, z)
+RUCY_DEF1(set_z, z)
 {
 	CHECK;
-
 	return value(THIS->z = to<coord>(z));
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF0(get_z)
+RUCY_DEF0(get_z)
 {
 	CHECK;
-
 	return value(THIS->z);
 }
-RUBY_END
+RUCY_END
 
+static
+RUCY_DEF1(add, point)
+{
+	CHECK;
+
+	Rays::Point p = *THIS;
+	p += to<Rays::Point&>(point);
+	return value(p);
+}
+RUCY_END
+
+static
+RUCY_DEF1(sub, point)
+{
+	CHECK;
+
+	Rays::Point p = *THIS;
+	p -= to<Rays::Point&>(point);
+	return value(p);
+}
+RUCY_END
+
+static
+RUCY_DEF1(mult, point)
+{
+	CHECK;
+
+	Rays::Point p = *THIS;
+	p *= to<Rays::Point&>(point);
+	return value(p);
+}
+RUCY_END
+
+static
+RUCY_DEF1(div, point)
+{
+	CHECK;
+
+	Rays::Point p = *THIS;
+	p /= to<Rays::Point&>(point);
+	return value(p);
+}
+RUCY_END
+
+static
+RUCY_DEF1(array_get, index)
+{
+	CHECK;
+
+	int i = index.as_i();
+	if (i < 0 || 2 < i)
+		index_error(__FILE__, __LINE__);
+
+	return value((*THIS)[i]);
+}
+RUCY_END
+
+static
+RUCY_DEF2(array_set, index, value)
+{
+	CHECK;
+
+	int i = index.as_i();
+	if (i < 0 || 2 < i)
+		index_error(__FILE__, __LINE__);
+
+	(*THIS)[i] = to<coord>(value);
+	return value;
+}
+RUCY_END
+
+static
+RUCY_DEF0(inspect)
+{
+	CHECK;
+	return value(Xot::stringf("#<Rays::Point %s>", THIS->inspect().c_str()));
+}
+RUCY_END
 
 void
 Init_point ()
@@ -166,10 +238,81 @@ Init_point ()
 	cPoint.define_alloc_func(alloc);
 	cPoint.define_private_method("initialize", initialize);
 	cPoint.define_private_method("initialize_copy", initialize_copy);
+	cPoint.define_method("move_to!", move_to);
+	cPoint.define_method("move_by!", move_by);
 	cPoint.define_method("x=", set_x);
 	cPoint.define_method("x", get_x);
 	cPoint.define_method("y=", set_y);
 	cPoint.define_method("y", get_y);
 	cPoint.define_method("z=", set_z);
 	cPoint.define_method("z", get_z);
+	cPoint.define_method("op_add", add);
+	cPoint.define_method("op_sub", sub);
+	cPoint.define_method("op_mult", mult);
+	cPoint.define_method("op_div", div);
+	cPoint.define_method("[]",  array_get);
+	cPoint.define_method("[]=", array_set);
+	cPoint.define_method("inspect", inspect);
 }
+
+
+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/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,39 +10,29 @@ using namespace Rucy;
 static Module mRays;
 
 
-namespace Rays
+static
+RUCY_DEF0(init)
 {
-
-
-	Module
-	rays_module ()
-	{
-		return mRays;
-	}
-
-
-}// Rays
-
+	Rays::init();
+	return self;
+}
+RUCY_END
 
 static
-RUBY_DEF0(init)
+RUCY_DEF0(fin)
 {
-	if (!Rays::init())
-		rays_error("Rays::init() failed.");
-
+	Rays::fin();
 	return self;
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF0(fin)
+RUCY_DEF0(init_offscreen_context)
 {
-	if (!Rays::fin())
-		rays_error("Rays::fin() failed.");
-
+	Rays::init_offscreen_context();
 	return self;
 }
-RUBY_END
+RUCY_END
 
 
 void
@@ -50,4 +41,19 @@ Init_rays ()
 	mRays = define_module("Rays");
 	mRays.define_singleton_method("init!", init);
 	mRays.define_singleton_method("fin!", fin);
+	mRays.define_singleton_method("init_offscreen_context", init_offscreen_context);
 }
+
+
+namespace Rays
+{
+
+
+	Module
+	rays_module ()
+	{
+		return mRays;
+	}
+
+
+}// Rays

data/ext/rays/shader.cpp

@@ -0,0 +1,63 @@
+#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
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	return new_type<Rays::Shader>(klass);
+}
+RUCY_END
+
+static
+RUCY_DEF1(initialize, source)
+{
+	RUCY_CHECK_OBJ(Rays::Shader, cShader, self);
+
+	if (!source.is_s())
+		argument_error(__FILE__, __LINE__);
+
+	*THIS = Rays::Shader(source.c_str());
+	return self;
+}
+RUCY_END
+
+
+void
+Init_shader ()
+{
+	Module mRays = define_module("Rays");
+
+	cShader = mRays.define_class("Shader");
+	cShader.define_alloc_func(alloc);
+	cShader.define_private_method("initialize", initialize);
+}
+
+
+namespace Rays
+{
+
+
+	Class
+	shader_class ()
+	{
+		return cShader;
+	}
+
+
+}// Rays

data/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,134 +14,105 @@ using Rays::coord;
 
 static Class cTexture;
 
+RUCY_DEFINE_VALUE_FROM_TO(Rays::Texture, cTexture)
 
-namespace Rays
-{
+#define THIS  to<Rays::Texture*>(self)
 
-
-	Class
-	texture_class ()
-	{
-		return cTexture;
-	}
-
-
-}// Rays
-
-
-namespace Rucy
-{
-
-
-	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
-RUBY_DEF_ALLOC(alloc, klass)
+RUCY_DEF_ALLOC(alloc, klass)
 {
 	return new_type<Rays::Texture>(klass);
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEFN(initialize)
+RUCY_DEF4(setup, width, height, color_space, alpha_only)
 {
-	RUCY_CHECK_OBJ(self, Rays::Texture, cTexture);
+	RUCY_CHECK_OBJ(Rays::Texture, cTexture, self);
 
-	if (argc != 1 && argc != 2)
-		arg_count_error("Texture#initialize", argc, 1, 2);
+	Rays::ColorSpace* cs = to<Rays::ColorSpace*>(color_space);
+	if (!cs) argument_error(__FILE__, __LINE__);
 
-	Rays::Bitmap* bitmap = to<Rays::Bitmap*>(argv[0]);
-	bool alphaonly = (argc == 2) ? to<bool>(argv[1]) : false;
-
-	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;
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF0(width)
+RUCY_DEF0(width)
 {
 	CHECK;
-
 	return value(THIS->width());
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF0(height)
+RUCY_DEF0(height)
 {
 	CHECK;
-
 	return value(THIS->height());
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF1(s, x)
+RUCY_DEF0(color_space)
 {
 	CHECK;
+	return value(THIS->color_space());
+}
+RUCY_END
 
-	return value(THIS->s(x.as_f(true)));
+static
+RUCY_DEF0(alpha_only)
+{
+	CHECK;
+	return value(THIS->alpha_only());
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF1(t, y)
+RUCY_DEF1(s, x)
 {
 	CHECK;
+	return value(THIS->s(x.as_f(true)));
+}
+RUCY_END
 
+static
+RUCY_DEF1(t, y)
+{
+	CHECK;
 	return value(THIS->t(y.as_f(true)));
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF0(s_max)
+RUCY_DEF0(s_max)
 {
 	CHECK;
-
 	return value(THIS->s_max());
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF0(t_max)
+RUCY_DEF0(t_max)
 {
 	CHECK;
-
 	return value(THIS->t_max());
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF0(bitmap)
+RUCY_DEF0(to_bitmap)
 {
 	CHECK;
-
-	return value(THIS->bitmap());
+	return value(Rays::Bitmap(*THIS));
 }
-RUBY_END
+RUCY_END
 
 
 void
@@ -150,10 +122,28 @@ Init_texture ()
 
 	cTexture = mRays.define_class("Texture");
 	cTexture.define_alloc_func(alloc);
-	cTexture.define_private_method("initialize", initialize);
+	cTexture.define_private_method("setup", setup);
 	cTexture.define_method("width", width);
 	cTexture.define_method("height", height);
+	cTexture.define_method("color_space", color_space);
+	cTexture.define_method("alpha_only", alpha_only);
+	cTexture.define_method("s", s);
+	cTexture.define_method("t", t);
 	cTexture.define_method("s_max", s_max);
 	cTexture.define_method("t_max", t_max);
-	cTexture.define_method("bitmap", bitmap);
+	cTexture.define_method("to_bitmap", to_bitmap);
 }
+
+
+namespace Rays
+{
+
+
+	Class
+	texture_class ()
+	{
+		return cTexture;
+	}
+
+
+}// Rays