reflexion 0.1.12 → 0.1.13

data/samples/views.rb

@@ -14,9 +14,9 @@ win = Window.new do
   images = [:red, :blue].map do |col|
     Image.new(32, 32).tap do |img|
       img.paint do
-        color :white
+        fill :white
         rect img.bounds
-        color col
+        fill col
         ellipse img.bounds.inset_by(2, 2)
       end
     end
@@ -33,7 +33,7 @@ win = Window.new do
     image1.image = images[count % 2]
   end
 
-  set title: 'Many View Sample', frame: [100, 100, 500, 400]
+  set title: 'Many View Sample', frame: [100, 100, 500, 400], flow: :right
 end
 
 

data/samples/visuals.rb

@@ -10,12 +10,9 @@ require 'reflex'
 
 Reflex::Application.start name: 'Visuals' do |app|
   Reflex::Window.new title: app.name, frame: [100, 100, 600, 500] do |win|
-    win.painter.background = 0.8
+    win.style.background 0.1
     10.times do |i|
-      Reflex::TextView.new name: 'hello', data: 'HELLO WORLD!' do |v|
-        v.move_to *([i * 5] * 2)
-        win.add v
-      end
+      win.add Reflex::TextView.new name: 'hello', pos: [i * 5] * 2, data: 'HELLO WORLD!'
     end
   end.show
 end

data/src/body.cpp

@@ -1,505 +1,306 @@
-#include "reflex/body.h"
+#include "body.h"
 
 
-#include <math.h>
 #include <assert.h>
-#include <vector>
-#include <Box2D/Common/b2Math.h>
 #include <Box2D/Dynamics/b2Body.h>
-#include <Box2D/Dynamics/b2Fixture.h>
-#include <Box2D/Collision/Shapes/b2CircleShape.h>
-#include <Box2D/Collision/Shapes/b2EdgeShape.h>
-#include <Box2D/Collision/Shapes/b2ChainShape.h>
-#include <Box2D/Collision/Shapes/b2PolygonShape.h>
+#include <Box2D/Dynamics/b2World.h>
 #include <xot/util.h>
 #include "reflex/exception.h"
-#include "reflex/painter.h"
 #include "world.h"
 
 
