box2d-rails 0.0.1

data/vendor/assets/javascripts/box2d/dynamics/b2WorldListener.js

@@ -0,0 +1,52 @@
+/*
+* Copyright (c) 2006-2007 Erin Catto http:
+*
+* This software is provided 'as-is', without any express or implied
+* warranty.  In no event will the authors be held liable for any damages
+* arising from the use of this software.
+* Permission is granted to anyone to use this software for any purpose,
+* including commercial applications, and to alter it and redistribute it
+* freely, subject to the following restrictions:
+* 1. The origin of this software must not be misrepresented; you must not
+* claim that you wrote the original software. If you use this software
+* in a product, an acknowledgment in the product documentation would be
+* appreciated but is not required.
+* 2. Altered source versions must be plainly marked, and must not be
+* misrepresented the original software.
+* 3. This notice may not be removed or altered from any source distribution.
+*/
+
+
+
+
+
+
+
+var b2WorldListener = Class.create();
+b2WorldListener.prototype = 
+{
+
+	// If a body is destroyed, then any joints attached to it are also destroyed.
+	// This prevents memory leaks, but you may unexpectedly be left with an
+	// orphaned joint pointer.
+	// Box2D will notify you when a joint is implicitly destroyed.
+	// It is NOT called if you directly destroy a joint.
+	// Implement this abstract class and provide it to b2World via
+	// b2World::SetListener().
+	// DO NOT modify the Box2D world inside this callback.
+	NotifyJointDestroyed: function(joint){},
+
+	// This is called when a body's shape passes outside of the world boundary. If you
+	// override this and pass back e_destroyBody, you must nullify your copies of the
+	// body pointer.
+	NotifyBoundaryViolated: function(body)
+	{
+		//NOT_USED(body);
+		return b2WorldListener.b2_freezeBody;
+	},
+
+
+
+	initialize: function() {}};
+b2WorldListener.b2_freezeBody = 0;
+b2WorldListener.b2_destroyBody = 1;

data/vendor/assets/javascripts/box2d/dynamics/contacts/b2CircleContact.js

@@ -0,0 +1,102 @@
+/*
+* Copyright (c) 2006-2007 Erin Catto http:
+*
+* This software is provided 'as-is', without any express or implied
+* warranty.  In no event will the authors be held liable for any damages
+* arising from the use of this software.
+* Permission is granted to anyone to use this software for any purpose,
+* including commercial applications, and to alter it and redistribute it
+* freely, subject to the following restrictions:
+* 1. The origin of this software must not be misrepresented; you must not
+* claim that you wrote the original software. If you use this software
+* in a product, an acknowledgment in the product documentation would be
+* appreciated but is not required.
+* 2. Altered source versions must be plainly marked, and must not be
+* misrepresented the original software.
+* 3. This notice may not be removed or altered from any source distribution.
+*/
+
+
+
+
+var b2CircleContact = Class.create();
+Object.extend(b2CircleContact.prototype, b2Contact.prototype);
+Object.extend(b2CircleContact.prototype, 
+{
+
+		initialize: function(s1, s2) {
+		// The constructor for b2Contact
+		// initialize instance variables for references
+		this.m_node1 = new b2ContactNode();
+		this.m_node2 = new b2ContactNode();
+		//
+		this.m_flags = 0;
+
+		if (!s1 || !s2){
+			this.m_shape1 = null;
+			this.m_shape2 = null;
+			return;
+		}
+
+		this.m_shape1 = s1;
+		this.m_shape2 = s2;
+
+		this.m_manifoldCount = 0;
+
+		this.m_friction = Math.sqrt(this.m_shape1.m_friction * this.m_shape2.m_friction);
+		this.m_restitution = b2Math.b2Max(this.m_shape1.m_restitution, this.m_shape2.m_restitution);
+
+		this.m_prev = null;
+		this.m_next = null;
+
+		this.m_node1.contact = null;
+		this.m_node1.prev = null;
+		this.m_node1.next = null;
+		this.m_node1.other = null;
+
+		this.m_node2.contact = null;
+		this.m_node2.prev = null;
+		this.m_node2.next = null;
+		this.m_node2.other = null;
+		//
+
+		// initialize instance variables for references
+		this.m_manifold = [new b2Manifold()];
+		//
+
+		//super(shape1, shape2);
+
+		//b2Settings.b2Assert(this.m_shape1.m_type == b2Shape.e_circleShape);
+		//b2Settings.b2Assert(this.m_shape2.m_type == b2Shape.e_circleShape);
+		this.m_manifold[0].pointCount = 0;
+		this.m_manifold[0].points[0].normalImpulse = 0.0;
+		this.m_manifold[0].points[0].tangentImpulse = 0.0;
+	},
+	//~b2CircleContact() {}
+
+	Evaluate: function(){
+		b2Collision.b2CollideCircle(this.m_manifold[0], this.m_shape1, this.m_shape2, false);
+
+		if (this.m_manifold[0].pointCount > 0)
+		{
+			this.m_manifoldCount = 1;
+		}
+		else
+		{
+			this.m_manifoldCount = 0;
+		}
+	},
+
+	GetManifolds: function()
+	{
+		return this.m_manifold;
+	},
+
+	m_manifold: [new b2Manifold()]});
+
+b2CircleContact.Create = function(shape1, shape2, allocator){
+		return new b2CircleContact(shape1, shape2);
+	};
+b2CircleContact.Destroy = function(contact, allocator){
+		//
+	};

