reflexion 0.4.2 → 0.5.1

data/src/world.cpp

@@ -3,9 +3,10 @@
 
 #include <assert.h>
 #include <memory>
-#include <box2d/b2_draw.h>
-#include <box2d/b2_world.h>
-#include <box2d/b2_contact.h>
+#include <vector>
+#include <map>
+#include <utility>
+#include <box2d/box2d.h>
 #include "reflex/event.h"
 #include "reflex/exception.h"
 #include "shape.h"
@@ -21,20 +22,28 @@ namespace Reflex
 	static constexpr double DELTA_TIME = 1. / 60.;
 
 
-	class DebugDraw : public b2Draw
+	class DebugDraw
 	{
 
 		public:
 
 			DebugDraw (float ppm)
-			:	ppm(ppm), painter(NULL)
+			:	ppm(ppm)
 			{
-				SetFlags(
-					e_shapeBit |
-					e_jointBit |
-					//e_aabbBit  |
-					e_pairBit  |
-					e_centerOfMassBit);
+				b2draw                     = b2DefaultDebugDraw();
+				b2draw.DrawPolygonFcn      = DrawPolygon;
+				b2draw.DrawSolidPolygonFcn = DrawSolidPolygon;
+				b2draw.DrawCircleFcn       = DrawCircle;
+				b2draw.DrawSolidCircleFcn  = DrawSolidCircle;
+				b2draw.DrawSolidCapsuleFcn = DrawSolidCapsule;
+				b2draw.DrawSegmentFcn      = DrawSegment;
+				b2draw.DrawTransformFcn    = DrawTransform;
+				b2draw.DrawPointFcn        = DrawPoint;
+				b2draw.DrawStringFcn       = DrawString;
+				b2draw.drawShapes          = true;
+				b2draw.drawJoints          = true;
+				b2draw.drawMass            = true;
+				b2draw.context             = this;
 			}
 
 			void begin (Painter* painter)
@@ -49,101 +58,284 @@ namespace Reflex
 				painter = NULL;
 			}
 
-			void DrawPolygon (
-				const b2Vec2* vertices, int32 vertexCount, const b2Color& color)
+			b2DebugDraw* b2ptr ()
 			{
-				assert(painter);
+				return &b2draw;
+			}
+
+		private:
 
-				painter->no_fill();
-				painter->set_stroke(color.r, color.g, color.b, color.a * 0.5);
+			b2DebugDraw b2draw;
+
+			float ppm;
+
+			Painter* painter = NULL;
+
+			static void set_fill (DebugDraw* draw, b2HexColor color)
+			{
+				draw->painter->set_fill(
+					((color >> 16) & 0xff) / 255.f,
+					((color >>  8) & 0xff) / 255.f,
+					( color        & 0xff) / 255.f,
+					0.5f);
+				draw->painter->no_stroke();
+			}
 
+			static void set_stroke (DebugDraw* draw, b2HexColor color)
+			{
+				draw->painter->no_fill();
+				draw->painter->set_stroke(
+					((color >> 16) & 0xff) / 255.f,
+					((color >>  8) & 0xff) / 255.f,
+					( color        & 0xff) / 255.f,
+					0.5f);
+			}
+
+			static void draw_polygon (
+				DebugDraw* draw, const b2Vec2* vertices, int vertexCount)
+			{
 				std::unique_ptr<Point[]> points(new Point[vertexCount]);
 				for (int i = 0; i < vertexCount; ++i)
-					points[i] = to_point(vertices[i], ppm);
+					points[i] = to_point(vertices[i], draw->ppm);
 
-				painter->line(&points[0], vertexCount, true);
+				draw->painter->line(&points[0], vertexCount, true);
 			}
 
-			void DrawSolidPolygon (
-				const b2Vec2* vertices, int32 vertexCount, const b2Color& color)
+			static void DrawPolygon (
+				const b2Vec2* vertices, int vertexCount, b2HexColor color,
+				void* context)
 			{
-				assert(painter);
+				DebugDraw* draw = (DebugDraw*) context;
+				assert(draw && draw->painter);
 
-				painter->set_fill(color.r, color.g, color.b, color.a * 0.5);
-				painter->no_stroke();
+				set_stroke(draw, color);
+				draw_polygon(draw, vertices, vertexCount);
+			}
 
