box2d-rails 0.0.1

data/vendor/assets/javascripts/box2d/collision/shapes/b2Shape.js

@@ -0,0 +1,339 @@
+/*
+* 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.
+*/
+
+
+
+
+
+
+
+
+// Shapes are created automatically when a body is created.
+// Client code does not normally interact with shapes.
+var b2Shape = Class.create();
+b2Shape.prototype = 
+{
+	TestPoint: function(p){return false},
+
+	GetUserData: function(){return this.m_userData;},
+
+	GetType: function(){
+		return this.m_type;
+	},
+
+	// Get the parent body of this shape.
+	GetBody: function(){
+		return this.m_body;
+	},
+
+	GetPosition: function(){
+		return this.m_position;
+	},
+	GetRotationMatrix: function(){
+		return this.m_R;
+	},
+
+	// Remove and then add proxy from the broad-phase.
+	// This is used to refresh the collision filters.
+	ResetProxy: function(broadPhase){},
+
+	// Get the next shape in the parent body's shape list.
+	GetNext: function(){
+		return this.m_next;
+	},
+
+	//--------------- Internals Below -------------------
+
+
+
+
+	initialize: function(def, body){
+		// initialize instance variables for references
+		this.m_R = new b2Mat22();
+		this.m_position = new b2Vec2();
+		//
+
+		this.m_userData = def.userData;
+
+		this.m_friction = def.friction;
+		this.m_restitution = def.restitution;
+		this.m_body = body;
+
+		this.m_proxyId = b2Pair.b2_nullProxy;
+
+		this.m_maxRadius = 0.0;
+
+		this.m_categoryBits = def.categoryBits;
+		this.m_maskBits = def.maskBits;
+		this.m_groupIndex = def.groupIndex;
+	},
+
+	// Internal use only. Do not call.
+	//b2Shape::~b2Shape()
+	//{
+	//	this.m_body->m_world->m_broadPhase->this.DestroyProxy(this.m_proxyId);
+	//}
+
+
+	DestroyProxy: function()
+	{
+		if (this.m_proxyId != b2Pair.b2_nullProxy)
+		{
+			this.m_body.m_world.m_broadPhase.DestroyProxy(this.m_proxyId);
+			this.m_proxyId = b2Pair.b2_nullProxy;
+		}
+	},
+
+
+	// Internal use only. Do not call.
+	Synchronize: function(position1, R1, position2, R2){},
+	QuickSync: function(position, R){},
+	Support: function(dX, dY, out){},
+	GetMaxRadius: function(){
+		return this.m_maxRadius;
+	},
+
+	m_next: null,
+
+	m_R: new b2Mat22(),
+	m_position: new b2Vec2(),
+
+	m_type: 0,
+
+	m_userData: null,
+
+	m_body: null,
+
+	m_friction: null,
+	m_restitution: null,
+
+	m_maxRadius: null,
+
+	m_proxyId: 0,
+	m_categoryBits: 0,
+	m_maskBits: 0,
+	m_groupIndex: 0
+
+
+
+	// b2ShapeType
+
+
+
+
+
+
+
+
+
+
+
+
+};
+
+
+b2Shape.Create = function(def, body, center){
+		switch (def.type)
+		{
+		case b2Shape.e_circleShape:
+			{
+				//void* mem = body->m_world->m_blockAllocator.Allocate(sizeof(b2CircleShape));
+				return new b2CircleShape(def, body, center);
+			}
+
+		case b2Shape.e_boxShape:
+		case b2Shape.e_polyShape:
+			{
+				//void* mem = body->m_world->m_blockAllocator.Allocate(sizeof(b2PolyShape));
+				return new b2PolyShape(def, body, center);
+			}
+		}
+
+		//b2Settings.b2Assert(false);
+		return null;
+	};
+b2Shape.Destroy = function(shape)
+	{
+		/*b2BlockAllocator& allocator = shape->m_body->m_world->m_blockAllocator;
+
+		switch (shape.m_type)
+		{
+		case b2Shape.e_circleShape:
+			shape->~b2Shape();
+			allocator.Free(shape, sizeof(b2CircleShape));
+			break;
+
+		case b2Shape.e_polyShape:
+			shape->~b2Shape();
+			allocator.Free(shape, sizeof(b2PolyShape));
+			break;
+
+		default:
+			b2Assert(false);
+		}
+
+		shape = NULL;*/
+
+		// FROM DESTRUCTOR
+		if (shape.m_proxyId != b2Pair.b2_nullProxy)
+			shape.m_body.m_world.m_broadPhase.DestroyProxy(shape.m_proxyId);
+	};
+b2Shape.e_unknownShape = -1;
+b2Shape.e_circleShape = 0;
+b2Shape.e_boxShape = 1;
+b2Shape.e_polyShape = 2;
+b2Shape.e_meshShape = 3;
+b2Shape.e_shapeTypeCount = 4;
+b2Shape.PolyMass = function(massData, vs, count, rho)
+	{
+		//b2Settings.b2Assert(count >= 3);
+
+		//var center = new b2Vec2(0.0, 0.0);
+		var center = new b2Vec2();
+		center.SetZero();
+
+		var area = 0.0;
+		var I = 0.0;
+
+		// pRef is the reference point for forming triangles.
+		// It's location doesn't change the result (except for rounding error).
+		var pRef = new b2Vec2(0.0, 0.0);
+
+		var inv3 = 1.0 / 3.0;
+
+		for (var i = 0; i < count; ++i)
+		{
+			// Triangle vertices.
+			var p1 = pRef;
+			var p2 = vs[i];
+			var p3 = i + 1 < count ? vs[i+1] : vs[0];
+
+			var e1 = b2Math.SubtractVV(p2, p1);
+			var e2 = b2Math.SubtractVV(p3, p1);
+
+			var D = b2Math.b2CrossVV(e1, e2);
+
+			var triangleArea = 0.5 * D;
+			area += triangleArea;
+
+			// Area weighted centroid
+			// center += triangleArea * inv3 * (p1 + p2 + p3);
+			var tVec = new b2Vec2();
+			tVec.SetV(p1);
+			tVec.Add(p2);
+			tVec.Add(p3);
+			tVec.Multiply(inv3*triangleArea);
+			center.Add(tVec);
+
+			var px = p1.x;
+			var py = p1.y;
+			var ex1 = e1.x;
+			var ey1 = e1.y;
+			var ex2 = e2.x;
+			var ey2 = e2.y;
+
+			var intx2 = inv3 * (0.25 * (ex1*ex1 + ex2*ex1 + ex2*ex2) + (px*ex1 + px*ex2)) + 0.5*px*px;
+			var inty2 = inv3 * (0.25 * (ey1*ey1 + ey2*ey1 + ey2*ey2) + (py*ey1 + py*ey2)) + 0.5*py*py;
+
+			I += D * (intx2 + inty2);
+		}
+
+		// Total mass
+		massData.mass = rho * area;
+
+		// Center of mass
+		//b2Settings.b2Assert(area > Number.MIN_VALUE);
+		center.Multiply( 1.0 / area );
+		massData.center = center;
+
+		// Inertia tensor relative to the center.
+		I = rho * (I - area * b2Math.b2Dot(center, center));
+		massData.I = I;
+	};
+b2Shape.PolyCentroid = function(vs, count, out)
+	{
+		//b2Settings.b2Assert(count >= 3);
+
+		//b2Vec2 c; c.Set(0.0f, 0.0f);
+		var cX = 0.0;
+		var cY = 0.0;
+		//float32 area = 0.0f;
+		var area = 0.0;
+
+		// pRef is the reference point for forming triangles.
+		// It's location doesn't change the result (except for rounding error).
+		//b2Vec2 pRef(0.0f, 0.0f);
+		var pRefX = 0.0;
+		var pRefY = 0.0;
+	/*
+		// This code would put the reference point inside the polygon.
+		for (var i = 0; i < count; ++i)
+		{
+			//pRef += vs[i];
+			pRef.x += vs[i].x;
+			pRef.y += vs[i].y;
+		}
+		pRef.x *= 1.0 / count;
+		pRef.y *= 1.0 / count;
+	*/
+
+		//const float32 inv3 = 1.0f / 3.0f;
+		var inv3 = 1.0 / 3.0;
+
+		for (var i = 0; i < count; ++i)
+		{
+			// Triangle vertices.
+			//b2Vec2 p1 = pRef;
+			var p1X = pRefX;
+			var p1Y = pRefY;
+			//b2Vec2 p2 = vs[i];
+			var p2X = vs[i].x;
+			var p2Y = vs[i].y;
+			//b2Vec2 p3 = i + 1 < count ? vs[i+1] : vs[0];
+			var p3X = i + 1 < count ? vs[i+1].x : vs[0].x;
+			var p3Y = i + 1 < count ? vs[i+1].y : vs[0].y;
+
+			//b2Vec2 e1 = p2 - p1;
+			var e1X = p2X - p1X;
+			var e1Y = p2Y - p1Y;
+			//b2Vec2 e2 = p3 - p1;
+			var e2X = p3X - p1X;
+			var e2Y = p3Y - p1Y;
+
+			//float32 D = b2Cross(e1, e2);
+			var D = (e1X * e2Y - e1Y * e2X);
+
+			//float32 triangleArea = 0.5f * D;
+			var triangleArea = 0.5 * D;
+			area += triangleArea;
+
+			// Area weighted centroid
+			//c += triangleArea * inv3 * (p1 + p2 + p3);
+			cX += triangleArea * inv3 * (p1X + p2X + p3X);
+			cY += triangleArea * inv3 * (p1Y + p2Y + p3Y);
+		}
+
+		// Centroid
+		//b2Settings.b2Assert(area > Number.MIN_VALUE);
+		cX *= 1.0 / area;
+		cY *= 1.0 / area;
+
+		// Replace return with 'out' vector
+		//return c;
+		out.Set(cX, cY);
+	};