-#define PTR ((b2Body*) handle)
-
-
 namespace Reflex
 {
 
 
-	static const float PI   = M_PI;
-
-	static const float PI_2 = PI * 2;
-
-
-	Body::Body (Handle h, float pixels_per_meter)
-	:	handle(h), ppm(pixels_per_meter)
+	struct Body::Data
 	{
-		assert(h);
-	}
-
-	Fixture
-	Body::add_box (coord width, coord height)
-	{
-		assert(PTR && PTR->GetWorld());
-
-		if (PTR->GetWorld()->IsLocked())
-			invalid_state_error(__FILE__, __LINE__);
 
-		b2Vec2 size(width / ppm / 2, height / ppm / 2);
+		b2Body* b2body;
 
-		b2PolygonShape shape;
-		shape.SetAsBox(size.x, size.y);
-		for (int i = 0; i < 4; ++i)
-			shape.m_vertices[i] += size;
-
-		b2FixtureDef fixture;
-		fixture.shape = &shape;
-
-		return PTR->CreateFixture(&fixture);
-	}
-
-	Fixture
-	add_circle (b2Body* handle, coord size, float ppm)
-	{
-		coord radius = size / ppm / 2.f;
-
-		b2CircleShape shape;
-		shape.m_radius = radius;
-		shape.m_p.Set(radius, radius);
-
-		b2FixtureDef fixture;
-		fixture.shape = &shape;
-
-		return PTR->CreateFixture(&fixture);
-	}
+		float ppm;
 
-	Fixture
-	add_ellipse (
-		b2Body* handle, coord width, coord height, float from, float to,
-		coord radius_min, uint nsegment, float ppm)
-	{
-		coord w = width / 2, h = height / 2;
-
-		if (nsegment == 0) nsegment = Painter::ELLIPSE_NSEGMENT;
+		Data ()
+		:	b2body(NULL), ppm(0)
+		{
+		}
 
-		std::vector<b2Vec2> vecs;
-		vecs.reserve(nsegment);
-		for (uint seg = 0; seg < nsegment; ++seg)
+		bool is_valid () const
 		{
-			float pos    = (float) seg / (float) nsegment;
-			float radian = (from + (to - from) * pos) * PI_2;
-			float x      = cos(radian);
-			float y      = -sin(radian);
-			vecs.push_back(b2Vec2(to_b2coord(w + w * x, ppm), to_b2coord(h + h * y, ppm)));
+			return b2body && ppm > 0;
 		}
 
-		b2PolygonShape shape;
-		shape.Set(&vecs[0], (int32) nsegment);
+	};// Body::Data
 
-		b2FixtureDef fixture;
-		fixture.shape = &shape;
 
-		return PTR->CreateFixture(&fixture);
-	}
-
-	Fixture
-	Body::add_ellipse (coord width, coord height, coord radius_min, uint nsegment)
+	static void
+	validate (const Body* body, bool check_world_lock = false)
 	{
-		assert(PTR && PTR->GetWorld());
+		assert(body);
 
-		if (PTR->GetWorld()->IsLocked())
+		if (!body->self->is_valid())
 			invalid_state_error(__FILE__, __LINE__);
 
-		if (width == height && radius_min == 0)
-			return add_circle(PTR, width, ppm);
-		else
+		if (check_world_lock)
 		{
-			return Reflex::add_ellipse(
-				PTR, width, height, 0, 360, radius_min, nsegment, ppm);
-		}
-	}
-
-	Fixture
-	Body::add_arc (
-		coord width, coord height, float angle_from, float angle_to,
-		coord radius_min, uint nsegment)
-	{
-		assert(PTR && PTR->GetWorld());
-
-		if (PTR->GetWorld()->IsLocked())
-			invalid_state_error(__FILE__, __LINE__);
+			assert(body->self->b2body->GetWorld());
 
-		if (width == height && angle_from == 0 && angle_to == 360 && radius_min == 0)
-			return add_circle(PTR, width, ppm);
-		else
-		{
-			return Reflex::add_ellipse(
-				PTR, width, height, angle_from, angle_to, radius_min, nsegment, ppm);
+			if (body->self->b2body->GetWorld()->IsLocked())
+				physics_error(__FILE__, __LINE__);
 		}
 	}
 
-	Fixture
-	Body::add_edge (const Point& begin, const Point& end)
-	{
-		assert(PTR && PTR->GetWorld());
-
-		if (PTR->GetWorld()->IsLocked())
-			invalid_state_error(__FILE__, __LINE__);
-
-		b2EdgeShape shape;
-		shape.Set(to_b2vec2(begin, ppm), to_b2vec2(end, ppm));
-
-		b2FixtureDef fixture;
-		fixture.shape = &shape;
 
-		return PTR->CreateFixture(&fixture);
-	}
-
-	Fixture
-	Body::add_edge (const Point* points, size_t size, bool loop)
+	Body::Body (World* world, const Point& position, float angle)
 	{
-		assert(PTR && PTR->GetWorld());
-
-		if (PTR->GetWorld()->IsLocked())
-			invalid_state_error(__FILE__, __LINE__);
-
-		if (size == 2)
-			return add_edge(points[0], points[1]);
+		assert(world);
 
-		std::vector<b2Vec2> vecs;
-		vecs.reserve(size);
-		for (size_t i = 0; i < size; ++i)
-			vecs.push_back(to_b2vec2(points[i], ppm));
+		b2World* b2world = World_get_b2ptr(world);
+		float ppm        = world->meter2pixel();
+		assert(b2world && ppm > 0);
 
-		b2ChainShape shape;
-		if (loop)
-			shape.CreateLoop(&vecs[0], (int32) size);
-		else
-			shape.CreateChain(&vecs[0], (int32) size);
-
-		b2FixtureDef fixture;
-		fixture.shape = &shape;
-
-		return PTR->CreateFixture(&fixture);
-	}
-
-	Fixture
-	Body::add_polygon (const Point* points, size_t size)
-	{
-		assert(PTR && PTR->GetWorld());
-
-		if (PTR->GetWorld()->IsLocked())
+		if (b2world->IsLocked())
 			invalid_state_error(__FILE__, __LINE__);
 
-		std::vector<b2Vec2> vecs;
-		vecs.reserve(size);
-		for (size_t i = 0; i < size; ++i)
-			vecs.push_back(to_b2vec2(points[i], ppm));
-
-		b2PolygonShape shape;
-		shape.Set(&vecs[0], (int32) size);
+		b2BodyDef def;
+		def.position = to_b2vec2(position, ppm);
+		def.angle    = Xot::deg2rad(angle);
 
-		b2FixtureDef fixture;
-		fixture.shape = &shape;
+		b2Body* b2body = b2world->CreateBody(&def);
+		if (!b2body)
+			physics_error(__FILE__, __LINE__);
 
-		return PTR->CreateFixture(&fixture);
+		self->b2body = b2body;
+		self->ppm    = ppm;
 	}
 
