reflexion 0.1.8 → 0.1.9

data/samples/reflexion/hello.rb

@@ -14,11 +14,9 @@ array = []
 draw do
   gray += 0.01
   gray %= 1
-  painter.tap do |p|
-    p.background gray, gray, gray
-    array.unshift fps
-    array.slice! 32..-1
-    p.text "#{array.reduce(0) {|sum, n| sum + n}.tap {|n| break n / array.size}.to_i} FPS", 10, 30
-    p.text "#{fps} FPS", 10, 10
-  end
+  background gray, gray, gray
+  array.unshift event.fps
+  array.slice! 32..-1
+  text "#{array.reduce(0) {|sum, n| sum + n}.tap {|n| break n / array.size}.to_i} FPS", 10, 30
+  text "#{event.fps} FPS", 10, 10
 end

data/samples/reflexion/paint.rb

@@ -10,30 +10,29 @@ require 'reflexion/include'
 
 FILENAME = 'paint.png'
 
-canvas = Image.load(FILENAME) rescue nil || Image.new(512, 512).paint {
-  background :white
-  clear
-}
+canvas =
+  Image.load(FILENAME) rescue nil ||
+  Image.new(512, 512).paint {background :white}
 
 setup do
   size canvas.size
 end
 
 draw do
-  painter.image canvas
+  image canvas
 end
 
-pointer do |e|
-  if e.down? || e.drag?
+pointer do
+  if down? || drag?
     canvas.paint do
-      fill e.left? ? :red : e.right? ? :blue : :white
-      ellipse e.x - 10, e.y - 10, 20, 20
+      fill event.left? ? :red : event.right? ? :blue : :white
+      ellipse *(event.pos - 10).to_a, 20, 20
     end
   end
 end
 
-key do |e|
-  case e.chars
+key do
+  case chars
   when /s/i       then canvas.save FILENAME
   when /q/i, "\e" then quit
   end

data/samples/reflexion/physics.rb

@@ -0,0 +1,28 @@
+# -*- coding: utf-8 -*-
+
+
+%w[xot rays reflex]
+  .map  {|s| File.expand_path "../../../../#{s}/lib", __FILE__}
+  .each {|s| $:.unshift s if !$:.include?(s) && File.directory?(s)}
+
+require 'reflexion/include'
+
+
+setup do
+  set size: [600, 400], gravity: Point.new(0, 9.8) * meter #, debug: true
+end
+
+draw do
+  text "#{event.fps.to_i} FPS", 10, 10
+end
+
+pointer do
+  if down? || drag?
+    window.add [RectShape, EllipseShape].sample.new {
+      size  = rand 20..40
+      color = event.right? ? :gray : [:red, :green, :blue].sample
+      set frame: [*event.pos.to_a, size, size], fill: color
+      set dynamic: event.left?, density: 1
+    }
+  end
+end

data/samples/reflexion/pulse.rb

@@ -17,18 +17,20 @@ setup do
   painter.font = Font.new nil, 24
 end
 
-draw do |e|
+draw do
   frame += 1
-  fps = e.fps.to_i if (frame % 5) == 0
-  e.painter.text "#{fps} FPS | FRAME: #{frame}", 10, 10
+  fps = event.fps.to_i if (frame % 5) == 0
+  text "#{fps} FPS | FRAME: #{frame}", 10, 10
 end
 
-key do |e|
-  quit if e.chars == 'q' || e.code == 53
+key do
+  quit if chars == 'q' || code == 53
 end
 
-pointer do |e|
-  if e.down? || e.drag?
-    window.add EllipseShape.new {set frame: [e.x - 10, e.y - 10, 20, 20], color: :red}
+pointer do
+  if down? || drag?
+    window.add EllipseShape.new {
+      set frame: [*(event.pos - 10).to_a, 20, 20], fill: :red
+    }
   end
 end

data/samples/shapes.rb

@@ -17,9 +17,9 @@ win = Window.new do
   p.background 0
   p.fill 1
 
-  %w[line rect ellipse arc].each.with_index do |shape, i|
+  %w[rect ellipse arc].each.with_index do |shape, i|
     add Reflex.const_get("#{shape.capitalize}Shape").new {
-      set frame: [32 + 64 * i, 32, 50, 50], color: :gray, border: :white
+      set frame: [32 + 64 * i, 32, 50, 50], fill: :gray, stroke: :white
     }
   end
 end

