reflexion 0.1.8 → 0.1.9

data/.doc/ext/reflex/shape_view.cpp

@@ -0,0 +1,153 @@
+#include "reflex/ruby/shape_view.h"
+
+
+#include <rucy.h>
+#include <rays/ruby/color.h>
+#include "reflex/ruby/view.h"
+
+
+using namespace Rucy;
+
+using Reflex::coord;
+
+
+RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(Reflex::ShapeView)
+
+#define THIS      to<Reflex::ShapeView*>(self)
+
+#define CHECK     RUCY_CHECK_OBJECT(Reflex::ShapeView, self)
+
+#define CALL(fun) RUCY_WRAPPER_CALL(Reflex::ShapeView, THIS, fun)
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	return value(new Reflex::RubyShapeView<Reflex::ShapeView>, klass);
+}
+
+static
+VALUE set_fill(VALUE self)
+{
+	CHECK;
+	check_arg_count(__FILE__, __LINE__, "ShapeView#set_fill", argc, 1, 2, 3, 4);
+
+	if (argc == 1 && argv[0].is_kind_of(Rays::color_class()))
+		THIS->set_fill(to<Rays::Color&>(argv[0]));
+	else if (argc == 1 || argc == 2)
+	{
+		float v = to<float>(argv[0]);
+		float a = (argc >= 2) ? to<float>(argv[1]) : 1;
+		THIS->set_fill(v, v, v, a);
+	}
+	else
+	{
+		float r = to<float>(argv[0]);
+		float g = to<float>(argv[1]);
+		float b = to<float>(argv[2]);
+		float a = (argc == 4) ? to<float>(argv[3]) : 1;
+		THIS->set_fill(r, g, b, a);
+	}
+
+	return self;
+}
+
+static
+VALUE no_fill(VALUE self)
+{
+	CHECK;
+	THIS->no_fill();
+	return self;
+}
+
+static
+VALUE get_fill(VALUE self)
+{
+	CHECK;
+	return value(THIS->fill());
+}
+
+static
+VALUE set_stroke(VALUE self)
+{
+	CHECK;
+	check_arg_count(__FILE__, __LINE__, "ShapeView#set_stroke", argc, 1, 2, 3, 4);
+
+	if (argc == 1 && argv[0].is_kind_of(Rays::color_class()))
+		THIS->set_stroke(to<Rays::Color&>(argv[0]));
+	else if (argc == 1 || argc == 2)
+	{
+		float v = to<float>(argv[0]);
+		float a = (argc >= 2) ? to<float>(argv[1]) : 1;
+		THIS->set_stroke(v, v, v, a);
+	}
+	else
+	{
+		float r = to<float>(argv[0]);
+		float g = to<float>(argv[1]);
+		float b = to<float>(argv[2]);
+		float a = (argc == 4) ? to<float>(argv[3]) : 1;
+		THIS->set_stroke(r, g, b, a);
+	}
+
+	return self;
+}
+
+static
+VALUE no_stroke(VALUE self)
+{
+	CHECK;
+	THIS->no_stroke();
+	return self;
+}
+
+static
+VALUE get_stroke(VALUE self)
+{
+	CHECK;
+	return value(THIS->stroke());
+}
+
+static
+VALUE on_draw_shape(VALUE self, VALUE event)
+{
+	CHECK;
+	CALL(on_draw_shape(to<Reflex::DrawEvent*>(event)));
+}
+
+static
+RUCY_DEF_clear_override_flags(cof, Reflex::ShapeView);
+
+
+static Class cShapeView;
+
+void
+Init_shape_view ()
+{
+	Module mReflex = rb_define_module("Reflex");
+
+	cShapeView = mReflex.define_class("ShapeView", Reflex::view_class());
+	rb_define_alloc_func(cShapeView, alloc);
+	rb_define_private_method(cShapeView, "set_fill", RUBY_METHOD_FUNC(set_fill), -1);
+	rb_define_method(cShapeView, "no_fill", RUBY_METHOD_FUNC(no_fill), 0);
+	rb_define_method(cShapeView, "fill", RUBY_METHOD_FUNC(get_fill), 0);
+	rb_define_private_method(cShapeView, "set_stroke", RUBY_METHOD_FUNC(set_stroke), -1);
+	rb_define_method(cShapeView, "no_stroke", RUBY_METHOD_FUNC(no_stroke), 0);
+	rb_define_method(cShapeView, "stroke", RUBY_METHOD_FUNC(get_stroke), 0);
+	rb_define_method(cShapeView, "on_draw_shape", RUBY_METHOD_FUNC(on_draw_shape), 1);
+	
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	shape_view_class ()
+	{
+		return cShapeView;
+	}
+
+
+}// Reflex

