reflexion 0.1.12 → 0.1.13

data/src/world.cpp

@@ -2,20 +2,25 @@
 
 
 #include <assert.h>
-#include <boost/scoped_array.hpp>
-#include <Box2D/Dynamics/b2Body.h>
+#include <memory>
 #include <Box2D/Common/b2Draw.h>
-#include <xot/util.h>
-#include "reflex/body.h"
-#include "reflex/view.h"
+#include <Box2D/Dynamics/b2World.h>
+#include <Box2D/Dynamics/Contacts/b2Contact.h>
 #include "reflex/event.h"
 #include "reflex/exception.h"
+#include "shape.h"
+#include "view.h"
+#include "body.h"
+#include "fixture.h"
 
 
 namespace Reflex
 {
 
 
+	static constexpr double DELTA_TIME = 1. / 60.;
+
+
 	class DebugDraw : public b2Draw
 	{
 
@@ -35,12 +40,12 @@ namespace Reflex
 			void begin (Painter* painter)
 			{
 				this->painter = painter;
-				painter->push_attr();
+				painter->push_state();
 			}
 
 			void end ()
 			{
-				painter->pop_attr();
+				painter->pop_state();
 				painter = NULL;
 			}
 
@@ -52,11 +57,11 @@ namespace Reflex
 				painter->no_fill();
 				painter->set_stroke(color.r, color.g, color.b, color.a * 0.5);
 
-				boost::scoped_array<Coord2> points(new Coord2[vertexCount]);
+				std::unique_ptr<Point[]> points(new Point[vertexCount]);
 				for (int i = 0; i < vertexCount; ++i)
-					points[i] = to_coord2(vertices[i], ppm);
+					points[i] = to_point(vertices[i], ppm);
 
-				painter->polygon(&points[0], vertexCount);
+				painter->line(&points[0], vertexCount, true);
 			}
 
 			void DrawSolidPolygon (
@@ -67,11 +72,11 @@ namespace Reflex
 				painter->set_fill(color.r, color.g, color.b, color.a * 0.5);
 				painter->no_stroke();
 
-				boost::scoped_array<Coord2> points(new Coord2[vertexCount]);
+				std::unique_ptr<Point[]> points(new Point[vertexCount]);
 				for (int i = 0; i < vertexCount; ++i)
-					points[i] = to_coord2(vertices[i], ppm);
+					points[i] = to_point(vertices[i], ppm);
 
-				painter->polygon(&points[0], vertexCount);
+				painter->line(&points[0], vertexCount, true);
 			}
 
 			void DrawCircle (
@@ -118,176 +123,172 @@ namespace Reflex
 	};// DebugDraw
 
 
-	World::World (View* owner, float pixels_per_meter)
-	:	world(b2Vec2(0, 0)), ppm(pixels_per_meter), last_step(0), wall_(NULL),
-		debug_draw(NULL)
+	struct World::Data
 	{
-		world.SetContactListener(this);
-		wall_ = create_body(owner);
-	}
 
-	World::~World ()
-	{
-		delete debug_draw;
-	}
+		b2World b2world;
 
-	void
-	World::step (float dt)
-	{
-		static const double DT = 1. / 60.;
+		float ppm, time_scale;
 
-		dt       += last_step;
-		last_step = fmod(dt, DT);
+		std::unique_ptr<DebugDraw> debug_draw;
 
-		int count = (int) (dt / DT);
-		for (int i = 0; i < count; ++i)
-			world.Step(DT, 8, 4);
-	}
+		Data ()
+		:	b2world(b2Vec2(0, 0)), ppm(0), time_scale(1)
+		{
+		}
 
-	Body*
-	World::create_body (View* owner, const Point& position, float degree)
-	{
-		if (!owner)
-			argument_error(__FILE__, __LINE__);
-
-		if (world.IsLocked())
-			invalid_state_error(__FILE__, __LINE__);
-
-		b2BodyDef def;
-		def.position = to_b2vec2(position, ppm);
-		def.angle    = Xot::deg2rad(degree);
-		b2Body* body = world.CreateBody(&def);
-		body->SetUserData(owner);
-		return new Body(body, ppm);
-	}
+	};// World::Data
 
