reflexion 0.1.12 → 0.1.17

data/src/window.h

@@ -0,0 +1,94 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_SRC_WINDOW_H__
+#define __REFLEX_SRC_WINDOW_H__
+
+
+#include <map>
+#include <xot/time.h>
+#include <rays/point.h>
+#include <rays/painter.h>
+#include <reflex/window.h>
+#include <reflex/view.h>
+
+
+namespace Reflex
+{
+
+
+	struct Window::Data
+	{
+
+		typedef std::map<View::Ref, bool> CapturingViews;
+
+		int hide_count = 1;
+
+		bool redraw = true;
+
+		Painter painter;
+
+		View::Ref root, focus;
+
+		Point prev_position, prev_size;
+
+		double prev_time_update, prev_time_draw, prev_fps = 0;
+
+		CapturingViews capturing_views;
+
+		Data ()
+		{
+			prev_time_update = prev_time_draw = Xot::time();
+		}
+
+		virtual ~Data ()
+		{
+		}
+
+		virtual bool is_valid () const = 0;
+
+		operator bool () const
+		{
+			return is_valid();
+		}
+
+		bool operator ! () const
+		{
+			return !operator bool();
+		}
+
+	};// Window::Data
+
+
+	Window::Data* Window_create_data ();
+
+	void Window_initialize (Window* window);
+
+	void Window_show (Window* window);
+
+	void Window_hide (Window* window);
+
+	void Window_close (Window* window);
+
+	void        Window_set_title (      Window* window, const char* title);
+
+	const char* Window_get_title (const Window& window);
+
+	void   Window_set_frame (
+		Window* window, coord x, coord y, coord width, coord height);
+
+	Bounds Window_get_frame (const Window& window);
+
+	void Window_set_focus (Window* window, View* view);
+
+	void Window_call_draw_event (Window* window, DrawEvent* event);
+
+
+	typedef View* (*Window_CreateRootViewFun) ();
+
+	void Window_set_create_root_view_fun (Window_CreateRootViewFun fun);
+
+
+}// Reflex
+
+
+#endif//EOH

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