data/.doc/ext/reflex/view.cpp

@@ -205,7 +205,7 @@ static
 VALUE content_size(VALUE self)
 {
 	CHECK;
-	return value(THIS->content_size());
+	return value(CALL(content_size()));
 }
 
 static
@@ -290,6 +290,13 @@ VALUE get_frame(VALUE self)
 	return value(THIS->frame());
 }
 
+static
+VALUE get_angle(VALUE self)
+{
+	CHECK;
+	return value(THIS->angle());
+}
+
 static
 VALUE set_capture(VALUE self, VALUE types)
 {
@@ -372,27 +379,14 @@ VALUE body(VALUE self)
 }
 
 static
-VALUE set_density(VALUE self, VALUE value)
+VALUE meter2pixel(VALUE self)
 {
 	CHECK;
-	THIS->set_density(value.as_f(true));
-	return value;
-}
+	check_arg_count(__FILE__, __LINE__, "View#meter2pixel", argc, 0, 1, 2);
 
-static
-VALUE set_friction(VALUE self, VALUE value)
-{
-	CHECK;
-	THIS->set_friction(value.as_f(true));
-	return value;
-}
-
-static
-VALUE set_restitution(VALUE self, VALUE value)
-{
-	CHECK;
-	THIS->set_restitution(value.as_f(true));
-	return value;
+	float meter       = argc >= 1 ? argv[0].as_f(true) : 1;
+	bool create_world = argc >= 2 ? (bool) argv[1]     : true;
+	return value(THIS->meter2pixel(meter, create_world));
 }
 
 static
@@ -410,6 +404,13 @@ VALUE get_gravity(VALUE self)
 	return value(THIS->gravity());
 }
 
+static
+VALUE wall(VALUE self)
+{
+	CHECK;
+	return value(THIS->wall());
+}
+
 static
 VALUE set_debug(VALUE self, VALUE state)
 {
@@ -419,16 +420,20 @@ VALUE set_debug(VALUE self, VALUE state)
 }
 
 static
-VALUE is_debug(VALUE self)
+VALUE debugging(VALUE self)
 {
 	CHECK;
-	return value(THIS->is_debug());
+	return value(THIS->debugging());
 }
 
 static
 VALUE on_attach(VALUE self, VALUE event)
 {
 	CHECK;
+
+	RUCY_SYM(call_attach_block);
+	self.call(call_attach_block);
+
 	CALL(on_attach(to<Reflex::Event*>(event)));
 }
 
@@ -481,6 +486,13 @@ VALUE on_resize(VALUE self, VALUE event)
 	CALL(on_resize(to<Reflex::FrameEvent*>(event)));
 }
 
+static
+VALUE on_rotate(VALUE self, VALUE event)
+{
+	CHECK;
+	CALL(on_rotate(to<Reflex::FrameEvent*>(event)));
+}
+
 static
 VALUE on_scroll(VALUE self, VALUE event)
 {
@@ -565,6 +577,27 @@ VALUE on_capture(VALUE self, VALUE event)
 	CALL(on_capture(to<Reflex::CaptureEvent*>(event)));
 }
 
+static
+VALUE on_contact(VALUE self, VALUE event)
+{
+	CHECK;
+	CALL(on_contact(to<Reflex::ContactEvent*>(event)));
+}
+
+static
+VALUE on_contact_begin(VALUE self, VALUE event)
+{
+	CHECK;
+	CALL(on_contact_begin(to<Reflex::ContactEvent*>(event)));
+}
+
+static
+VALUE on_contact_end(VALUE self, VALUE event)
+{
+	CHECK;
+	CALL(on_contact_end(to<Reflex::ContactEvent*>(event)));
+}
+
 static
 RUCY_DEF_clear_override_flags(cof, Reflex::View);
 
