Added function b2World::Dump that dumps the world to a text file that…

… can be pasted into the Testbed.

Fixed body angle access.

git-svn-id: http://box2d.googlecode.com/svn/trunk@210 cafe418c-1137-0410-84cc-357ec87a5d9b

Box2D/Box2D/Collision/Shapes/b2ChainShape.h

@@ -79,21 +79,6 @@ class b2ChainShape : public b2Shape
 	/// @see b2Shape::ComputeMass
 	void ComputeMass(b2MassData* massData, float32 density) const;
 
-	/// Get the number of vertices.
-	int32 GetVertexCount() const { return m_count; }
-
-	/// Get the vertices (read-only).
-	const b2Vec2& GetVertex(int32 index) const
-	{
-		b2Assert(0 <= index && index < m_count);
-		return m_vertices[index];
-	}
-
-	/// Get the vertices (read-only).
-	const b2Vec2* GetVertices() const { return m_vertices; }
-
-protected:
-
 	/// The vertices. Owned by this class.
 	b2Vec2* m_vertices;
 

Box2D/Box2D/Collision/Shapes/b2EdgeShape.h

@@ -63,6 +63,10 @@ inline b2EdgeShape::b2EdgeShape()
 {
 	m_type = e_edge;
 	m_radius = b2_polygonRadius;
+	m_vertex0.x = 0.0f;
+	m_vertex0.y = 0.0f;
+	m_vertex3.x = 0.0f;
+	m_vertex3.y = 0.0f;
 	m_hasVertex0 = false;
 	m_hasVertex3 = false;
 }

Box2D/Box2D/Collision/b2Distance.cpp

@@ -50,16 +50,16 @@ void b2DistanceProxy::Set(const b2Shape* shape, int32 index)
 	case b2Shape::e_chain:
 		{
 			const b2ChainShape* chain = (b2ChainShape*)shape;
-			b2Assert(0 <= index && index < chain->GetVertexCount());
+			b2Assert(0 <= index && index < chain->m_count);
 
-			m_buffer[0] = chain->GetVertex(index);
-			if (index + 1 < chain->GetVertexCount())
+			m_buffer[0] = chain->m_vertices[index];
+			if (index + 1 < chain->m_count)
 			{
-				m_buffer[1] = chain->GetVertex(index + 1);
+				m_buffer[1] = chain->m_vertices[index + 1];
 			}
 			else
 			{
-				m_buffer[1] = chain->GetVertex(0);
+				m_buffer[1] = chain->m_vertices[0];
 			}
 
 			m_vertices = m_buffer;

Box2D/Box2D/Common/b2Settings.cpp

@@ -18,6 +18,8 @@
 
 #include <Box2D/Common/b2Settings.h>
 #include <cstdlib>
+#include <cstdio>
+#include <cstdarg>
 
 b2Version b2_version = {2, 2, 0};
 
@@ -31,3 +33,12 @@ void b2Free(void* mem)
 {
 	free(mem);
 }
+
+// You can modify this to use your logging facility.
+void b2Log(const char* string, ...)
+{
+	va_list args;
+	va_start(args, string);
+	vprintf(string, args);
+	va_end(args);
+}

Box2D/Box2D/Common/b2Settings.h

@@ -132,6 +132,9 @@ void* b2Alloc(int32 size);
 /// If you implement b2Alloc, you should also implement this function.
 void b2Free(void* mem);
 
+/// Logging function.
+void b2Log(const char* string, ...);
+
 /// Version numbering scheme.
 /// See http://en.wikipedia.org/wiki/Software_versioning
 struct b2Version

Box2D/Box2D/Dynamics/Joints/b2DistanceJoint.cpp

@@ -236,3 +236,19 @@ float32 b2DistanceJoint::GetReactionTorque(float32 inv_dt) const
 	B2_NOT_USED(inv_dt);
 	return 0.0f;
 }
+
+void b2DistanceJoint::Dump()
+{
+	int32 indexA = m_bodyA->m_islandIndex;
+	int32 indexB = m_bodyB->m_islandIndex;
+
+	b2Log("  b2DistanceJointDef jd;\n");
+	b2Log("  jd.bodyA = bodies[%d];\n", indexA);
+	b2Log("  jd.bodyB = bodies[%d];\n", indexB);
+	b2Log("  jd.collideConnected = bool(%d);\n", m_collideConnected);
+	b2Log("  jd.localAnchorA.Set(%.15lef, %.15lef);\n", m_localAnchorA.x, m_localAnchorA.y);
+	b2Log("  jd.localAnchorB.Set(%.15lef, %.15lef);\n", m_localAnchorB.x, m_localAnchorB.y);
+	b2Log("  jd.length = %.15lef;\n", m_length);
+	b2Log("  jd.frequencyHz = %.15lef;\n", m_frequencyHz);
+	b2Log("  jd.dampingRatio = %.15lef;\n", m_dampingRatio);
+}