-	void
-	World::destroy_body (Body* body)
+
+	World::World (float pixels_per_meter)
 	{
-		if (!body)
-			argument_error(__FILE__, __LINE__);
+		assert(pixels_per_meter > 0);
 
-		b2Body* b = (b2Body*) body->handle;
-		if (!b || world.IsLocked())
-			invalid_state_error(__FILE__, __LINE__);
+		self->ppm = pixels_per_meter;
 
-		world.DestroyBody(b);
+		self->b2world.SetContactListener(this);
 	}
 
-	void
-	World::resize (coord width, coord height)
+	World::~World ()
 	{
-		wall_->clear_fixtures();
-
-		const Point points[] = {
-			Point(0,     0),
-			Point(0,     height),
-			Point(width, height),
-			Point(width, 0),
-		};
-		wall_->add_edge(points, 4, true);
+		self->b2world.SetContactListener(NULL);
 	}
 
 	void
-	World::draw (Painter* painter)
+	World::update (float duration)
 	{
-		if (!debug_draw) return;
+		float dt = DELTA_TIME * self->time_scale;
+		if (dt <= 0) return;
+
+		int count = (int) (duration / DELTA_TIME);
+		if (count < 1) count = 1;
 
-		debug_draw->begin(painter);
-		world.DrawDebugData();
-		debug_draw->end();
+		for (int i = 0; i < count; ++i)
+			self->b2world.Step(dt, 8, 4);
 	}
 
 	float
 	World::meter2pixel (float meter) const
 	{
-		return meter * ppm;
+		return meter == 1 ? self->ppm : meter * self->ppm;
 	}
 
 	void
 	World::set_gravity (const Point& gravity)
 	{
-		world.SetGravity(to_b2vec2(gravity, ppm));
+		b2Vec2 b2gravity = to_b2vec2(gravity, self->ppm);
+		if (b2gravity == self->b2world.GetGravity())
+			return;
+
+		self->b2world.SetGravity(b2gravity);
 	}
 
 	Point
 	World::gravity () const
 	{
-		return to_point(world.GetGravity(), ppm);
+		return to_point(self->b2world.GetGravity(), self->ppm);
 	}
 
-	Body*
-	World::wall ()
+	void
+	World::set_time_scale (float scale)
 	{
-		return wall_;
+		self->time_scale = scale;
 	}
 
-	const Body*
-	World::wall () const
+	float
+	World::time_scale () const
 	{
-		return const_cast<World*>(this)->wall();
+		return self->time_scale;
 	}
 
 	void
 	World::set_debug (bool state)
 	{
-		if (state == debugging()) return;
+		if (state == debug()) return;
 
-		if (!debug_draw)
-			debug_draw = new DebugDraw(ppm);
-		else
+		if (state)
 		{
-			delete debug_draw;
-			debug_draw = NULL;
+			assert(!self->debug_draw);
+			self->debug_draw.reset(new DebugDraw(self->ppm));
 		}
+		else
+			self->debug_draw.reset();
 
-		world.SetDebugDraw(debug_draw);
+		self->b2world.SetDebugDraw(self->debug_draw.get());
 	}
 
 	bool
-	World::debugging () const
+	World::debug () const
 	{
-		return debug_draw;
+		return !!self->debug_draw;
 	}
 