data/vendor/assets/javascripts/box2d/collision/shapes/b2ShapeDef.js

@@ -0,0 +1,109 @@
+/*
+* 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 b2ShapeDef = Class.create();
+b2ShapeDef.prototype = 
+{
+	initialize: function()
+	{
+		this.type = b2Shape.e_unknownShape;
+		this.userData = null;
+		this.localPosition = new b2Vec2(0.0, 0.0);
+		this.localRotation = 0.0;
+		this.friction = 0.2;
+		this.restitution = 0.0;
+		this.density = 0.0;
+		this.categoryBits = 0x0001;
+		this.maskBits = 0xFFFF;
+		this.groupIndex = 0;
+	},
+
+	//virtual ~b2ShapeDef() {}
+
+	ComputeMass: function(massData)
+	{
+
+		massData.center = new b2Vec2(0.0, 0.0)
+
+		if (this.density == 0.0)
+		{
+			massData.mass = 0.0;
+			massData.center.Set(0.0, 0.0);
+			massData.I = 0.0;
+		};
+
+		switch (this.type)
+		{
+		case b2Shape.e_circleShape:
+			{
+				var circle = this;
+				massData.mass = this.density * b2Settings.b2_pi * circle.radius * circle.radius;
+				massData.center.Set(0.0, 0.0);
+				massData.I = 0.5 * (massData.mass) * circle.radius * circle.radius;
+			}
+			break;
+
+		case b2Shape.e_boxShape:
+			{
+				var box = this;
+				massData.mass = 4.0 * this.density * box.extents.x * box.extents.y;
+				massData.center.Set(0.0, 0.0);
+				massData.I = massData.mass / 3.0 * b2Math.b2Dot(box.extents, box.extents);
+			}
+			break;
+
+		case b2Shape.e_polyShape:
+			{
+				var poly = this;
+				b2Shape.PolyMass(massData, poly.vertices, poly.vertexCount, this.density);
+			}
+			break;
+
+		default:
+			massData.mass = 0.0;
+			massData.center.Set(0.0, 0.0);
+			massData.I = 0.0;
+			break;
+		}
+	},
+
+	type: 0,
+	userData: null,
+	localPosition: null,
+	localRotation: null,
+	friction: null,
+	restitution: null,
+	density: null,
+
+	// The collision category bits. Normally you would just set one bit.
+	categoryBits: 0,
+
+	// The collision mask bits. This states the categories that this
+	// shape would accept for collision.
+	maskBits: 0,
+
+	// Collision groups allow a certain group of objects to never collide (negative)
+	// or always collide (positive). Zero means no collision group. Non-zero group
+	// filtering always wins against the mask bits.
+	groupIndex: 0};

data/vendor/assets/javascripts/box2d/common/b2Settings.js

@@ -0,0 +1,72 @@
+/*
+* 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 b2Settings = Class.create();
+b2Settings.prototype = {
+
+
+
+	// Define your unit system here. The default system is
+	// meters-kilograms-seconds. For the tuning to work well,
+	// your dynamic objects should be bigger than a pebble and smaller
+	// than a house.
+	//static public const b2Settings.b2_lengthUnitsPerMeter = 1.0;
+
+	// Use this for pixels:
+
+	// Global tuning constants based on MKS units.
+
+	// Collision
+
+	// Dynamics
+
+	// Sleep
+
+	// assert
+
+	initialize: function() {}}
+b2Settings.USHRT_MAX = 0x0000ffff;
+b2Settings.b2_pi = Math.PI;
+b2Settings.b2_massUnitsPerKilogram = 1.0;
+b2Settings.b2_timeUnitsPerSecond = 1.0;
+b2Settings.b2_lengthUnitsPerMeter = 30.0;
+b2Settings.b2_maxManifoldPoints = 2;
+b2Settings.b2_maxShapesPerBody = 64;
+b2Settings.b2_maxPolyVertices = 8;
+b2Settings.b2_maxProxies = 1024;
+b2Settings.b2_maxPairs = 8 * b2Settings.b2_maxProxies;
+b2Settings.b2_linearSlop = 0.005 * b2Settings.b2_lengthUnitsPerMeter;
+b2Settings.b2_angularSlop = 2.0 / 180.0 * b2Settings.b2_pi;
+b2Settings.b2_velocityThreshold = 1.0 * b2Settings.b2_lengthUnitsPerMeter / b2Settings.b2_timeUnitsPerSecond;
+b2Settings.b2_maxLinearCorrection = 0.2 * b2Settings.b2_lengthUnitsPerMeter;
+b2Settings.b2_maxAngularCorrection = 8.0 / 180.0 * b2Settings.b2_pi;
+b2Settings.b2_contactBaumgarte = 0.2;
+b2Settings.b2_timeToSleep = 0.5 * b2Settings.b2_timeUnitsPerSecond;
+b2Settings.b2_linearSleepTolerance = 0.01 * b2Settings.b2_lengthUnitsPerMeter / b2Settings.b2_timeUnitsPerSecond;
+b2Settings.b2_angularSleepTolerance = 2.0 / 180.0 / b2Settings.b2_timeUnitsPerSecond;
+b2Settings.b2Assert = function(a)
+	{
+		if (!a){
+			var nullVec;
+			nullVec.x++;
+		}
+	};