Box2D/Box2D/Dynamics/Joints/b2DistanceJoint.h

@@ -83,14 +83,17 @@ class b2DistanceJoint : public b2Joint
 	void SetLength(float32 length);
 	float32 GetLength() const;
 
-	// Set/get frequency in Hz.
+	/// Set/get frequency in Hz.
 	void SetFrequency(float32 hz);
 	float32 GetFrequency() const;
 
-	// Set/get damping ratio.
+	/// Set/get damping ratio.
 	void SetDampingRatio(float32 ratio);
 	float32 GetDampingRatio() const;
 
+	/// Dump joint to dmLog
+	void Dump();
+
 protected:
 
 	friend class b2Joint;

Box2D/Box2D/Dynamics/Joints/b2GearJoint.cpp

@@ -76,7 +76,7 @@ b2GearJoint::b2GearJoint(const b2GearJointDef* def)
 		b2PrismaticJoint* prismatic = (b2PrismaticJoint*)def->joint1;
 		m_localAnchorC = prismatic->m_localAnchorA;
 		m_localAnchorA = prismatic->m_localAnchorB;
-		m_referenceAngleA = prismatic->m_refAngle;
+		m_referenceAngleA = prismatic->m_referenceAngle;
 		m_localAxisC = prismatic->m_localXAxisA;
 
 		b2Vec2 pC = m_localAnchorC;
@@ -108,7 +108,7 @@ b2GearJoint::b2GearJoint(const b2GearJointDef* def)
 		b2PrismaticJoint* prismatic = (b2PrismaticJoint*)def->joint2;
 		m_localAnchorD = prismatic->m_localAnchorA;
 		m_localAnchorB = prismatic->m_localAnchorB;
-		m_referenceAngleB = prismatic->m_refAngle;
+		m_referenceAngleB = prismatic->m_referenceAngle;
 		m_localAxisD = prismatic->m_localXAxisA;
 
 		b2Vec2 pD = m_localAnchorD;

Box2D/Box2D/Dynamics/Joints/b2Joint.h

@@ -142,6 +142,9 @@ class b2Joint
 	/// the flag is only checked when fixture AABBs begin to overlap.
 	bool GetCollideConnected() const;
 
+	/// Dump this joint to the log file.
+	virtual void Dump() {}
+
 protected:
 	friend class b2World;
 	friend class b2Body;

Box2D/Box2D/Dynamics/Joints/b2PrismaticJoint.cpp

@@ -104,7 +104,7 @@ b2PrismaticJoint::b2PrismaticJoint(const b2PrismaticJointDef* def)
 	m_localAnchorB = def->localAnchorB;
 	m_localXAxisA = def->localAxisA;
 	m_localYAxisA = b2Cross(1.0f, m_localXAxisA);
-	m_refAngle = def->referenceAngle;
+	m_referenceAngle = def->referenceAngle;
 
 	m_impulse.SetZero();
 	m_motorMass = 0.0;
@@ -384,7 +384,7 @@ bool b2PrismaticJoint::SolvePositionConstraints(const b2SolverData& data)
 	b2Vec3 impulse;
 	b2Vec2 C1;
 	C1.x = b2Dot(perp, d);
-	C1.y = aB - aA - m_refAngle;
+	C1.y = aB - aA - m_referenceAngle;
 
 	float32 linearError = b2Abs(C1.x);
 	float32 angularError = b2Abs(C1.y);
@@ -599,3 +599,25 @@ float32 b2PrismaticJoint::GetMotorForce(float32 inv_dt) const
 {
 	return inv_dt * m_motorImpulse;
 }
