box2d-rails 0.0.1

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

@@ -0,0 +1,331 @@
+/*
+* 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.
+*/
+
+
+
+
+
+/*
+Position Correction Notes
+=========================
+I tried the several algorithms for position correction of the 2D revolute joint.
+I looked at these systems:
+- simple pendulum (1m diameter sphere on massless 5m stick) with initial angular velocity of 100 rad/s.
+- suspension bridge with 30 1m long planks of length 1m.
+- multi-link chain with 30 1m long links.
+
+Here are the algorithms:
+
+Baumgarte - A fraction of the position error is added to the velocity error. There is no
+separate position solver.
+
+Pseudo Velocities - After the velocity solver and position integration,
+the position error, Jacobian, and effective mass are recomputed. Then
+the velocity constraints are solved with pseudo velocities and a fraction
+of the position error is added to the pseudo velocity error. The pseudo
+velocities are initialized to zero and there is no warm-starting. After
+the position solver, the pseudo velocities are added to the positions.
+This is also called the First Order World method or the Position LCP method.
+
+Modified Nonlinear Gauss-Seidel (NGS) - Like Pseudo Velocities except the
+position error is re-computed for each constraint and the positions are updated
+after the constraint is solved. The radius vectors (aka Jacobians) are
+re-computed too (otherwise the algorithm has horrible instability). The pseudo
+velocity states are not needed because they are effectively zero at the beginning
+of each iteration. Since we have the current position error, we allow the
+iterations to terminate early if the error becomes smaller than b2_linearSlop.
+
+Full NGS or just NGS - Like Modified NGS except the effective mass are re-computed
+each time a constraint is solved.
+
+Here are the results:
+Baumgarte - this is the cheapest algorithm but it has some stability problems,
+especially with the bridge. The chain links separate easily close to the root
+and they jitter struggle to pull together. This is one of the most common
+methods in the field. The big drawback is that the position correction artificially
+affects the momentum, thus leading to instabilities and false bounce. I used a
+bias factor of 0.2. A larger bias factor makes the bridge less stable, a smaller
+factor makes joints and contacts more spongy.
+
+Pseudo Velocities - the is more stable than the Baumgarte method. The bridge is
+stable. However, joints still separate with large angular velocities. Drag the
+simple pendulum in a circle quickly and the joint will separate. The chain separates
+easily and does not recover. I used a bias factor of 0.2. A larger value lead to
+the bridge collapsing when a heavy cube drops on it.
+
+Modified NGS - this algorithm is better in some ways than Baumgarte and Pseudo
+Velocities, but in other ways it is worse. The bridge and chain are much more
+stable, but the simple pendulum goes unstable at high angular velocities.
+
+Full NGS - stable in all tests. The joints display good stiffness. The bridge
+still sags, but this is better than infinite forces.
+
+Recommendations
+Pseudo Velocities are not really worthwhile because the bridge and chain cannot
+recover from joint separation. In other cases the benefit over Baumgarte is small.
+
+Modified NGS is not a robust method for the revolute joint due to the violent
+instability seen in the simple pendulum. Perhaps it is viable with other constraint
+types, especially scalar constraints where the effective mass is a scalar.
+
+This leaves Baumgarte and Full NGS. Baumgarte has small, but manageable instabilities
+and is very fast. I don't think we can escape Baumgarte, especially in highly
+demanding cases where high constraint fidelity is not needed.
+
+Full NGS is robust and easy on the eyes. I recommend this option for
+higher fidelity simulation and certainly for suspension bridges and long chains.
+Full NGS might be a good choice for ragdolls, especially motorized ragdolls where
+joint separation can be problematic. The number of NGS iterations can be reduced
+for better performance without harming robustness much.
+
+Each joint in a can be handled differently in the position solver. So I recommend
+a system where the user can select the algorithm on a per joint basis. I would
+probably default to the slower Full NGS and let the user select the faster
+Baumgarte method in performance critical scenarios.
+*/
+
+
+var b2Island = Class.create();
+b2Island.prototype = 
+{
+	initialize: function(bodyCapacity, contactCapacity, jointCapacity, allocator)
+	{
+		var i = 0;
+
+		this.m_bodyCapacity = bodyCapacity;
+		this.m_contactCapacity = contactCapacity;
+		this.m_jointCapacity	 = jointCapacity;
+		this.m_bodyCount = 0;
+		this.m_contactCount = 0;
+		this.m_jointCount = 0;
+
+
+		//this.m_bodies = (b2Body**)allocator->Allocate(bodyCapacity * sizeof(b2Body*));
+		this.m_bodies = new Array(bodyCapacity);
+		for (i = 0; i < bodyCapacity; i++)
+			this.m_bodies[i] = null;
+
+		//this.m_contacts = (b2Contact**)allocator->Allocate(contactCapacity	 * sizeof(b2Contact*));
+		this.m_contacts = new Array(contactCapacity);
+		for (i = 0; i < contactCapacity; i++)
+			this.m_contacts[i] = null;
+
+		//this.m_joints = (b2Joint**)allocator->Allocate(jointCapacity * sizeof(b2Joint*));
+		this.m_joints = new Array(jointCapacity);
+		for (i = 0; i < jointCapacity; i++)
+			this.m_joints[i] = null;
+
+		this.m_allocator = allocator;
+	},
+	//~b2Island();
+
+	Clear: function()
+	{
+		this.m_bodyCount = 0;
+		this.m_contactCount = 0;
+		this.m_jointCount = 0;
+	},
+
+	Solve: function(step, gravity)
+	{
+		var i = 0;
+		var b;
+
+		for (i = 0; i < this.m_bodyCount; ++i)
+		{
+			b = this.m_bodies[i];
+
+			if (b.m_invMass == 0.0)
+				continue;
+
+			b.m_linearVelocity.Add( b2Math.MulFV (step.dt, b2Math.AddVV(gravity, b2Math.MulFV( b.m_invMass, b.m_force ) ) ) );
+			b.m_angularVelocity += step.dt * b.m_invI * b.m_torque;
+
+			//b.m_linearVelocity *= b.m_linearDamping;
+			b.m_linearVelocity.Multiply(b.m_linearDamping);
+			b.m_angularVelocity *= b.m_angularDamping;
+
+			// Store positions for conservative advancement.
+			b.m_position0.SetV(b.m_position);
+			b.m_rotation0 = b.m_rotation;
+		}
+
+		var contactSolver = new b2ContactSolver(this.m_contacts, this.m_contactCount, this.m_allocator);
+
+		// Pre-solve
+		contactSolver.PreSolve();
+
+		for (i = 0; i < this.m_jointCount; ++i)
+		{
+			this.m_joints[i].PrepareVelocitySolver();
+		}
+
+		// this.Solve velocity constraints.
+		for (i = 0; i < step.iterations; ++i)
+		{
+			contactSolver.SolveVelocityConstraints();
+
+			for (var j = 0; j < this.m_jointCount; ++j)
+			{
+				this.m_joints[j].SolveVelocityConstraints(step);
+			}
+		}
+
+		// Integrate positions.
+		for (i = 0; i < this.m_bodyCount; ++i)
+		{
+			b = this.m_bodies[i];
+
+			if (b.m_invMass == 0.0)
+				continue;
+
+			//b.m_position.Add( b2Math.MulFV (step.dt, b.m_linearVelocity) );
+			b.m_position.x += step.dt * b.m_linearVelocity.x;
+			b.m_position.y += step.dt * b.m_linearVelocity.y;
+			b.m_rotation += step.dt * b.m_angularVelocity;
+
+			b.m_R.Set(b.m_rotation);
+		}
+
+		for (i = 0; i < this.m_jointCount; ++i)
+		{
+			this.m_joints[i].PreparePositionSolver();
+		}
+
+		// this.Solve position constraints.
+		if (b2World.s_enablePositionCorrection)
+		{
+			for (b2Island.m_positionIterationCount = 0; b2Island.m_positionIterationCount < step.iterations; ++b2Island.m_positionIterationCount)
+			{
+				var contactsOkay = contactSolver.SolvePositionConstraints(b2Settings.b2_contactBaumgarte);
+
+				var jointsOkay = true;
+				for (i = 0; i < this.m_jointCount; ++i)
+				{
+					var jointOkay = this.m_joints[i].SolvePositionConstraints();
+					jointsOkay = jointsOkay && jointOkay;
+				}
+
+				if (contactsOkay && jointsOkay)
+				{
+					break;
+				}
+			}
+		}
+
+		// Post-solve.
+		contactSolver.PostSolve();
+
+		// Synchronize shapes and reset forces.
+		for (i = 0; i < this.m_bodyCount; ++i)
+		{
+			b = this.m_bodies[i];
+
+			if (b.m_invMass == 0.0)
+				continue;
+
+			b.m_R.Set(b.m_rotation);
+
+			b.SynchronizeShapes();
+			b.m_force.Set(0.0, 0.0);
+			b.m_torque = 0.0;
+		}
+	},
+
+	UpdateSleep: function(dt)
+	{
+		var i = 0;
+		var b;
+
+		var minSleepTime = Number.MAX_VALUE;
+
+		var linTolSqr = b2Settings.b2_linearSleepTolerance * b2Settings.b2_linearSleepTolerance;
+		var angTolSqr = b2Settings.b2_angularSleepTolerance * b2Settings.b2_angularSleepTolerance;
+
+		for (i = 0; i < this.m_bodyCount; ++i)
+		{
+			b = this.m_bodies[i];
+			if (b.m_invMass == 0.0)
+			{
+				continue;
+			}
+
+			if ((b.m_flags & b2Body.e_allowSleepFlag) == 0)
+			{
+				b.m_sleepTime = 0.0;
+				minSleepTime = 0.0;
+			}
+
+			if ((b.m_flags & b2Body.e_allowSleepFlag) == 0 ||
+				b.m_angularVelocity * b.m_angularVelocity > angTolSqr ||
+				b2Math.b2Dot(b.m_linearVelocity, b.m_linearVelocity) > linTolSqr)
+			{
+				b.m_sleepTime = 0.0;
+				minSleepTime = 0.0;
+			}
+			else
+			{
+				b.m_sleepTime += dt;
+				minSleepTime = b2Math.b2Min(minSleepTime, b.m_sleepTime);
+			}
+		}
+
+		if (minSleepTime >= b2Settings.b2_timeToSleep)
+		{
+			for (i = 0; i < this.m_bodyCount; ++i)
+			{
+				b = this.m_bodies[i];
+				b.m_flags |= b2Body.e_sleepFlag;
+			}
+		}
+	},
+
+	AddBody: function(body)
+	{
+		//b2Settings.b2Assert(this.m_bodyCount < this.m_bodyCapacity);
+		this.m_bodies[this.m_bodyCount++] = body;
+	},
+
+	AddContact: function(contact)
+	{
+		//b2Settings.b2Assert(this.m_contactCount < this.m_contactCapacity);
+		this.m_contacts[this.m_contactCount++] = contact;
+	},
+
+	AddJoint: function(joint)
+	{
+		//b2Settings.b2Assert(this.m_jointCount < this.m_jointCapacity);
+		this.m_joints[this.m_jointCount++] = joint;
+	},
+
+	m_allocator: null,
+
+	m_bodies: null,
+	m_contacts: null,
+	m_joints: null,
+
+	m_bodyCount: 0,
+	m_jointCount: 0,
+	m_contactCount: 0,
+
+	m_bodyCapacity: 0,
+	m_contactCapacity: 0,
+	m_jointCapacity: 0,
+
+	m_positionError: null};
+b2Island.m_positionIterationCount = 0;

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