-	bool is_view_active (View* view);
+	void
+	World::on_update (float dt)
+	{
+		update(DELTA_TIME);
+	}
+
+	void
+	World::on_draw (Painter* painter)
+	{
+		if (!self->debug_draw) return;
+
+		self->debug_draw->begin(painter);
+		self->b2world.DrawDebugData();
+		self->debug_draw->end();
+	}
 
 	void
 	World::BeginContact (b2Contact* contact)
 	{
-		View* v1 = (View*) contact->GetFixtureA()->GetBody()->GetUserData();
-		if (!v1) return;
+		Shape* s1 = (Shape*) contact->GetFixtureA()->GetUserData();
+		if (!s1) return;
 
-		View* v2 = (View*) contact->GetFixtureB()->GetBody()->GetUserData();
-		if (!v2) return;
+		Shape* s2 = (Shape*) contact->GetFixtureB()->GetUserData();
+		if (!s2) return;
 
-		if (!is_view_active(v1) || !is_view_active(v2))
+		if (!View_is_active(*s1->owner()) || !View_is_active(*s2->owner()))
 			return;
 
-		ContactEvent e1(ContactEvent::BEGIN, v2);
-		v1->on_contact(&e1);
-
-		ContactEvent e2(ContactEvent::BEGIN, v1);
-		v2->on_contact(&e2);
+		Shape_call_contact_event(s1, ContactEvent(ContactEvent::BEGIN, s2));
+		Shape_call_contact_event(s2, ContactEvent(ContactEvent::BEGIN, s1));
 	}
 
 	void
 	World::EndContact (b2Contact* contact)
 	{
-		View* v1 = (View*) contact->GetFixtureA()->GetBody()->GetUserData();
-		if (!v1) return;
+		Shape* s1 = (Shape*) contact->GetFixtureA()->GetUserData();
+		if (!s1) return;
 
-		View* v2 = (View*) contact->GetFixtureB()->GetBody()->GetUserData();
-		if (!v2) return;
+		Shape* s2 = (Shape*) contact->GetFixtureB()->GetUserData();
+		if (!s2) return;
 
-		if (!is_view_active(v1) || !is_view_active(v2))
+		if (!View_is_active(*s1->owner()) || !View_is_active(*s2->owner()))
 			return;
 
-		ContactEvent e1(ContactEvent::END, v2);
-		v1->on_contact(&e1);
+		Shape_call_contact_event(s1, ContactEvent(ContactEvent::END, s2));
+		Shape_call_contact_event(s2, ContactEvent(ContactEvent::END, s1));
+	}
+
 
-		ContactEvent e2(ContactEvent::END, v1);
-		v2->on_contact(&e2);
+	World*
+	World_get_temporary ()
+	{
+		static World world;
+		return &world;
+	}
+
+	b2World*
+	World_get_b2ptr (World* world)
+	{
+		return world ? &world->self->b2world : NULL;
+	}
+
+	const b2World*
+	World_get_b2ptr (const World* world)
+	{
+		return World_get_b2ptr(const_cast<World*>(world));
 	}
 
 

data/src/world.h

@@ -4,13 +4,16 @@
 #define __REFLEX_SRC_WORLD_H__
 
 
-#include <boost/noncopyable.hpp>
-#include <Box2D/Dynamics/b2World.h>
+#include <Box2D/Common/b2Math.h>
 #include <Box2D/Dynamics/b2WorldCallbacks.h>
-#include <Box2D/Dynamics/Contacts/b2Contact.h>
+#include <xot/noncopyable.h>
+#include <xot/pimpl.h>
+#include <rays/point.h>
+#include <rays/painter.h>
 #include <reflex/defs.h>
-#include <reflex/point.h>
-#include <reflex/painter.h>
+
+
+class b2World;
 
 
 namespace Reflex
@@ -18,30 +21,24 @@ namespace Reflex
 
 
 	class View;
-
 	class Body;
 
-	class DebugDraw;
-
 
-	class World : public boost::noncopyable, private b2ContactListener
+	class World : public Xot::NonCopyable, private b2ContactListener
 	{
 
 		public:
 
-			World (View* owner, float pixels_per_meter = 100);
-
-			~World ();
-
-			void step (float dt);
-
-			Body* create_body (View* owner, const Point& position = 0, float degree = 0);
+			enum
+			{
+				DEFAULT_PIXELS_PER_METER = 100
+			};
 
-			void destroy_body (Body* body);
+			World (float pixels_per_meter = DEFAULT_PIXELS_PER_METER);
 
-			void resize (coord width, coord height);
+			virtual ~World ();
 
-			void draw (Painter* painter);
+			void update (float duration = 0);
 
 			float meter2pixel (float meter = 1) const;
 
@@ -49,29 +46,27 @@ namespace Reflex
 
 			Point    gravity () const;
 
-			void set_debug (bool state = true);
-
-			bool     debugging () const;
+			void set_time_scale (float scale);
 
-			      Body* wall ();
+			float    time_scale () const;
 
-			const Body* wall () const;
+			void set_debug (bool state = true);
 
-		protected:
+			bool     debug () const;
 
-			void BeginContact (b2Contact* contact);
+			virtual void on_update (float dt);
 
-			void EndContact   (b2Contact* contact);
+			virtual void on_draw (Painter* painter);
 
-		private:
+			struct Data;
 
-			b2World world;
+			Xot::PImpl<Data> self;
 
-			float ppm, last_step;
+		protected:
 
-			Body* wall_;
+			virtual void BeginContact (b2Contact* contact);
 
-			DebugDraw* debug_draw;
+			virtual void   EndContact (b2Contact* contact);
 
 	};// World
 