+
+void b2PrismaticJoint::Dump()
+{
+	int32 indexA = m_bodyA->m_islandIndex;
+	int32 indexB = m_bodyB->m_islandIndex;
+
+	b2Log("  b2PrismaticJointDef jd;\n");
+	b2Log("  jd.bodyA = bodies[%d];\n", indexA);
+	b2Log("  jd.bodyB = bodies[%d];\n", indexB);
+	b2Log("  jd.collideConnected = bool(%d);\n", m_collideConnected);
+	b2Log("  jd.localAnchorA.Set(%.15lef, %.15lef);\n", m_localAnchorA.x, m_localAnchorA.y);
+	b2Log("  jd.localAnchorB.Set(%.15lef, %.15lef);\n", m_localAnchorB.x, m_localAnchorB.y);
+	b2Log("  jd.localAxisA.Set(%.15lef, %.15lef);\n", m_localXAxisA.x, m_localXAxisA.y);
+	b2Log("  jd.referenceAngle = %.15lef;\n", m_referenceAngle);
+	b2Log("  jd.enableLimit = bool(%d);\n", m_enableLimit);
+	b2Log("  jd.lowerTranslation = %.15lef;\n", m_lowerTranslation);
+	b2Log("  jd.upperTranslation = %.15lef;\n", m_upperTranslation);
+	b2Log("  jd.enableMotor = bool(%d);\n", m_enableMotor);
+	b2Log("  jd.motorSpeed = %.15lef;\n", m_motorSpeed);
+	b2Log("  jd.maxMotorForce = %.15lef;\n", m_maxMotorForce);
+	b2Log("  m_world->CreateJoint(&jd);\n");
+}

Box2D/Box2D/Dynamics/Joints/b2PrismaticJoint.h

@@ -131,6 +131,9 @@ class b2PrismaticJoint : public b2Joint
 	/// Get the current motor force given the inverse time step, usually in N.
 	float32 GetMotorForce(float32 inv_dt) const;
 
+	/// Dump to b2Log
+	void Dump();
+
 protected:
 	friend class b2Joint;
 	friend class b2GearJoint;
@@ -145,7 +148,7 @@ class b2PrismaticJoint : public b2Joint
 	b2Vec2 m_localAnchorB;
 	b2Vec2 m_localXAxisA;
 	b2Vec2 m_localYAxisA;
-	float32 m_refAngle;
+	float32 m_referenceAngle;
 	b2Vec3 m_impulse;
 	float32 m_motorImpulse;
 	float32 m_lowerTranslation;

Box2D/Box2D/Dynamics/Joints/b2RevoluteJoint.cpp

@@ -481,3 +481,24 @@ void b2RevoluteJoint::SetLimits(float32 lower, float32 upper)
 		m_upperAngle = upper;
 	}
 }
+
+void b2RevoluteJoint::Dump()
+{
+	int32 indexA = m_bodyA->m_islandIndex;
+	int32 indexB = m_bodyB->m_islandIndex;
+
+	b2Log("  b2RevoluteJointDef jd;\n");
+	b2Log("  jd.bodyA = bodies[%d];\n", indexA);
+	b2Log("  jd.bodyB = bodies[%d];\n", indexB);
+	b2Log("  jd.collideConnected = bool(%d);\n", m_collideConnected);
+	b2Log("  jd.localAnchorA.Set(%.15lef, %.15lef);\n", m_localAnchorA.x, m_localAnchorA.y);
+	b2Log("  jd.localAnchorB.Set(%.15lef, %.15lef);\n", m_localAnchorB.x, m_localAnchorB.y);
+	b2Log("  jd.referenceAngle = %.15lef;\n", m_referenceAngle);
+	b2Log("  jd.enableLimit = bool(%d);\n", m_enableLimit);
+	b2Log("  jd.lowerAngle = %.15lef;\n", m_lowerAngle);
+	b2Log("  jd.upperAngle = %.15lef;\n", m_upperAngle);
+	b2Log("  jd.enableMotor = bool(%d);\n", m_enableMotor);
+	b2Log("  jd.motorSpeed = %.15lef;\n", m_motorSpeed);
+	b2Log("  jd.maxMotorTorque = %.15lef;\n", m_maxMotorTorque);
+	b2Log("  m_world->CreateJoint(&jd);\n");
+}

Box2D/Box2D/Dynamics/Joints/b2RevoluteJoint.h

@@ -141,6 +141,9 @@ class b2RevoluteJoint : public b2Joint
 	/// Unit is N*m.
 	float32 GetMotorTorque(float32 inv_dt) const;
 
+	/// Dump to b2Log.
+	void Dump();
+
 protected:
 
 	friend class b2Joint;

