reflexion 0.1.11 → 0.1.16

data/src/body.h

@@ -0,0 +1,91 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_SRC_BODY_H__
+#define __REFLEX_SRC_BODY_H__
+
+
+#include <xot/noncopyable.h>
+#include <xot/pimpl.h>
+#include <rays/point.h>
+#include <reflex/defs.h>
+
+
+class b2Body;
+
+
+namespace Reflex
+{
+
+
+	class World;
+
+
+	class Body : public Xot::NonCopyable
+	{
+
+		public:
+
+			Body (World* world, const Point& position = 0, float angle = 0);
+
+			~Body ();
+
+			void apply_force (coord x, coord y);
+
+			void apply_force (const Point& force);
+
+			void apply_torque (float torque);
+
+			void apply_linear_impulse (coord x, coord y);
+
+			void apply_linear_impulse (const Point& impulse);
+
+			void apply_angular_impulse (float impulse);
+
+			float meter2pixel (float meter = 1) const;
+
+			void set_transform (coord x, coord y, float degree);
+
+			Point position () const;
+
+			float angle () const;
+
+			void set_dynamic (bool dynamic = true);
+
+			bool  is_dynamic () const;
+
+			void set_linear_velocity (coord x, coord y);
+
+			void set_linear_velocity (const Point& velocity);
+
+			Point    linear_velocity () const;
+
+			void set_angular_velocity (float velocity);
+
+			float    angular_velocity () const;
+
+			void set_gravity_scale (float scale);
+
+			float    gravity_scale () const;
+
+			struct Data;
+
+			Xot::PImpl<Data> self;
+
+	};// Body
+
+
+	void Body_copy_attributes (Body* to, const Body& from);
+
+	Body* Body_create_temporary ();
+
+	bool Body_is_temporary (const Body& body);
+
+	      b2Body* Body_get_b2ptr (      Body* body);
+
+	const b2Body* Body_get_b2ptr (const Body* body);
+
+
+}// Reflex
+
+
+#endif//EOH

data/src/event.cpp

@@ -1,6 +1,8 @@
 #include "reflex/event.h"
 
 
+#include "reflex/timer.h"
+#include "reflex/shape.h"
 #include "reflex/exception.h"
 
 
@@ -26,8 +28,8 @@ namespace Reflex
 	}
 
 
-	UpdateEvent::UpdateEvent (float dt)
-	:	dt(dt)
+	UpdateEvent::UpdateEvent (double now, float dt)
+	:	now(now), dt(dt)
 	{
 	}
 
@@ -114,8 +116,8 @@ namespace Reflex
 	{
 	}
 
-	FocusEvent::FocusEvent (Type type, View* focus, View* last)
-	:	type(type), focus(focus), last(last)
+	FocusEvent::FocusEvent (Type type, View* current, View* last)
+	:	type(type), current(current), last(last)
 	{
 	}
 
@@ -206,27 +208,27 @@ namespace Reflex
 	}
 
 	Point&
-	WheelEvent::delta ()
+	WheelEvent::position ()
 	{
-		return *(Point*) &delta_;
+		return *(Point*) &position_;
 	}
 
 	const Point&
-	WheelEvent::delta () const
+	WheelEvent::position () const
 	{
-		return const_cast<WheelEvent*>(this)->delta();
+		return const_cast<WheelEvent*>(this)->position();
 	}
 
 	Point&
-	WheelEvent::position ()
+	WheelEvent::delta ()
 	{
-		return *(Point*) &position_;
+		return *(Point*) &delta_;
 	}
 
 	const Point&
-	WheelEvent::position () const
+	WheelEvent::delta () const
 	{
-		return const_cast<WheelEvent*>(this)->position();
+		return const_cast<WheelEvent*>(this)->delta();
 	}
 
 
@@ -241,13 +243,61 @@ namespace Reflex
 	}
 
 
+	TimerEvent::TimerEvent (Timer* timer)
+	:	timer(timer)
+	{
+	}
+
+	View*
+	TimerEvent::owner () const
+	{
+		return timer ? timer->owner() : NULL;
+	}
+
+	int
+	TimerEvent::id () const
+	{
+		return timer ? timer->id() : Timer::ID_INVALID;
+	}
+
+	float
+	TimerEvent::interval () const
+	{
+		return timer ? timer->interval() : -1;
+	}
+
+	void
+	TimerEvent::set_count (int count)
+	{
+		if (timer) timer->set_count(count);
+	}
+
+	int
+	TimerEvent::count () const
+	{
+		return timer ? timer->count() : 0;
+	}
+
+	bool
+	TimerEvent::is_finished () const
+	{
+		return timer ? timer->is_finished() : true;
+	}
+
+
 	ContactEvent::ContactEvent ()
-	:	type(NONE), view(NULL)
+	:	type(NONE), shape(NULL), view(NULL)
 	{
 	}
 
