reflexion 0.1.12 → 0.1.17

data/samples/reflexion/noise.rb

@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-
+
+
+%w[xot beeps rays reflex]
+  .map  {|s| File.expand_path "../../../../#{s}/lib", __FILE__}
+  .each {|s| $:.unshift s if !$:.include?(s) && File.directory?(s)}
+
+require 'reflexion/include'
+
+
+y = 0
+
+draw do
+  stroke :white
+  lines *(0..200).map {|x|
+    xx = x * 5
+    yy = 200 + Rays.perlin(x / 10.0, y / 100.0) * 100
+    [xx, yy]
+  }
+  y += 1
+
+  text "#{event.fps.to_i} FPS", 10, 10
+end

data/samples/reflexion/paint.rb

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 
 
-%w[xot rays reflex]
+%w[xot beeps rays reflex]
   .map  {|s| File.expand_path "../../../../#{s}/lib", __FILE__}
   .each {|s| $:.unshift s if !$:.include?(s) && File.directory?(s)}
 
@@ -10,21 +10,22 @@ require 'reflexion/include'
 
 FILENAME = 'paint.png'
 
-canvas =
+$canvas =
   Image.load(FILENAME) rescue nil ||
   Image.new(512, 512).paint {background :white}
 
+
 setup do
-  size canvas.size
+  size $canvas.size
 end
 
 draw do
-  image canvas
+  image $canvas
 end
 
 pointer do
   if down? || drag?
-    canvas.paint do
+    $canvas.paint do
       fill event.left? ? :red : event.right? ? :blue : :white
       ellipse *(event.pos - 10).to_a, 20, 20
     end
@@ -33,7 +34,7 @@ end
 
 key do
   case chars
-  when /s/i       then canvas.save FILENAME
+  when /s/i       then $canvas.save FILENAME
   when /q/i, "\e" then quit
   end
 end

data/samples/reflexion/physics.rb

@@ -1,28 +1,35 @@
 # -*- coding: utf-8 -*-
 
 
-%w[xot rays reflex]
+%w[xot beeps rays reflex]
   .map  {|s| File.expand_path "../../../../#{s}/lib", __FILE__}
   .each {|s| $:.unshift s if !$:.include?(s) && File.directory?(s)}
 
 require 'reflexion/include'
 
 
+COLORS = [:red, :green, :blue, :orange, :yellow, :indigo, :pink, :peach, :brown]
+
+count = 0
+
 setup do
-  set size: [600, 400], gravity: Point.new(0, 9.8) * meter #, debug: true
+  size    600, 400
+  gravity 0, 9.8 * meter
 end
 
 draw do
-  text "#{event.fps.to_i} FPS", 10, 10
+  text "#{event.fps.to_i} FPS | #{count} BLOCKS", 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
+    count += 1 if window.add View.new {
+      pos        event.pos
+      size       rand 20..40
+      background event.right? ? :gray : COLORS.sample
+      dynamic    event.left?
+      shape      [RectShape, EllipseShape].sample.new(density: 1)
+      interval(1) {fill rand, rand, rand}
     }
   end
 end

data/samples/reflexion/pulse.rb

@@ -1,36 +1,50 @@
 # -*- coding: utf-8 -*-
 
 
-%w[xot rays reflex]
+%w[xot beeps rays reflex]
   .map  {|s| File.expand_path "../../../../#{s}/lib", __FILE__}
   .each {|s| $:.unshift s if !$:.include?(s) && File.directory?(s)}
 
 require 'reflexion/include'
 
 
-frame = 0
-fps   = 0
+frame = fps = 0
 
 
 setup do
-  set width: 600, height: 300
+  size 600, 300
   painter.font = Font.new nil, 24
+  interval do
+    3.times {put $pos} if $pos
+  end
 end
 
 draw do
   frame += 1
   fps = event.fps.to_i if (frame % 5) == 0
-  text "#{fps} FPS | FRAME: #{frame}", 10, 10
+  text "FRAME: #{frame} | #{fps} FPS", 10, 10
 end
 
 key do
   quit if chars == 'q' || code == 53
 end
 
+def put (pos)
+  window.add View.new {
+    position pos
+    size     20
+    fill     1, rand(0.2..0.7), rand(0.2..0.4)
+    shape    EllipseShape.new
+    interval do
+      self.pos += [rand(-1.0..1.0) * 4, rand(-1.0..0.0) * 8]
+    end
+    interval do
+      self.fill = fill.tap {|f| f.alpha -= 0.02}
+      parent.remove self if fill.alpha <= 0
+    end
+  }
+end
+
 pointer do
-  if down? || drag?
-    window.add EllipseShape.new {
-      set frame: [*(event.pos - 10).to_a, 20, 20], fill: :red
-    }
-  end
+  $pos = pos
 end

data/samples/shader.rb

@@ -12,21 +12,23 @@ win = Reflex::Window.new do
   set :title, "Shader Sample"
   set :frame, 100, 100, 300, 300
 
-  start  = Time.now.to_f
-  shader = Reflex::Shader.new <<-END
+  start = Time.now.to_f
+
+  painter.shader <<-END
+    varying vec4 v_TexCoord;
     uniform vec2 resolution;
     uniform float time;
     void main ()
     {
-      vec2 pos = gl_FragCoord.xy / resolution;
+      vec2 pos = v_TexCoord.xy / resolution;
       gl_FragColor = vec4(pos, float(mod(time, 1.0)), 1);
     }
   END
 
   on :draw do |e|