Box2D/Box2D/Dynamics/Joints/b2WeldJoint.cpp

@@ -227,3 +227,18 @@ float32 b2WeldJoint::GetReactionTorque(float32 inv_dt) const
 {
 	return inv_dt * m_impulse.z;
 }
+
+void b2WeldJoint::Dump()
+{
+	int32 indexA = m_bodyA->m_islandIndex;
+	int32 indexB = m_bodyB->m_islandIndex;
+
+	b2Log("  b2WeldJoint jd;\n");
+	b2Log("  jd.bodyA = bodies[%d];\n", indexA);
+	b2Log("  jd.bodyB = bodies[%d];\n", indexB);
+	b2Log("  jd.collideConnected = bool(%d);\n", m_collideConnected);
+	b2Log("  jd.localAnchorA.Set(%.15lef, %.15lef);\n", m_localAnchorA.x, m_localAnchorA.y);
+	b2Log("  jd.localAnchorB.Set(%.15lef, %.15lef);\n", m_localAnchorB.x, m_localAnchorB.y);
+	b2Log("  jd.referenceAngle = %.15lef;\n", m_referenceAngle);
+	b2Log("  m_world->CreateJoint(&jd);\n");
+}

Box2D/Box2D/Dynamics/Joints/b2WeldJoint.h

@@ -59,6 +59,9 @@ class b2WeldJoint : public b2Joint
 	b2Vec2 GetReactionForce(float32 inv_dt) const;
 	float32 GetReactionTorque(float32 inv_dt) const;
 
+	/// Dump to b2Log
+	void Dump();
+
 protected:
 
 	friend class b2Joint;

Box2D/Box2D/Dynamics/b2Body.cpp

@@ -481,4 +481,36 @@ void b2Body::SetActive(bool flag)
 		}
 		m_contactList = NULL;
 	}
+}
+
+void b2Body::Dump()
+{
+	int32 bodyIndex = m_islandIndex;
+
+	b2Log("{\n");
+	b2Log("  b2BodyDef bd;\n");
+	b2Log("  bd.type = b2BodyType(%d);\n", m_type);
+	b2Log("  bd.position.Set(%.15lef, %.15lef);\n", m_xf.p.x, m_xf.p.y);
+	b2Log("  bd.angle = %.15lef;\n", m_sweep.a);
+	b2Log("  bd.linearVelocity.Set(%.15lef, %.15lef);\n", m_linearVelocity.x, m_linearVelocity.y);
+	b2Log("  bd.angularVelocity = %.15lef;\n", m_angularVelocity);
+	b2Log("  bd.linearDamping = %.15lef;\n", m_linearDamping);
+	b2Log("  bd.angularDamping = %.15lef;\n", m_angularDamping);
+	b2Log("  bd.allowSleep = bool(%d);\n", m_flags & e_autoSleepFlag);
+	b2Log("  bd.awake = bool(%d);\n", m_flags & e_awakeFlag);
+	b2Log("  bd.fixedRotation = bool(%d);\n", m_flags & e_fixedRotationFlag);
+	b2Log("  bd.bullet = bool(%d);\n", m_flags & e_bulletFlag);
+	b2Log("  bd.active = bool(%d);\n", m_flags & e_activeFlag);
+	b2Log("  bd.gravityScale = %.15lef;\n", m_gravityScale);
+	b2Log("\n");
+	b2Log("  b2Body* b = m_world->CreateBody(&bd);\n");
+	b2Log("  bodies[%d] = b;\n", m_islandIndex);
+	b2Log("\n");
+	for (b2Fixture* f = m_fixtureList; f; f = f->m_next)
+	{
+		b2Log("  {\n");
+		f->Dump(m_islandIndex);
+		b2Log("  }\n");
+	}
+	b2Log("}\n");
 }

Box2D/Box2D/Dynamics/b2Body.h

@@ -375,6 +375,9 @@ class b2Body
 	b2World* GetWorld();
 	const b2World* GetWorld() const;
 
+	/// Dump this body to a log file
+	void Dump();
+
 private:
 
 	friend class b2World;
@@ -474,7 +477,7 @@ inline const b2Vec2& b2Body::GetPosition() const
 
 inline float32 b2Body::GetAngle() const
 {
-	return m_xf.q.GetAngle();
+	return m_sweep.a;
 }
 
 inline const b2Vec2& b2Body::GetWorldCenter() const