-	void
-	Body::clear_fixtures ()
+	Body::~Body ()
 	{
-		assert(PTR && PTR->GetWorld());
-
-		if (PTR->GetWorld()->IsLocked())
-			invalid_state_error(__FILE__, __LINE__);
+		validate(this, true);
 
-		b2Fixture* f;
-		while ((f = PTR->GetFixtureList()))
-			PTR->DestroyFixture(f);
+		self->b2body->GetWorld()->DestroyBody(self->b2body);
 	}
 
-	float
-	Body::meter2pixel (float meter) const
+	void
+	Body::apply_force (coord x, coord y)
 	{
-		return meter * ppm;
+		apply_force(Point(x, y));
 	}
 
 	void
-	Body::set_static (bool state)
+	Body::apply_force (const Point& force)
 	{
-		assert(PTR && PTR->GetWorld());
+		validate(this);
 
-		if (PTR->GetWorld()->IsLocked())
-			invalid_state_error(__FILE__, __LINE__);
-
-		PTR->SetType(state ? b2_staticBody : b2_dynamicBody);
+		self->b2body->ApplyForceToCenter(to_b2vec2(force, self->ppm), true);
 	}
 
-	bool
-	Body::is_static () const
+	void
+	Body::apply_torque (float torque)
 	{
-		assert(PTR);
+		validate(this);
 
-		return PTR->GetType() == b2_staticBody;
+		self->b2body->ApplyTorque(torque, true);
 	}
 
 	void
-	Body::set_dynamic (bool state)
+	Body::apply_linear_impulse (coord x, coord y)
 	{
-		assert(PTR && PTR->GetWorld());
-
-		if (PTR->GetWorld()->IsLocked())
-			invalid_state_error(__FILE__, __LINE__);
-
-		PTR->SetType(state ? b2_dynamicBody : b2_staticBody);
+		apply_linear_impulse(Point(x, y));
 	}
 
-	bool
-	Body::is_dynamic () const
+	void
+	Body::apply_linear_impulse (const Point& impulse)
 	{
-		assert(PTR);
+		validate(this);
 
-		return PTR->GetType() == b2_dynamicBody;
+		self->b2body->ApplyLinearImpulse(
+			to_b2vec2(impulse, self->ppm), self->b2body->GetWorldCenter(), true);
 	}
 
-	Point
-	Body::position () const
+	void
+	Body::apply_angular_impulse (float impulse)
 	{
-		assert(PTR);
+		validate(this);
 
-		return to_point(PTR->GetPosition(), ppm);
+		self->b2body->ApplyAngularImpulse(impulse, true);
 	}
 
 	float
-	Body::angle () const
+	Body::meter2pixel (float meter) const
 	{
-		assert(PTR);
-
-		return Xot::rad2deg(PTR->GetAngle());
+		return meter * self->ppm;
 	}
 
 	void
-	Body::set_linear_velocity (coord x, coord y)
-	{
-		set_linear_velocity(Point(x, y));
-	}
-
-	void
-	Body::set_linear_velocity (const Point& velocity)
+	Body::set_transform (coord x, coord y, float degree)
 	{
-		assert(PTR);
+		validate(this, true);
 
-		PTR->SetLinearVelocity(to_b2vec2(velocity, ppm));
+		self->b2body->SetTransform(
+			to_b2vec2(x, y, self->ppm), Xot::deg2rad(degree));
 	}
 
 	Point
