reflexion 0.1.8 → 0.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 79a0d8b46171362cf5f24dff3960d8495a066497
-  data.tar.gz: 37d83b584fccb668c2f58fbbde8e73240f29f002
+  metadata.gz: 17839f16761a4d363fdfe730341a63687985cf22
+  data.tar.gz: 3d1dd6d5ef7a126d949f0d20cb7fdbe97753dc23
 SHA512:
-  metadata.gz: ba12b310b4e57c5426aae9c5d90a12bc1220911b1276090da4a0427a504e1ec0ab7e9a9de63ca78e6022112327f183e8ca4f2140bd91151e889202fef90d2d62
-  data.tar.gz: 73449bffdbe6fb05e268f7f63aba4dccce08b1c8f1d101019df24a96638a25024a81cf8e8a4b13c1e2e4162652f5adedcf73a4bc83064c93fdadfe82a6fc78b8
+  metadata.gz: 41c713b7191d8ddc3817f08012c473f765c82c3f60efb9dcb8aa8b355fff0bcdc1c77584d025d515ad199b352370410f0daec814a1b7e4267927cbe0518ad3c7
+  data.tar.gz: 63caf9f342985e743b9d78b2ee90d93129b72dc72768187f1d6e12e08f6b502763e508e6a5dec1ead9a1b057639b52110675d6e4f294abb4665136bb0309ed15

data/.doc/ext/reflex/application.cpp

@@ -58,6 +58,10 @@ static
 VALUE on_start(VALUE self, VALUE event)
 {
 	CHECK;
+
+	RUCY_SYM(call_start_block);
+	self.call(call_start_block);
+
 	CALL(on_start(to<Reflex::Event*>(event)));
 }
 
@@ -102,7 +106,7 @@ Init_application ()
 	rb_define_method(cApplication, "quit", RUBY_METHOD_FUNC(quit), 0);
 	rb_define_method(cApplication, "name=", RUBY_METHOD_FUNC(set_name), 1);
 	rb_define_method(cApplication, "name", RUBY_METHOD_FUNC(get_name), 0);
-	cApplication.define_method("on_start!", on_start);
+	rb_define_method(cApplication, "on_start", RUBY_METHOD_FUNC(on_start), 1);
 	rb_define_method(cApplication, "on_quit", RUBY_METHOD_FUNC(on_quit), 1);
 	rb_define_method(cApplication, "on_preference", RUBY_METHOD_FUNC(on_preference), 1);
 	rb_define_method(cApplication, "on_about", RUBY_METHOD_FUNC(on_about), 1);

data/.doc/ext/reflex/arc_shape.cpp

@@ -0,0 +1,89 @@
+#include "reflex/ruby/shape_view.h"
+
+
+#include <rucy.h>
+
+
+using namespace Rucy;
+
+using Reflex::coord;
+
+
+RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(Reflex::ArcShape)
+
+#define THIS      to<Reflex::ArcShape*>(self)
+
+#define CHECK     RUCY_CHECK_OBJECT(Reflex::ArcShape, self)
+
+#define CALL(fun) RUCY_WRAPPER_CALL(Reflex::ArcShape, THIS, fun)
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	return value(new Reflex::RubyShapeView<Reflex::ArcShape>, klass);
+}
+
+static
+VALUE set_angle_from(VALUE self, VALUE degree)
+{
+	CHECK;
+	THIS->set_angle_from(degree.as_f(true));
+	return self;
+}
+
+static
+VALUE get_angle_from(VALUE self)
+{
+	CHECK;
+	return value(THIS->angle_from());
+}
+
+static
+VALUE set_angle_to(VALUE self, VALUE degree)
+{
+	CHECK;
+	THIS->set_angle_to(degree.as_f(true));
+	return self;
+}
+
+static
+VALUE get_angle_to(VALUE self)
+{
+	CHECK;
+	return value(THIS->angle_to());
+}
+
+static
+RUCY_DEF_clear_override_flags(cof, Reflex::ArcShape);
+
+
+static Class cArcShape;
+
+void
+Init_arc_shape ()
+{
+	Module mReflex = rb_define_module("Reflex");
+
+	cArcShape = mReflex.define_class("ArcShape", Reflex::ellipse_shape_class());
+	rb_define_alloc_func(cArcShape, alloc);
+	rb_define_method(cArcShape, "angle_from=", RUBY_METHOD_FUNC(set_angle_from), 1);
+	rb_define_method(cArcShape, "angle_from", RUBY_METHOD_FUNC(get_angle_from), 0);
+	rb_define_method(cArcShape, "angle_to=", RUBY_METHOD_FUNC(set_angle_to), 1);
+	rb_define_method(cArcShape, "angle_to=", RUBY_METHOD_FUNC(get_angle_to), 0);
+	
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	arc_shape_class ()
+	{
+		return cArcShape;
+	}
+
+
+}// Reflex