-	ContactEvent::ContactEvent (Type type, View* view)
-	:	type(type), view(view)
+	ContactEvent::ContactEvent (Type type, Shape* shape)
+	:	type(type), shape(shape), view(shape ? shape->owner() : NULL)
+	{
+	}
+
+
+	MotionEvent::MotionEvent (const Point& gravity)
+	:	gravity(gravity)
 	{
 	}
 

data/src/exception.cpp

@@ -1,9 +1,6 @@
 #include "reflex/exception.h"
 
 
-#include <xot/string.h>
-
-
 namespace Reflex
 {
 
@@ -20,6 +17,12 @@ namespace Reflex
 	}
 
 
+	PhysicsError::PhysicsError (const char* str)
+	:	Super(str)
+	{
+	}
+
+
 	namespace ErrorFunctions
 	{
 
@@ -37,6 +40,13 @@ namespace Reflex
 			throw LayoutError(Xot::error_text(file, line, s));
 		}
 
+		void
+		physics_error (const char* file, int line, const char* format, ...)
+		{
+			XOT_STRINGF(format, s);
+			throw PhysicsError(Xot::error_text(file, line, s));
+		}
+
 	}// ErrorFunctions
 
 

data/src/filter.cpp

@@ -0,0 +1,76 @@
+#include "reflex/filter.h"
+
+
+#include "reflex/exception.h"
+#include "reflex/debug.h"
+
+
+namespace Reflex
+{
+
+
+	struct Filter::Data
+	{
+
+		Shader shader;
+
+	};// Filter::Data
+
+
+	Filter::Filter ()
+	{
+	}
+
+	Filter::Filter (const Shader& shader)
+	{
+		self->shader = shader;
+	}
+
+	Filter::~Filter ()
+	{
+	}
+
+	void
+	Filter::apply (Painter* painter, const Image& image) const
+	{
+		if (!self->shader)
+			return;
+
+		if (!painter || !image)
+			argument_error(__FILE__, __LINE__);
+
+		painter->set_shader(self->shader);
+		painter->image(image);
+	}
+
+	void
+	Filter::set_shader (const Shader& shader)
+	{
+		self->shader = shader;
+	}
+
+	Shader&
+	Filter::shader ()
+	{
+		return self->shader;
+	}
+
+	const Shader&
+	Filter::shader () const
+	{
+		return const_cast<Filter*>(this)->shader();
+	}
+
+	Filter::operator bool () const
+	{
+		return self->shader;
+	}
+
+	bool
+	Filter::operator ! () const
+	{
+		return !operator bool();
+	}
+
+
+}// Reflex

data/src/fixture.cpp

@@ -1,107 +1,232 @@
-#include "reflex/fixture.h"
+#include "fixture.h"
 
 
 #include <assert.h>
 #include <Box2D/Dynamics/b2Fixture.h>