data/vendor/assets/javascripts/box2d/dynamics/contacts/b2Conservative.js

@@ -0,0 +1,228 @@
+/*
+* Copyright (c) 2006-2007 Erin Catto http:
+*
+* This software is provided 'as-is', without any express or implied
+* warranty.  In no event will the authors be held liable for any damages
+* arising from the use of this software.
+* Permission is granted to anyone to use this software for any purpose,
+* including commercial applications, and to alter it and redistribute it
+* freely, subject to the following restrictions:
+* 1. The origin of this software must not be misrepresented; you must not
+* claim that you wrote the original software. If you use this software
+* in a product, an acknowledgment in the product documentation would be
+* appreciated but is not required.
+* 2. Altered source versions must be plainly marked, and must not be
+* misrepresented the original software.
+* 3. This notice may not be removed or altered from any source distribution.
+*/
+
+
+
+
+
+var b2Conservative = Class.create();
+b2Conservative.prototype = {
+
+	// Temp vars
+
+
+
+	initialize: function() {}}
+b2Conservative.R1 = new b2Mat22();
+b2Conservative.R2 = new b2Mat22();
+b2Conservative.x1 = new b2Vec2();
+b2Conservative.x2 = new b2Vec2();
+b2Conservative.Conservative = function(shape1, shape2){
+		var body1 = shape1.GetBody();
+		var body2 = shape2.GetBody();
+
+		//b2Vec2 v1 = body1->m_position - body1->m_position0;
+		var v1X = body1.m_position.x - body1.m_position0.x;
+		var v1Y = body1.m_position.y - body1.m_position0.y;
+		//float32 omega1 = body1->m_rotation - body1->m_rotation0;
+		var omega1 = body1.m_rotation - body1.m_rotation0;
+		//b2Vec2 v2 = body2->m_position - body2->m_position0;
+		var v2X = body2.m_position.x - body2.m_position0.x;
+		var v2Y = body2.m_position.y - body2.m_position0.y;
+		//float32 omega2 = body2->m_rotation - body2->m_rotation0;
+		var omega2 = body2.m_rotation - body2.m_rotation0;
+
+		//float32 r1 = shape1->GetMaxRadius();
+		var r1 = shape1.GetMaxRadius();
+		//float32 r2 = shape2->GetMaxRadius();
+		var r2 = shape2.GetMaxRadius();
+
+		//b2Vec2 p1Start = body1->m_position0;
+		var p1StartX = body1.m_position0.x;
+		var p1StartY = body1.m_position0.y;
+		//float32 a1Start = body1->m_rotation0;
+		var a1Start = body1.m_rotation0;
+
+		//b2Vec2 p2Start = body2->m_position0;
+		var p2StartX = body2.m_position0.x;
+		var p2StartY = body2.m_position0.y;
+		//float32 a2Start = body2->m_rotation0;
+		var a2Start = body2.m_rotation0;
+
+		//b2Vec2 p1 = p1Start;
+		var p1X = p1StartX;
+		var p1Y = p1StartY;
+		//float32 a1 = a1Start;
+		var a1 = a1Start;
+		//b2Vec2 p2 = p2Start;
+		var p2X = p2StartX;
+		var p2Y = p2StartY;
+		//float32 a2 = a2Start;
+		var a2 = a2Start;
+
+		//b2Mat22 b2Conservative.R1(a1), b2Conservative.R2(a2);
+		b2Conservative.R1.Set(a1);
+		b2Conservative.R2.Set(a2);
+
+		//shape1->QuickSync(p1, b2Conservative.R1);
+		shape1.QuickSync(p1, b2Conservative.R1);
+		//shape2->QuickSync(p2, b2Conservative.R2);
+		shape2.QuickSync(p2, b2Conservative.R2);
+
+		//float32 s1 = 0.0f;
+		var s1 = 0.0;
+		//const int32 maxIterations = 10;
+		var maxIterations = 10;
+		//b2Vec2 d;
+		var dX;
+		var dY;
+		//float32 invRelativeVelocity = 0.0f;
+		var invRelativeVelocity = 0.0;
+		//bool hit = true;
+		var hit = true;
+		//b2Vec2 b2Conservative.x1, b2Conservative.x2; moved to static var
+		for (var iter = 0; iter < maxIterations; ++iter)
+		{
+			// Get the accurate distance between shapes.
+			//float32 distance = b2Distance.Distance(&b2Conservative.x1, &b2Conservative.x2, shape1, shape2);
+			var distance = b2Distance.Distance(b2Conservative.x1, b2Conservative.x2, shape1, shape2);
+			if (distance < b2Settings.b2_linearSlop)
+			{
+				if (iter == 0)
+				{
+					hit = false;
+				}
+				else
+				{
+					hit = true;
+				}
+				break;
+			}
+
+			if (iter == 0)
+			{
+				//b2Vec2 d = b2Conservative.x2 - b2Conservative.x1;
+				dX = b2Conservative.x2.x - b2Conservative.x1.x;
+				dY = b2Conservative.x2.y - b2Conservative.x1.y;
+				//d.Normalize();
+				var dLen = Math.sqrt(dX*dX + dY*dY);
+				//float32 relativeVelocity = b2Dot(d, v1 - v2) + b2Abs(omega1) * r1 + b2Abs(omega2) * r2;
+				var relativeVelocity = (dX*(v1X-v2X) + dY*(v1Y - v2Y)) + Math.abs(omega1) * r1 + Math.abs(omega2) * r2;
+				if (Math.abs(relativeVelocity) < Number.MIN_VALUE)
+				{
+					hit = false;
+					break;
+				}
+
+				invRelativeVelocity = 1.0 / relativeVelocity;
+			}
+
+			// Get the conservative movement.
+			//float32 ds = distance * invRelativeVelocity;
+			var ds = distance * invRelativeVelocity;
+			//float32 s2 = s1 + ds;
+			var s2 = s1 + ds;
+
+			if (s2 < 0.0 || 1.0 < s2)
+			{
+				hit = false;
+				break;
+			}
+
+			if (s2 < (1.0 + 100.0 * Number.MIN_VALUE) * s1)
+			{
+				hit = true;
+				break;
+			}
+
+			s1 = s2;
+
+			// Move forward conservatively.
+			//p1 = p1Start + s1 * v1;
+			p1X = p1StartX + s1 * v1.x;
+			p1Y = p1StartY + s1 * v1.y;
+			//a1 = a1Start + s1 * omega1;
+			a1 = a1Start + s1 * omega1;
+			//p2 = p2Start + s1 * v2;
+			p2X = p2StartX + s1 * v2.x;
+			p2Y = p2StartY + s1 * v2.y;
+			//a2 = a2Start + s1 * omega2;
+			a2 = a2Start + s1 * omega2;
+
+			b2Conservative.R1.Set(a1);
+			b2Conservative.R2.Set(a2);
+			shape1.QuickSync(p1, b2Conservative.R1);
+			shape2.QuickSync(p2, b2Conservative.R2);
+		}
+
+		if (hit)
+		{
+			// Hit, move bodies to safe position and re-sync shapes.
+			//b2Vec2 d = b2Conservative.x2 - b2Conservative.x1;
+			dX = b2Conservative.x2.x - b2Conservative.x1.x;
+			dY = b2Conservative.x2.y - b2Conservative.x1.y;
+			//float32 length = d.Length();
+			var length = Math.sqrt(dX*dX + dY*dY);
+			if (length > FLT_EPSILON)
+			{
+				d *= b2_linearSlop / length;
+			}
+
+			if (body1.IsStatic())
+			{
+				//body1.m_position = p1;
+				body1.m_position.x = p1X;
+				body1.m_position.y = p1Y;
+			}
+			else
+			{
+				//body1.m_position = p1 - d;
+				body1.m_position.x = p1X - dX;
+				body1.m_position.y = p1Y - dY;
+			}
+			body1.m_rotation = a1;
+			body1.m_R.Set(a1);
+			body1.QuickSyncShapes();
+
+			if (body2.IsStatic())
+			{
+				//body2->m_position = p2;
+				body2.m_position.x = p2X;
+				body2.m_position.y = p2Y;
+			}
+			else
+			{
+				//body2->m_position = p2 + d;
+				body2.m_position.x = p2X + dX;
+				body2.m_position.y = p2Y + dY;
+			}
+			//body2.m_position = p2 + d;
+			body2.m_position.x = p2X + dX;
+			body2.m_position.y = p2Y + dY;
+			body2.m_rotation = a2;
+			body2.m_R.Set(a2);
+			body2.QuickSyncShapes();
+
+			return true;
+		}
+
+		// No hit, restore shapes.
+		shape1.QuickSync(body1.m_position, body1.m_R);
+		shape2.QuickSync(body2.m_position, body2.m_R);
+		return false;
+	};