data/src/body.cpp

@@ -1,6 +1,7 @@
 #include "reflex/body.h"
 
 
+#include <math.h>
 #include <assert.h>
 #include <vector>
 #include <Box2D/Common/b2Math.h>
@@ -10,7 +11,9 @@
 #include <Box2D/Collision/Shapes/b2EdgeShape.h>
 #include <Box2D/Collision/Shapes/b2ChainShape.h>
 #include <Box2D/Collision/Shapes/b2PolygonShape.h>
+#include "xot/util.h"
 #include "reflex/exception.h"
+#include "reflex/painter.h"
 #include "world.h"
 
 
@@ -21,18 +24,26 @@ namespace Reflex
 {
 
 
-	Body::Body (Handle h, float scale)
-	:	handle(h), scale(scale)
+	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)
 	{
 		assert(h);
 	}
 
 	Fixture
-	Body::add_box (float width, float height)
+	Body::add_box (coord width, coord height)
 	{
-		assert(PTR);
+		assert(PTR && PTR->GetWorld());
 
-		b2Vec2 size(width / scale / 2, height / scale / 2);
+		if (PTR->GetWorld()->IsLocked())
+			invalid_state_error(__FILE__, __LINE__);
+
+		b2Vec2 size(width / ppm / 2, height / ppm / 2);
 
 		b2PolygonShape shape;
 		shape.SetAsBox(size.x, size.y);
@@ -46,11 +57,9 @@ namespace Reflex
 	}
 
 	Fixture
-	Body::add_circle (float size)
+	add_circle (b2Body* handle, coord size, float ppm)
 	{
-		assert(PTR);
-
-		float radius = size / scale / 2.f;
+		coord radius = size / ppm / 2.f;
 
 		b2CircleShape shape;
 		shape.m_radius = radius;
@@ -62,13 +71,81 @@ namespace Reflex
 		return PTR->CreateFixture(&fixture);
 	}
 