-				std::unique_ptr<Point[]> points(new Point[vertexCount]);
+			static void DrawSolidPolygon (
+				b2Transform transform, const b2Vec2* vertices, int vertexCount,
+				float radius, b2HexColor color, void* context)
+			{
+				DebugDraw* draw = (DebugDraw*) context;
+				assert(draw && draw->painter);
+
+				std::vector<b2Vec2> points;
+				points.reserve(vertexCount);
 				for (int i = 0; i < vertexCount; ++i)
-					points[i] = to_point(vertices[i], ppm);
+					points.emplace_back(b2TransformPoint(transform, vertices[i]));
 
-				painter->line(&points[0], vertexCount, true);
+				set_fill(draw, color);
+				draw_polygon(draw, &points[0], vertexCount);
 			}
 
-			void DrawCircle (
-				const b2Vec2& center, float radius, const b2Color& color)
+			static void DrawCircle (
+				b2Vec2 center, float radius, b2HexColor color, void* context)
 			{
-				assert(painter);
+				DebugDraw* draw = (DebugDraw*) context;
+				assert(draw && draw->painter);
 
-				painter->no_fill();
-				painter->set_stroke(color.r, color.g, color.b, color.a * 0.5);
-				painter->ellipse(to_point(center, ppm), to_coord(radius, ppm));
+				set_stroke(draw, color);
+				draw->painter->ellipse(
+					to_point(center, draw->ppm), to_coord(radius, draw->ppm));
 			}
 
-			void DrawSolidCircle (
-				const b2Vec2& center, float radius, const b2Vec2& axis, const b2Color& color)
+			static void DrawSolidCircle (
+				b2Transform transform, float radius, b2HexColor color, void* context)
 			{
-				assert(painter);
+				DebugDraw* draw = (DebugDraw*) context;
+				assert(draw && draw->painter);
 
-				painter->set_fill(color.r, color.g, color.b, color.a * 0.5);
-				painter->no_stroke();
-				painter->ellipse(to_point(center, ppm), to_coord(radius, ppm));
+				set_fill(draw, color);
+				draw->painter->ellipse(
+					to_point(transform.p, draw->ppm), to_coord(radius, draw->ppm));
 			}
 
-			void DrawSegment (
-				const b2Vec2& p1, const b2Vec2& p2, const b2Color& color)
+			static void DrawSolidCapsule (
+				b2Vec2 p1, b2Vec2 p2, float radius, b2HexColor color, void* context)
 			{
-				assert(painter);
+				DebugDraw* draw = (DebugDraw*) context;
+				assert(draw && draw->painter);
+
+				set_fill(draw, color);
+				draw->painter->ellipse(
+					to_point(p1, draw->ppm), to_coord(radius, draw->ppm));
+				draw->painter->ellipse(
+					to_point(p2, draw->ppm), to_coord(radius, draw->ppm));
+				draw->painter->line(
+					to_point(p1, draw->ppm), to_point(p2, draw->ppm));
+			}
+
+			static void DrawSegment (
+				b2Vec2 p1, b2Vec2 p2, b2HexColor color, void* context)
+			{
+				DebugDraw* draw = (DebugDraw*) context;
+				assert(draw && draw->painter);
 
-				painter->no_fill();
-				painter->set_stroke(color.r, color.g, color.b, color.a * 0.5);
-				painter->line(to_point(p1, ppm), to_point(p2, ppm));
+				set_stroke(draw, color);
+				draw->painter->line(
+					to_point(p1, draw->ppm), to_point(p2, draw->ppm));
 			}
 
-			void DrawPoint (const b2Vec2& center, float size, const b2Color& color)
+			static void DrawPoint (
+				b2Vec2 p, float size, b2HexColor color, void* context)
 			{
-				assert(painter);
+				DebugDraw* draw = (DebugDraw*) context;
+				assert(draw && draw->painter);
 
-				painter->set_fill(color.r, color.g, color.b, color.a * 0.5);
-				painter->no_stroke();
-				painter->ellipse(to_point(center, ppm), to_coord(size / 2, ppm));
+				set_fill(draw, color);
+				draw->painter->ellipse(
+					to_point(p, draw->ppm), to_coord(size / 2, draw->ppm));
 			}
 
-			void DrawTransform (const b2Transform& transform)
+			static void DrawTransform (b2Transform transform, void* context)
 			{
-				assert(painter);
 			}
 
-		private:
+			static void DrawString (
+				b2Vec2 p, const char* s, b2HexColor color, void* context)
+			{
+			}
 
-			float ppm;
+	};// DebugDraw
 