data/.doc/ext/reflex/body.cpp

@@ -33,32 +33,37 @@ VALUE add_box(VALUE self, VALUE width, VALUE height)
 }
 
 static
-VALUE add_circle(VALUE self, VALUE size)
+VALUE add_ellipse(VALUE self, VALUE width, VALUE height)
 {
 	CHECK;
-	return value(THIS->add_circle(size.as_f(true)));
+	return value(THIS->add_ellipse(width.as_f(true), height.as_f(true)));
 }
 
 static
-VALUE clear_fixtures(VALUE self)
+VALUE add_arc(VALUE self, VALUE width, VALUE height, VALUE angle_from, VALUE angle_to)
 {
 	CHECK;
-	THIS->clear_fixtures();
-	return self;
+	return value(THIS->add_arc(
+		width.as_f(true), height.as_f(true),
+		angle_from.as_f(true), angle_to.as_f(true)));
 }
 
 static
-VALUE get_position(VALUE self)
+VALUE clear_fixtures(VALUE self)
 {
 	CHECK;
-	return value(THIS->position());
+	THIS->clear_fixtures();
+	return self;
 }
 
 static
-VALUE get_angle(VALUE self)
+VALUE meter2pixel(VALUE self)
 {
 	CHECK;
-	return value(THIS->angle());
+	check_arg_count(__FILE__, __LINE__, "View#meter2pixel", argc, 0, 1);
+
+	float meter = argc >= 1 ? argv[0].as_f(true) : 1;
+	return value(THIS->meter2pixel(meter));
 }
 
 static
@@ -91,6 +96,50 @@ VALUE is_dynamic(VALUE self)
 	return value(THIS->is_dynamic());
 }
 
+static
+VALUE get_position(VALUE self)
+{
+	CHECK;
+	return value(THIS->position());
+}
+
+static
+VALUE get_angle(VALUE self)
+{
+	CHECK;
+	return value(THIS->angle());
+}
+
+static
+VALUE set_linear_velocity(VALUE self, VALUE velocity)
+{
+	CHECK;
+	THIS->set_linear_velocity(to<Rays::Point&>(velocity));
+	return self;
+}
+
+static
+VALUE get_linear_velocity(VALUE self)
+{
+	CHECK;
+	return value(THIS->linear_velocity());
+}
+
+static
+VALUE set_angular_velocity(VALUE self, VALUE velocity)
+{
+	CHECK;
+	THIS->set_angular_velocity(velocity.as_f(true));
+	return self;
+}
+
+static
+VALUE get_angular_velocity(VALUE self)
+{
+	CHECK;
+	return value(THIS->angular_velocity());
+}
+
 static
 VALUE set_density(VALUE self, VALUE density)
 {
@@ -99,6 +148,13 @@ VALUE set_density(VALUE self, VALUE density)
 	return self;
 }
 
+static
+VALUE get_density(VALUE self)
+{
+	CHECK;
+	return value(THIS->density());
+}
+
 static
 VALUE set_friction(VALUE self, VALUE friction)
 {
@@ -107,6 +163,13 @@ VALUE set_friction(VALUE self, VALUE friction)
 	return self;
 }
 
+static
+VALUE get_friction(VALUE self)
+{
+	CHECK;
+	return value(THIS->friction());
+}
+
 static
 VALUE set_restitution(VALUE self, VALUE restitution)
 {
@@ -115,6 +178,13 @@ VALUE set_restitution(VALUE self, VALUE restitution)
 	return self;
 }
 