data/vendor/assets/javascripts/box2d/dynamics/contacts/b2Contact.js

@@ -0,0 +1,201 @@
+/*
+* Copyright (c) 2006-2007 Erin Catto http:
+*
+* This software is provided 'as-is', without any express or implied
+* warranty.  In no event will the authors be held liable for any damages
+* arising from the use of this software.
+* Permission is granted to anyone to use this software for any purpose,
+* including commercial applications, and to alter it and redistribute it
+* freely, subject to the following restrictions:
+* 1. The origin of this software must not be misrepresented; you must not
+* claim that you wrote the original software. If you use this software
+* in a product, an acknowledgment in the product documentation would be
+* appreciated but is not required.
+* 2. Altered source versions must be plainly marked, and must not be
+* misrepresented the original software.
+* 3. This notice may not be removed or altered from any source distribution.
+*/
+
+
+
+
+
+//typedef b2Contact* b2ContactCreateFcn(b2Shape* shape1, b2Shape* shape2, b2BlockAllocator* allocator);
+//typedef void b2ContactDestroyFcn(b2Contact* contact, b2BlockAllocator* allocator);
+
+
+
+var b2Contact = Class.create();
+b2Contact.prototype = 
+{
+	GetManifolds: function(){return null},
+	GetManifoldCount: function()
+	{
+		return this.m_manifoldCount;
+	},
+
+	GetNext: function(){
+		return this.m_next;
+	},
+
+	GetShape1: function(){
+		return this.m_shape1;
+	},
+
+	GetShape2: function(){
+		return this.m_shape2;
+	},
+
+	//--------------- Internals Below -------------------
+
+	// this.m_flags
+	// enum
+
+
+	initialize: function(s1, s2)
+	{
+		// initialize instance variables for references
+		this.m_node1 = new b2ContactNode();
+		this.m_node2 = new b2ContactNode();
+		//
+
+		this.m_flags = 0;
+
+		if (!s1 || !s2){
+			this.m_shape1 = null;
+			this.m_shape2 = null;
+			return;
+		}
+
+		this.m_shape1 = s1;
+		this.m_shape2 = s2;
+
+		this.m_manifoldCount = 0;
+
+		this.m_friction = Math.sqrt(this.m_shape1.m_friction * this.m_shape2.m_friction);
+		this.m_restitution = b2Math.b2Max(this.m_shape1.m_restitution, this.m_shape2.m_restitution);
+
+		this.m_prev = null;
+		this.m_next = null;
+
+		this.m_node1.contact = null;
+		this.m_node1.prev = null;
+		this.m_node1.next = null;
+		this.m_node1.other = null;
+
+		this.m_node2.contact = null;
+		this.m_node2.prev = null;
+		this.m_node2.next = null;
+		this.m_node2.other = null;
+	},
+
+	//virtual ~b2Contact() {}
+
+	Evaluate: function(){},
+
+	m_flags: 0,
+
+	// World pool and list pointers.
+	m_prev: null,
+	m_next: null,
+
+	// Nodes for connecting bodies.
+	m_node1: new b2ContactNode(),
+	m_node2: new b2ContactNode(),
+
+	m_shape1: null,
+	m_shape2: null,
+
+	m_manifoldCount: 0,
+
+	// Combined friction
+	m_friction: null,
+	m_restitution: null};
+b2Contact.e_islandFlag = 0x0001;
+b2Contact.e_destroyFlag = 0x0002;
+b2Contact.AddType = function(createFcn, destroyFcn, type1, type2)
+	{
+		//b2Settings.b2Assert(b2Shape.e_unknownShape < type1 && type1 < b2Shape.e_shapeTypeCount);
+		//b2Settings.b2Assert(b2Shape.e_unknownShape < type2 && type2 < b2Shape.e_shapeTypeCount);
+
+		b2Contact.s_registers[type1][type2].createFcn = createFcn;
+		b2Contact.s_registers[type1][type2].destroyFcn = destroyFcn;
+		b2Contact.s_registers[type1][type2].primary = true;
+
+		if (type1 != type2)
+		{
+			b2Contact.s_registers[type2][type1].createFcn = createFcn;
+			b2Contact.s_registers[type2][type1].destroyFcn = destroyFcn;
+			b2Contact.s_registers[type2][type1].primary = false;
+		}
+	};
+b2Contact.InitializeRegisters = function(){
+		b2Contact.s_registers = new Array(b2Shape.e_shapeTypeCount);
+		for (var i = 0; i < b2Shape.e_shapeTypeCount; i++){
+			b2Contact.s_registers[i] = new Array(b2Shape.e_shapeTypeCount);
+			for (var j = 0; j < b2Shape.e_shapeTypeCount; j++){
+				b2Contact.s_registers[i][j] = new b2ContactRegister();
+			}
+		}
+
+		b2Contact.AddType(b2CircleContact.Create, b2CircleContact.Destroy, b2Shape.e_circleShape, b2Shape.e_circleShape);
+		b2Contact.AddType(b2PolyAndCircleContact.Create, b2PolyAndCircleContact.Destroy, b2Shape.e_polyShape, b2Shape.e_circleShape);
+		b2Contact.AddType(b2PolyContact.Create, b2PolyContact.Destroy, b2Shape.e_polyShape, b2Shape.e_polyShape);
+
+	};
+b2Contact.Create = function(shape1, shape2, allocator){
+		if (b2Contact.s_initialized == false)
+		{
+			b2Contact.InitializeRegisters();
+			b2Contact.s_initialized = true;
+		}
+
+		var type1 = shape1.m_type;
+		var type2 = shape2.m_type;
+
+		//b2Settings.b2Assert(b2Shape.e_unknownShape < type1 && type1 < b2Shape.e_shapeTypeCount);
+		//b2Settings.b2Assert(b2Shape.e_unknownShape < type2 && type2 < b2Shape.e_shapeTypeCount);
+
+		var createFcn = b2Contact.s_registers[type1][type2].createFcn;
+		if (createFcn)
+		{
+			if (b2Contact.s_registers[type1][type2].primary)
+			{
+				return createFcn(shape1, shape2, allocator);
+			}
+			else
+			{
+				var c = createFcn(shape2, shape1, allocator);
+				for (var i = 0; i < c.GetManifoldCount(); ++i)
+				{
+					var m = c.GetManifolds()[ i ];
+					m.normal = m.normal.Negative();
+				}
+				return c;
+			}
+		}
+		else
+		{
+			return null;
+		}
+	};
+b2Contact.Destroy = function(contact, allocator){
+		//b2Settings.b2Assert(b2Contact.s_initialized == true);
+
+		if (contact.GetManifoldCount() > 0)
+		{
+			contact.m_shape1.m_body.WakeUp();
+			contact.m_shape2.m_body.WakeUp();
+		}
+
+		var type1 = contact.m_shape1.m_type;
+		var type2 = contact.m_shape2.m_type;
+
+		//b2Settings.b2Assert(b2Shape.e_unknownShape < type1 && type1 < b2Shape.e_shapeTypeCount);
+		//b2Settings.b2Assert(b2Shape.e_unknownShape < type2 && type2 < b2Shape.e_shapeTypeCount);
+
+		var destroyFcn = b2Contact.s_registers[type1][type2].destroyFcn;
+		destroyFcn(contact, allocator);
+	};
+b2Contact.s_registers = null;
+b2Contact.s_initialized = false;