-			Painter* painter;
 
-	};// DebugDraw
+	typedef std::pair<uint64_t, uint64_t>     ShapePairKey;
+
+	typedef std::pair<Shape*, Shape*>         ShapePair;
+
+	typedef std::map<ShapePairKey, ShapePair> ShapePairMap;
+
+	static ShapePairKey
+	make_pair_key (b2ShapeId b2shape1, b2ShapeId b2shape2)
+	{
+		uint64_t key1 = b2StoreShapeId(b2shape1);
+		uint64_t key2 = b2StoreShapeId(b2shape2);
+		return key1 < key2
+			?	std::make_pair(key1, key2)
+			:	std::make_pair(key2, key1);
+	}
+
+	static Shape*
+	get_shape (b2ShapeId b2shape)
+	{
+		if (B2_IS_NULL(b2shape)) return NULL;
+		return (Shape*) b2Shape_GetUserData(b2shape);
+	}
+
+	static bool
+	should_collide (Shape* s1, Shape* s2)
+	{
+		if (!s1 || !s2)
+			return false;
+
+		View* v1 = s1->owner();
+		View* v2 = s2->owner();
+		if (!v1 || !v2 || !View_is_active(*v1) || !View_is_active(*v2))
+			return false;
+
+		return
+			s1->will_contact(s2) &&
+			s2->will_contact(s1) &&
+			v1->will_contact(v2) &&
+			v2->will_contact(v1);
+	}
+
+	static bool
+	custom_filter_callback (b2ShapeId b2shape1, b2ShapeId b2shape2, void* context)
+	{
+		return should_collide(get_shape(b2shape1), get_shape(b2shape2));
+	}
+
+	static void
+	call_contact_events (Shape* s1, Shape* s2, ContactEvent::Action action)
+	{
+		if (!s1 || !s2)
+			return;
+
+		View* v1 = s1->owner();
+		View* v2 = s2->owner();
+		if (!v1 || !v2 || !View_is_active(*v1) || !View_is_active(*v2))
+			return;
+
+		ContactEvent e1(action, s2), e2(action, s1);
+		Shape_call_contact_event(s1, &e1);
+		Shape_call_contact_event(s2, &e2);
+	}
 
 
 	struct World::Data
 	{
 
-		b2World b2world;
+		b2WorldId b2world = b2_nullWorldId;
+
+		float ppm         = 0;
+
+		float time_scale  = 1;
 
-		float ppm, time_scale;
+		bool stepping     = false;
 
 		std::unique_ptr<DebugDraw> debug_draw;
 
-		Data ()
-		:	b2world(b2Vec2(0, 0)), ppm(0), time_scale(1)
+		// tracked to deliver contact-end events for shapes that Box2D has already
+		// forgotten on destruction
+		ShapePairMap touching_pairs;
+
+		void begin_contact (b2ShapeId b2shape1, b2ShapeId b2shape2, bool is_sensor_event)
 		{
+			Shape* s1 = get_shape(b2shape1);
+			Shape* s2 = get_shape(b2shape2);
+			if (!s1 || !s2)
+				return;
+
+			// Box2D 3.x does not call the custom filter for sensor overlaps,
+			// so respect will_contact() here
+			if (is_sensor_event && !should_collide(s1, s2))
+				return;
+
+			ShapePairKey key = make_pair_key(b2shape1, b2shape2);
+			if (!touching_pairs.emplace(key, ShapePair(s1, s2)).second)
+				return;// already touching
+
+			call_contact_events(s1, s2, ContactEvent::BEGIN);
+		}
+
+		void end_contact (b2ShapeId id1, b2ShapeId id2)
+		{
+			auto it = touching_pairs.find(make_pair_key(id1, id2));
+			if (it == touching_pairs.end())
+				return;
+
+			ShapePair pair = it->second;
+			touching_pairs.erase(it);
+
+			call_contact_events(pair.first, pair.second, ContactEvent::END);
+		}
+
+		void handle_contact_events ()
+		{
+			b2ContactEvents contacts = b2World_GetContactEvents(b2world);
+			for (int i = 0; i < contacts.beginCount; ++i)
+			{
+				const auto& e = contacts.beginEvents[i];
+				begin_contact(e.shapeIdA, e.shapeIdB, false);
+			}
+			for (int i = 0; i < contacts.endCount; ++i)
+			{
+				const auto& e = contacts.endEvents[i];
+				end_contact(e.shapeIdA, e.shapeIdB);
+			}
+
+			b2SensorEvents sensors = b2World_GetSensorEvents(b2world);
+			for (int i = 0; i < sensors.beginCount; ++i)
+			{
+				const auto& e = sensors.beginEvents[i];
+				begin_contact(e.sensorShapeId, e.visitorShapeId, true);
+			}
+			for (int i = 0; i < sensors.endCount; ++i)
+			{
+				const auto& e = sensors.endEvents[i];
+				end_contact(e.sensorShapeId, e.visitorShapeId);
+			}
 		}
 
 	};// World::Data