@@ -607,6 +640,7 @@ Init_view ()
 	rb_define_method(cView, "selector", RUBY_METHOD_FUNC(get_selector), 0);
 	rb_define_private_method(cView, "set_frame", RUBY_METHOD_FUNC(set_frame), 1);
 	rb_define_private_method(cView, "get_frame", RUBY_METHOD_FUNC(get_frame), 0);
+	rb_define_method(cView, "angle", RUBY_METHOD_FUNC(get_angle), 0);
 	rb_define_method(cView, "scroll_to", RUBY_METHOD_FUNC(scroll_to), -1);
 	rb_define_method(cView, "scroll_by", RUBY_METHOD_FUNC(scroll_by), -1);
 	rb_define_method(cView, "scroll", RUBY_METHOD_FUNC(get_scroll), 0);
@@ -615,14 +649,13 @@ Init_view ()
 	rb_define_method(cView, "parent", RUBY_METHOD_FUNC(parent), 0);
 	rb_define_method(cView, "window", RUBY_METHOD_FUNC(window), 0);
 	rb_define_method(cView, "body", RUBY_METHOD_FUNC(body), 0);
-	rb_define_method(cView, "density=", RUBY_METHOD_FUNC(set_density), 1);
-	rb_define_method(cView, "friction=", RUBY_METHOD_FUNC(set_friction), 1);
-	rb_define_method(cView, "restitution=", RUBY_METHOD_FUNC(set_restitution), 1);
+	rb_define_method(cView, "meter2pixel", RUBY_METHOD_FUNC(meter2pixel), -1);
 	rb_define_method(cView, "set_gravity", RUBY_METHOD_FUNC(set_gravity), 2);
 	rb_define_method(cView, "gravity", RUBY_METHOD_FUNC(get_gravity), 0);
+	rb_define_method(cView, "wall", RUBY_METHOD_FUNC(wall), 0);
 	rb_define_method(cView, "debug=", RUBY_METHOD_FUNC(set_debug), 1);
-	cView.define_method("debug?",  is_debug);
-	cView.define_method("on_attach!", on_attach);
+	cView.define_method("debug?",     debugging);
+	rb_define_method(cView, "on_attach", RUBY_METHOD_FUNC(on_attach), 1);
 	rb_define_method(cView, "on_detach", RUBY_METHOD_FUNC(on_detach), 1);
 	rb_define_method(cView, "on_show", RUBY_METHOD_FUNC(on_show), 1);
 	rb_define_method(cView, "on_hide", RUBY_METHOD_FUNC(on_hide), 1);
@@ -630,6 +663,7 @@ Init_view ()
 	rb_define_method(cView, "on_draw", RUBY_METHOD_FUNC(on_draw), 1);
 	rb_define_method(cView, "on_move", RUBY_METHOD_FUNC(on_move), 1);
 	rb_define_method(cView, "on_resize", RUBY_METHOD_FUNC(on_resize), 1);
+	rb_define_method(cView, "on_rotate", RUBY_METHOD_FUNC(on_rotate), 1);
 	rb_define_method(cView, "on_scroll", RUBY_METHOD_FUNC(on_scroll), 1);
 	rb_define_method(cView, "on_focus", RUBY_METHOD_FUNC(on_focus), 1);
 	rb_define_method(cView, "on_blur", RUBY_METHOD_FUNC(on_blur), 1);
@@ -642,6 +676,9 @@ Init_view ()
 	rb_define_method(cView, "on_pointer_move", RUBY_METHOD_FUNC(on_pointer_move), 1);
 	rb_define_method(cView, "on_wheel", RUBY_METHOD_FUNC(on_wheel), 1);
 	rb_define_method(cView, "on_capture", RUBY_METHOD_FUNC(on_capture), 1);
+	rb_define_method(cView, "on_contact", RUBY_METHOD_FUNC(on_contact), 1);
+	rb_define_method(cView, "on_contact_begin", RUBY_METHOD_FUNC(on_contact_begin), 1);
+	rb_define_method(cView, "on_contact_end", RUBY_METHOD_FUNC(on_contact_end), 1);
 	cView.define_const("CAPTURE_NONE",      Reflex::View::CAPTURE_NONE);
 	cView.define_const("CAPTURE_KEY",       Reflex::View::CAPTURE_KEY);
 	cView.define_const("CAPTURE_POINTER",   Reflex::View::CAPTURE_POINTER);