+static
+VALUE get_restitution(VALUE self)
+{
+	CHECK;
+	return value(THIS->restitution());
+}
+
 static
 VALUE each(VALUE self)
 {
@@ -138,17 +208,26 @@ Init_body ()
 	cBody = rb_define_class_under(mReflex, "Body", rb_cObject);
 	rb_define_private_method(cBody, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
 	rb_define_method(cBody, "add_box", RUBY_METHOD_FUNC(add_box), 2);
-	rb_define_method(cBody, "add_circle", RUBY_METHOD_FUNC(add_circle), 1);
+	rb_define_method(cBody, "add_ellipse", RUBY_METHOD_FUNC(add_ellipse), 2);
+	rb_define_method(cBody, "add_arc", RUBY_METHOD_FUNC(add_arc), 4);
 	rb_define_method(cBody, "clear_fixtures", RUBY_METHOD_FUNC(clear_fixtures), 0);
-	rb_define_method(cBody, "position", RUBY_METHOD_FUNC(get_position), 0);
-	rb_define_method(cBody, "angle", RUBY_METHOD_FUNC(get_angle), 0);
+	rb_define_method(cBody, "meter2pixel", RUBY_METHOD_FUNC(meter2pixel), -1);
 	rb_define_method(cBody, "static=", RUBY_METHOD_FUNC(set_static), 1);
 	cBody.define_method("static?",  is_static);
 	rb_define_method(cBody, "dynamic=", RUBY_METHOD_FUNC(set_dynamic), 1);
 	cBody.define_method("dynamic?",  is_dynamic);
+	rb_define_method(cBody, "position", RUBY_METHOD_FUNC(get_position), 0);
+	rb_define_method(cBody, "angle", RUBY_METHOD_FUNC(get_angle), 0);
+	rb_define_method(cBody, "linear_velocity=", RUBY_METHOD_FUNC(set_linear_velocity), 1);
+	rb_define_method(cBody, "linear_velocity", RUBY_METHOD_FUNC(get_linear_velocity), 0);
+	rb_define_method(cBody, "angular_velocity=", RUBY_METHOD_FUNC(set_angular_velocity), 1);
+	rb_define_method(cBody, "angular_velocity", RUBY_METHOD_FUNC(get_angular_velocity), 0);
 	rb_define_method(cBody, "density=", RUBY_METHOD_FUNC(set_density), 1);
+	rb_define_method(cBody, "density", RUBY_METHOD_FUNC(get_density), 0);
 	rb_define_method(cBody, "friction=", RUBY_METHOD_FUNC(set_friction), 1);
+	rb_define_method(cBody, "friction", RUBY_METHOD_FUNC(get_friction), 0);
 	rb_define_method(cBody, "restitution=", RUBY_METHOD_FUNC(set_restitution), 1);
+	rb_define_method(cBody, "restitution", RUBY_METHOD_FUNC(get_restitution), 0);
 	rb_define_method(cBody, "each", RUBY_METHOD_FUNC(each), 0);
 }
 

data/.doc/ext/reflex/contact_event.cpp

@@ -0,0 +1,90 @@
+#include "reflex/ruby/event.h"
+
+
+#include <rucy.h>
+#include "reflex/ruby/view.h"
+#include "defs.h"
+
+
+using namespace Rucy;
+
+
+RUCY_DEFINE_VALUE_FROM_TO(Reflex::ContactEvent)
+
+#define THIS  to<Reflex::ContactEvent*>(self)
+
+#define CHECK RUCY_CHECK_OBJ(Reflex::ContactEvent, self)
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	return new_type<Reflex::ContactEvent>(klass);
+}
+
+static
+VALUE initialize(VALUE self)
+{
+	CHECK;
+	check_arg_count(__FILE__, __LINE__, "ContactEvent#initialize", argc, 0, 2);
+
+	THIS->type = (argc >= 1) ? (Reflex::ContactEvent::Type) to<int>(argv[0]) : Reflex::ContactEvent::NONE;
+	THIS->view = (argc >= 2) ? to<Reflex::View*>(argv[1]) : NULL;
+
+	return rb_call_super(0, NULL);
+}
+
+static
+VALUE initialize_copy(VALUE self, VALUE obj)
+{
+	CHECK;
+	*THIS = to<Reflex::ContactEvent&>(obj);
+	return self;
+}
+
+static
+VALUE get_type(VALUE self)
+{
+	CHECK;
+	return value(THIS->type);
+}
+
+static
+VALUE get_view(VALUE self)
+{
+	CHECK;
+	return value(THIS->view);
+}
+
+
+static Class cContactEvent;
+
+void
+Init_contact_event ()
+{
+	Module mReflex = rb_define_module("Reflex");
+
+	cContactEvent = mReflex.define_class("ContactEvent", Reflex::event_class());
+	rb_define_alloc_func(cContactEvent, alloc);
+	rb_define_private_method(cContactEvent, "initialize", RUBY_METHOD_FUNC(initialize), -1);
+	rb_define_private_method(cContactEvent, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
+	rb_define_method(cContactEvent, "get_type", RUBY_METHOD_FUNC(get_type), 0);
+	rb_define_method(cContactEvent, "view", RUBY_METHOD_FUNC(get_view), 0);
+	cContactEvent.define_const("TYPE_NONE",  Reflex::ContactEvent::NONE);
+	cContactEvent.define_const("TYPE_BEGIN", Reflex::ContactEvent::BEGIN);
+	cContactEvent.define_const("TYPE_END",   Reflex::ContactEvent::END);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	contact_event_class ()
+	{
+		return cContactEvent;
+	}
+
+
+}// Reflex

data/.doc/ext/reflex/ellipse_shape.cpp

@@ -0,0 +1,89 @@
+#include "reflex/ruby/shape_view.h"
+
+
+#include <rucy.h>
+
+
+using namespace Rucy;
+
+using Reflex::coord;
+
+
+RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(Reflex::EllipseShape)
+
+#define THIS      to<Reflex::EllipseShape*>(self)
+
+#define CHECK     RUCY_CHECK_OBJECT(Reflex::EllipseShape, self)
+
+#define CALL(fun) RUCY_WRAPPER_CALL(Reflex::EllipseShape, THIS, fun)
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	return value(new Reflex::RubyShapeView<Reflex::EllipseShape>, klass);
+}
+
+static
+VALUE set_radius_min(VALUE self, VALUE radius)
+{
+	CHECK;
+	THIS->set_radius_min(radius.as_f(true));
+	return radius;
+}
+
+static
+VALUE get_radius_min(VALUE self)
+{
+	CHECK;
+	return value(THIS->radius_min());
+}
+
+static
+VALUE set_nsegment(VALUE self, VALUE nsegment)
+{
+	CHECK;
+	THIS->set_nsegment(nsegment.as_i(true));
+	return nsegment;
+}
+
+static
+VALUE get_nsegment(VALUE self)
+{
+	CHECK;
+	return value(THIS->nsegment());
+}
+
+static
+RUCY_DEF_clear_override_flags(cof, Reflex::EllipseShape);
+
+
+static Class cEllipseShape;
+
+void
+Init_ellipse_shape ()
+{
+	Module mReflex = rb_define_module("Reflex");
+
+	cEllipseShape = mReflex.define_class("EllipseShape", Reflex::shape_view_class());
+	rb_define_alloc_func(cEllipseShape, alloc);
+	rb_define_private_method(cEllipseShape, "radius_min=", RUBY_METHOD_FUNC(set_radius_min), 1);
+	rb_define_method(cEllipseShape, "radius_min", RUBY_METHOD_FUNC(get_radius_min), 0);
+	rb_define_private_method(cEllipseShape, "nsegment=", RUBY_METHOD_FUNC(set_nsegment), 1);
+	rb_define_method(cEllipseShape, "nsegment", RUBY_METHOD_FUNC(get_nsegment), 0);
+	
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	ellipse_shape_class ()
+	{
+		return cEllipseShape;
+	}
+
+
+}// Reflex