@@ -155,14 +347,23 @@ namespace Reflex
 
 		self->ppm = pixels_per_meter;
 
-		self->b2world.SetContactListener(this);
-		self->b2world.SetContactFilter(this);
+		b2WorldDef def = b2DefaultWorldDef();
+		def.gravity    = b2Vec2{0, 0};
+		def.userData   = this;
+
+		self->b2world = b2CreateWorld(&def);
+		if (!b2World_IsValid(self->b2world))
+			physics_error(__FILE__, __LINE__);
+
+		b2World_SetCustomFilterCallback(self->b2world, custom_filter_callback, this);
 	}
 
 	World::~World ()
 	{
-		self->b2world.SetContactListener(NULL);
-		self->b2world.SetContactFilter(NULL);
+		self->touching_pairs.clear();
+
+		b2DestroyWorld(self->b2world);
+		self->b2world = b2_nullWorldId;
 	}
 
 	void
@@ -175,7 +376,13 @@ namespace Reflex
 		if (count < 1) count = 1;
 
 		for (int i = 0; i < count; ++i)
-			self->b2world.Step(dt, 8, 4);
+		{
+			self->stepping = true;
+			b2World_Step(self->b2world, dt, 4);
+			self->stepping = false;
+
+			self->handle_contact_events();
+		}
 	}
 
 	float
@@ -187,17 +394,18 @@ namespace Reflex
 	void
 	World::set_gravity (const Point& gravity)
 	{
-		b2Vec2 b2gravity = to_b2vec2(gravity, self->ppm);
-		if (b2gravity == self->b2world.GetGravity())
+		b2Vec2 b2vec   = to_b2vec2(gravity, self->ppm);
+		b2Vec2 current = b2World_GetGravity(self->b2world);
+		if (b2vec.x == current.x && b2vec.y == current.y)
 			return;
 
-		self->b2world.SetGravity(b2gravity);
+		b2World_SetGravity(self->b2world, b2vec);
 	}
 
 	Point
 	World::gravity () const
 	{
-		return to_point(self->b2world.GetGravity(), self->ppm);
+		return to_point(b2World_GetGravity(self->b2world), self->ppm);
 	}
 
 	void
@@ -218,14 +426,9 @@ namespace Reflex
 		if (state == debug()) return;
 
 		if (state)
-		{
-			assert(!self->debug_draw);
 			self->debug_draw.reset(new DebugDraw(self->ppm));
-		}
 		else
 			self->debug_draw.reset();
-
-		self->b2world.SetDebugDraw(self->debug_draw.get());
 	}
 
 	bool
@@ -246,65 +449,47 @@ namespace Reflex
 		if (!self->debug_draw) return;
 
 		self->debug_draw->begin(painter);
-		self->b2world.DebugDraw();
+		b2World_Draw(self->b2world, self->debug_draw->b2ptr());
 		self->debug_draw->end();
 	}
 
