rays 0.1.3 → 0.1.4

data/ext/rays/bounds.cpp

@@ -0,0 +1,426 @@
+#include "rays/ruby/bounds.h"
+
+
+#include <rucy.h>
+#include <rays/ruby/point.h>
+#include "defs.h"
+
+
+using namespace Rucy;
+
+using Rays::coord;
+
+
+static Class cBounds;
+
+
+namespace Rays
+{
+
+
+	Class
+	bounds_class ()
+	{
+		return cBounds;
+	}
+
+
+}// Rays
+
+
+namespace Rucy
+{
+
+
+	Value
+	value (const Rays::Bounds& obj)
+	{
+		return new_type(cBounds, new Rays::Bounds(obj));
+	}
+
+	Value
+	value (const Rays::Bounds* obj)
+	{
+		return obj ? value(*obj) : nil();
+	}
+
+
+}// Rucy
+
+
+#define THIS to<Rays::Bounds*>(self)
+
+#define CHECK RUCY_CHECK_OBJ(self, Rays::Bounds, cBounds)
+
+
+static
+RUBY_DEF_ALLOC(alloc, klass)
+{
+	return new_type<Rays::Bounds>(klass);
+}
+RUBY_END
+
+static
+RUBY_DEFN(initialize)
+{
+	RUCY_CHECK_OBJ(self, Rays::Bounds, cBounds);
+
+	if (argc != 0 && argc != 1 && argc != 2 && argc != 3 && argc != 4 && argc != 6)
+		arg_count_error("Bounds#initialize", argc, 0, 1, 2, 3, 4, 6);
+
+	if (argc == 0) return self;
+
+	switch (argc)
+	{
+		case 1:
+			*THIS = Rays::Bounds(to<coord>(argv[0]));
+			break;
+
+		case 2:
+			*THIS = Rays::Bounds(to<coord>(argv[0]), to<coord>(argv[1]));
+			break;
+
+		case 3:
+			*THIS = Rays::Bounds(
+				to<coord>(argv[0]), to<coord>(argv[1]), to<coord>(argv[2]));
+			break;
+
+		case 4:
+			*THIS = Rays::Bounds(
+				to<coord>(argv[0]), to<coord>(argv[1]),
+				to<coord>(argv[2]), to<coord>(argv[3]));
+			break;
+
+		case 6:
+			*THIS = Rays::Bounds(
+				to<coord>(argv[0]), to<coord>(argv[1]), to<coord>(argv[2]),
+				to<coord>(argv[3]), to<coord>(argv[4]), to<coord>(argv[5]));
+			break;
+	}
+
+	return self;
+}
+RUBY_END
+
+static
+RUBY_DEF1(initialize_copy, obj)
+{
+	RUCY_CHECK_OBJ(self, Rays::Bounds, cBounds);
+
+	Rays::Bounds* bounds = to<Rays::Bounds*>(obj);
+	if (!bounds) argument_error();
+
+	*THIS = *bounds;
+	return self;
+}
+RUBY_END
+
+static
+RUBY_DEF1(set_x, x)
+{
+	CHECK;
+
+	return value(THIS->x = to<coord>(x));
+}
+RUBY_END
+
+static
+RUBY_DEF0(get_x)
+{
+	CHECK;
+
+	return value(THIS->x);
+}
+RUBY_END
+
+static
+RUBY_DEF1(set_y, y)
+{
+	CHECK;
+
+	return value(THIS->y = to<coord>(y));
+}
+RUBY_END
+
+static
+RUBY_DEF0(get_y)
+{
+	CHECK;
+
+	return value(THIS->y);
+}
+RUBY_END
+
+static
+RUBY_DEF1(set_z, z)
+{
+	CHECK;
+
+	return value(THIS->z = to<coord>(z));
+}
+RUBY_END
+
+static
+RUBY_DEF0(get_z)
+{
+	CHECK;
+
+	return value(THIS->z);
+}
+RUBY_END
+
+static
+RUBY_DEF1(set_width, width)
+{
+	CHECK;
+
+	return value(THIS->width = to<coord>(width));
+}
+RUBY_END
+
+static
+RUBY_DEF0(get_width)
+{
+	CHECK;
+
+	return value(THIS->width);
+}
+RUBY_END
+
+static
+RUBY_DEF1(set_height, height)
+{
+	CHECK;
+
+	return value(THIS->height = to<coord>(height));
+}
+RUBY_END
+
+static
+RUBY_DEF0(get_height)
+{
+	CHECK;
+
+	return value(THIS->height);
+}
+RUBY_END
+
+static
+RUBY_DEF1(set_depth, depth)
+{
+	CHECK;
+
+	return value(THIS->depth = to<coord>(depth));
+}
+RUBY_END
+
+static
+RUBY_DEF0(get_depth)
+{
+	CHECK;
+
+	return value(THIS->depth);
+}
+RUBY_END
+
+static
+RUBY_DEF1(set_left, left)
+{
+	CHECK;
+	Rays::Bounds* this_ = THIS;
+
+	this_->set_left(to<coord>(left));
+	return value(this_->left());
+}
+RUBY_END
+
+static
+RUBY_DEF0(get_left)
+{
+	CHECK;
+
+	return value(THIS->left());
+}
+RUBY_END
+
+static
+RUBY_DEF1(set_right, right)
+{
+	CHECK;
+	Rays::Bounds* this_ = THIS;
+
+	this_->set_right(to<coord>(right));
+	return value(this_->right());
+}
+RUBY_END
+
+static
+RUBY_DEF0(get_right)
+{
+	CHECK;
+
+	return value(THIS->right());
+}
+RUBY_END
+
+static
+RUBY_DEF1(set_top, top)
+{
+	CHECK;
+	Rays::Bounds* this_ = THIS;
+
+	this_->set_top(to<coord>(top));
+	return value(this_->top());
+}
+RUBY_END
+
+static
+RUBY_DEF0(get_top)
+{
+	CHECK;
+
+	return value(THIS->top());
+}
+RUBY_END
+
+static
+RUBY_DEF1(set_bottom, bottom)
+{
+	CHECK;
+	Rays::Bounds* this_ = THIS;
+
+	this_->set_bottom(to<coord>(bottom));
+	return value(this_->bottom());
+}
+RUBY_END
+
+static
+RUBY_DEF0(get_bottom)
+{
+	CHECK;
+
+	return value(THIS->bottom());
+}
+RUBY_END
+
+static
+RUBY_DEF1(set_back, back)
+{
+	CHECK;
+	Rays::Bounds* this_ = THIS;
+
+	this_->set_back(to<coord>(back));
+	return value(this_->back());
+}
+RUBY_END
+
+static
+RUBY_DEF0(get_back)
+{
+	CHECK;
+
+	return value(THIS->back());
+}
+RUBY_END
+
+static
+RUBY_DEF1(set_front, front)
+{
+	CHECK;
+	Rays::Bounds* this_ = THIS;
+
+	this_->set_front(to<coord>(front));
+	return value(this_->front());
+}
+RUBY_END
+
+static
+RUBY_DEF0(get_front)
+{
+	CHECK;
+
+	return value(THIS->front());
+}
+RUBY_END
+
+static
+RUBY_DEF1(set_position, pos)
+{
+	CHECK;
+
+	Rays::Point* p = to<Rays::Point*>(pos);
+	if (!p) argument_error("%s is not a Rays::Point.", pos.inspect().c_str());
+
+	return value(THIS->position() = *p);
+}
+RUBY_END
+
+static
+RUBY_DEF0(get_position)
+{
+	CHECK;
+
+	return value(THIS->position());
+}
+RUBY_END
+
+static
+RUBY_DEF1(set_size, size)
+{
+	CHECK;
+
+	Rays::Point* p = to<Rays::Point*>(size);
+	if (!p) argument_error("%s is not a Rays::Point.", size.inspect().c_str());
+
+	return value(THIS->size() = *p);
+}
+RUBY_END
+
+static
+RUBY_DEF0(get_size)
+{
+	CHECK;
+
+	return value(THIS->size());
+}
+RUBY_END
+
+
+void
+Init_bounds ()
+{
+	Module mRays = define_module("Rays");
+
+	cBounds = mRays.define_class("Bounds");
+	cBounds.define_alloc_func(alloc);
+	cBounds.define_private_method("initialize", initialize);
+	cBounds.define_private_method("initialize_copy", initialize_copy);
+	cBounds.define_method("x=", set_x);
+	cBounds.define_method("x", get_x);
+	cBounds.define_method("y=", set_y);
+	cBounds.define_method("y", get_y);
+	cBounds.define_method("z=", set_z);
+	cBounds.define_method("z", get_z);
+	cBounds.define_method("width=", set_width);
+	cBounds.define_method("width", get_width);
+	cBounds.define_method("height=", set_height);
+	cBounds.define_method("height", get_height);
+	cBounds.define_method("depth=", set_depth);
+	cBounds.define_method("depth", get_depth);
+	cBounds.define_method("left=", set_left);
+	cBounds.define_method("left", get_left);
+	cBounds.define_method("right=", set_right);
+	cBounds.define_method("right", get_right);
+	cBounds.define_method("top=", set_top);
+	cBounds.define_method("top", get_top);
+	cBounds.define_method("bottom=", set_bottom);
+	cBounds.define_method("bottom", get_bottom);
+	cBounds.define_method("back=", set_back);
+	cBounds.define_method("back", get_back);
+	cBounds.define_method("front=", set_front);
+	cBounds.define_method("front", get_front);
+	cBounds.define_method("position=", set_position);
+	cBounds.define_method("position", get_position);
+	cBounds.define_method("size=", set_size);
+	cBounds.define_method("size", get_size);
+}

