rays 0.1.3 → 0.1.4

data/ext/rays/point.cpp

@@ -0,0 +1,175 @@
+#include "rays/ruby/point.h"
+
+
+#include <rucy.h>
+#include "defs.h"
+
+
+using namespace Rucy;
+
+using Rays::coord;
+
+
+static Class cPoint;
+
+
+namespace Rays
+{
+
+
+	Class
+	point_class ()
+	{
+		return cPoint;
+	}
+
+
+}// Rays
+
+
+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)
+
+
+static
+RUBY_DEF_ALLOC(alloc, klass)
+{
+	return new_type<Rays::Point>(klass);
+}
+RUBY_END
+
+static
+RUBY_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;
+
+	switch (argc)
+	{
+		case 1:
+			*THIS = Rays::Point(to<coord>(argv[0]));
+			break;
+
+		case 2:
+			*THIS = Rays::Point(to<coord>(argv[0]), to<coord>(argv[1]));
+			break;
+
+		case 3:
+			*THIS = Rays::Point(
+				to<coord>(argv[0]), to<coord>(argv[1]), to<coord>(argv[2]));
+			break;
+	}
+
+	return self;
+}
+RUBY_END
+
+static
+RUBY_DEF1(initialize_copy, obj)
+{
+	RUCY_CHECK_OBJ(self, Rays::Point, cPoint);
+
+	Rays::Point* point = to<Rays::Point*>(obj);
+	if (!point) argument_error();
+
+	*THIS = *point;
+	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
+
+
+void
+Init_point ()
+{
+	Module mRays = define_module("Rays");
+
+	cPoint = mRays.define_class("Point");
+	cPoint.define_alloc_func(alloc);
+	cPoint.define_private_method("initialize", initialize);
+	cPoint.define_private_method("initialize_copy", initialize_copy);
+	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);
+}

data/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
 RUBY_DEF0(init)
 {
 	if (!Rays::init())
-		error("Rays::init() failed.");
+		rays_error("Rays::init() failed.");
 
 	return self;
 }
@@ -36,7 +37,7 @@ static
 RUBY_DEF0(fin)
 {
 	if (!Rays::fin())
-		error("Rays::fin() failed.");
+		rays_error("Rays::fin() failed.");
 
 	return self;
 }
@@ -46,9 +47,7 @@ RUBY_END
 void
 Init_rays ()
 {
-	Module m = define_module("Rays");
-	Rays::mRays = m;
-
-	m.define_singleton_method("init!", init);
-	m.define_singleton_method("fin!", fin);
+	mRays = define_module("Rays");
+	mRays.define_singleton_method("init!", init);
+	mRays.define_singleton_method("fin!", fin);
 }

data/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,33 +33,40 @@ namespace Rucy
 
 
 	Value