-    e.painter.push do
-      attach shader, resolution: bounds.size.to_a, time: Time.now.to_f - start
-      rect *bounds.to_a
+    e.paint do
+      shader.uniform resolution: bounds.size.to_a, time: Time.now.to_f - start
+      rect bounds
     end
   end
 

data/samples/shapes.rb

@@ -7,24 +7,89 @@
 
 require 'reflex'
 
-include Reflex
 
+Reflex::Window.new do
+  title 'Shape Sample'
+  frame 100, 100, 800, 500
 
-win = Window.new do
-  set title: 'Shape Sample', frame: [100, 100, 500, 400]
+  def on_draw (e)
+    e.painter.push do
+      fill :pink
+      stroke 1
+      stroke_width 2
 
-  p = painter
-  p.background 0
-  p.fill 1
+      x, y, y2, w, h = 10, 10, 100, 50, 50
 
-  %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], fill: :gray, stroke: :white
-    }
+      push do
+        rect                       x, y,  w, h
+        polygon Rays::Polygon.rect x, y2, w, h
+
+        translate 100, 0
+        rect                       x, y,  w, h, 5
+        polygon Rays::Polygon.rect x, y2, w, h, 5
+
+        translate 100, 0
+        rect                       x, y,  w, h, 5, 10, 15, 20
+        polygon Rays::Polygon.rect x, y2, w, h, 5, 10, 15, 20
+
+        translate 100, 0
+        ellipse                       x, y,  w, h
+        polygon Rays::Polygon.ellipse x, y2, w, h
+
+        translate 100, 0
+        ellipse                       x, y,  w, h, from: 45, to: 180
+        polygon Rays::Polygon.ellipse x, y2, w, h, from: 45, to: 180
+
+        translate 100, 0
+        ellipse                       x, y,  w, h, hole: 10
+        polygon Rays::Polygon.ellipse x, y2, w, h, hole: 10
+
+        translate 100, 0
+        ellipse                       x, y,  w, h, hole: 10, from: 200, to: 300
+        polygon Rays::Polygon.ellipse x, y2, w, h, hole: 10, from: 200, to: 300
+
+        translate 100, 0
+        curve                       x, y,  x + w, y,  x + w, y  + h, x, y  + h
+        polygon Rays::Polygon.curve x, y2, x + w, y2, x + w, y2 + h, x, y2 + h
+
+        translate 100, 0
+        curve                       x, y,  x + w, y,  x + w, y  + h, x, y  + h, loop: true
+        polygon Rays::Polygon.curve x, y2, x + w, y2, x + w, y2 + h, x, y2 + h, loop: true
+
+        translate 100, 0
+        bezier                       x, y,  x + w, y,  x + w, y  + h, x, y  + h
+        polygon Rays::Polygon.bezier x, y2, x + w, y2, x + w, y2 + h, x, y2 + h
+
+        translate 100, 0
+        bezier                       x, y,  x + w, y,  x + w, y  + h, x, y  + h, loop: true
+        polygon Rays::Polygon.bezier x, y2, x + w, y2, x + w, y2 + h, x, y2 + h, loop: true
+      end
+
+      translate 0, 200
+      push do
+        line                    x, y,  x + w, y  + h
+        line Rays::Polyline.new x, y2, x + w, y2 + h
+
+        translate 100, 0
+        line                    x, y,  x + w, y  + h, x, y  + h
+        line Rays::Polyline.new x, y2, x + w, y2 + h, x, y2 + h
+
+        translate 100, 0
+        line                    x, y,  x + w, y  + h, x, y  + h, loop: true
+        line Rays::Polyline.new x, y2, x + w, y2 + h, x, y2 + h, loop: true
+
+        translate 100, 0
+        polygon Rays::Polyline.new(x, y, x + w, y + h).expand 10
+
+        translate 100, 0
+        polygon Rays::Polyline.new(x, y, x + w, y + h, x, y + h).expand 10
+
+        translate 100, 0
+        polygon Rays::Polyline.new(x, y, x + w, y + h, x, y + h, loop: true).expand 10
+      end
+    end
   end
-end
+end.show
 
 
-Reflex.start do
-  win.show
-end
+Reflex.start

data/samples/tree.rb

@@ -10,9 +10,8 @@ require 'reflex'
 
 class V < Reflex::View
 
-  def initialize (offset = [0, 0])
-    super()
-    frame *offset, 400, 200
+  def initialize (offset = 0)
+    super position: offset, size: [400, 200]
   end
 
   def on_update (e)
@@ -23,14 +22,14 @@ class V < Reflex::View
     e.painter.push do
       b = e.bounds.to_a
 
-      color [0.2, 0.1]
+      fill 0.2
+      stroke 1
+      stroke_width 2
       rect *b
 
-      color :green, :red
+      fill :green
+      stroke :red
       text e.fps.to_i.to_s + " FPS."
-
-      color :none, [1, 0, 0, 0.4]
-      rect *b
     end
   end
 
@@ -41,7 +40,7 @@ class W < Reflex::Window
 
   def initialize ()
     set :title, "View Tree Sample"
-    set :frame, 100, 100, 320, 240
+    set :frame, 100, 100, 800, 600
 
     painter.background 0
     painter.fill 1
@@ -58,7 +57,7 @@ end# W
 def setup (parent, level)
   return unless level > 0
   1.times do |i|
-    v = V.new [i * 10] * 2
+    v = V.new i * 10
     parent.add v
     setup v, level - 1
   end

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));
 	}