reflexion 0.1.11 → 0.1.16

data/ext/reflex/reflex.cpp

@@ -1,15 +1,33 @@
-#include <rucy.h>
-#include "reflex/reflex.h"
+#include "reflex/ruby/reflex.h"
+
+
+#include "reflex/ruby/view.h"
+#include "reflex/ruby/timer.h"
+#include "../../src/window.h"
+#include "../../src/timer.h"
 #include "defs.h"
 
 
-using namespace Rucy;
+static Reflex::View*
+create_root_view ()
+{
+	return new Reflex::RubyView<Reflex::View>;
+}
+
+static Reflex::Timer*
+create_timer ()
+{
+	return new Reflex::RubyTimer<Reflex::Timer>;
+}
 
 
 static
 RUCY_DEF0(init)
 {
 	Reflex::init();
+	Reflex::Window_set_create_root_view_fun(create_root_view);
+	Reflex::Timer_set_create_fun(create_timer);
+
 	return self;
 }
 RUCY_END
@@ -17,7 +35,10 @@ RUCY_END
 static
 RUCY_DEF0(fin)
 {
+	Reflex::Window_set_create_root_view_fun(NULL);
+	Reflex::Timer_set_create_fun(NULL);
 	Reflex::fin();
+
 	return self;
 }
 RUCY_END

data/ext/reflex/scroll_event.cpp

@@ -1,16 +1,10 @@
 #include "reflex/ruby/event.h"
 
 
-#include <rucy.h>
 #include "rays/ruby/point.h"
 #include "defs.h"
 
 
-using namespace Rucy;
-
-using Reflex::coord;
-
-
 RUCY_DEFINE_VALUE_FROM_TO(Reflex::ScrollEvent)
 
 #define THIS  to<Reflex::ScrollEvent*>(self)
@@ -26,17 +20,16 @@ RUCY_DEF_ALLOC(alloc, klass)
 RUCY_END
 
 static
-RUCY_DEFN(initialize)
+RUCY_DEF6(initialize, x, y, z, dx, dy, dz)
 {
 	CHECK;
-	check_arg_count(__FILE__, __LINE__, "ScrollEvent#initialize", argc, 0, 1, 2, 3, 4, 5, 6);
 
-	THIS->x       = (argc >= 1) ? to<coord>(argv[0]) : 0;
-	THIS->y       = (argc >= 2) ? to<coord>(argv[1]) : 0;
-	THIS->z       = (argc >= 3) ? to<coord>(argv[2]) : 0;
-	THIS->dx      = (argc >= 4) ? to<coord>(argv[3]) : 0;
-	THIS->dy      = (argc >= 5) ? to<coord>(argv[4]) : 0;
-	THIS->dz      = (argc >= 6) ? to<coord>(argv[5]) : 0;
+	THIS->x  = to<coord>(x);
+	THIS->y  = to<coord>(y);
+	THIS->z  = to<coord>(z);
+	THIS->dx = to<coord>(dx);
+	THIS->dy = to<coord>(dy);
+	THIS->dz = to<coord>(dz);
 
 	return rb_call_super(0, NULL);
 }
@@ -125,7 +118,7 @@ Init_scroll_event ()
 
 	cScrollEvent = mReflex.define_class("ScrollEvent", Reflex::event_class());
 	cScrollEvent.define_alloc_func(alloc);
-	cScrollEvent.define_private_method("initialize", initialize);
+	cScrollEvent.define_private_method("initialize",      initialize);
 	cScrollEvent.define_private_method("initialize_copy", initialize_copy);
 	cScrollEvent.define_method("x", x);
 	cScrollEvent.define_method("y", y);

data/ext/reflex/selector.cpp

@@ -1,16 +1,13 @@
 #include "reflex/ruby/selector.h"
 
 
-#include <rucy.h>
 #include "defs.h"
 
 
-using namespace Rucy;
+RUCY_DEFINE_VALUE_OR_ARRAY_FROM_TO(Reflex::Selector)
 
