reflexion 0.1.8 → 0.1.9

data/ext/reflex/contact_event.cpp

@@ -0,0 +1,95 @@
+#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
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	return new_type<Reflex::ContactEvent>(klass);
+}
+RUCY_END
+
+static
+RUCY_DEFN(initialize)
+{
+	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);
+}
+RUCY_END
+
+static
+RUCY_DEF1(initialize_copy, obj)
+{
+	CHECK;
+	*THIS = to<Reflex::ContactEvent&>(obj);
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_type)
+{
+	CHECK;
+	return value(THIS->type);
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_view)
+{
+	CHECK;
+	return value(THIS->view);
+}
+RUCY_END
+
+
+static Class cContactEvent;
+
+void
+Init_contact_event ()
+{
+	Module mReflex = define_module("Reflex");
+
+	cContactEvent = mReflex.define_class("ContactEvent", Reflex::event_class());
+	cContactEvent.define_alloc_func(alloc);
+	cContactEvent.define_private_method("initialize", initialize);
+	cContactEvent.define_private_method("initialize_copy", initialize_copy);
+	cContactEvent.define_method("get_type", get_type);
+	cContactEvent.define_method("view",     get_view);
+	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/ext/reflex/ellipse_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::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
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	return value(new Reflex::RubyShapeView<Reflex::EllipseShape>, klass);
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_radius_min, radius)
+{
+	CHECK;
+	THIS->set_radius_min(radius.as_f(true));
+	return radius;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_radius_min)
+{
+	CHECK;
+	return value(THIS->radius_min());
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_nsegment, nsegment)
+{
+	CHECK;
+	THIS->set_nsegment(nsegment.as_i(true));
+	return nsegment;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_nsegment)
+{
+	CHECK;
+	return value(THIS->nsegment());
+}
+RUCY_END
+
+static
+RUCY_DEF_clear_override_flags(cof, Reflex::EllipseShape);
+
+
+static Class cEllipseShape;
+
+void
+Init_ellipse_shape ()
+{
+	Module mReflex = define_module("Reflex");
+
+	cEllipseShape = mReflex.define_class("EllipseShape", Reflex::shape_view_class());
+	cEllipseShape.define_alloc_func(alloc);
+	cEllipseShape.define_private_method("radius_min=", set_radius_min);
+	cEllipseShape.define_method(        "radius_min",  get_radius_min);
+	cEllipseShape.define_private_method("nsegment=", set_nsegment);
+	cEllipseShape.define_method(        "nsegment",  get_nsegment);
+	cEllipseShape.define_clear_override_flags(cof);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	ellipse_shape_class ()
+	{
+		return cEllipseShape;
+	}
+
+
+}// Reflex

data/ext/reflex/image_view.cpp

@@ -45,22 +45,6 @@ RUCY_DEF1(set_image, image)
 }
 RUCY_END
 
-static
-RUCY_DEF0(content_size)
-{
-	CHECK;
-	return value(THIS->content_size());
-}
-RUCY_END
-
-static
-RUCY_DEF1(on_draw, event)
-{
-	CHECK;
-	CALL(on_draw(to<Reflex::DrawEvent*>(event)));
-}
-RUCY_END
-
 static
 RUCY_DEF_clear_override_flags(cof, Reflex::ImageView);
 
@@ -76,8 +60,6 @@ Init_image_view ()
 	cImageView.define_alloc_func(alloc);
 	cImageView.define_private_method("set_image", set_image);
 	cImageView.define_method(            "image", get_image);
-	cImageView.define_method("content_size", content_size);
-	cImageView.define_method("on_draw", on_draw);
 	cImageView.define_clear_override_flags(cof);
 }
 

data/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/ext/reflex/rect_shape.cpp