data/.doc/ext/reflex/image_view.cpp

@@ -42,20 +42,6 @@ VALUE set_image(VALUE self, VALUE image)
 	return image;
 }
 
-static
-VALUE content_size(VALUE self)
-{
-	CHECK;
-	return value(THIS->content_size());
-}
-
-static
-VALUE on_draw(VALUE self, VALUE event)
-{
-	CHECK;
-	CALL(on_draw(to<Reflex::DrawEvent*>(event)));
-}
-
 static
 RUCY_DEF_clear_override_flags(cof, Reflex::ImageView);
 
@@ -71,8 +57,6 @@ Init_image_view ()
 	rb_define_alloc_func(cImageView, alloc);
 	rb_define_private_method(cImageView, "set_image", RUBY_METHOD_FUNC(set_image), 1);
 	rb_define_method(cImageView, "image", RUBY_METHOD_FUNC(get_image), 0);
-	rb_define_method(cImageView, "content_size", RUBY_METHOD_FUNC(content_size), 0);
-	rb_define_method(cImageView, "on_draw", RUBY_METHOD_FUNC(on_draw), 1);
 	
 }
 

data/.doc/ext/reflex/native.cpp

@@ -23,16 +23,22 @@ void Init_key_event ();
 void Init_pointer_event ();
 void Init_wheel_event ();
 void Init_capture_event ();