-	bool
-	World::ShouldCollide (b2Fixture* f1, b2Fixture* f2)
-	{
-		Shape* s1 = (Shape*) f1->GetUserData().pointer;
-		Shape* s2 = (Shape*) f2->GetUserData().pointer;
-		if (!s1 || !s2)
-			return false;
 
-		View* v1 = s1->owner();
-		View* v2 = s2->owner();
-		if (!v1 || !v2 || !View_is_active(*v1) || !View_is_active(*v2))
-			return false;
-
-		return
-			s1->will_contact(s2) &&
-			s2->will_contact(s1) &&
-			v1->will_contact(v2) &&
-			v2->will_contact(v1);
+	b2WorldId
+	World_get_id (const World* world)
+	{
+		return world ? world->self->b2world : b2_nullWorldId;
 	}
 
-	void
-	World::BeginContact (b2Contact* contact)
+	bool
+	World_is_stepping (const World* world)
 	{
-		Shape* s1 = (Shape*) contact->GetFixtureA()->GetUserData().pointer;
-		if (!s1) return;
-
-		Shape* s2 = (Shape*) contact->GetFixtureB()->GetUserData().pointer;
-		if (!s2) return;
-
-		if (!View_is_active(*s1->owner()) || !View_is_active(*s2->owner()))
-			return;
-
-		ContactEvent e1(ContactEvent::BEGIN, s2), e2(ContactEvent::BEGIN, s1);
-		Shape_call_contact_event(s1, &e1);
-		Shape_call_contact_event(s2, &e2);
+		return world ? world->self->stepping : false;
 	}
 
 	void
-	World::EndContact (b2Contact* contact)
+	World_end_contacts_for (World* world, b2ShapeId b2shape)
 	{
-		Shape* s1 = (Shape*) contact->GetFixtureA()->GetUserData().pointer;
-		if (!s1) return;
+		if (!world) return;
 
-		Shape* s2 = (Shape*) contact->GetFixtureB()->GetUserData().pointer;
-		if (!s2) return;
+		uint64_t key = b2StoreShapeId(b2shape);
 
-		if (!View_is_active(*s1->owner()) || !View_is_active(*s2->owner()))
-			return;
+		std::vector<ShapePair> ended;
+		auto& pairs = world->self->touching_pairs;
+		for (auto it = pairs.begin(); it != pairs.end();)
+		{
+			if (it->first.first == key || it->first.second == key)
+			{
+				ended.emplace_back(it->second);
+				it = pairs.erase(it);
+			}
+			else
+				++it;
+		}
 
-		ContactEvent e1(ContactEvent::END, s2), e2(ContactEvent::END, s1);
-		Shape_call_contact_event(s1, &e1);
-		Shape_call_contact_event(s2, &e2);
+		for (auto& pair : ended)
+			call_contact_events(pair.first, pair.second, ContactEvent::END);
 	}
 
-
 	World*
 	World_get_temporary ()
 	{
@@ -312,17 +497,5 @@ namespace Reflex
 		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));
-	}
-
 
 }// Reflex

data/src/world.h

@@ -4,8 +4,8 @@
 #define __REFLEX_SRC_WORLD_H__
 
 
-#include <box2d/b2_math.h>
-#include <box2d/b2_world_callbacks.h>
+#include <box2d/id.h>
+#include <box2d/math_functions.h>
 #include <xot/noncopyable.h>
 #include <xot/pimpl.h>
 #include <rays/point.h>
@@ -13,9 +13,6 @@
 #include "reflex/defs.h"
 
 
-class b2World;
-
-
 namespace Reflex
 {
 
@@ -24,7 +21,7 @@ namespace Reflex
 	class Body;
 
 
-	class World : public Xot::NonCopyable, private b2ContactFilter, b2ContactListener
+	class World : public Xot::NonCopyable
 	{
 
 		public:
@@ -62,14 +59,6 @@ namespace Reflex
 
 			Xot::PImpl<Data> self;
 
-		protected:
-
-			virtual bool ShouldCollide (b2Fixture* f1, b2Fixture* f2) override;
-
-			virtual void BeginContact (b2Contact* contact) override;
-
-			virtual void   EndContact (b2Contact* contact) override;
-
 	};// World
 
 
@@ -84,18 +73,18 @@ namespace Reflex
 	inline b2Vec2
 	to_b2vec2 (T x, T y, float scale)
 	{
-		return b2Vec2(
+		return b2Vec2{
 			to_b2coord(x, scale),
-			to_b2coord(y, scale));
+			to_b2coord(y, scale)};
 	}
 
 	template <typename VEC>
 	inline b2Vec2
 	to_b2vec2 (const VEC& v, float scale)
 	{
-		return b2Vec2(
+		return b2Vec2{
 			to_b2coord(v.x, scale),
-			to_b2coord(v.y, scale));
+			to_b2coord(v.y, scale)};
 	}
 
 	inline coord
@@ -113,11 +102,13 @@ namespace Reflex
 	}
 
 
-	World* World_get_temporary ();
+	b2WorldId World_get_id (const World* world);
 
-	      b2World* World_get_b2ptr (      World* world);
+	bool World_is_stepping (const World* world);
 
-	const b2World* World_get_b2ptr (const World* world);
+	void World_end_contacts_for (World* world, b2ShapeId b2shape);
+
+	World* World_get_temporary ();
 
 
 }// Reflex