+	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;
+
+		std::vector<b2Vec2> vecs;
+		vecs.reserve(nsegment);
+		for (uint seg = 0; seg < nsegment; ++seg)
+		{
+			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)));
+		}
+
+		b2PolygonShape shape;
+		shape.Set(&vecs[0], (int32) nsegment);
+
+		b2FixtureDef fixture;
+		fixture.shape = &shape;
+
+		return PTR->CreateFixture(&fixture);
+	}
+
+	Fixture
+	Body::add_ellipse (coord width, coord height, coord radius_min, uint nsegment)
+	{
+		assert(PTR && PTR->GetWorld());
+
+		if (PTR->GetWorld()->IsLocked())
+			invalid_state_error(__FILE__, __LINE__);
+
+		if (width == height && radius_min == 0)
+			return add_circle(PTR, width, ppm);
+		else
+		{
+			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__);
+
+		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);
+		}
+	}
+
 	Fixture
 	Body::add_edge (const Point& begin, const Point& end)
 	{
-		assert(PTR);
+		assert(PTR && PTR->GetWorld());
+
+		if (PTR->GetWorld()->IsLocked())
+			invalid_state_error(__FILE__, __LINE__);
 
 		b2EdgeShape shape;
-		shape.Set(to_box2d(begin, scale), to_box2d(end, scale));
+		shape.Set(to_b2vec2(begin, ppm), to_b2vec2(end, ppm));
 
 		b2FixtureDef fixture;
 		fixture.shape = &shape;
@@ -79,7 +156,10 @@ namespace Reflex
 	Fixture
 	Body::add_edge (const Point* points, size_t size, bool loop)
 	{
-		assert(PTR);
+		assert(PTR && PTR->GetWorld());
+
+		if (PTR->GetWorld()->IsLocked())
+			invalid_state_error(__FILE__, __LINE__);
 
 		if (size == 2)
 			return add_edge(points[0], points[1]);
@@ -87,7 +167,7 @@ namespace Reflex
 		std::vector<b2Vec2> vecs;
 		vecs.reserve(size);
 		for (size_t i = 0; i < size; ++i)
-			vecs.push_back(to_box2d(points[i], scale));
+			vecs.push_back(to_b2vec2(points[i], ppm));
 
 		b2ChainShape shape;
 		if (loop)
@@ -104,12 +184,15 @@ namespace Reflex
 	Fixture
 	Body::add_polygon (const Point* points, size_t size)
 	{
-		assert(PTR);
+		assert(PTR && PTR->GetWorld());
+
+		if (PTR->GetWorld()->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_box2d(points[i], scale));
+			vecs.push_back(to_b2vec2(points[i], ppm));
 
 		b2PolygonShape shape;
 		shape.Set(&vecs[0], (int32) size);
@@ -123,19 +206,66 @@ namespace Reflex
 	void
 	Body::clear_fixtures ()
 	{
-		assert(PTR);
+		assert(PTR && PTR->GetWorld());
+
+		if (PTR->GetWorld()->IsLocked())
+			invalid_state_error(__FILE__, __LINE__);
 
 		b2Fixture* f;
 		while (f = PTR->GetFixtureList())
 			PTR->DestroyFixture(f);
 	}
 
+	float
+	Body::meter2pixel (float meter) const
+	{
+		return meter * ppm;
+	}
+
+	void
+	Body::set_static (bool state)
+	{
+		assert(PTR && PTR->GetWorld());
+
+		if (PTR->GetWorld()->IsLocked())
+			invalid_state_error(__FILE__, __LINE__);
+
+		PTR->SetType(state ? b2_staticBody : b2_dynamicBody);
+	}
+
+	bool
+	Body::is_static () const
+	{
+		assert(PTR);
+
+		return PTR->GetType() == b2_staticBody;
+	}
+
+	void
+	Body::set_dynamic (bool state)
+	{
+		assert(PTR && PTR->GetWorld());
+
+		if (PTR->GetWorld()->IsLocked())
+			invalid_state_error(__FILE__, __LINE__);
+
+		PTR->SetType(state ? b2_dynamicBody : b2_staticBody);
+	}
+
+	bool
+	Body::is_dynamic () const
+	{
+		assert(PTR);
+
+		return PTR->GetType() == b2_dynamicBody;
+	}
+
 	Point
 	Body::position () const
 	{
 		assert(PTR);
 
-		return to_point(PTR->GetPosition(), scale);
+		return to_point(PTR->GetPosition(), ppm);
 	}
 
 	float
@@ -143,69 +273,129 @@ namespace Reflex
 	{
 		assert(PTR);
 
-		return PTR->GetAngle();
+		return Xot::rad2deg(PTR->GetAngle());
 	}
 
 	void
-	Body::set_static (bool state)
+	Body::set_linear_velocity (coord x, coord y)
+	{
+		set_linear_velocity(Point(x, y));
+	}
+
+	void
+	Body::set_linear_velocity (const Point& velocity)
 	{
 		assert(PTR);
 
-		PTR->SetType(state ? b2_staticBody : b2_dynamicBody);
+		PTR->SetLinearVelocity(to_b2vec2(velocity, ppm));
 	}
 
-	bool
-	Body::is_static () const
+	Point
+	Body::linear_velocity () const
 	{
 		assert(PTR);
 
-		return PTR->GetType() == b2_staticBody;
+		return to_point(PTR->GetLinearVelocity(), ppm);
 	}
 
 	void
-	Body::set_dynamic (bool state)
+	Body::set_angular_velocity (float velocity)
 	{
 		assert(PTR);
 
-		PTR->SetType(state ? b2_dynamicBody : b2_staticBody);
+		PTR->SetAngularVelocity(Xot::deg2rad(velocity));
 	}
 
-	bool
-	Body::is_dynamic () const
+	float
+	Body::angular_velocity () const
 	{
 		assert(PTR);
 
-		return PTR->GetType() == b2_dynamicBody;
+		return Xot::rad2deg(PTR->GetAngularVelocity());
 	}
 
 	void
 	Body::set_density (float density)
 	{
-		iterator first = begin();
-		if (!first)
-			invalid_state_error(__FILE__, __LINE__, "no fixture");
+		iterator end_ = end();
+		for (iterator it = begin(); it != end_; ++it)
+			it->set_density(density);
+	}
 
-		first->set_density(density);
+	float
+	Body::density () const
+	{
+		const_iterator it = begin(), end_ = end();
+		if (it == end_)
+			invalid_state_error(__FILE__, __LINE__, "no fixture.");
+
+		float val = it->density();
+		for (; it != end_; ++it)
+		{
+			if (val != it->density())
+			{
+				invalid_state_error(
+					__FILE__, __LINE__,
+					"each fixture have different values.");
+			}
+		}
+		return val;
 	}
 
 	void
 	Body::set_friction (float friction)
 	{
-		iterator first = begin();
-		if (!first)
-			invalid_state_error(__FILE__, __LINE__, "no fixture");
+		iterator end_ = end();
+		for (iterator it = begin(); it != end_; ++it)
+			it->set_friction(friction);
+	}
 
-		first->set_friction(friction);
+	float
+	Body::friction () const
+	{
+		const_iterator it = begin(), end_ = end();
+		if (it == end_)
+			invalid_state_error(__FILE__, __LINE__, "no fixture.");
+
+		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 first = begin();
-		if (!first)
-			invalid_state_error(__FILE__, __LINE__, "no fixture");
+		iterator end_ = end();
+		for (iterator it = begin(); it != end_; ++it)
+			it->set_restitution(restitution);
+	}
 
-		first->set_restitution(restitution);
+	float
+	Body::restitution () const
+	{
+		const_iterator it = begin(), end_ = end();
+		if (it == end_)
+			invalid_state_error(__FILE__, __LINE__, "no fixture.");
+
+		float val = it->restitution();
+		for (; it != end_; ++it)
+		{
+			if (val != it->restitution())
+			{
+				invalid_state_error(
+					__FILE__, __LINE__,
+					"each fixture have different values.");
+			}
+		}
+		return val;
 	}
 
 	Body::iterator
@@ -240,5 +430,16 @@ namespace Reflex
 		return Fixture(NULL);
 	}
 
+	void
+	Body::set_transform (coord x, coord y, float degree)
+	{
+		assert(PTR && PTR->GetWorld());
+
+		if (PTR->GetWorld()->IsLocked())
+			invalid_state_error(__FILE__, __LINE__);
+
+		PTR->SetTransform(to_b2vec2(x, y, ppm), Xot::deg2rad(degree));
+	}
+
 
 }// Reflex

data/src/event.cpp

@@ -38,8 +38,21 @@ namespace Reflex
 	}
 
 