@@ -0,0 +1,86 @@
+#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
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	return value(new Reflex::RubyShapeView<Reflex::RectShape>, klass);
+}
+RUCY_END
+
+static
+RUCY_DEFN(set_round)
+{
+	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;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_round)
+{
+	CHECK;
+	return value(THIS->round());
+}
+RUCY_END
+
+static
+RUCY_DEF_clear_override_flags(cof, Reflex::RectShape);
+
+
+static Class cRectShape;
+
+void
+Init_rect_shape ()
+{
+	Module mReflex = define_module("Reflex");
+
+	cRectShape = mReflex.define_class("RectShape", Reflex::shape_view_class());
+	cRectShape.define_alloc_func(alloc);
+	cRectShape.define_private_method("round=", set_round);
+	cRectShape.define_method(        "round",  get_round);
+	cRectShape.define_clear_override_flags(cof);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	rect_shape_class ()
+	{
+		return cRectShape;
+	}
+
+
+}// Reflex

data/ext/reflex/shape_view.cpp

@@ -0,0 +1,161 @@
+#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
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	return value(new Reflex::RubyShapeView<Reflex::ShapeView>, klass);
+}
+RUCY_END
+
+static
+RUCY_DEFN(set_fill)
+{
+	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;
+}
+RUCY_END
+
+static
+RUCY_DEF0(no_fill)
+{
+	CHECK;
+	THIS->no_fill();
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_fill)
+{
+	CHECK;
+	return value(THIS->fill());
+}
+RUCY_END
+
+static
+RUCY_DEFN(set_stroke)
+{
+	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;
+}
+RUCY_END
+
+static
+RUCY_DEF0(no_stroke)
+{
+	CHECK;
+	THIS->no_stroke();
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_stroke)
+{
+	CHECK;
+	return value(THIS->stroke());
+}
+RUCY_END
+
+static
+RUCY_DEF1(on_draw_shape, event)
+{
+	CHECK;
+	CALL(on_draw_shape(to<Reflex::DrawEvent*>(event)));
+}
+RUCY_END
+
+static
+RUCY_DEF_clear_override_flags(cof, Reflex::ShapeView);
+
+
+static Class cShapeView;
+
+void
+Init_shape_view ()
+{
+	Module mReflex = define_module("Reflex");
+
+	cShapeView = mReflex.define_class("ShapeView", Reflex::view_class());
+	cShapeView.define_alloc_func(alloc);
+	cShapeView.define_private_method("set_fill", set_fill);
+	cShapeView.define_method(         "no_fill",  no_fill);
+	cShapeView.define_method(            "fill", get_fill);
+	cShapeView.define_private_method("set_stroke", set_stroke);
+	cShapeView.define_method(         "no_stroke",  no_stroke);
+	cShapeView.define_method(            "stroke", get_stroke);
+	cShapeView.define_method("on_draw_shape", on_draw_shape);
+	cShapeView.define_clear_override_flags(cof);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	shape_view_class ()
+	{
+		return cShapeView;
+	}
+
+
+}// Reflex

data/ext/reflex/view.cpp

@@ -223,7 +223,7 @@ static
 RUCY_DEF0(content_size)
 {
 	CHECK;
-	return value(THIS->content_size());
+	return value(CALL(content_size()));
 }
 RUCY_END
 
@@ -320,6 +320,14 @@ RUCY_DEF0(get_frame)
 }
 RUCY_END
 
+static
+RUCY_DEF0(get_angle)
+{
+	CHECK;
+	return value(THIS->angle());
+}
+RUCY_END
+
 static
 RUCY_DEF1(set_capture, types)
 {
@@ -410,46 +418,39 @@ RUCY_DEF0(body)
 RUCY_END
 
 static
-RUCY_DEF1(set_density, value)
+RUCY_DEFN(meter2pixel)
 {
 	CHECK;
-	THIS->set_density(value.as_f(true));
-	return value;
-}
-RUCY_END
+	check_arg_count(__FILE__, __LINE__, "View#meter2pixel", argc, 0, 1, 2);
 
-static
-RUCY_DEF1(set_friction, value)
-{
-	CHECK;
-	THIS->set_friction(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));
 }
 RUCY_END
 
 static
-RUCY_DEF1(set_restitution, value)
+RUCY_DEF2(set_gravity, x, y)
 {
 	CHECK;
-	THIS->set_restitution(value.as_f(true));
-	return value;
+	THIS->set_gravity(x.as_f(true), y.as_f(true));
+	return self;
 }
 RUCY_END
 
 static