-	Body::linear_velocity () const
+	Body::position () const
 	{
-		assert(PTR);
+		validate(this);
 
-		return to_point(PTR->GetLinearVelocity(), ppm);
+		return to_point(self->b2body->GetPosition(), self->ppm);
 	}
 
-	void
-	Body::set_angular_velocity (float velocity)
+	float
+	Body::angle () const
 	{
-		assert(PTR);
+		validate(this);
 
-		PTR->SetAngularVelocity(Xot::deg2rad(velocity));
+		return Xot::rad2deg(self->b2body->GetAngle());
 	}
 
-	float
-	Body::angular_velocity () const
+	static bool
+	is_body_dynamic (const Body* body)
 	{
-		assert(PTR);
+		assert(body);
 
-		return Xot::rad2deg(PTR->GetAngularVelocity());
+		return body->self->b2body->GetType() == b2_dynamicBody;
 	}
 
 	void
-	Body::apply_force (coord x, coord y)
+	Body::set_dynamic (bool dynamic)
 	{
-		apply_force(Point(x, y));
-	}
+		if (dynamic == is_body_dynamic(this))
+			return;
 
-	void
-	Body::apply_force (const Point& force)
-	{
-		assert(PTR);
+		validate(this, true);
 
-		PTR->ApplyForceToCenter(to_b2vec2(force, ppm), true);
+		self->b2body->SetType(dynamic ? b2_dynamicBody : b2_staticBody);
 	}
 
-	void
-	Body::apply_torque (float torque)
+	bool
+	Body::is_dynamic () const
 	{
-		assert(PTR);
+		validate(this);
 
-		PTR->ApplyTorque(torque, true);
+		return is_body_dynamic(this);
 	}
 
-	void
-	Body::apply_linear_impulse (coord x, coord y)
+	static void
+	make_body_kinematic (Body* body)
 	{
-		apply_linear_impulse(Point(x, y));
+		if (body->self->b2body->GetType() == b2_staticBody)
+			body->self->b2body->SetType(b2_kinematicBody);
 	}
 
 	void
-	Body::apply_linear_impulse (const Point& impulse)
+	Body::set_linear_velocity (coord x, coord y)
 	{
-		assert(PTR);
-
-		PTR->ApplyLinearImpulse(
-			to_b2vec2(impulse, ppm), PTR->GetWorldCenter(), true);
+		set_linear_velocity(Point(x, y));
 	}
 
 	void
-	Body::apply_angular_impulse (float impulse)
+	Body::set_linear_velocity (const Point& velocity)
 	{
-		assert(PTR);
+		validate(this);
 
-		PTR->ApplyAngularImpulse(impulse, true);
-	}
+		make_body_kinematic(this);
 
-	void
-	Body::set_density (float density)
-	{
-		iterator end_ = end();
-		for (iterator it = begin(); it != end_; ++it)
-			it->set_density(density);
+		self->b2body->SetLinearVelocity(to_b2vec2(velocity, self->ppm));
 	}
 
-	float
-	Body::density () const
+	Point
+	Body::linear_velocity () const
 	{
-		const_iterator it = begin(), end_ = end();
-		if (it == end_)
-			invalid_state_error(__FILE__, __LINE__, "no fixture.");
+		validate(this);
 
-		float val = it->density();
-		for (; it != end_; ++it)
-		{
-			if (val != it->density())
-			{
-				invalid_state_error(
-					__FILE__, __LINE__,
-					"each fixture have different values.");
-			}
-		}
-		return val;
+		return to_point(self->b2body->GetLinearVelocity(), self->ppm);
 	}
 
 	void
-	Body::set_friction (float friction)
+	Body::set_angular_velocity (float velocity)
 	{
-		iterator end_ = end();
-		for (iterator it = begin(); it != end_; ++it)
-			it->set_friction(friction);
-	}
+		validate(this);
 