-
-RUCY_DEFINE_VALUE_FROM_TO(Reflex::Selector)
-
-#define THIS  to<Reflex::Selector*>(self)
+#define   THIS to<      Reflex::Selector*>(self)
+#define C_THIS to<const Reflex::Selector*>(self)
 
 #define CHECK RUCY_CHECK_OBJ(Reflex::Selector, self)
 
@@ -43,7 +40,8 @@ static
 RUCY_DEF0(get_name)
 {
 	CHECK;
-	return THIS->name() ? value(THIS->name()) : nil();
+	const char* name = C_THIS->name();
+	return name ? value(name) : nil();
 }
 RUCY_END
 
@@ -63,14 +61,30 @@ RUCY_DEF1(remove_tag, tag)
 }
 RUCY_END
 
+static
+RUCY_DEF0(clear_tags)
+{
+	CHECK;
+	THIS->clear_tags();
+}
+RUCY_END
+
+static
+RUCY_DEF1(has_tag, tag)
+{
+	CHECK;
+	return value(C_THIS->has_tag(tag.c_str()));
+}
+RUCY_END
+
 static
 RUCY_DEF0(each_tag)
 {
 	CHECK;
 
 	Value ret;
-	Reflex::Selector::iterator end = THIS->end();
-	for (Reflex::Selector::iterator it = THIS->begin(); it != end; ++it)
+	Reflex::Selector::const_iterator end = C_THIS->end();
+	for (Reflex::Selector::const_iterator it = C_THIS->begin(); it != end; ++it)
 		ret = rb_yield(value(*it));
 	return ret;
 }
@@ -80,7 +94,7 @@ static
 RUCY_DEF1(contains, selector)
 {
 	CHECK;
-	return value(THIS->contains(to<Reflex::Selector&>(selector)));
+	return value(C_THIS->contains(to<Reflex::Selector&>(selector)));
 }
 RUCY_END
 
@@ -88,7 +102,7 @@ static
 RUCY_DEF1(equal, selector)
 {
 	CHECK;
-	return value(*THIS == to<Reflex::Selector&>(selector));
+	return value(*C_THIS == to<const Reflex::Selector&>(selector));
 }
 RUCY_END
 
@@ -107,7 +121,9 @@ Init_selector ()
 	cSelector.define_method("name",  get_name);
 	cSelector.define_method("add_tag",    add_tag);
 	cSelector.define_method("remove_tag", remove_tag);
-	cSelector.define_method("each_tag", each_tag);
+	cSelector.define_method("clear_tags", clear_tags);
+	cSelector.define_method("tag?",       has_tag);
+	cSelector.define_method("each_tag",   each_tag);
 	cSelector.define_method("contains", contains);
 	cSelector.define_method("==", equal);
 }
@@ -118,12 +134,26 @@ namespace Rucy
 
 
 	template <> Reflex::Selector
-	value_to<Reflex::Selector> (Value value, bool convert)
+	value_to<Reflex::Selector> (int argc, const Value* argv, bool convert)
 	{
-		if (convert && (value.is_s() || value.is_sym()))
-			return Reflex::Selector(value.c_str());
+		if (argc == 1 && argv->is_array())
+		{
+			argc = argv->size();
+			argv = argv->as_array();
+		}
+
+		assert(argc > 0 && argv);
+
+		if (convert)
+		{
+			if (argc == 1 && (argv->is_s() || argv->is_sym()))
+				return Reflex::Selector(argv[0].c_str());
+		}
+
+		if (argc != 1)
+			argument_error(__FILE__, __LINE__);
 
-		return value_to<Reflex::Selector&>(value, convert);
+		return value_to<Reflex::Selector&>(*argv, convert);
 	}
 
 

data/ext/reflex/selector.h