@@ -101,33 +96,12 @@ namespace Reflex
 			to_b2coord(v.y, scale));
 	}
 
-
 	inline coord
 	to_coord (float32 t, float scale)
 	{
 		return t * scale;
 	}
 
-	inline Coord2
-	to_coord2 (const b2Vec2& v, float scale)
-	{
-		Coord2 c;
-		c.reset(
-			to_coord(v.x, scale),
-			to_coord(v.y, scale));
-		return c;
-	}
-
-	inline Coord3
-	to_coord3 (const b2Vec2& v, float scale)
-	{
-		Coord3 c;
-		c.reset(
-			to_coord(v.x, scale),
-			to_coord(v.y, scale));
-		return c;
-	}
-
 	inline Point
 	to_point (const b2Vec2& v, float scale)
 	{
@@ -137,6 +111,13 @@ namespace Reflex
 	}
 
 
+	World* World_get_temporary ();
+
+	      b2World* World_get_b2ptr (      World* world);
+
+	const b2World* World_get_b2ptr (const World* world);
+
+
 }// Reflex
 
 

data/task/box2d.rake

@@ -1,25 +1,46 @@
 # -*- mode: ruby; coding: utf-8 -*-
 
 
+task :box2d => 'box2d:update'
+
+
 namespace :box2d do
 
 