-RUCY_DEF2(set_gravity, x, y)
+RUCY_DEF0(get_gravity)
 {
 	CHECK;
-	THIS->set_gravity(x.as_f(true), y.as_f(true));
-	return self;
+	return value(THIS->gravity());
 }
 RUCY_END
 
 static
-RUCY_DEF0(get_gravity)
+RUCY_DEF0(wall)
 {
 	CHECK;
-	return value(THIS->gravity());
+	return value(THIS->wall());
 }
 RUCY_END
 
@@ -463,10 +464,10 @@ RUCY_DEF1(set_debug, state)
 RUCY_END
 
 static
-RUCY_DEF0(is_debug)
+RUCY_DEF0(debugging)
 {
 	CHECK;
-	return value(THIS->is_debug());
+	return value(THIS->debugging());
 }
 RUCY_END
 
@@ -474,6 +475,10 @@ static
 RUCY_DEF1(on_attach, event)
 {
 	CHECK;
+
+	RUCY_SYM(call_attach_block);
+	self.call(call_attach_block);
+
 	CALL(on_attach(to<Reflex::Event*>(event)));
 }
 RUCY_END
@@ -534,6 +539,14 @@ RUCY_DEF1(on_resize, event)
 }
 RUCY_END
 
+static
+RUCY_DEF1(on_rotate, event)
+{
+	CHECK;
+	CALL(on_rotate(to<Reflex::FrameEvent*>(event)));
+}
+RUCY_END
+
 static
 RUCY_DEF1(on_scroll, event)
 {
@@ -630,6 +643,30 @@ RUCY_DEF1(on_capture, 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
 RUCY_DEF_clear_override_flags(cof, Reflex::View);
 
@@ -672,6 +709,7 @@ Init_view ()
 	cView.define_method("selector",  get_selector);
 	cView.define_private_method("set_frame", set_frame);
 	cView.define_private_method("get_frame", get_frame);
+	cView.define_method("angle",  get_angle);
 	cView.define_method("scroll_to", scroll_to);
 	cView.define_method("scroll_by", scroll_by);
 	cView.define_method("scroll", get_scroll);
@@ -680,21 +718,21 @@ Init_view ()
 	cView.define_method("parent", parent);
 	cView.define_method("window", window);
 	cView.define_method("body", body);
-	cView.define_method("density=",     set_density);
-	cView.define_method("friction=",    set_friction);
-	cView.define_method("restitution=", set_restitution);
-	cView.define_method("set_gravity",  set_gravity);
-	cView.define_method("gravity",      get_gravity);
+	cView.define_method("meter2pixel", meter2pixel);
+	cView.define_method("set_gravity", set_gravity);
+	cView.define_method("gravity",     get_gravity);
+	cView.define_method("wall", wall);
 	cView.define_method("debug=", set_debug);
-	cView.define_method("debug?",  is_debug);
-	cView.define_method("on_attach!", on_attach);
-	cView.define_method("on_detach",  on_detach);
+	cView.define_method("debug?",     debugging);
+	cView.define_method("on_attach", on_attach);
+	cView.define_method("on_detach", on_detach);
 	cView.define_method("on_show", on_show);
 	cView.define_method("on_hide", on_hide);
 	cView.define_method("on_update", on_update);
 	cView.define_method("on_draw",   on_draw);
 	cView.define_method("on_move",   on_move);
 	cView.define_method("on_resize", on_resize);
+	cView.define_method("on_rotate", on_rotate);
 	cView.define_method("on_scroll", on_scroll);
 	cView.define_method("on_focus", on_focus);
 	cView.define_method("on_blur",  on_blur);
@@ -707,6 +745,9 @@ Init_view ()
 	cView.define_method("on_pointer_move", on_pointer_move);
 	cView.define_method("on_wheel", on_wheel);
 	cView.define_method("on_capture", on_capture);
+	cView.define_method("on_contact",       on_contact);
+	cView.define_method("on_contact_begin", on_contact_begin);
+	cView.define_method("on_contact_end",   on_contact_end);
 	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);