@@ -0,0 +1,130 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_EXT_SELECTOR_H__
+#define __REFLEX_EXT_SELECTOR_H__
+
+
+#include <reflex/ruby/selector.h>
+
+
+template <typename T>
+static
+RUCY_DEF1(set_name, name)
+{
+	RUCY_CHECK_OBJ(T, self);
+	Reflex::HasSelector* this_ = Rucy::to<T*>(self);
+
+	this_->set_name(name.is_nil() ? NULL : name.c_str());
+}
+RUCY_END
+
+template <typename T>
+static
+RUCY_DEF0(get_name)
+{
+	RUCY_CHECK_OBJ(T, self);
+	const Reflex::HasSelector* this_ = Rucy::to<const T*>(self);
+
+	return this_->name() ? Rucy::value(this_->name()) : Rucy::nil();
+}
+RUCY_END
+
+template <typename T>
+static
+RUCY_DEF1(add_tag, tag)
+{
+	RUCY_CHECK_OBJ(T, self);
+	Reflex::HasSelector* this_ = Rucy::to<T*>(self);
+
+	this_->add_tag(tag.c_str());
+}
+RUCY_END
+
+template <typename T>
+static
+RUCY_DEF1(remove_tag, tag)
+{
+	RUCY_CHECK_OBJ(T, self);
+	Reflex::HasSelector* this_ = Rucy::to<T*>(self);
+
+	this_->remove_tag(tag.c_str());
+}
+RUCY_END
+
+template <typename T>
+static
+RUCY_DEF0(clear_tags)
+{
+	RUCY_CHECK_OBJ(T, self);
+	Reflex::HasSelector* this_ = Rucy::to<T*>(self);
+
+	this_->clear_tags();
+}
+RUCY_END
+
+template <typename T>
+static
+RUCY_DEF1(has_tag, tag)
+{
+	RUCY_CHECK_OBJ(T, self);
+	const Reflex::HasSelector* this_ = Rucy::to<const T*>(self);
+
+	return Rucy::value(this_->has_tag(tag.c_str()));
+}
+RUCY_END
+
+template <typename T>
+static
+RUCY_DEF0(each_tag)
+{
+	RUCY_CHECK_OBJ(T, self);
+	const Reflex::HasSelector* this_ = Rucy::to<const T*>(self);
+
+	Rucy::Value ret;
+	Reflex::Selector::const_iterator end = this_->tag_end();
+	for (Reflex::Selector::const_iterator it = this_->tag_begin(); it != end; ++it)
+		ret = rb_yield(Rucy::value(*it));
+	return ret;
+}
+RUCY_END
+
+template <typename T>
+static
+RUCY_DEF1(set_selector, selector)
+{
+	RUCY_CHECK_OBJ(T, self);
+	Reflex::HasSelector* this_ = Rucy::to<T*>(self);
+
+	this_->set_selector(Rucy::to<Reflex::Selector>(selector));
+}
+RUCY_END
+
+template <typename T>
+static
+RUCY_DEF0(get_selector)
+{
+	RUCY_CHECK_OBJ(T, self);
+	const Reflex::HasSelector* this_ = Rucy::to<const T*>(self);
+
+	return Rucy::value(this_->selector());
+}
+RUCY_END
+
+
+template <typename T>
+static void
+define_selector_methods (Rucy::Class klass)
+{
+	klass.define_method("name=", set_name<T>);
+	klass.define_method("name",  get_name<T>);
+	klass.define_method("add_tag",    add_tag<T>);
+	klass.define_method("remove_tag", remove_tag<T>);
+	klass.define_method("clear_tags", clear_tags<T>);
+	klass.define_method("tag?",       has_tag<T>);
+	klass.define_method("each_tag",   each_tag<T>);
+	klass.define_method("selector=", set_selector<T>);
+	klass.define_method("selector",  get_selector<T>);
+}
+
+
+#endif//EOH

data/ext/reflex/shape.cpp