@@ -0,0 +1,27 @@
+/*
+* 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 b2TimeStep = Class.create();
+b2TimeStep.prototype = 
+{
+	dt: null,
+	inv_dt: null,
+	iterations: 0,
+	initialize: function() {}};

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

@@ -0,0 +1,522 @@
+/*
+* 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 b2World = Class.create();
+b2World.prototype = 
+{
+	initialize: function(worldAABB, gravity, doSleep){
+		// initialize instance variables for references
+		this.step = new b2TimeStep();
+		this.m_contactManager = new b2ContactManager();
+		//
+
+
+		this.m_listener = null;
+		this.m_filter = b2CollisionFilter.b2_defaultFilter;
+
+		this.m_bodyList = null;
+		this.m_contactList = null;
+		this.m_jointList = null;
+
+		this.m_bodyCount = 0;
+		this.m_contactCount = 0;
+		this.m_jointCount = 0;
+
+		this.m_bodyDestroyList = null;
+
+		this.m_allowSleep = doSleep;
+
+		this.m_gravity = gravity;
+
+		this.m_contactManager.m_world = this;
+		this.m_broadPhase = new b2BroadPhase(worldAABB, this.m_contactManager);
+
+		var bd = new b2BodyDef();
+		this.m_groundBody = this.CreateBody(bd);
+	},
+	//~b2World(){
+	//	this.DestroyBody(this.m_groundBody);
+	//	delete this.m_broadPhase;
+	//}
+
+	// Set a callback to notify you when a joint is implicitly destroyed
+	// when an attached body is destroyed.
+	SetListener: function(listener){
+		this.m_listener = listener;
+	},
+
+	// Register a collision filter to provide specific control over collision.
+	// Otherwise the default filter is used (b2CollisionFilter).
+	SetFilter: function(filter){
+		this.m_filter = filter;
+	},
+
+	// Create and destroy rigid bodies. Destruction is deferred until the
+	// the next call to this.Step. This is done so that bodies may be destroyed
+	// while you iterate through the contact list.
+	CreateBody: function(def){
+		//void* mem = this.m_blockAllocator.Allocate(sizeof(b2Body));
+		var b = new b2Body(def, this);
+		b.m_prev = null;
+
+		b.m_next = this.m_bodyList;
+		if (this.m_bodyList)
+		{
+			this.m_bodyList.m_prev = b;
+		}
+		this.m_bodyList = b;
+		++this.m_bodyCount;
+
+		return b;
+	},
+	// Body destruction is deferred to make contact processing more robust.
+	DestroyBody: function(b)
+	{
+
+		if (b.m_flags & b2Body.e_destroyFlag)
+		{
+			return;
+		}
+
+		// Remove from normal body list.
+		if (b.m_prev)
+		{
+			b.m_prev.m_next = b.m_next;
+		}
+
+		if (b.m_next)
+		{
+			b.m_next.m_prev = b.m_prev;
+		}
+
+		if (b == this.m_bodyList)
+		{
+			this.m_bodyList = b.m_next;
+		}
+
+		b.m_flags |= b2Body.e_destroyFlag;
+		//b2Settings.b2Assert(this.m_bodyCount > 0);
+		--this.m_bodyCount;
+
+		//b->~b2Body();
+		//b.Destroy();
+		// Add to the deferred destruction list.
+		b.m_prev = null;
+		b.m_next = this.m_bodyDestroyList;
+		this.m_bodyDestroyList = b;
+	},
+
+	CleanBodyList: function()
+	{
+		this.m_contactManager.m_destroyImmediate = true;
+
+		var b = this.m_bodyDestroyList;
+		while (b)
+		{
+			//b2Settings.b2Assert((b.m_flags & b2Body.e_destroyFlag) != 0);
+
+			// Preserve the next pointer.
+			var b0 = b;
+			b = b.m_next;
+
+			// Delete the attached joints
+			var jn = b0.m_jointList;
+			while (jn)
+			{
+				var jn0 = jn;
+				jn = jn.next;
+
+				if (this.m_listener)
+				{
+					this.m_listener.NotifyJointDestroyed(jn0.joint);
+				}
+
+				this.DestroyJoint(jn0.joint);
+			}
+
+			b0.Destroy();
+			//this.m_blockAllocator.Free(b0, sizeof(b2Body));
+		}
+
+		// Reset the list.
+		this.m_bodyDestroyList = null;
+
+		this.m_contactManager.m_destroyImmediate = false;
+	},
+
+	CreateJoint: function(def){
+		var j = b2Joint.Create(def, this.m_blockAllocator);
+
+		// Connect to the world list.
+		j.m_prev = null;
+		j.m_next = this.m_jointList;
+		if (this.m_jointList)
+		{
+			this.m_jointList.m_prev = j;
+		}
+		this.m_jointList = j;
+		++this.m_jointCount;
+
+		// Connect to the bodies
+		j.m_node1.joint = j;
+		j.m_node1.other = j.m_body2;
+		j.m_node1.prev = null;
+		j.m_node1.next = j.m_body1.m_jointList;
+		if (j.m_body1.m_jointList) j.m_body1.m_jointList.prev = j.m_node1;
+		j.m_body1.m_jointList = j.m_node1;
+
+		j.m_node2.joint = j;
+		j.m_node2.other = j.m_body1;
+		j.m_node2.prev = null;
+		j.m_node2.next = j.m_body2.m_jointList;
+		if (j.m_body2.m_jointList) j.m_body2.m_jointList.prev = j.m_node2;
+		j.m_body2.m_jointList = j.m_node2;
+
+		// If the joint prevents collisions, then reset collision filtering.
+		if (def.collideConnected == false)
+		{
+			// Reset the proxies on the body with the minimum number of shapes.
+			var b = def.body1.m_shapeCount < def.body2.m_shapeCount ? def.body1 : def.body2;
+			for (var s = b.m_shapeList; s; s = s.m_next)
+			{
+				s.ResetProxy(this.m_broadPhase);
+			}
+		}
+
+		return j;
+	},
+	DestroyJoint: function(j)
+	{
+
+		var collideConnected = j.m_collideConnected;
+
+		// Remove from the world.
+		if (j.m_prev)
+		{
+			j.m_prev.m_next = j.m_next;
+		}
+
+		if (j.m_next)
+		{
+			j.m_next.m_prev = j.m_prev;
+		}
+
+		if (j == this.m_jointList)
+		{
+			this.m_jointList = j.m_next;
+		}
+
+		// Disconnect from island graph.
+		var body1 = j.m_body1;
+		var body2 = j.m_body2;
+
+		// Wake up touching bodies.
+		body1.WakeUp();
+		body2.WakeUp();
+
+		// Remove from body 1
+		if (j.m_node1.prev)
+		{
+			j.m_node1.prev.next = j.m_node1.next;
+		}
+
+		if (j.m_node1.next)
+		{
+			j.m_node1.next.prev = j.m_node1.prev;
+		}
+
+		if (j.m_node1 == body1.m_jointList)
+		{
+			body1.m_jointList = j.m_node1.next;
+		}
+
+		j.m_node1.prev = null;
+		j.m_node1.next = null;
+
+		// Remove from body 2
+		if (j.m_node2.prev)
+		{
+			j.m_node2.prev.next = j.m_node2.next;
+		}
+
+		if (j.m_node2.next)
+		{
+			j.m_node2.next.prev = j.m_node2.prev;
+		}
+
+		if (j.m_node2 == body2.m_jointList)
+		{
+			body2.m_jointList = j.m_node2.next;
+		}
+
+		j.m_node2.prev = null;
+		j.m_node2.next = null;
+
+		b2Joint.Destroy(j, this.m_blockAllocator);
+
+		//b2Settings.b2Assert(this.m_jointCount > 0);
+		--this.m_jointCount;
+
+		// If the joint prevents collisions, then reset collision filtering.
+		if (collideConnected == false)
+		{
+			// Reset the proxies on the body with the minimum number of shapes.
+			var b = body1.m_shapeCount < body2.m_shapeCount ? body1 : body2;
+			for (var s = b.m_shapeList; s; s = s.m_next)
+			{
+				s.ResetProxy(this.m_broadPhase);
+			}
+		}
+	},
+
+	// The world provides a single ground body with no collision shapes. You
+	// can use this to simplify the creation of joints.
+	GetGroundBody: function(){
+		return this.m_groundBody;
+	},
+
+
+	step: new b2TimeStep(),
+	// this.Step
+	Step: function(dt, iterations){
+
+		var b;
+		var other;
+
+
+		this.step.dt = dt;
+		this.step.iterations	= iterations;
+		if (dt > 0.0)
+		{
+			this.step.inv_dt = 1.0 / dt;
+		}
+		else
+		{
+			this.step.inv_dt = 0.0;
+		}
+
+		this.m_positionIterationCount = 0;
+
+		// Handle deferred contact destruction.
+		this.m_contactManager.CleanContactList();
+
+		// Handle deferred body destruction.
+		this.CleanBodyList();
+
+		// Update contacts.
+		this.m_contactManager.Collide();
+
+		// Size the island for the worst case.
+		var island = new b2Island(this.m_bodyCount, this.m_contactCount, this.m_jointCount, this.m_stackAllocator);
+
+		// Clear all the island flags.
+		for (b = this.m_bodyList; b != null; b = b.m_next)
+		{
+			b.m_flags &= ~b2Body.e_islandFlag;
+		}
+		for (var c = this.m_contactList; c != null; c = c.m_next)
+		{
+			c.m_flags &= ~b2Contact.e_islandFlag;
+		}
+		for (var j = this.m_jointList; j != null; j = j.m_next)
+		{
+			j.m_islandFlag = false;
+		}
+
+		// Build and simulate all awake islands.
+		var stackSize = this.m_bodyCount;
+		//var stack = (b2Body**)this.m_stackAllocator.Allocate(stackSize * sizeof(b2Body*));
+		var stack = new Array(this.m_bodyCount);
+		for (var k = 0; k < this.m_bodyCount; k++)
+			stack[k] = null;
+
+		for (var seed = this.m_bodyList; seed != null; seed = seed.m_next)
+		{
+			if (seed.m_flags & (b2Body.e_staticFlag | b2Body.e_islandFlag | b2Body.e_sleepFlag | b2Body.e_frozenFlag))
+			{
+				continue;
+			}
+
+			// Reset island and stack.
+			island.Clear();
+			var stackCount = 0;
+			stack[stackCount++] = seed;
+			seed.m_flags |= b2Body.e_islandFlag;;
+
+			// Perform a depth first search (DFS) on the constraint graph.
+			while (stackCount > 0)
+			{
+				// Grab the next body off the stack and add it to the island.
+				b = stack[--stackCount];
+				island.AddBody(b);
+
+				// Make sure the body is awake.
+				b.m_flags &= ~b2Body.e_sleepFlag;
+
+				// To keep islands, we don't
+				// propagate islands across static bodies.
+				if (b.m_flags & b2Body.e_staticFlag)
+				{
+					continue;
+				}
+
+				// Search all contacts connected to this body.
+				for (var cn = b.m_contactList; cn != null; cn = cn.next)
+				{
+					if (cn.contact.m_flags & b2Contact.e_islandFlag)
+					{
+						continue;
+					}
+
+					island.AddContact(cn.contact);
+					cn.contact.m_flags |= b2Contact.e_islandFlag;
+
+					other = cn.other;
+					if (other.m_flags & b2Body.e_islandFlag)
+					{
+						continue;
+					}
+
+					//b2Settings.b2Assert(stackCount < stackSize);
+					stack[stackCount++] = other;
+					other.m_flags |= b2Body.e_islandFlag;
+				}
+
+				// Search all joints connect to this body.
+				for (var jn = b.m_jointList; jn != null; jn = jn.next)
+				{
+					if (jn.joint.m_islandFlag == true)
+					{
+						continue;
+					}
+
+					island.AddJoint(jn.joint);
+					jn.joint.m_islandFlag = true;
+
+					other = jn.other;
+					if (other.m_flags & b2Body.e_islandFlag)
+					{
+						continue;
+					}
+
+					//b2Settings.b2Assert(stackCount < stackSize);
+					stack[stackCount++] = other;
+					other.m_flags |= b2Body.e_islandFlag;
+				}
+			}
+
+			island.Solve(this.step, this.m_gravity);
+
+			this.m_positionIterationCount = b2Math.b2Max(this.m_positionIterationCount, b2Island.m_positionIterationCount);
+
+			if (this.m_allowSleep)
+			{
+				island.UpdateSleep(dt);
+			}
+
+			// Post solve cleanup.
+			for (var i = 0; i < island.m_bodyCount; ++i)
+			{
+				// Allow static bodies to participate in other islands.
+				b = island.m_bodies[i];
+				if (b.m_flags & b2Body.e_staticFlag)
+				{
+					b.m_flags &= ~b2Body.e_islandFlag;
+				}
+
+				// Handle newly frozen bodies.
+				if (b.IsFrozen() && this.m_listener)
+				{
+					var response = this.m_listener.NotifyBoundaryViolated(b);
+					if (response == b2WorldListener.b2_destroyBody)
+					{
+						this.DestroyBody(b);
+						b = null;
+						island.m_bodies[i] = null;
+					}
+				}
+			}
+		}
+
+		this.m_broadPhase.Commit();
+
+		//this.m_stackAllocator.Free(stack);
+	},
+
+	// this.Query the world for all shapes that potentially overlap the
+	// provided AABB. You provide a shape pointer buffer of specified
+	// size. The number of shapes found is returned.
+	Query: function(aabb, shapes, maxCount){
+
+		//void** results = (void**)this.m_stackAllocator.Allocate(maxCount * sizeof(void*));
+		var results = new Array();
+		var count = this.m_broadPhase.QueryAABB(aabb, results, maxCount);
+
+		for (var i = 0; i < count; ++i)
+		{
+			shapes[i] = results[i];
+		}
+
+		//this.m_stackAllocator.Free(results);
+		return count;
+	},
+
+	// You can use these to iterate over all the bodies, joints, and contacts.
+	GetBodyList: function(){
+		return this.m_bodyList;
+	},
+	GetJointList: function(){
+		return this.m_jointList;
+	},
+	GetContactList: function(){
+		return this.m_contactList;
+	},
+
+	//--------------- Internals Below -------------------
+
+	m_blockAllocator: null,
+	m_stackAllocator: null,
+
+	m_broadPhase: null,
+	m_contactManager: new b2ContactManager(),
+
+	m_bodyList: null,
+	m_contactList: null,
+	m_jointList: null,
+
+	m_bodyCount: 0,
+	m_contactCount: 0,
+	m_jointCount: 0,
+
+	// These bodies will be destroyed at the next time this.step.
+	m_bodyDestroyList: null,
+
+	m_gravity: null,
+	m_allowSleep: null,
+
+	m_groundBody: null,
+
+	m_listener: null,
+	m_filter: null,
+
+	m_positionIterationCount: 0};
+b2World.s_enablePositionCorrection = 1;
+b2World.s_enableWarmStarting = 1;