data/.doc/ext/reflex/window.cpp

@@ -120,6 +120,10 @@ static
 VALUE on_show(VALUE self, VALUE event)
 {
 	CHECK;
+
+	RUCY_SYM(call_show_block);
+	self.call(call_show_block);
+
 	CALL(on_show(to<Reflex::Event*>(event)));
 }
 
@@ -246,7 +250,7 @@ Init_window ()
 	rb_define_method(cWindow, "root", RUBY_METHOD_FUNC(root), 0);
 	rb_define_method(cWindow, "focus", RUBY_METHOD_FUNC(focus), 0);
 	rb_define_method(cWindow, "painter", RUBY_METHOD_FUNC(painter), 0);
-	cWindow.define_method("on_show!", on_show);
+	rb_define_method(cWindow, "on_show", RUBY_METHOD_FUNC(on_show), 1);
 	rb_define_method(cWindow, "on_hide", RUBY_METHOD_FUNC(on_hide), 1);
 	rb_define_method(cWindow, "on_close", RUBY_METHOD_FUNC(on_close), 1);
 	rb_define_method(cWindow, "on_update", RUBY_METHOD_FUNC(on_update), 1);

data/VERSION

@@ -1 +1 @@
-0.1.8
+0.1.9

data/ext/reflex/application.cpp

@@ -63,6 +63,10 @@ static
 RUCY_DEF1(on_start, event)
 {
 	CHECK;
+
+	RUCY_SYM(call_start_block);
+	self.call(call_start_block);
+
 	CALL(on_start(to<Reflex::Event*>(event)));
 }
 RUCY_END
@@ -112,8 +116,8 @@ Init_application ()
 	cApplication.define_method("quit",  quit);
 	cApplication.define_method("name=", set_name);
 	cApplication.define_method("name",  get_name);
-	cApplication.define_method("on_start!", on_start);
-	cApplication.define_method("on_quit",   on_quit);
+	cApplication.define_method("on_start", on_start);
+	cApplication.define_method("on_quit",  on_quit);
 	cApplication.define_method("on_preference", on_preference);
 	cApplication.define_method("on_about",      on_about);
 	cApplication.define_singleton_method("instance", instance);

data/ext/reflex/arc_shape.cpp

@@ -0,0 +1,94 @@
+#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
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	return value(new Reflex::RubyShapeView<Reflex::ArcShape>, klass);
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_angle_from, degree)
+{
+	CHECK;
+	THIS->set_angle_from(degree.as_f(true));
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_angle_from)
+{
+	CHECK;
+	return value(THIS->angle_from());
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_angle_to, degree)
+{
+	CHECK;
+	THIS->set_angle_to(degree.as_f(true));
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_angle_to)
+{
+	CHECK;
+	return value(THIS->angle_to());
+}
+RUCY_END
+
+static
+RUCY_DEF_clear_override_flags(cof, Reflex::ArcShape);
+
+
+static Class cArcShape;
+
+void
+Init_arc_shape ()
+{
+	Module mReflex = define_module("Reflex");
+
+	cArcShape = mReflex.define_class("ArcShape", Reflex::ellipse_shape_class());
+	cArcShape.define_alloc_func(alloc);
+	cArcShape.define_method("angle_from=", set_angle_from);
+	cArcShape.define_method("angle_from",  get_angle_from);
+	cArcShape.define_method("angle_to=",   set_angle_to);
+	cArcShape.define_method("angle_to=",   get_angle_to);
+	cArcShape.define_clear_override_flags(cof);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	arc_shape_class ()
+	{
+		return cArcShape;
+	}
+
+
+}// Reflex

data/ext/reflex/body.cpp

@@ -35,35 +35,40 @@ RUCY_DEF2(add_box, width, height)
 RUCY_END
 
 static