@@ -0,0 +1,231 @@
+#include "reflex/ruby/shape.h"
+
+
+#include <rays/ruby/bounds.h>
+#include "reflex/exception.h"
+#include "reflex/ruby/view.h"
+#include "defs.h"
+#include "selector.h"
+
+
+RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(Reflex::Shape)
+
+#define THIS      to<Reflex::Shape*>(self)
+
+#define CHECK     RUCY_CHECK_OBJ(Reflex::Shape, self)
+
+#define CALL(fun) RUCY_CALL_SUPER(THIS, fun)
+
+
+static
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	Reflex::reflex_error(__FILE__, __LINE__, "can not instantiate Shape class.");
+}
+RUCY_END
+
+static
+RUCY_DEF0(owner)
+{
+	CHECK;
+	return value(THIS->owner());
+}
+RUCY_END
+
+static
+RUCY_DEFN(set_frame)
+{
+	CHECK;
+	THIS->set_frame(to<Rays::Bounds>(argc, argv));
+	return value(THIS->frame());
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_frame)
+{
+	CHECK;
+	return value(THIS->frame());
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_density, density)
+{
+	CHECK;
+	THIS->set_density(to<float>(density));
+	return density;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_density)
+{
+	CHECK;
+	return value(THIS->density());
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_friction, friction)
+{
+	CHECK;
+	THIS->set_friction(to<float>(friction));
+	return friction;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_friction)
+{
+	CHECK;
+	return value(THIS->friction());
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_restitution, restitution)
+{
+	CHECK;
+	THIS->set_restitution(to<float>(restitution));
+	return restitution;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_restitution)
+{
+	CHECK;
+	return value(THIS->restitution());
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_sensor, state)
+{
+	CHECK;
+	THIS->set_sensor(state);
+	return state;
+}
+RUCY_END
+
+static
+RUCY_DEF0(is_sensor)
+{
+	CHECK;
+	return value(THIS->is_sensor());
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_category_bits, bits)
+{
+	CHECK;
+	THIS->set_category_bits(to<uint>(bits));
+	return bits;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_category_bits)
+{
+	CHECK;
+	return value(THIS->category_bits());
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_collision_mask, mask)
+{
+	CHECK;
+	THIS->set_collision_mask(to<uint>(mask));
+	return mask;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_collision_mask)
+{
+	CHECK;
+	return value(THIS->collision_mask());
+}
+RUCY_END
+
+static
+RUCY_DEF1(on_draw, event)
+{
+	CHECK;
+	CALL(on_draw(to<Reflex::DrawEvent*>(event)));
+}
+RUCY_END
+
+static
+RUCY_DEF1(on_contact, event)
+{
+	CHECK;
+	CALL(on_contact(to<Reflex::ContactEvent*>(event)));
+}
+RUCY_END
+
+static
+RUCY_DEF1(on_contact_begin, event)
+{
+	CHECK;
+	CALL(on_contact_begin(to<Reflex::ContactEvent*>(event)));
+}
+RUCY_END
+
+static
+RUCY_DEF1(on_contact_end, event)
+{
+	CHECK;
+	CALL(on_contact_end(to<Reflex::ContactEvent*>(event)));
+}
+RUCY_END
+
+
+static Class cShape;
+
+void
+Init_shape ()
+{
+	Module mReflex = define_module("Reflex");
+
+	cShape = mReflex.define_class("Shape");
+	cShape.define_alloc_func(alloc);
+	cShape.define_method("owner", owner);
+	cShape.define_method("frame=", set_frame);
+	cShape.define_method("frame",  get_frame);
+	cShape.define_method("density=",     set_density);
+	cShape.define_method("density",      get_density);
+	cShape.define_method("friction=",    set_friction);
+	cShape.define_method("friction",     get_friction);
+	cShape.define_method("restitution=", set_restitution);
+	cShape.define_method("restitution",  get_restitution);
+	cShape.define_method("sensor=",      set_sensor);
+	cShape.define_method("sensor",        is_sensor);
+	cShape.define_method("category_bits=",  set_category_bits);
+	cShape.define_method("category_bits",   get_category_bits);
+	cShape.define_method("collision_mask=", set_collision_mask);
+	cShape.define_method("collision_mask",  get_collision_mask);
+	cShape.define_method("on_draw",          on_draw);
+	cShape.define_private_method("call_contact!",       on_contact);
+	cShape.define_private_method("call_contact_begin!", on_contact_begin);
+	cShape.define_private_method("call_contact_end!",   on_contact_end);
+
+	define_selector_methods<Reflex::Shape>(cShape);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	shape_class ()
+	{
+		return cShape;
+	}
+
+
+}// Reflex