-
-
-#define PTR ((b2Fixture*) handle)
+#include <Box2D/Collision/Shapes/b2CircleShape.h>
+#include "reflex/exception.h"
+#include "reflex/debug.h"
+#include "view.h"
+#include "world.h"
+#include "body.h"
 
 
 namespace Reflex
 {
 
 
-	Fixture::Fixture (Handle h)
-	:	handle(h)
+	Fixture::Fixture (Body* body, const b2Shape* b2shape, void* userdata)
+	:	b2fixture(NULL)
 	{
+		assert(body);
+
+		b2Body* b2body = Body_get_b2ptr(body);
+		assert(b2body);
+
+		b2fixture = b2body->CreateFixture(b2shape, 0);
+		if (!b2fixture)
+			system_error(__FILE__, __LINE__);
+
+		b2fixture->SetUserData(userdata);
 	}
 
-	Fixture&
-	Fixture::operator = (Handle h)
+	Fixture::~Fixture ()
 	{
-		handle = h;
-		return *this;
+		b2fixture->SetUserData(NULL);
+		b2fixture->GetBody()->DestroyFixture(b2fixture);
 	}
 
 	void
 	Fixture::set_density (float density)
 	{
-		assert(PTR && PTR->GetBody());
+		if (density == this->density())
+			return;
+
+		for (Fixture* p = this; p; p = p->pnext.get())
+			p->b2fixture->SetDensity(density);
 
-		PTR->SetDensity(density);
-		PTR->GetBody()->ResetMassData();
+		b2fixture->GetBody()->ResetMassData();
 	}
 
 	float
 	Fixture::density () const
 	{
-		assert(PTR);
-
-		return PTR->GetDensity();
+		return b2fixture->GetDensity();
 	}
 
 	void
 	Fixture::set_friction (float friction)
 	{
-		assert(PTR);
+		if (friction == this->friction())
+			return;
 
-		PTR->SetFriction(friction);
+		for (Fixture* p = this; p; p = p->pnext.get())
+			p->b2fixture->SetFriction(friction);
 	}
 
 	float
 	Fixture::friction () const
 	{
-		assert(PTR);
-
-		return PTR->GetFriction();
+		return b2fixture->GetFriction();
 	}
 
 	void
 	Fixture::set_restitution (float restitution)
 	{
-		assert(PTR);
+		if (restitution == this->restitution())
+			return;
 
-		PTR->SetRestitution(restitution);
+		for (Fixture* p = this; p; p = p->pnext.get())
+			p->b2fixture->SetRestitution(restitution);
 	}
 
 	float
 	Fixture::restitution () const
 	{
-		assert(PTR);
+		return b2fixture->GetRestitution();
+	}
+
+	void
+	Fixture::set_sensor (bool state)
+	{
+		if (state == is_sensor())
+			return;
 
-		return PTR->GetRestitution();
+		for (Fixture* p = this; p; p = p->pnext.get())
+			p->b2fixture->SetSensor(state);
 	}
 
-	Fixture::Handle
-	Fixture::next () const
+	bool
+	Fixture::is_sensor () const
 	{
-		assert(PTR);
+		return b2fixture->IsSensor();
+	}
 
-		return PTR->GetNext();
+	void
+	Fixture::set_category_bits (uint bits)
+	{
+		if (bits > USHRT_MAX)
+		{
+			argument_error(
+				__FILE__, __LINE__, "category_bits must be less then USHRT_MAX.");
+		}
+
+		if (bits == category_bits())
+			return;
+
+		for (Fixture* p = this; p; p = p->pnext.get())
+		{
+			b2Filter f = p->b2fixture->GetFilterData();
+			f.categoryBits = bits;
+			p->b2fixture->SetFilterData(f);
+		}
 	}
 
-	Fixture::operator bool () const
+	uint
+	Fixture::category_bits () const
 	{
-		return PTR;
+		return b2fixture->GetFilterData().categoryBits;
 	}
 
-	bool
-	Fixture::operator ! () const
+	void
+	Fixture::set_collision_mask (uint mask)
 	{
-		return !operator bool();
+		if (mask > USHRT_MAX)
+		{
+			argument_error(
+				__FILE__, __LINE__, "collision_mask must be less then USHRT_MAX.");
+		}
+
+		if (mask == collision_mask())
+			return;
+
+		for (Fixture* p = this; p; p = p->pnext.get())
+		{
+			b2Filter f = b2fixture->GetFilterData();
+			f.maskBits = mask;
+			b2fixture->SetFilterData(f);
+		}
 	}
 
-	bool
-	operator == (const Fixture& lhs, const Fixture& rhs)
+	uint
+	Fixture::collision_mask () const
+	{
+		return b2fixture->GetFilterData().maskBits;
+	}
+
+	b2Fixture*
+	Fixture::b2ptr ()
+	{
+		return b2fixture;
+	}
+
+	const b2Fixture*
+	Fixture::b2ptr () const
 	{
-		return lhs.handle == rhs.handle;
+		return const_cast<Fixture*>(this)->b2ptr();
+	}
+
+	void
+	Fixture::set_next (Fixture* fixture)
+	{
+		if (fixture)
+			Fixture_copy_attributes(fixture, *this);
+
+		pnext.reset(fixture);
+	}
+
+	Fixture*
+	Fixture::next ()
+	{
+		return pnext.get();
+	}
+
+	const Fixture*
+	Fixture::next () const
+	{
+		return const_cast<Fixture*>(this)->next();
+	}
+
+
+	void
+	Fixture_copy_attributes (Fixture* to, const Fixture& from)
+	{
+		if (!to)
+			return;
+
+		to->set_density(       from.density());
+		to->set_friction(      from.friction());
+		to->set_restitution(   from.restitution());
+		to->set_sensor(        from.is_sensor());
+		to->set_category_bits( from.category_bits());
+		to->set_collision_mask(from.collision_mask());
+	}
+
+	static Body*
+	get_temporary_body ()
+	{
+		static Body* body = NULL;
+		if (!body) body = Body_create_temporary();
+		return body;
+	}
+
+	Fixture*
+	Fixture_create_temporary ()
+	{
+		Body* body = get_temporary_body();
+		if (!body)
+			invalid_state_error(__FILE__, __LINE__);
+
+		b2CircleShape b2shape;
+		b2shape.m_radius = 1;
+
+		return new Fixture(body, &b2shape);
 	}
 
 	bool
-	operator != (const Fixture& lhs, const Fixture& rhs)
+	Fixture_is_temporary (const Fixture& fixture)
 	{
-		return !(lhs == rhs);
+		return fixture.b2ptr()->GetBody() == Body_get_b2ptr(get_temporary_body());
 	}