-RUCY_DEF1(add_circle, size)
+RUCY_DEF2(add_ellipse, width, height)
 {
 	CHECK;
-	return value(THIS->add_circle(size.as_f(true)));
+	return value(THIS->add_ellipse(width.as_f(true), height.as_f(true)));
 }
 RUCY_END
 
 static
-RUCY_DEF0(clear_fixtures)
+RUCY_DEF4(add_arc, width, height, angle_from, 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)));
 }
 RUCY_END
 
 static
-RUCY_DEF0(get_position)
+RUCY_DEF0(clear_fixtures)
 {
 	CHECK;
-	return value(THIS->position());
+	THIS->clear_fixtures();
+	return self;
 }
 RUCY_END
 
 static
-RUCY_DEF0(get_angle)
+RUCY_DEFN(meter2pixel)
 {
 	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));
 }
 RUCY_END
 
@@ -101,6 +106,56 @@ RUCY_DEF0(is_dynamic)
 }
 RUCY_END
 
+static
+RUCY_DEF0(get_position)
+{
+	CHECK;
+	return value(THIS->position());
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_angle)
+{
+	CHECK;
+	return value(THIS->angle());
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_linear_velocity, velocity)
+{
+	CHECK;
+	THIS->set_linear_velocity(to<Rays::Point&>(velocity));
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_linear_velocity)
+{
+	CHECK;
+	return value(THIS->linear_velocity());
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_angular_velocity, velocity)
+{
+	CHECK;
+	THIS->set_angular_velocity(velocity.as_f(true));
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_angular_velocity)
+{
+	CHECK;
+	return value(THIS->angular_velocity());
+}
+RUCY_END
+
 static
 RUCY_DEF1(set_density, density)
 {
@@ -110,6 +165,14 @@ RUCY_DEF1(set_density, density)
 }
 RUCY_END
 
+static
+RUCY_DEF0(get_density)
+{
+	CHECK;
+	return value(THIS->density());
+}
+RUCY_END
+
 static
 RUCY_DEF1(set_friction, friction)
 {
@@ -119,6 +182,14 @@ RUCY_DEF1(set_friction, friction)
 }
 RUCY_END
 
+static
+RUCY_DEF0(get_friction)
+{
+	CHECK;
+	return value(THIS->friction());
+}
+RUCY_END
+
 static
 RUCY_DEF1(set_restitution, restitution)
 {
@@ -128,6 +199,14 @@ RUCY_DEF1(set_restitution, restitution)
 }
 RUCY_END
 
+static
+RUCY_DEF0(get_restitution)
+{
+	CHECK;
+	return value(THIS->restitution());
+}
+RUCY_END
+
 static
 RUCY_DEF0(each)
 {
@@ -151,18 +230,27 @@ Init_body ()
 
 	cBody = mReflex.define_class("Body");
 	cBody.define_private_method("initialize_copy", initialize_copy);
-	cBody.define_method("add_box",    add_box);
-	cBody.define_method("add_circle", add_circle);
+	cBody.define_method("add_box",     add_box);
+	cBody.define_method("add_ellipse", add_ellipse);
+	cBody.define_method("add_arc",     add_arc);
 	cBody.define_method("clear_fixtures", clear_fixtures);
-	cBody.define_method("position", get_position);
-	cBody.define_method("angle",    get_angle);
+	cBody.define_method("meter2pixel", meter2pixel);
 	cBody.define_method("static=", set_static);
 	cBody.define_method("static?",  is_static);
 	cBody.define_method("dynamic=", set_dynamic);
 	cBody.define_method("dynamic?",  is_dynamic);
+	cBody.define_method("position", get_position);
+	cBody.define_method("angle",    get_angle);
+	cBody.define_method("linear_velocity=",  set_linear_velocity);
+	cBody.define_method("linear_velocity",   get_linear_velocity);
+	cBody.define_method("angular_velocity=", set_angular_velocity);
+	cBody.define_method("angular_velocity",  get_angular_velocity);
 	cBody.define_method("density=",     set_density);
+	cBody.define_method("density",      get_density);
 	cBody.define_method("friction=",    set_friction);
+	cBody.define_method("friction",     get_friction);
 	cBody.define_method("restitution=", set_restitution);
+	cBody.define_method("restitution",  get_restitution);
 	cBody.define_method("each", each);
 }