data/ext/rays/color.cpp

@@ -0,0 +1,199 @@
+#include "rays/ruby/color.h"
+
+
+#include <rucy.h>
+#include "defs.h"
+
+
+using namespace Rucy;
+
+
+static Class cColor;
+
+
+namespace Rays
+{
+
+
+	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)
+
+
+static
+RUBY_DEF_ALLOC(alloc, klass)
+{
+	return new_type<Rays::Color>(klass);
+}
+RUBY_END
+
+static
+RUBY_DEFN(initialize)
+{
+	RUCY_CHECK_OBJ(self, Rays::Color, cColor);
+
+	if (argc < 0 || 4 < argc)
+		arg_count_error("Color#initialize", argc, 0, 1, 2, 3, 4);
+
+	if (argc == 0) return self;
+
+	switch (argc)
+	{
+		case 1:
+			*THIS = Rays::Color(to<float>(argv[0]));
+			break;
+
+		case 2:
+			*THIS = Rays::Color(to<float>(argv[0]), to<float>(argv[1]));
+			break;
+
+		case 3:
+			*THIS = Rays::Color(
+				to<float>(argv[0]), to<float>(argv[1]), to<float>(argv[2]));
+			break;
+
+		case 4:
+			*THIS = Rays::Color(
+				to<float>(argv[0]), to<float>(argv[1]),
+				to<float>(argv[2]), to<float>(argv[3]));
+			break;
+	}
+
+	return self;
+}
+RUBY_END
+
+static
+RUBY_DEF1(initialize_copy, obj)
+{
+	RUCY_CHECK_OBJ(self, Rays::Color, cColor);
+
+	Rays::Color* color = to<Rays::Color*>(obj);
+	if (!color) argument_error();
+
+	*THIS = *color;
+	return self;
+}
+RUBY_END
+
+static
+RUBY_DEF1(set_red, red)
+{
+	CHECK;
+
+	return value(THIS->red = to<float>(red));
+}
+RUBY_END
+
+static
+RUBY_DEF0(get_red)
+{
+	CHECK;
+
+	return value(THIS->red);
+}
+RUBY_END
+
+static
+RUBY_DEF1(set_green, green)
+{
+	CHECK;
+
+	return value(THIS->green = to<float>(green));
+}
+RUBY_END
+
+static
+RUBY_DEF0(get_green)
+{
+	CHECK;
+
+	return value(THIS->green);
+}
+RUBY_END
+
+static
+RUBY_DEF1(set_blue, blue)
+{
+	CHECK;
+
+	return value(THIS->blue = to<float>(blue));
+}
+RUBY_END
+
+static
+RUBY_DEF0(get_blue)
+{
+	CHECK;
+
+	return value(THIS->blue);
+}
+RUBY_END
+
+static
+RUBY_DEF1(set_alpha, alpha)
+{
+	CHECK;
+
+	return value(THIS->alpha = to<float>(alpha));
+}
+RUBY_END
+
+static
+RUBY_DEF0(get_alpha)
+{
+	CHECK;
+
+	return value(THIS->alpha);
+}
+RUBY_END
+
+
+void
+Init_color ()
+{
+	Module mRays = define_module("Rays");
+
+	cColor = mRays.define_class("Color");
+	cColor.define_alloc_func(alloc);
+	cColor.define_private_method("initialize", initialize);
+	cColor.define_private_method("initialize_copy", initialize_copy);
+	cColor.define_method("red=", set_red);
+	cColor.define_method("red", get_red);
+	cColor.define_method("green=", set_green);
+	cColor.define_method("green", get_green);
+	cColor.define_method("blue=", set_blue);
+	cColor.define_method("blue", get_blue);
+	cColor.define_method("alpha=", set_alpha);
+	cColor.define_method("alpha", get_alpha);
+}