-	FrameEvent::FrameEvent (const Bounds& frame, coord dx, coord dy, coord dwidth, coord dheight)
-	:	frame(frame), dx(dx), dy(dy), dwidth(dwidth), dheight(dheight)
+	FrameEvent::FrameEvent (
+		const Bounds& frame, coord dx, coord dy, coord dwidth, coord dheight,
+		float angle, float dangle)
+	:	frame(frame), dx(dx), dy(dy), dwidth(dwidth), dheight(dheight),
+		angle(angle), dangle(dangle)
+	{
+	}
+
+	FrameEvent::FrameEvent (
+		const Bounds& frame, const Bounds& prev_frame,
+		float angle, float prev_angle)
+	:	frame(frame),
+		dx(    frame.x - prev_frame.x), dy(     frame.y - prev_frame.y),
+		dwidth(frame.w - prev_frame.w), dheight(frame.h - prev_frame.h),
+		angle(angle), dangle(angle - prev_angle)
 	{
 	}
 
@@ -55,6 +68,12 @@ namespace Reflex
 		return dwidth != 0 || dheight != 0;
 	}
 
+	bool
+	FrameEvent::is_rotate () const
+	{
+		return dangle != 0;
+	}
+
 
 	ScrollEvent::ScrollEvent ()
 	:	x(0), y(0), z(0), dx(0), dy(0), dz(0)
@@ -222,4 +241,15 @@ namespace Reflex
 	}
 
 
+	ContactEvent::ContactEvent ()
+	:	type(NONE), view(NULL)
+	{
+	}
+
+	ContactEvent::ContactEvent (Type type, View* view)
+	:	type(type), view(view)
+	{
+	}
+
+
 }// Reflex