+void Init_contact_event ();
+
+void Init_body ();
+void Init_fixture ();
 
 void Init_application ();
 void Init_window ();
 void Init_view ();
 
-void Init_body ();
-void Init_fixture ();
-
 void Init_image_view ();
 
+void Init_shape_view ();
+void Init_rect_shape ();
+void Init_ellipse_shape ();
+void Init_arc_shape ();
+
 
 extern "C" void
 Init_native ()
@@ -59,15 +65,21 @@ Init_native ()
 	Init_pointer_event();
 	Init_wheel_event();
 	Init_capture_event();
+	Init_contact_event();
+
+	Init_body();
+	Init_fixture();
 
 	Init_application();
 	Init_window();
 	Init_view();
 
-	Init_body();
-	Init_fixture();
-
 	Init_image_view();
 
+	Init_shape_view();
+	Init_rect_shape();
+	Init_ellipse_shape();
+	Init_arc_shape();
+
 	RUCY_CATCH
 }

data/.doc/ext/reflex/rect_shape.cpp

@@ -0,0 +1,83 @@
+#include "reflex/ruby/shape_view.h"
+
+
+#include <rucy.h>
+#include <rays/ruby/point.h>
+
+
+using namespace Rucy;
+
+using Reflex::coord;
+
+
+RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(Reflex::RectShape)
+
+#define THIS      to<Reflex::RectShape*>(self)
+
+#define CHECK     RUCY_CHECK_OBJECT(Reflex::RectShape, self)
+
+#define CALL(fun) RUCY_WRAPPER_CALL(Reflex::RectShape, THIS, fun)
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	return value(new Reflex::RubyShapeView<Reflex::RectShape>, klass);
+}
+
+static
+VALUE set_round(VALUE self)
+{
+	CHECK;
+	check_arg_count(__FILE__, __LINE__, "RectShape#set_fill", argc, 1, 2);
+
+	if (argc == 1 && argv[0].is_kind_of(Rays::point_class()))
+		THIS->set_round(to<Rays::Point&>(argv[0]));
+	else
+	{
+		float w =               to<float>(argv[0]);
+		float h = (argc >= 2) ? to<float>(argv[1]) : 1;
+		THIS->set_round(w, h);
+	}
+
+	return self;
+}
+
+static
+VALUE get_round(VALUE self)
+{
+	CHECK;
+	return value(THIS->round());
+}
+
+static
+RUCY_DEF_clear_override_flags(cof, Reflex::RectShape);
+
+
+static Class cRectShape;
+
+void
+Init_rect_shape ()
+{
+	Module mReflex = rb_define_module("Reflex");
+
+	cRectShape = mReflex.define_class("RectShape", Reflex::shape_view_class());
+	rb_define_alloc_func(cRectShape, alloc);
+	rb_define_private_method(cRectShape, "round=", RUBY_METHOD_FUNC(set_round), -1);
+	rb_define_method(cRectShape, "round", RUBY_METHOD_FUNC(get_round), 0);
+	
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	rect_shape_class ()
+	{
+		return cRectShape;
+	}
+
+
+}// Reflex