-	float
-	Body::friction () const
-	{
-		const_iterator it = begin(), end_ = end();
-		if (it == end_)
-			invalid_state_error(__FILE__, __LINE__, "no fixture.");
+		make_body_kinematic(this);
 
-		float val = it->friction();
-		for (; it != end_; ++it)
-		{
-			if (val != it->friction())
-			{
-				invalid_state_error(
-					__FILE__, __LINE__,
-					"each fixture have different values.");
-			}
-		}
-		return val;
-	}
-
-	void
-	Body::set_restitution (float restitution)
-	{
-		iterator end_ = end();
-		for (iterator it = begin(); it != end_; ++it)
-			it->set_restitution(restitution);
+		self->b2body->SetAngularVelocity(Xot::deg2rad(velocity));
 	}
 
 	float
-	Body::restitution () const
+	Body::angular_velocity () const
 	{
-		const_iterator it = begin(), end_ = end();
-		if (it == end_)
-			invalid_state_error(__FILE__, __LINE__, "no fixture.");
+		validate(this);
 
-		float val = it->restitution();
-		for (; it != end_; ++it)
-		{
-			if (val != it->restitution())
-			{
-				invalid_state_error(
-					__FILE__, __LINE__,
-					"each fixture have different values.");
-			}
-		}
-		return val;
+		return Xot::rad2deg(self->b2body->GetAngularVelocity());
 	}
 
 	void
 	Body::set_gravity_scale (float scale)
 	{
-		assert(PTR);
+		validate(this);
 
-		return PTR->SetGravityScale(scale);
+		if (scale == self->b2body->GetGravityScale())
+			return;
+
+		return self->b2body->SetGravityScale(scale);
 	}
 
 	float
 	Body::gravity_scale () const
 	{
-		assert(PTR);
+		validate(this);
 
-		return PTR->GetGravityScale();
+		return self->b2body->GetGravityScale();
 	}
 
-	Body::iterator
-	Body::begin ()
+
+	void
+	Body_copy_attributes (Body* to, const Body& from)
 	{
-		assert(PTR);
+		if (!to)
+			return;
 
-		return Fixture(PTR->GetFixtureList());
-	}
+		if (to->self->ppm != from.self->ppm)
+			physics_error(__FILE__, __LINE__);
 
-	Body::const_iterator
-	Body::begin () const
-	{
-		assert(PTR);
+		      b2Body* b2to   = Body_get_b2ptr(to);
+		const b2Body* b2from = Body_get_b2ptr(&from);
+		assert(b2to && b2from);
 
-		return Fixture(PTR->GetFixtureList());
+		b2to->SetType(           b2from->GetType());
+		b2to->SetTransform(      b2from->GetPosition(), b2from->GetAngle());
+		b2to->SetLinearVelocity( b2from->GetLinearVelocity());
+		b2to->SetAngularVelocity(b2from->GetAngularVelocity());
+		b2to->SetLinearDamping(  b2from->GetLinearDamping());
+		b2to->SetAngularDamping( b2from->GetAngularDamping());
+		b2to->SetGravityScale(   b2from->GetGravityScale());
+		b2to->SetBullet(         b2from->IsBullet());
 	}
 
-	Body::iterator
-	Body::end ()
+	Body*
+	Body_create_temporary ()
 	{
-		assert(PTR);
-
-		return Fixture(NULL);
+		return new Body(World_get_temporary());
 	}
 
-	Body::const_iterator
-	Body::end () const
+	bool
+	Body_is_temporary (const Body& body)
 	{
-		assert(PTR);
+		const b2Body* b2body = Body_get_b2ptr(&body);
+		if (!b2body) return false;
 
-		return Fixture(NULL);
+		return b2body->GetWorld() == World_get_b2ptr(World_get_temporary());
 	}
 
-	void
-	Body::set_transform (coord x, coord y, float degree)
+	b2Body*
+	Body_get_b2ptr (Body* body)
 	{
-		assert(PTR && PTR->GetWorld());
-
-		if (PTR->GetWorld()->IsLocked())
-			invalid_state_error(__FILE__, __LINE__);
+		return body ? body->self->b2body : NULL;
+	}
 
-		PTR->SetTransform(to_b2vec2(x, y, ppm), Xot::deg2rad(degree));
+	const b2Body*
+	Body_get_b2ptr (const Body* body)
+	{
+		return Body_get_b2ptr(const_cast<Body*>(body));
 	}