-  mod          = MODULE
-  box2d_srcdir = env :BOX2D, '~/lib/box2d/Box2D/Box2D'
-  srcdir       = mod.root_dir 'src/physics'
+  mod     = MODULE
+  tmp_dir = mod.root_dir 'tmp'
+
+  lib_git  = 'https://github.com/erincatto/Box2D'
+  lib_name = File.basename lib_git
+  lib_root = "#{tmp_dir}/#{lib_name}"
+  lib_path = "Box2D/Box2D"
+
+  copy_from    = "#{lib_root}/#{lib_path}"
+  copy_to_base = mod.root_dir 'src/physics'
+  copy_to      = "#{copy_to_base}/#{File.basename lib_path}"
+  copy_exts    = %w[h cpp]
 
 
-  task :update => srcdir do
-    sh %( rm -rf #{srcdir}/* )
-    sh %( cp -r #{box2d_srcdir} #{srcdir} )
+  task :update => [:clone, copy_to_base] do
+    sh %( rm -rf #{copy_to} )
+    sh %( cp -r #{copy_from} #{copy_to_base} )
+
+    Dir.glob "#{copy_to}/**/*" do |path|
+      ext = path[/\.[^.]+$/]
+      sh %( rm -f #{path} ) if ext && ext !~ /\.(#{copy_exts.join '|'})/i
+    end
+  end
 
-    Dir.glob "#{srcdir}/**/*" do |path|
-      ext = path[/\.(.+?)$/]
-      sh %( rm -f #{path} ) if ext && ext !~ /\.(h|cpp)/i
+  task :clone => tmp_dir do
+    Dir.chdir tmp_dir do
+      sh %( git clone #{lib_git} ) unless File.exist? lib_root
+      Dir.chdir lib_root do
+        sh %( git pull --rebase )
+      end
     end
   end
 
-  directory srcdir
+  directory tmp_dir, copy_to_base
 
 
 end# :box2d

data/test/test_capture_event.rb

@@ -6,18 +6,20 @@ require_relative 'helper'
 
 class TestCaptureEvent < Test::Unit::TestCase
 
-  def cap (*args)
-    Reflex::CaptureEvent.new *args.map {|arg| Reflex::CAPTURE_FLAG.symbols2bits *arg}
+  def event (*args)
+    Reflex::CaptureEvent.new *args.map {|arg|
+      Reflex::View.capture_flag.symbols2bits *arg
+    }
   end
 
   def test_begin ()
-    c = cap [:key, :pointer], []
+    c = event [:key, :pointer], []
     assert_equal [:key, :pointer], c.begin
     assert_equal true, c.begin?(:key)
     assert_equal true, c.begin?(:pointer)
     assert_equal true, c.begin?(:all)
 
-    c = cap [:key], []
+    c = event [:key], []
     assert_equal [:key], c.begin
     assert_equal true,  c.begin?(:key)
     assert_equal false, c.begin?(:pointer)
@@ -25,13 +27,13 @@ class TestCaptureEvent < Test::Unit::TestCase
   end
 
   def test_end ()
-    c = cap [], [:key, :pointer]
+    c = event [], [:key, :pointer]
     assert_equal [:key, :pointer], c.end
     assert_equal true, c.end?(:key)
     assert_equal true, c.end?(:pointer)
     assert_equal true, c.end?(:all)
 
-    c = cap [], [:key]
+    c = event [], [:key]
     assert_equal [:key], c.end
     assert_equal true,  c.end?(:key)
     assert_equal false, c.end?(:pointer)

data/test/test_pointer_event.rb

@@ -0,0 +1,85 @@
+# -*- coding: utf-8 -*-
+
+
+require_relative 'helper'
+
+
+class TestPointerEvent < Test::Unit::TestCase
+
+  T = true
+  F = false
+
+  def event (*args)
+    Reflex::PointerEvent.new *args
+  end
+
+  def type (arg)
+    event(arg).tap do |o|
+      def o.test ()
+        [type, down?, up?, move?]
+      end
+    end
+  end
+
+  def test_type ()
+    o = type Reflex::PointerEvent::TYPE_NONE
+    assert_equal [:none, F, F, F], o.test
+
+    o = type Reflex::PointerEvent::TYPE_DOWN
+    assert_equal [:down, T, F, F], o.test
+
+    o = type Reflex::PointerEvent::TYPE_UP
+    assert_equal [:up,   F, T, F], o.test
+
+    o = type Reflex::PointerEvent::TYPE_MOVE
+    assert_equal [:move, F, F, T], o.test
+  end
+
+  def pointer_type (arg)
+    event(Reflex::PointerEvent::TYPE_NONE, arg).tap do |o|
+      def o.test ()
+        [pointer_type, left?, right?, middle?, touch?, pen?]
+      end
+    end
+  end
+
+  def test_pointer_type ()
+    o = pointer_type Reflex::PointerEvent::POINTER_NONE
+    assert_equal [[],              F, F, F, F, F], o.test
+
+    o = pointer_type Reflex::PointerEvent::POINTER_MOUSE_LEFT
+    assert_equal [[:mouse_left],   T, F, F, F, F], o.test
+
+    o = pointer_type Reflex::PointerEvent::POINTER_MOUSE_RIGHT
+    assert_equal [[:mouse_right],  F, T, F, F, F], o.test
+
+    o = pointer_type Reflex::PointerEvent::POINTER_MOUSE_MIDDLE
+    assert_equal [[:mouse_middle], F, F, T, F, F], o.test
+
+    o = pointer_type Reflex::PointerEvent::POINTER_TOUCH
+    assert_equal [[:touch],        F, F, F, T, F], o.test
+
+    o = pointer_type Reflex::PointerEvent::POINTER_PEN
+    assert_equal [[:pen],          F, F, F, F, T], o.test
+
+    o = pointer_type Reflex::PointerEvent::POINTER_MOUSE_LEFT |
+      Reflex::PointerEvent::POINTER_MOUSE_RIGHT
+    types = [:mouse_left, :mouse_right]
+    assert_equal [types, T, T, F, F, F], o.test
+
+    o = pointer_type Reflex::PointerEvent::POINTER_MOUSE_LEFT |
+      Reflex::PointerEvent::POINTER_MOUSE_RIGHT |
+      Reflex::PointerEvent::POINTER_MOUSE_MIDDLE
+    types = [:mouse_left, :mouse_right, :mouse_middle]
+    assert_equal [types, T, T, T, F, F], o.test
+
+    o = pointer_type Reflex::PointerEvent::POINTER_MOUSE_LEFT |
+      Reflex::PointerEvent::POINTER_MOUSE_RIGHT |
+      Reflex::PointerEvent::POINTER_MOUSE_MIDDLE |
+      Reflex::PointerEvent::POINTER_TOUCH |
+      Reflex::PointerEvent::POINTER_PEN
+    types = [:mouse_left, :mouse_right, :mouse_middle, :touch, :pen]
+    assert_equal [types, T, T, T, T, T], o.test
+  end
+
+end# TestPointerEvent

data/test/test_selector.rb

@@ -21,7 +21,7 @@ class TestSelector < Test::Unit::TestCase
 
   def test_name ()
     s = sel
-    assert_equal '', s.name
+    assert_equal nil, s.name
     s.name = 'Test'
     assert_equal 'Test', s.name
   end