-	value (const Rays::Texture& texture)
+	value (const Rays::Texture& obj)
 	{
-		return new_type<Rays::Texture>(
-			Rays::texture_class(), new Rays::Texture(texture));
+		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 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
 RUBY_DEF_ALLOC(alloc, klass)
 {
-	return new_type<Rays::Texture>(klass, new Rays::Texture);
+	return new_type<Rays::Texture>(klass);
 }
 RUBY_END
 
 static
 RUBY_DEFN(initialize)
 {
-	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;
@@ -66,7 +74,7 @@ RUBY_DEFN(initialize)
 	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;
 }
 RUBY_END
@@ -76,7 +84,7 @@ RUBY_DEF0(width)
 {
 	CHECK;
 
-	return value(this->width());
+	return value(THIS->width());
 }
 RUBY_END
 
@@ -85,7 +93,25 @@ RUBY_DEF0(height)
 {
 	CHECK;
 
-	return value(this->height());
+	return value(THIS->height());
+}
+RUBY_END
+
+static
+RUBY_DEF1(s, x)
+{
+	CHECK;
+
+	return value(THIS->s(x.as_f(true)));
+}
+RUBY_END
+
+static
+RUBY_DEF1(t, y)
+{
+	CHECK;
+
+	return value(THIS->t(y.as_f(true)));
 }
 RUBY_END
 
@@ -94,7 +120,7 @@ RUBY_DEF0(s_max)
 {
 	CHECK;
 
-	return value(this->s_max());
+	return value(THIS->s_max());
 }
 RUBY_END
 
@@ -103,7 +129,7 @@ RUBY_DEF0(t_max)
 {
 	CHECK;
 
-	return value(this->t_max());
+	return value(THIS->t_max());
 }
 RUBY_END
 
@@ -112,7 +138,7 @@ RUBY_DEF0(bitmap)
 {
 	CHECK;
 
-	return value(this->bitmap());
+	return value(THIS->bitmap());
 }
 RUBY_END
 
@@ -120,16 +146,14 @@ RUBY_END
 void
 Init_texture ()
 {
-	Module m = define_module("Rays");
-
-	Class c = m.define_class("Texture");
-	Rays::cTexture = c;
-
-	c.define_alloc_func(alloc);
-	c.define_method("initialize", initialize);
-	c.define_method("width", width);
-	c.define_method("height", height);
-	c.define_method("s_max", s_max);
-	c.define_method("t_max", t_max);
-	c.define_method("bitmap", bitmap);
+	Module mRays = define_module("Rays");
+
+	cTexture = mRays.define_class("Texture");
+	cTexture.define_alloc_func(alloc);
+	cTexture.define_private_method("initialize", initialize);
+	cTexture.define_method("width", width);
+	cTexture.define_method("height", height);
+	cTexture.define_method("s_max", s_max);
+	cTexture.define_method("t_max", t_max);
+	cTexture.define_method("bitmap", bitmap);
 }

data/include/rays.h

@@ -7,15 +7,14 @@
 #include <rays/defs.h>
 #include <rays/rays.h>
 #include <rays/exception.h>
+#include <rays/point.h>
 #include <rays/colorspace.h>
 #include <rays/bitmap.h>
 #include <rays/texture.h>
 #include <rays/image.h>
 #include <rays/font.h>
-#include <rays/transform.h>
 #include <rays/painter.h>
 #include <rays/opengl.h>
-#include <rays/helpers.h>
 
 
 #endif//EOH

data/include/rays/bitmap.h

@@ -4,10 +4,10 @@
 #define __RAYS_BITMAP_H__
 
 
+#include <xot/pimpl.h>
 #include <rays/defs.h>
 #include <rays/colorspace.h>
 #include <rays/font.h>
-#include <rays/helpers.h>
 
 
 namespace Rays
@@ -17,6 +17,8 @@ namespace Rays
 	class Bitmap
 	{
 
+		typedef Bitmap This;
+
 		public:
 
 			Bitmap ();
@@ -50,7 +52,7 @@ namespace Rays
 
 			template <typename T> const T* at (int x, int y) const
 			{
-				return const_cast<Bitmap*>(this)->at<T>(x, y);
+				return const_cast<This*>(this)->at<T>(x, y);
 			}
 
 			operator bool () const;
@@ -59,7 +61,7 @@ namespace Rays
 
 			struct Data;
 
-			Impl<Data> self;
+			Xot::PImpl<Data, true> self;
 
 	};// Bitmap
 

data/include/rays/bounds.h

@@ -0,0 +1,94 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __RAYS_BOUNDS_H__
+#define __RAYS_BOUNDS_H__
+
+
+#include <rays/defs.h>
+#include <rays/point.h>
+
+
+namespace Rays
+{
+
+
+	struct Bounds
+	{
+
+		typedef Bounds This;
+
+		coord x, y, z, width, height, depth;
+
+		Bounds (coord size = 0);
+
+		Bounds (                           coord width, coord height, coord depth = 0);
+
+		Bounds (coord x, coord y,          coord width, coord height);
+
+		Bounds (coord x, coord y, coord z, coord width, coord height, coord depth);
+
+		Bounds dup () const;
+
+		Bounds& set (coord size = 0);
+
+		Bounds& set (                           coord width, coord height, coord depth = 0);
+
+		Bounds& set (coord x, coord y,          coord width, coord height);
+
+		Bounds& set (coord x, coord y, coord z, coord width, coord height, coord depth);
+
+		bool get (coord* x, coord* y, coord* width, coord* height) const;
+
+		bool get (coord* x, coord* y, coord* z, coord* width, coord* height, coord* depth) const;
+
+		void set_left (coord left);
+
+		coord    left () const;
+
+		void set_right (coord right);
+
+		coord    right () const;
+
+		void set_top (coord top);
+
+		coord    top () const;
+
+		void set_bottom (coord bottom);
+
+		coord    bottom () const;
+
+		void set_back (coord back);
+
+		coord    back () const;
+
+		void set_front (coord front);
+
+		coord    front () const;
+
+		      Point& position ();
+
+		const Point& position () const;
+
+		      Point& size ();
+
+		const Point& size () const;
+
+		      coord* array ();
+
+		const coord* array () const;
+
+		operator bool () const;
+
+		bool operator ! () const;
+
+		friend bool operator == (const Bounds& lhs, const Bounds& rhs);
+
+		friend bool operator != (const Bounds& lhs, const Bounds& rhs);
+
+	};// Bounds
+
+
+}// Rays
+
+
+#endif//EOH