Update Box2D [cache clear] (#2903)

https://github.com/erincatto/box2d/commit/9dc24a6fd4f32442c4bcf80791de47a0a7d25afb

Docs/Urho3D.dox

@@ -78,7 +78,7 @@ Urho3D uses the following third-party libraries:
 
 - AngelScript 2.35.1 WIP (http://www.angelcode.com/angelscript)
 - Boost 1.64.0 (http://www.boost.org) - only used for AngelScript generic bindings
-- Box2D 2.3.2 WIP (http://box2d.org)
+- Box2D 2.4.1+ (https://box2d.org)
 - Bullet 3.06+ (http://www.bulletphysics.org)
 - Civetweb 1.7 (https://github.com/civetweb/civetweb)
 - FreeType 2.8 (https://www.freetype.org)

README.md

@@ -42,7 +42,7 @@ Urho3D is greatly inspired by OGRE (http://www.ogre3d.org) and Horde3D
 Urho3D uses the following third-party libraries:
 - AngelScript 2.35.1 WIP (http://www.angelcode.com/angelscript)
 - Boost 1.64.0 (http://www.boost.org) - only used for AngelScript generic bindings
-- Box2D 2.3.2 WIP (http://box2d.org)
+- Box2D 2.4.1+ (https://box2d.org)
 - Bullet 3.06+ (http://www.bulletphysics.org)
 - Civetweb 1.7 (https://github.com/civetweb/civetweb)
 - FreeType 2.8 (https://www.freetype.org)

Source/Samples/28_Physics2DRope/Urho2DPhysicsRope.cpp

@@ -31,7 +31,6 @@
 #include <Urho3D/Physics2D/CollisionBox2D.h>
 #include <Urho3D/Physics2D/CollisionEdge2D.h>
 #include <Urho3D/Physics2D/ConstraintRevolute2D.h>
-#include <Urho3D/Physics2D/ConstraintRope2D.h>
 #include <Urho3D/Physics2D/PhysicsWorld2D.h>
 #include <Urho3D/Physics2D/RigidBody2D.h>
 #include <Urho3D/Scene/Scene.h>
@@ -143,11 +142,6 @@ void Urho2DPhysicsRope::CreateScene()
 
         prevBody = body;
     }
-
-    auto* constraintRope = groundNode->CreateComponent<ConstraintRope2D>();
-    constraintRope->SetOtherBody(prevBody);
-    constraintRope->SetOwnerBodyAnchor(Vector2(0.0f, y));
-    constraintRope->SetMaxLength(NUM_OBJECTS - 1.0f + 0.01f);
 }
 
 void Urho2DPhysicsRope::CreateInstructions()

Source/Samples/32_Physics2DConstraints/Urho2DConstraints.cpp

@@ -43,7 +43,6 @@
 #include <Urho3D/Physics2D/ConstraintPrismatic2D.h>
 #include <Urho3D/Physics2D/ConstraintPulley2D.h>
 #include <Urho3D/Physics2D/ConstraintRevolute2D.h>
-#include <Urho3D/Physics2D/ConstraintRope2D.h>
 #include <Urho3D/Physics2D/ConstraintWeld2D.h>
 #include <Urho3D/Physics2D/ConstraintWheel2D.h>
 #include <Urho3D/Physics2D/PhysicsWorld2D.h>
@@ -208,9 +207,11 @@ void Urho2DConstraints::CreateScene()
     constraintDistance->SetOtherBody(ballDistanceBody); // Constrain ball to box
     constraintDistance->SetOwnerBodyAnchor(boxDistanceNode->GetPosition2D());
     constraintDistance->SetOtherBodyAnchor(ballDistanceNode->GetPosition2D());
+    
     // Make the constraint soft (comment to make it rigid, which is its basic behavior)
-    constraintDistance->SetFrequencyHz(4.0f);
-    constraintDistance->SetDampingRatio(0.5f);
+    constraintDistance->SetMinLength(constraintDistance->GetLength() - 1.f);
+    constraintDistance->SetMaxLength(constraintDistance->GetLength() + 1.f);
+    constraintDistance->SetLinearStiffness(4.0f, 0.5f);
 
     // Create a ConstraintFriction2D ********** Not functional. From Box2d samples it seems that 2 anchors are required, Urho2D only provides 1, needs investigation ***********
     CreateFlag("ConstraintFriction2D", 0.03f, 1.0f); // Display Text3D flag
@@ -271,16 +272,14 @@ void Urho2DConstraints::CreateScene()
     wheel1->SetAnchor(ball1WheelNode->GetPosition2D());
     wheel1->SetAxis(Vector2(0.0f, 1.0f));
     wheel1->SetMaxMotorTorque(20.0f);
-    wheel1->SetFrequencyHz(4.0f);
-    wheel1->SetDampingRatio(0.4f);
+    wheel1->SetLinearStiffness(4.0f, 0.4f);
 
     auto* wheel2 = car->CreateComponent<ConstraintWheel2D>();
     wheel2->SetOtherBody(ball2WheelNode->GetComponent<RigidBody2D>());
     wheel2->SetAnchor(ball2WheelNode->GetPosition2D());
     wheel2->SetAxis(Vector2(0.0f, 1.0f));
     wheel2->SetMaxMotorTorque(10.0f);
-    wheel2->SetFrequencyHz(4.0f);
-    wheel2->SetDampingRatio(0.4f);
+    wheel2->SetLinearStiffness(4.0f, 0.4f);
 
     // ConstraintMotor2D
     CreateFlag("ConstraintMotor2D", 2.53f, -1.0f); // Display Text3D flag
@@ -356,21 +355,6 @@ void Urho2DConstraints::CreateScene()
     constraintRevolute->SetMotorSpeed(0.0f);
     constraintRevolute->SetEnableMotor(true);
 
-    // Create a ConstraintRope2D
-    CreateFlag("ConstraintRope2D", -4.97f, 1.0f); // Display Text3D flag
-    Node* boxRopeNode = box->Clone();
-    tempBody = boxRopeNode->GetComponent<RigidBody2D>();
-    tempBody->SetBodyType(BT_STATIC);
-    Node* ballRopeNode = ball->Clone();
-    boxRopeNode->SetPosition(Vector3(-3.7f, 0.7f, 0.0f));
-    ballRopeNode->SetPosition(Vector3(-4.5f, 0.0f, 0.0f));
-
-    auto* constraintRope = boxRopeNode->CreateComponent<ConstraintRope2D>();
-    constraintRope->SetOtherBody(ballRopeNode->GetComponent<RigidBody2D>()); // Constrain ball to box
-    constraintRope->SetOwnerBodyAnchor(Vector2(0.0f, -0.5f)); // Offset from box (OwnerBody) : the rope is rigid from OwnerBody center to this ownerBodyAnchor
-    constraintRope->SetMaxLength(0.9f); // Rope length
-    constraintRope->SetCollideConnected(true);
-
     // Create a ConstraintWeld2D
     CreateFlag("ConstraintWeld2D", -2.45f, 1.0f); // Display Text3D flag
     Node* boxWeldNode = box->Clone();
@@ -381,8 +365,7 @@ void Urho2DConstraints::CreateScene()
     auto* constraintWeld = boxWeldNode->CreateComponent<ConstraintWeld2D>();
     constraintWeld->SetOtherBody(ballWeldNode->GetComponent<RigidBody2D>()); // Constrain ball to box
     constraintWeld->SetAnchor(boxWeldNode->GetPosition2D());
-    constraintWeld->SetFrequencyHz(4.0f);
-    constraintWeld->SetDampingRatio(0.5f);
+    constraintWeld->SetAngularStiffness(4.0f, 0.5f);
 
     // Create a ConstraintWheel2D
     CreateFlag("ConstraintWheel2D",  2.53f, 1.0f); // Display Text3D flag
@@ -398,9 +381,8 @@ void Urho2DConstraints::CreateScene()
     constraintWheel->SetEnableMotor(true);
     constraintWheel->SetMaxMotorTorque(1.0f);
     constraintWheel->SetMotorSpeed(0.0f);
-    constraintWheel->SetFrequencyHz(4.0f);
-    constraintWheel->SetDampingRatio(0.5f);
-    constraintWheel->SetCollideConnected(true); // doesn't work
+    constraintWheel->SetLinearStiffness(4.0f, 0.5f);
+    //constraintWheel->SetCollideConnected(true); // doesn't work
 }
 
 void Urho2DConstraints::CreateFlag(const String& text, float x, float y) // Used to create Tex3D flags
@@ -524,6 +506,7 @@ void Urho2DConstraints::HandleMouseButtonDown(StringHash eventType, VariantMap&
         constraintMouse->SetMaxForce(1000 * rigidBody->GetMass());
         constraintMouse->SetCollideConnected(true);
         constraintMouse->SetOtherBody(dummyBody);  // Use dummy body instead of rigidBody. It's better to create a dummy body automatically in ConstraintMouse2D
+        constraintMouse->SetLinearStiffness(5.0f, 0.7f);
     }
     SubscribeToEvent(E_MOUSEMOVE, URHO3D_HANDLER(Urho2DConstraints, HandleMouseMove));
     SubscribeToEvent(E_MOUSEBUTTONUP, URHO3D_HANDLER(Urho2DConstraints, HandleMouseButtonUp));
@@ -581,7 +564,7 @@ void Urho2DConstraints::HandleTouchBegin3(StringHash eventType, VariantMap& even
         constraintMouse->SetMaxForce(1000 * rigidBody->GetMass());
         constraintMouse->SetCollideConnected(true);
         constraintMouse->SetOtherBody(dummyBody);  // Use dummy body instead of rigidBody. It's better to create a dummy body automatically in ConstraintMouse2D
-        constraintMouse->SetDampingRatio(0);
+        constraintMouse->SetLinearStiffness(5.0f, 0.7f);
     }
     SubscribeToEvent(E_TOUCHMOVE, URHO3D_HANDLER(Urho2DConstraints, HandleTouchMove3));
     SubscribeToEvent(E_TOUCHEND, URHO3D_HANDLER(Urho2DConstraints, HandleTouchEnd3));

Source/Samples/Utilities2D/Sample2D.cpp

@@ -34,6 +34,7 @@
 #include <Urho3D/Physics2D/CollisionBox2D.h>
 #include <Urho3D/Physics2D/CollisionChain2D.h>
 #include <Urho3D/Physics2D/CollisionCircle2D.h>
+#include <Urho3D/Physics2D/CollisionEdge2D.h>
 #include <Urho3D/Physics2D/CollisionPolygon2D.h>
 #include <Urho3D/Physics2D/RigidBody2D.h>
 #include <Urho3D/Resource/ResourceCache.h>
@@ -152,8 +153,9 @@ CollisionPolygon2D* Sample2D::CreatePolygonShape(Node* node, TileMapObject2D* ob
     return shape;
 }
 
-CollisionChain2D* Sample2D::CreatePolyLineShape(Node* node, TileMapObject2D* object)
+void Sample2D::CreatePolyLineShape(Node* node, TileMapObject2D* object)
 {
+    /*
     auto* shape = node->CreateComponent<CollisionChain2D>();
     int numVertices = object->GetNumPoints();
     shape->SetVertexCount(numVertices);
@@ -163,6 +165,21 @@ CollisionChain2D* Sample2D::CreatePolyLineShape(Node* node, TileMapObject2D* obj
     if (object->HasProperty("Friction"))
         shape->SetFriction(ToFloat(object->GetProperty("Friction")));
     return shape;
+    */
+
+    // Latest Box2D supports only one sided chains with ghost vertices, use two sided edges instead.
+    // But this can cause stuck at the edges ends https://box2d.org/posts/2020/06/ghost-collisions/
+
+    u32 numVertices = object->GetNumPoints();
+
+    for (u32 i = 1; i < numVertices; ++i)
+    {
+        CollisionEdge2D* shape = node->CreateComponent<CollisionEdge2D>();
+        shape->SetVertices(object->GetPoint(i - 1), object->GetPoint(i));
+        shape->SetFriction(0.8f);
+        if (object->HasProperty("Friction"))
+            shape->SetFriction(ToFloat(object->GetProperty("Friction")));
+    }
 }
 
 Node* Sample2D::CreateCharacter(const TileMapInfo2D& info, float friction, const Vector3& position, float scale)
@@ -180,10 +197,12 @@ Node* Sample2D::CreateCharacter(const TileMapInfo2D& info, float friction, const
     auto* impBody = spriteNode->CreateComponent<RigidBody2D>();
     impBody->SetBodyType(BT_DYNAMIC);
     impBody->SetAllowSleep(false);
+    impBody->SetFixedRotation(true);
     auto* shape = spriteNode->CreateComponent<CollisionCircle2D>();
     shape->SetRadius(1.1f); // Set shape size
     shape->SetFriction(friction); // Set friction
     shape->SetRestitution(0.1f); // Bounce
+    shape->SetDensity(6.6f);
 
     return spriteNode;
 }

Source/Samples/Utilities2D/Sample2D.h

@@ -69,7 +69,7 @@ public:
     /// Build collision shape from Tiled 'Polygon' objects.
     CollisionPolygon2D* CreatePolygonShape(Node* node, TileMapObject2D* object);
     /// Build collision shape from Tiled 'Poly Line' objects.
-    CollisionChain2D* CreatePolyLineShape(Node* node, TileMapObject2D* object);
+    void CreatePolyLineShape(Node* node, TileMapObject2D* object);
     /// Create Imp Spriter character.
     Node* CreateCharacter(const TileMapInfo2D& info, float friction, const Vector3& position, float scale);
     /// Create a trigger (will be cloned at each tmx placeholder).

Source/ThirdParty/Box2D/Box2D/Box2D.h

@@ -1,68 +0,0 @@
-/*
-* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef BOX2D_H
-#define BOX2D_H
-
-/**
-\mainpage Box2D API Documentation
-
-\section intro_sec Getting Started
-
-For documentation please see http://box2d.org/documentation.html
-
-For discussion please visit http://box2d.org/forum
-*/
-
-// These include files constitute the main Box2D API
-
-#include "Box2D/Common/b2Settings.h"
-#include "Box2D/Common/b2Draw.h"
-#include "Box2D/Common/b2Timer.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/Collision/b2BroadPhase.h"
-#include "Box2D/Collision/b2Distance.h"
-#include "Box2D/Collision/b2DynamicTree.h"
-#include "Box2D/Collision/b2TimeOfImpact.h"
-
-#include "Box2D/Dynamics/b2Body.h"
-#include "Box2D/Dynamics/b2Fixture.h"
-#include "Box2D/Dynamics/b2WorldCallbacks.h"
-#include "Box2D/Dynamics/b2TimeStep.h"
-#include "Box2D/Dynamics/b2World.h"
-
-#include "Box2D/Dynamics/Contacts/b2Contact.h"
-
-#include "Box2D/Dynamics/Joints/b2DistanceJoint.h"
-#include "Box2D/Dynamics/Joints/b2FrictionJoint.h"
-#include "Box2D/Dynamics/Joints/b2GearJoint.h"
-#include "Box2D/Dynamics/Joints/b2MotorJoint.h"
-#include "Box2D/Dynamics/Joints/b2MouseJoint.h"
-#include "Box2D/Dynamics/Joints/b2PrismaticJoint.h"
-#include "Box2D/Dynamics/Joints/b2PulleyJoint.h"
-#include "Box2D/Dynamics/Joints/b2RevoluteJoint.h"
-#include "Box2D/Dynamics/Joints/b2RopeJoint.h"
-#include "Box2D/Dynamics/Joints/b2WeldJoint.h"
-#include "Box2D/Dynamics/Joints/b2WheelJoint.h"
-
-#endif

Source/ThirdParty/Box2D/Box2D/Collision/Shapes/b2ChainShape.h

@@ -1,105 +0,0 @@
-/*
-* Copyright (c) 2006-2010 Erin Catto http://www.box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef B2_CHAIN_SHAPE_H
-#define B2_CHAIN_SHAPE_H
-
-#include "Box2D/Collision/Shapes/b2Shape.h"
-
-class b2EdgeShape;
-
-/// A chain shape is a free form sequence of line segments.
-/// The chain has two-sided collision, so you can use inside and outside collision.
-/// Therefore, you may use any winding order.
-/// Since there may be many vertices, they are allocated using b2Alloc.
-/// Connectivity information is used to create smooth collisions.
-/// WARNING: The chain will not collide properly if there are self-intersections.
-class b2ChainShape : public b2Shape
-{
-public:
-	b2ChainShape();
-
-	/// The destructor frees the vertices using b2Free.
-	~b2ChainShape();
-
-	/// Clear all data.
-	void Clear();
-
-	/// Create a loop. This automatically adjusts connectivity.
-	/// @param vertices an array of vertices, these are copied
-	/// @param count the vertex count
-	void CreateLoop(const b2Vec2* vertices, int32 count);
-
-	/// Create a chain with isolated end vertices.
-	/// @param vertices an array of vertices, these are copied
-	/// @param count the vertex count
-	void CreateChain(const b2Vec2* vertices, int32 count);
-
-	/// Establish connectivity to a vertex that precedes the first vertex.
-	/// Don't call this for loops.
-	void SetPrevVertex(const b2Vec2& prevVertex);
-
-	/// Establish connectivity to a vertex that follows the last vertex.
-	/// Don't call this for loops.
-	void SetNextVertex(const b2Vec2& nextVertex);
-
-	/// Implement b2Shape. Vertices are cloned using b2Alloc.
-	b2Shape* Clone(b2BlockAllocator* allocator) const override;
-
-	/// @see b2Shape::GetChildCount
-	int32 GetChildCount() const override;
-
-	/// Get a child edge.
-	void GetChildEdge(b2EdgeShape* edge, int32 index) const;
-
-	/// This always return false.
-	/// @see b2Shape::TestPoint
-	bool TestPoint(const b2Transform& transform, const b2Vec2& p) const override;
-
-	/// Implement b2Shape.
-	bool RayCast(b2RayCastOutput* output, const b2RayCastInput& input,
-					const b2Transform& transform, int32 childIndex) const override;
-
-	/// @see b2Shape::ComputeAABB
-	void ComputeAABB(b2AABB* aabb, const b2Transform& transform, int32 childIndex) const override;
-
-	/// Chains have zero mass.
-	/// @see b2Shape::ComputeMass
-	void ComputeMass(b2MassData* massData, float32 density) const override;
-
-	/// The vertices. Owned by this class.
-	b2Vec2* m_vertices;
-
-	/// The vertex count.
-	int32 m_count;
-
-	b2Vec2 m_prevVertex, m_nextVertex;
-	bool m_hasPrevVertex, m_hasNextVertex;
-};
-
-inline b2ChainShape::b2ChainShape()
-{
-	m_type = e_chain;
-	m_radius = b2_polygonRadius;
-	m_vertices = nullptr;
-	m_count = 0;
-	m_hasPrevVertex = false;
-	m_hasNextVertex = false;
-}
-
-#endif

Source/ThirdParty/Box2D/Box2D/Collision/Shapes/b2CircleShape.h

@@ -1,60 +0,0 @@
-/*
-* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef B2_CIRCLE_SHAPE_H
-#define B2_CIRCLE_SHAPE_H
-
-#include "Box2D/Collision/Shapes/b2Shape.h"
-
-/// A circle shape.
-class b2CircleShape : public b2Shape
-{
-public:
-	b2CircleShape();
-
-	/// Implement b2Shape.
-	b2Shape* Clone(b2BlockAllocator* allocator) const override;
-
-	/// @see b2Shape::GetChildCount
-	int32 GetChildCount() const override;
-
-	/// Implement b2Shape.
-	bool TestPoint(const b2Transform& transform, const b2Vec2& p) const override;
-
-	/// Implement b2Shape.
-	bool RayCast(b2RayCastOutput* output, const b2RayCastInput& input,
-				const b2Transform& transform, int32 childIndex) const override;
-
-	/// @see b2Shape::ComputeAABB
-	void ComputeAABB(b2AABB* aabb, const b2Transform& transform, int32 childIndex) const override;
-
-	/// @see b2Shape::ComputeMass
-	void ComputeMass(b2MassData* massData, float32 density) const override;
-
-	/// Position
-	b2Vec2 m_p;
-};
-
-inline b2CircleShape::b2CircleShape()
-{
-	m_type = e_circle;
-	m_radius = 0.0f;
-	m_p.SetZero();
-}
-
-#endif

Source/ThirdParty/Box2D/Box2D/Collision/Shapes/b2EdgeShape.h

@@ -1,74 +0,0 @@
-/*
-* Copyright (c) 2006-2010 Erin Catto http://www.box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef B2_EDGE_SHAPE_H
-#define B2_EDGE_SHAPE_H
-
-#include "Box2D/Collision/Shapes/b2Shape.h"
-
-/// A line segment (edge) shape. These can be connected in chains or loops
-/// to other edge shapes. The connectivity information is used to ensure
-/// correct contact normals.
-class b2EdgeShape : public b2Shape
-{
-public:
-	b2EdgeShape();
-
-	/// Set this as an isolated edge.
-	void Set(const b2Vec2& v1, const b2Vec2& v2);
-
-	/// Implement b2Shape.
-	b2Shape* Clone(b2BlockAllocator* allocator) const override;
-
-	/// @see b2Shape::GetChildCount
-	int32 GetChildCount() const override;
-
-	/// @see b2Shape::TestPoint
-	bool TestPoint(const b2Transform& transform, const b2Vec2& p) const override;
-
-	/// Implement b2Shape.
-	bool RayCast(b2RayCastOutput* output, const b2RayCastInput& input,
-				const b2Transform& transform, int32 childIndex) const override;
-
-	/// @see b2Shape::ComputeAABB
-	void ComputeAABB(b2AABB* aabb, const b2Transform& transform, int32 childIndex) const override;
-
-	/// @see b2Shape::ComputeMass
-	void ComputeMass(b2MassData* massData, float32 density) const override;
-	
-	/// These are the edge vertices
-	b2Vec2 m_vertex1, m_vertex2;
-
-	/// Optional adjacent vertices. These are used for smooth collision.
-	b2Vec2 m_vertex0, m_vertex3;
-	bool m_hasVertex0, m_hasVertex3;
-};
-
-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;
-}
-
-#endif

Source/ThirdParty/Box2D/Box2D/Collision/b2CollideEdge.cpp

@@ -1,698 +0,0 @@
-/*
- * Copyright (c) 2007-2009 Erin Catto http://www.box2d.org
- *
- * 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 as such, and must not be
- * misrepresented as being the original software.
- * 3. This notice may not be removed or altered from any source distribution.
- */
-
-#include "Box2D/Collision/b2Collision.h"
-#include "Box2D/Collision/Shapes/b2CircleShape.h"
-#include "Box2D/Collision/Shapes/b2EdgeShape.h"
-#include "Box2D/Collision/Shapes/b2PolygonShape.h"
-
-
-// Compute contact points for edge versus circle.
-// This accounts for edge connectivity.
-void b2CollideEdgeAndCircle(b2Manifold* manifold,
-							const b2EdgeShape* edgeA, const b2Transform& xfA,
-							const b2CircleShape* circleB, const b2Transform& xfB)
-{
-	manifold->pointCount = 0;
-	
-	// Compute circle in frame of edge
-	b2Vec2 Q = b2MulT(xfA, b2Mul(xfB, circleB->m_p));
-	
-	b2Vec2 A = edgeA->m_vertex1, B = edgeA->m_vertex2;
-	b2Vec2 e = B - A;
-	
-	// Barycentric coordinates
-	float32 u = b2Dot(e, B - Q);
-	float32 v = b2Dot(e, Q - A);
-	
-	float32 radius = edgeA->m_radius + circleB->m_radius;
-	
-	b2ContactFeature cf;
-	cf.indexB = 0;
-	cf.typeB = b2ContactFeature::e_vertex;
-	
-	// Region A
-	if (v <= 0.0f)
-	{
-		b2Vec2 P = A;
-		b2Vec2 d = Q - P;
-		float32 dd = b2Dot(d, d);
-		if (dd > radius * radius)
-		{
-			return;
-		}
-		
-		// Is there an edge connected to A?
-		if (edgeA->m_hasVertex0)
-		{
-			b2Vec2 A1 = edgeA->m_vertex0;
-			b2Vec2 B1 = A;
-			b2Vec2 e1 = B1 - A1;
-			float32 u1 = b2Dot(e1, B1 - Q);
-			
-			// Is the circle in Region AB of the previous edge?
-			if (u1 > 0.0f)
-			{
-				return;
-			}
-		}
-		
-		cf.indexA = 0;
-		cf.typeA = b2ContactFeature::e_vertex;
-		manifold->pointCount = 1;
-		manifold->type = b2Manifold::e_circles;
-		manifold->localNormal.SetZero();
-		manifold->localPoint = P;
-		manifold->points[0].id.key = 0;
-		manifold->points[0].id.cf = cf;
-		manifold->points[0].localPoint = circleB->m_p;
-		return;
-	}
-	
-	// Region B
-	if (u <= 0.0f)
-	{
-		b2Vec2 P = B;
-		b2Vec2 d = Q - P;
-		float32 dd = b2Dot(d, d);
-		if (dd > radius * radius)
-		{
-			return;
-		}
-		
-		// Is there an edge connected to B?
-		if (edgeA->m_hasVertex3)
-		{
-			b2Vec2 B2 = edgeA->m_vertex3;
-			b2Vec2 A2 = B;
-			b2Vec2 e2 = B2 - A2;
-			float32 v2 = b2Dot(e2, Q - A2);
-			
-			// Is the circle in Region AB of the next edge?
-			if (v2 > 0.0f)
-			{
-				return;
-			}
-		}
-		
-		cf.indexA = 1;
-		cf.typeA = b2ContactFeature::e_vertex;
-		manifold->pointCount = 1;
-		manifold->type = b2Manifold::e_circles;
-		manifold->localNormal.SetZero();
-		manifold->localPoint = P;
-		manifold->points[0].id.key = 0;
-		manifold->points[0].id.cf = cf;
-		manifold->points[0].localPoint = circleB->m_p;
-		return;
-	}
-	
-	// Region AB
-	float32 den = b2Dot(e, e);
-	b2Assert(den > 0.0f);
-	b2Vec2 P = (1.0f / den) * (u * A + v * B);
-	b2Vec2 d = Q - P;
-	float32 dd = b2Dot(d, d);
-	if (dd > radius * radius)
-	{
-		return;
-	}
-	
-	b2Vec2 n(-e.y, e.x);
-	if (b2Dot(n, Q - A) < 0.0f)
-	{
-		n.Set(-n.x, -n.y);
-	}
-	n.Normalize();
-	
-	cf.indexA = 0;
-	cf.typeA = b2ContactFeature::e_face;
-	manifold->pointCount = 1;
-	manifold->type = b2Manifold::e_faceA;
-	manifold->localNormal = n;
-	manifold->localPoint = A;
-	manifold->points[0].id.key = 0;
-	manifold->points[0].id.cf = cf;
-	manifold->points[0].localPoint = circleB->m_p;
-}
-
-// This structure is used to keep track of the best separating axis.
-struct b2EPAxis
-{
-	enum Type
-	{
-		e_unknown,
-		e_edgeA,
-		e_edgeB
-	};
-	
-	Type type;
-	int32 index;
-	float32 separation;
-};
-
-// This holds polygon B expressed in frame A.
-struct b2TempPolygon
-{
-	b2Vec2 vertices[b2_maxPolygonVertices];
-	b2Vec2 normals[b2_maxPolygonVertices];
-	int32 count;
-};
-
-// Reference face used for clipping
-struct b2ReferenceFace
-{
-	int32 i1, i2;
-	
-	b2Vec2 v1, v2;
-	
-	b2Vec2 normal;
-	
-	b2Vec2 sideNormal1;
-	float32 sideOffset1;
-	
-	b2Vec2 sideNormal2;
-	float32 sideOffset2;
-};
-
-// This class collides and edge and a polygon, taking into account edge adjacency.
-struct b2EPCollider
-{
-	void Collide(b2Manifold* manifold, const b2EdgeShape* edgeA, const b2Transform& xfA,
-				 const b2PolygonShape* polygonB, const b2Transform& xfB);
-	b2EPAxis ComputeEdgeSeparation();
-	b2EPAxis ComputePolygonSeparation();
-	
-	enum VertexType
-	{
-		e_isolated,
-		e_concave,
-		e_convex
-	};
-	
-	b2TempPolygon m_polygonB;
-	
-	b2Transform m_xf;
-	b2Vec2 m_centroidB;
-	b2Vec2 m_v0, m_v1, m_v2, m_v3;
-	b2Vec2 m_normal0, m_normal1, m_normal2;
-	b2Vec2 m_normal;
-	VertexType m_type1, m_type2;
-	b2Vec2 m_lowerLimit, m_upperLimit;
-	float32 m_radius;
-	bool m_front;
-};
-
-// Algorithm:
-// 1. Classify v1 and v2
-// 2. Classify polygon centroid as front or back
-// 3. Flip normal if necessary
-// 4. Initialize normal range to [-pi, pi] about face normal
-// 5. Adjust normal range according to adjacent edges
-// 6. Visit each separating axes, only accept axes within the range
-// 7. Return if _any_ axis indicates separation
-// 8. Clip
-void b2EPCollider::Collide(b2Manifold* manifold, const b2EdgeShape* edgeA, const b2Transform& xfA,
-						   const b2PolygonShape* polygonB, const b2Transform& xfB)
-{
-	m_xf = b2MulT(xfA, xfB);
-	
-	m_centroidB = b2Mul(m_xf, polygonB->m_centroid);
-	
-	m_v0 = edgeA->m_vertex0;
-	m_v1 = edgeA->m_vertex1;
-	m_v2 = edgeA->m_vertex2;
-	m_v3 = edgeA->m_vertex3;
-	
-	bool hasVertex0 = edgeA->m_hasVertex0;
-	bool hasVertex3 = edgeA->m_hasVertex3;
-	
-	b2Vec2 edge1 = m_v2 - m_v1;
-	edge1.Normalize();
-	m_normal1.Set(edge1.y, -edge1.x);
-	float32 offset1 = b2Dot(m_normal1, m_centroidB - m_v1);
-	float32 offset0 = 0.0f, offset2 = 0.0f;
-	bool convex1 = false, convex2 = false;
-	
-	// Is there a preceding edge?
-	if (hasVertex0)
-	{
-		b2Vec2 edge0 = m_v1 - m_v0;
-		edge0.Normalize();
-		m_normal0.Set(edge0.y, -edge0.x);
-		convex1 = b2Cross(edge0, edge1) >= 0.0f;
-		offset0 = b2Dot(m_normal0, m_centroidB - m_v0);
-	}
-	
-	// Is there a following edge?
-	if (hasVertex3)
-	{
-		b2Vec2 edge2 = m_v3 - m_v2;
-		edge2.Normalize();
-		m_normal2.Set(edge2.y, -edge2.x);
-		convex2 = b2Cross(edge1, edge2) > 0.0f;
-		offset2 = b2Dot(m_normal2, m_centroidB - m_v2);
-	}
-	
-	// Determine front or back collision. Determine collision normal limits.
-	if (hasVertex0 && hasVertex3)
-	{
-		if (convex1 && convex2)
-		{
-			m_front = offset0 >= 0.0f || offset1 >= 0.0f || offset2 >= 0.0f;
-			if (m_front)
-			{
-				m_normal = m_normal1;
-				m_lowerLimit = m_normal0;
-				m_upperLimit = m_normal2;
-			}
-			else
-			{
-				m_normal = -m_normal1;
-				m_lowerLimit = -m_normal1;
-				m_upperLimit = -m_normal1;
-			}
-		}
-		else if (convex1)
-		{
-			m_front = offset0 >= 0.0f || (offset1 >= 0.0f && offset2 >= 0.0f);
-			if (m_front)
-			{
-				m_normal = m_normal1;
-				m_lowerLimit = m_normal0;
-				m_upperLimit = m_normal1;
-			}
-			else
-			{
-				m_normal = -m_normal1;
-				m_lowerLimit = -m_normal2;
-				m_upperLimit = -m_normal1;
-			}
-		}
-		else if (convex2)
-		{
-			m_front = offset2 >= 0.0f || (offset0 >= 0.0f && offset1 >= 0.0f);
-			if (m_front)
-			{
-				m_normal = m_normal1;
-				m_lowerLimit = m_normal1;
-				m_upperLimit = m_normal2;
-			}
-			else
-			{
-				m_normal = -m_normal1;
-				m_lowerLimit = -m_normal1;
-				m_upperLimit = -m_normal0;
-			}
-		}
-		else
-		{
-			m_front = offset0 >= 0.0f && offset1 >= 0.0f && offset2 >= 0.0f;
-			if (m_front)
-			{
-				m_normal = m_normal1;
-				m_lowerLimit = m_normal1;
-				m_upperLimit = m_normal1;
-			}
-			else
-			{
-				m_normal = -m_normal1;
-				m_lowerLimit = -m_normal2;
-				m_upperLimit = -m_normal0;
-			}
-		}
-	}
-	else if (hasVertex0)
-	{
-		if (convex1)
-		{
-			m_front = offset0 >= 0.0f || offset1 >= 0.0f;
-			if (m_front)
-			{
-				m_normal = m_normal1;
-				m_lowerLimit = m_normal0;
-				m_upperLimit = -m_normal1;
-			}
-			else
-			{
-				m_normal = -m_normal1;
-				m_lowerLimit = m_normal1;
-				m_upperLimit = -m_normal1;
-			}
-		}
-		else
-		{
-			m_front = offset0 >= 0.0f && offset1 >= 0.0f;
-			if (m_front)
-			{
-				m_normal = m_normal1;
-				m_lowerLimit = m_normal1;
-				m_upperLimit = -m_normal1;
-			}
-			else
-			{
-				m_normal = -m_normal1;
-				m_lowerLimit = m_normal1;
-				m_upperLimit = -m_normal0;
-			}
-		}
-	}
-	else if (hasVertex3)
-	{
-		if (convex2)
-		{
-			m_front = offset1 >= 0.0f || offset2 >= 0.0f;
-			if (m_front)
-			{
-				m_normal = m_normal1;
-				m_lowerLimit = -m_normal1;
-				m_upperLimit = m_normal2;
-			}
-			else
-			{
-				m_normal = -m_normal1;
-				m_lowerLimit = -m_normal1;
-				m_upperLimit = m_normal1;
-			}
-		}
-		else
-		{
-			m_front = offset1 >= 0.0f && offset2 >= 0.0f;
-			if (m_front)
-			{
-				m_normal = m_normal1;
-				m_lowerLimit = -m_normal1;
-				m_upperLimit = m_normal1;
-			}
-			else
-			{
-				m_normal = -m_normal1;
-				m_lowerLimit = -m_normal2;
-				m_upperLimit = m_normal1;
-			}
-		}		
-	}
-	else
-	{
-		m_front = offset1 >= 0.0f;
-		if (m_front)
-		{
-			m_normal = m_normal1;
-			m_lowerLimit = -m_normal1;
-			m_upperLimit = -m_normal1;
-		}
-		else
-		{
-			m_normal = -m_normal1;
-			m_lowerLimit = m_normal1;
-			m_upperLimit = m_normal1;
-		}
-	}
-	
-	// Get polygonB in frameA
-	m_polygonB.count = polygonB->m_count;
-	for (int32 i = 0; i < polygonB->m_count; ++i)
-	{
-		m_polygonB.vertices[i] = b2Mul(m_xf, polygonB->m_vertices[i]);
-		m_polygonB.normals[i] = b2Mul(m_xf.q, polygonB->m_normals[i]);
-	}
-	
-	m_radius = polygonB->m_radius + edgeA->m_radius;
-	
-	manifold->pointCount = 0;
-	
-	b2EPAxis edgeAxis = ComputeEdgeSeparation();
-	
-	// If no valid normal can be found than this edge should not collide.
-	if (edgeAxis.type == b2EPAxis::e_unknown)
-	{
-		return;
-	}
-	
-	if (edgeAxis.separation > m_radius)
-	{
-		return;
-	}
-	
-	b2EPAxis polygonAxis = ComputePolygonSeparation();
-	if (polygonAxis.type != b2EPAxis::e_unknown && polygonAxis.separation > m_radius)
-	{
-		return;
-	}
-	
-	// Use hysteresis for jitter reduction.
-	const float32 k_relativeTol = 0.98f;
-	const float32 k_absoluteTol = 0.001f;
-	
-	b2EPAxis primaryAxis;
-	if (polygonAxis.type == b2EPAxis::e_unknown)
-	{
-		primaryAxis = edgeAxis;
-	}
-	else if (polygonAxis.separation > k_relativeTol * edgeAxis.separation + k_absoluteTol)
-	{
-		primaryAxis = polygonAxis;
-	}
-	else
-	{
-		primaryAxis = edgeAxis;
-	}
-	
-	b2ClipVertex ie[2];
-	b2ReferenceFace rf;
-	if (primaryAxis.type == b2EPAxis::e_edgeA)
-	{
-		manifold->type = b2Manifold::e_faceA;
-		
-		// Search for the polygon normal that is most anti-parallel to the edge normal.
-		int32 bestIndex = 0;
-		float32 bestValue = b2Dot(m_normal, m_polygonB.normals[0]);
-		for (int32 i = 1; i < m_polygonB.count; ++i)
-		{
-			float32 value = b2Dot(m_normal, m_polygonB.normals[i]);
-			if (value < bestValue)
-			{
-				bestValue = value;
-				bestIndex = i;
-			}
-		}
-		
-		int32 i1 = bestIndex;
-		int32 i2 = i1 + 1 < m_polygonB.count ? i1 + 1 : 0;
-		
-		ie[0].v = m_polygonB.vertices[i1];
-		ie[0].id.cf.indexA = 0;
-		ie[0].id.cf.indexB = static_cast<uint8>(i1);
-		ie[0].id.cf.typeA = b2ContactFeature::e_face;
-		ie[0].id.cf.typeB = b2ContactFeature::e_vertex;
-		
-		ie[1].v = m_polygonB.vertices[i2];
-		ie[1].id.cf.indexA = 0;
-		ie[1].id.cf.indexB = static_cast<uint8>(i2);
-		ie[1].id.cf.typeA = b2ContactFeature::e_face;
-		ie[1].id.cf.typeB = b2ContactFeature::e_vertex;
-		
-		if (m_front)
-		{
-			rf.i1 = 0;
-			rf.i2 = 1;
-			rf.v1 = m_v1;
-			rf.v2 = m_v2;
-			rf.normal = m_normal1;
-		}
-		else
-		{
-			rf.i1 = 1;
-			rf.i2 = 0;
-			rf.v1 = m_v2;
-			rf.v2 = m_v1;
-			rf.normal = -m_normal1;
-		}		
-	}
-	else
-	{
-		manifold->type = b2Manifold::e_faceB;
-		
-		ie[0].v = m_v1;
-		ie[0].id.cf.indexA = 0;
-		ie[0].id.cf.indexB = static_cast<uint8>(primaryAxis.index);
-		ie[0].id.cf.typeA = b2ContactFeature::e_vertex;
-		ie[0].id.cf.typeB = b2ContactFeature::e_face;
-		
-		ie[1].v = m_v2;
-		ie[1].id.cf.indexA = 0;
-		ie[1].id.cf.indexB = static_cast<uint8>(primaryAxis.index);		
-		ie[1].id.cf.typeA = b2ContactFeature::e_vertex;
-		ie[1].id.cf.typeB = b2ContactFeature::e_face;
-		
-		rf.i1 = primaryAxis.index;
-		rf.i2 = rf.i1 + 1 < m_polygonB.count ? rf.i1 + 1 : 0;
-		rf.v1 = m_polygonB.vertices[rf.i1];
-		rf.v2 = m_polygonB.vertices[rf.i2];
-		rf.normal = m_polygonB.normals[rf.i1];
-	}
-	
-	rf.sideNormal1.Set(rf.normal.y, -rf.normal.x);
-	rf.sideNormal2 = -rf.sideNormal1;
-	rf.sideOffset1 = b2Dot(rf.sideNormal1, rf.v1);
-	rf.sideOffset2 = b2Dot(rf.sideNormal2, rf.v2);
-	
-	// Clip incident edge against extruded edge1 side edges.
-	b2ClipVertex clipPoints1[2];
-	b2ClipVertex clipPoints2[2];
-	int32 np;
-	
-	// Clip to box side 1
-	np = b2ClipSegmentToLine(clipPoints1, ie, rf.sideNormal1, rf.sideOffset1, rf.i1);
-	
-	if (np < b2_maxManifoldPoints)
-	{
-		return;
-	}
-	
-	// Clip to negative box side 1
-	np = b2ClipSegmentToLine(clipPoints2, clipPoints1, rf.sideNormal2, rf.sideOffset2, rf.i2);
-	
-	if (np < b2_maxManifoldPoints)
-	{
-		return;
-	}
-	
-	// Now clipPoints2 contains the clipped points.
-	if (primaryAxis.type == b2EPAxis::e_edgeA)
-	{
-		manifold->localNormal = rf.normal;
-		manifold->localPoint = rf.v1;
-	}
-	else
-	{
-		manifold->localNormal = polygonB->m_normals[rf.i1];
-		manifold->localPoint = polygonB->m_vertices[rf.i1];
-	}
-	
-	int32 pointCount = 0;
-	for (int32 i = 0; i < b2_maxManifoldPoints; ++i)
-	{
-		float32 separation;
-		
-		separation = b2Dot(rf.normal, clipPoints2[i].v - rf.v1);
-		
-		if (separation <= m_radius)
-		{
-			b2ManifoldPoint* cp = manifold->points + pointCount;
-			
-			if (primaryAxis.type == b2EPAxis::e_edgeA)
-			{
-				cp->localPoint = b2MulT(m_xf, clipPoints2[i].v);
-				cp->id = clipPoints2[i].id;
-			}
-			else
-			{
-				cp->localPoint = clipPoints2[i].v;
-				cp->id.cf.typeA = clipPoints2[i].id.cf.typeB;
-				cp->id.cf.typeB = clipPoints2[i].id.cf.typeA;
-				cp->id.cf.indexA = clipPoints2[i].id.cf.indexB;
-				cp->id.cf.indexB = clipPoints2[i].id.cf.indexA;
-			}
-			
-			++pointCount;
-		}
-	}
-	
-	manifold->pointCount = pointCount;
-}
-
-b2EPAxis b2EPCollider::ComputeEdgeSeparation()
-{
-	b2EPAxis axis;
-	axis.type = b2EPAxis::e_edgeA;
-	axis.index = m_front ? 0 : 1;
-	axis.separation = FLT_MAX;
-	
-	for (int32 i = 0; i < m_polygonB.count; ++i)
-	{
-		float32 s = b2Dot(m_normal, m_polygonB.vertices[i] - m_v1);
-		if (s < axis.separation)
-		{
-			axis.separation = s;
-		}
-	}
-	
-	return axis;
-}
-
-b2EPAxis b2EPCollider::ComputePolygonSeparation()
-{
-	b2EPAxis axis;
-	axis.type = b2EPAxis::e_unknown;
-	axis.index = -1;
-	axis.separation = -FLT_MAX;
-
-	b2Vec2 perp(-m_normal.y, m_normal.x);
-
-	for (int32 i = 0; i < m_polygonB.count; ++i)
-	{
-		b2Vec2 n = -m_polygonB.normals[i];
-		
-		float32 s1 = b2Dot(n, m_polygonB.vertices[i] - m_v1);
-		float32 s2 = b2Dot(n, m_polygonB.vertices[i] - m_v2);
-		float32 s = b2Min(s1, s2);
-		
-		if (s > m_radius)
-		{
-			// No collision
-			axis.type = b2EPAxis::e_edgeB;
-			axis.index = i;
-			axis.separation = s;
-			return axis;
-		}
-		
-		// Adjacency
-		if (b2Dot(n, perp) >= 0.0f)
-		{
-			if (b2Dot(n - m_upperLimit, m_normal) < -b2_angularSlop)
-			{
-				continue;
-			}
-		}
-		else
-		{
-			if (b2Dot(n - m_lowerLimit, m_normal) < -b2_angularSlop)
-			{
-				continue;
-			}
-		}
-		
-		if (s > axis.separation)
-		{
-			axis.type = b2EPAxis::e_edgeB;
-			axis.index = i;
-			axis.separation = s;
-		}
-	}
-	
-	return axis;
-}
-
-void b2CollideEdgeAndPolygon(	b2Manifold* manifold,
-							 const b2EdgeShape* edgeA, const b2Transform& xfA,
-							 const b2PolygonShape* polygonB, const b2Transform& xfB)
-{
-	b2EPCollider collider;
-	collider.Collide(manifold, edgeA, xfA, polygonB, xfB);
-}

Source/ThirdParty/Box2D/Box2D/Collision/b2TimeOfImpact.h

@@ -1,58 +0,0 @@
-/*
-* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef B2_TIME_OF_IMPACT_H
-#define B2_TIME_OF_IMPACT_H
-
-#include "Box2D/Common/b2Math.h"
-#include "Box2D/Collision/b2Distance.h"
-
-/// Input parameters for b2TimeOfImpact
-struct b2TOIInput
-{
-	b2DistanceProxy proxyA;
-	b2DistanceProxy proxyB;
-	b2Sweep sweepA;
-	b2Sweep sweepB;
-	float32 tMax;		// defines sweep interval [0, tMax]
-};
-
-/// Output parameters for b2TimeOfImpact.
-struct b2TOIOutput
-{
-	enum State
-	{
-		e_unknown,
-		e_failed,
-		e_overlapped,
-		e_touching,
-		e_separated
-	};
-
-	State state;
-	float32 t;
-};
-
-/// Compute the upper bound on time before two shapes penetrate. Time is represented as
-/// a fraction between [0,tMax]. This uses a swept separating axis and may miss some intermediate,
-/// non-tunneling collisions. If you change the time interval, you should call this function
-/// again.
-/// Note: use b2Distance to compute the contact point and normal at the time of impact.
-void b2TimeOfImpact(b2TOIOutput* output, const b2TOIInput* input);
-
-#endif

Source/ThirdParty/Box2D/Box2D/Common/b2BlockAllocator.h

@@ -1,62 +0,0 @@
-/*
-* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef B2_BLOCK_ALLOCATOR_H
-#define B2_BLOCK_ALLOCATOR_H
-
-#include "Box2D/Common/b2Settings.h"
-
-const int32 b2_chunkSize = 16 * 1024;
-const int32 b2_maxBlockSize = 640;
-const int32 b2_blockSizes = 14;
-const int32 b2_chunkArrayIncrement = 128;
-
-struct b2Block;
-struct b2Chunk;
-
-/// This is a small object allocator used for allocating small
-/// objects that persist for more than one time step.
-/// See: http://www.codeproject.com/useritems/Small_Block_Allocator.asp
-class b2BlockAllocator
-{
-public:
-	b2BlockAllocator();
-	~b2BlockAllocator();
-
-	/// Allocate memory. This will use b2Alloc if the size is larger than b2_maxBlockSize.
-	void* Allocate(int32 size);
-
-	/// Free memory. This will use b2Free if the size is larger than b2_maxBlockSize.
-	void Free(void* p, int32 size);
-
-	void Clear();
-
-private:
-
-	b2Chunk* m_chunks;
-	int32 m_chunkCount;
-	int32 m_chunkSpace;
-
-	b2Block* m_freeLists[b2_blockSizes];
-
-	static int32 s_blockSizes[b2_blockSizes];
-	static uint8 s_blockSizeLookup[b2_maxBlockSize + 1];
-	static bool s_blockSizeLookupInitialized;
-};
-
-#endif

Source/ThirdParty/Box2D/Box2D/Common/b2Draw.cpp

@@ -1,44 +0,0 @@
-/*
-* Copyright (c) 2011 Erin Catto http://box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
-
-#include "Box2D/Common/b2Draw.h"
-
-b2Draw::b2Draw()
-{
-	m_drawFlags = 0;
-}
-
-void b2Draw::SetFlags(uint32 flags)
-{
-	m_drawFlags = flags;
-}
-
-uint32 b2Draw::GetFlags() const
-{
-	return m_drawFlags;
-}
-
-void b2Draw::AppendFlags(uint32 flags)
-{
-	m_drawFlags |= flags;
-}
-
-void b2Draw::ClearFlags(uint32 flags)
-{
-	m_drawFlags &= ~flags;
-}

Source/ThirdParty/Box2D/Box2D/Common/b2Draw.h

@@ -1,97 +0,0 @@
-/*
-* Copyright (c) 2011 Erin Catto http://box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef B2_DRAW_H
-#define B2_DRAW_H
-
-#include "Box2D/Common/b2Math.h"
-
-/// Color for debug drawing. Each value has the range [0,1].
-struct b2Color
-{
-	b2Color() {}
-	b2Color(float32 rIn, float32 gIn, float32 bIn, float32 aIn = 1.0f)
-	{
-		r = rIn; g = gIn; b = bIn; a = aIn;
-	}
-
-	void Set(float32 rIn, float32 gIn, float32 bIn, float32 aIn = 1.0f)
-	{
-		r = rIn; g = gIn; b = bIn; a = aIn;
-	}
-
-	float32 r, g, b, a;
-};
-
-/// Implement and register this class with a b2World to provide debug drawing of physics
-/// entities in your game.
-class b2Draw
-{
-public:
-	b2Draw();
-
-	virtual ~b2Draw() {}
-
-	enum
-	{
-		e_shapeBit				= 0x0001,	///< draw shapes
-		e_jointBit				= 0x0002,	///< draw joint connections
-		e_aabbBit				= 0x0004,	///< draw axis aligned bounding boxes
-		e_pairBit				= 0x0008,	///< draw broad-phase pairs
-		e_centerOfMassBit		= 0x0010	///< draw center of mass frame
-	};
-
-	/// Set the drawing flags.
-	void SetFlags(uint32 flags);
-
-	/// Get the drawing flags.
-	uint32 GetFlags() const;
-	
-	/// Append flags to the current flags.
-	void AppendFlags(uint32 flags);
-
-	/// Clear flags from the current flags.
-	void ClearFlags(uint32 flags);
-
-	/// Draw a closed polygon provided in CCW order.
-	virtual void DrawPolygon(const b2Vec2* vertices, int32 vertexCount, const b2Color& color) = 0;
-
-	/// Draw a solid closed polygon provided in CCW order.
-	virtual void DrawSolidPolygon(const b2Vec2* vertices, int32 vertexCount, const b2Color& color) = 0;
-
-	/// Draw a circle.
-	virtual void DrawCircle(const b2Vec2& center, float32 radius, const b2Color& color) = 0;
-	
-	/// Draw a solid circle.
-	virtual void DrawSolidCircle(const b2Vec2& center, float32 radius, const b2Vec2& axis, const b2Color& color) = 0;
-	
-	/// Draw a line segment.
-	virtual void DrawSegment(const b2Vec2& p1, const b2Vec2& p2, const b2Color& color) = 0;
-
-	/// Draw a transform. Choose your own length scale.
-	/// @param xf a transform.
-	virtual void DrawTransform(const b2Transform& xf) = 0;
-
-	/// Draw a point.
-	virtual void DrawPoint(const b2Vec2& p, float32 size, const b2Color& color) = 0;
-
-protected:
-	uint32 m_drawFlags;
-};
-
-#endif

Source/ThirdParty/Box2D/Box2D/Common/b2GrowableStack.h

@@ -1,85 +0,0 @@
-/*
-* Copyright (c) 2010 Erin Catto http://www.box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef B2_GROWABLE_STACK_H
-#define B2_GROWABLE_STACK_H
-#include "Box2D/Common/b2Settings.h"
-#include <string.h>
-
-/// This is a growable LIFO stack with an initial capacity of N.
-/// If the stack size exceeds the initial capacity, the heap is used
-/// to increase the size of the stack.
-template <typename T, int32 N>
-class b2GrowableStack
-{
-public:
-	b2GrowableStack()
-	{
-		m_stack = m_array;
-		m_count = 0;
-		m_capacity = N;
-	}
-
-	~b2GrowableStack()
-	{
-		if (m_stack != m_array)
-		{
-			b2Free(m_stack);
-			m_stack = nullptr;
-		}
-	}
-
-	void Push(const T& element)
-	{
-		if (m_count == m_capacity)
-		{
-			T* old = m_stack;
-			m_capacity *= 2;
-			m_stack = (T*)b2Alloc(m_capacity * sizeof(T));
-			memcpy(m_stack, old, m_count * sizeof(T));
-			if (old != m_array)
-			{
-				b2Free(old);
-			}
-		}
-
-		m_stack[m_count] = element;
-		++m_count;
-	}
-
-	T Pop()
-	{
-		b2Assert(m_count > 0);
-		--m_count;
-		return m_stack[m_count];
-	}
-
-	int32 GetCount()
-	{
-		return m_count;
-	}
-
-private:
-	T* m_stack;
-	T m_array[N];
-	int32 m_count;
-	int32 m_capacity;
-};
-
-
-#endif

Source/ThirdParty/Box2D/Box2D/Common/b2Math.cpp

@@ -1,94 +0,0 @@
-/*
-* Copyright (c) 2007-2009 Erin Catto http://www.box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
-
-#include "Box2D/Common/b2Math.h"
-
-const b2Vec2 b2Vec2_zero(0.0f, 0.0f);
-
-/// Solve A * x = b, where b is a column vector. This is more efficient
-/// than computing the inverse in one-shot cases.
-b2Vec3 b2Mat33::Solve33(const b2Vec3& b) const
-{
-	float32 det = b2Dot(ex, b2Cross(ey, ez));
-	if (det != 0.0f)
-	{
-		det = 1.0f / det;
-	}
-	b2Vec3 x;
-	x.x = det * b2Dot(b, b2Cross(ey, ez));
-	x.y = det * b2Dot(ex, b2Cross(b, ez));
-	x.z = det * b2Dot(ex, b2Cross(ey, b));
-	return x;
-}
-
-/// Solve A * x = b, where b is a column vector. This is more efficient
-/// than computing the inverse in one-shot cases.
-b2Vec2 b2Mat33::Solve22(const b2Vec2& b) const
-{
-	float32 a11 = ex.x, a12 = ey.x, a21 = ex.y, a22 = ey.y;
-	float32 det = a11 * a22 - a12 * a21;
-	if (det != 0.0f)
-	{
-		det = 1.0f / det;
-	}
-	b2Vec2 x;
-	x.x = det * (a22 * b.x - a12 * b.y);
-	x.y = det * (a11 * b.y - a21 * b.x);
-	return x;
-}
-
-///
-void b2Mat33::GetInverse22(b2Mat33* M) const
-{
-	float32 a = ex.x, b = ey.x, c = ex.y, d = ey.y;
-	float32 det = a * d - b * c;
-	if (det != 0.0f)
-	{
-		det = 1.0f / det;
-	}
-
-	M->ex.x =  det * d;	M->ey.x = -det * b; M->ex.z = 0.0f;
-	M->ex.y = -det * c;	M->ey.y =  det * a; M->ey.z = 0.0f;
-	M->ez.x = 0.0f; M->ez.y = 0.0f; M->ez.z = 0.0f;
-}
-
-/// Returns the zero matrix if singular.
-void b2Mat33::GetSymInverse33(b2Mat33* M) const
-{
-	float32 det = b2Dot(ex, b2Cross(ey, ez));
-	if (det != 0.0f)
-	{
-		det = 1.0f / det;
-	}
-
-	float32 a11 = ex.x, a12 = ey.x, a13 = ez.x;
-	float32 a22 = ey.y, a23 = ez.y;
-	float32 a33 = ez.z;
-
-	M->ex.x = det * (a22 * a33 - a23 * a23);
-	M->ex.y = det * (a13 * a23 - a12 * a33);
-	M->ex.z = det * (a12 * a23 - a13 * a22);
-
-	M->ey.x = M->ex.y;
-	M->ey.y = det * (a11 * a33 - a13 * a13);
-	M->ey.z = det * (a13 * a12 - a11 * a23);
-
-	M->ez.x = M->ex.z;
-	M->ez.y = M->ey.z;
-	M->ez.z = det * (a11 * a22 - a12 * a12);
-}

Source/ThirdParty/Box2D/Box2D/Common/b2Settings.cpp

@@ -1,44 +0,0 @@
-/*
-* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
-
-#include "Box2D/Common/b2Settings.h"
-#include <stdio.h>
-#include <stdarg.h>
-#include <stdlib.h>
-
-b2Version b2_version = {2, 3, 2};
-
-// Memory allocators. Modify these to use your own allocator.
-void* b2Alloc(int32 size)
-{
-	return malloc(size);
-}
-
-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);
-}

Source/ThirdParty/Box2D/Box2D/Common/b2StackAllocator.cpp

@@ -1,83 +0,0 @@
-/*
-* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
-
-#include "Box2D/Common/b2StackAllocator.h"
-#include "Box2D/Common/b2Math.h"
-
-b2StackAllocator::b2StackAllocator()
-{
-	m_index = 0;
-	m_allocation = 0;
-	m_maxAllocation = 0;
-	m_entryCount = 0;
-}
-
-b2StackAllocator::~b2StackAllocator()
-{
-	b2Assert(m_index == 0);
-	b2Assert(m_entryCount == 0);
-}
-
-void* b2StackAllocator::Allocate(int32 size)
-{
-	b2Assert(m_entryCount < b2_maxStackEntries);
-
-	b2StackEntry* entry = m_entries + m_entryCount;
-	entry->size = size;
-	if (m_index + size > b2_stackSize)
-	{
-		entry->data = (char*)b2Alloc(size);
-		entry->usedMalloc = true;
-	}
-	else
-	{
-		entry->data = m_data + m_index;
-		entry->usedMalloc = false;
-		m_index += size;
-	}
-
-	m_allocation += size;
-	m_maxAllocation = b2Max(m_maxAllocation, m_allocation);
-	++m_entryCount;
-
-	return entry->data;
-}
-
-void b2StackAllocator::Free(void* p)
-{
-	b2Assert(m_entryCount > 0);
-	b2StackEntry* entry = m_entries + m_entryCount - 1;
-	b2Assert(p == entry->data);
-	if (entry->usedMalloc)
-	{
-		b2Free(p);
-	}
-	else
-	{
-		m_index -= entry->size;
-	}
-	m_allocation -= entry->size;
-	--m_entryCount;
-
-	p = nullptr;
-}
-
-int32 b2StackAllocator::GetMaxAllocation() const
-{
-	return m_maxAllocation;
-}

Source/ThirdParty/Box2D/Box2D/Common/b2StackAllocator.h

@@ -1,60 +0,0 @@
-/*
-* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef B2_STACK_ALLOCATOR_H
-#define B2_STACK_ALLOCATOR_H
-
-#include "Box2D/Common/b2Settings.h"
-
-const int32 b2_stackSize = 100 * 1024;	// 100k
-const int32 b2_maxStackEntries = 32;
-
-struct b2StackEntry
-{
-	char* data;
-	int32 size;
-	bool usedMalloc;
-};
-
-// This is a stack allocator used for fast per step allocations.
-// You must nest allocate/free pairs. The code will assert
-// if you try to interleave multiple allocate/free pairs.
-class b2StackAllocator
-{
-public:
-	b2StackAllocator();
-	~b2StackAllocator();
-
-	void* Allocate(int32 size);
-	void Free(void* p);
-
-	int32 GetMaxAllocation() const;
-
-private:
-
-	char m_data[b2_stackSize];
-	int32 m_index;
-
-	int32 m_allocation;
-	int32 m_maxAllocation;
-
-	b2StackEntry m_entries[b2_maxStackEntries];
-	int32 m_entryCount;
-};
-
-#endif

Source/ThirdParty/Box2D/Box2D/Common/b2Timer.cpp

@@ -1,121 +0,0 @@
-/*
-* Copyright (c) 2011 Erin Catto http://box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
-
-#include "Box2D/Common/b2Timer.h"
-
-#if defined(_WIN32)
-
-float64 b2Timer::s_invFrequency = 0.0f;
-
-#ifndef WIN32_LEAN_AND_MEAN
-#define WIN32_LEAN_AND_MEAN
-#endif
-
-#include <windows.h>
-
-b2Timer::b2Timer()
-{
-	LARGE_INTEGER largeInteger;
-
-	if (s_invFrequency == 0.0f)
-	{
-		QueryPerformanceFrequency(&largeInteger);
-		s_invFrequency = float64(largeInteger.QuadPart);
-		if (s_invFrequency > 0.0f)
-		{
-			s_invFrequency = 1000.0f / s_invFrequency;
-		}
-	}
-
-	QueryPerformanceCounter(&largeInteger);
-	m_start = float64(largeInteger.QuadPart);
-}
-
-void b2Timer::Reset()
-{
-	LARGE_INTEGER largeInteger;
-	QueryPerformanceCounter(&largeInteger);
-	m_start = float64(largeInteger.QuadPart);
-}
-
-float32 b2Timer::GetMilliseconds() const
-{
-	LARGE_INTEGER largeInteger;
-	QueryPerformanceCounter(&largeInteger);
-	float64 count = float64(largeInteger.QuadPart);
-	float32 ms = float32(s_invFrequency * (count - m_start));
-	return ms;
-}
-
-#elif defined(__linux__) || defined (__APPLE__)
-
-#include <sys/time.h>
-
-b2Timer::b2Timer()
-{
-    Reset();
-}
-
-void b2Timer::Reset()
-{
-    timeval t;
-    gettimeofday(&t, 0);
-    m_start_sec = t.tv_sec;
-    m_start_usec = t.tv_usec;
-}
-
-float32 b2Timer::GetMilliseconds() const
-{
-    timeval t;
-    gettimeofday(&t, 0);
-	time_t start_sec = m_start_sec;
-	suseconds_t start_usec = m_start_usec;
-	
-	// http://www.gnu.org/software/libc/manual/html_node/Elapsed-Time.html
-	if (t.tv_usec < start_usec)
-	{
-		int nsec = (start_usec - t.tv_usec) / 1000000 + 1;
-		start_usec -= 1000000 * nsec;
-		start_sec += nsec;
-	}
-	
-	if (t.tv_usec - start_usec > 1000000)
-	{
-		int nsec = (t.tv_usec - start_usec) / 1000000;
-		start_usec += 1000000 * nsec;
-		start_sec -= nsec;
-	}
-	return 1000.0f * (t.tv_sec - start_sec) + 0.001f * (t.tv_usec - start_usec);
-}
-
-#else
-
-b2Timer::b2Timer()
-{
-}
-
-void b2Timer::Reset()
-{
-}
-
-float32 b2Timer::GetMilliseconds() const
-{
-	return 0.0f;
-}
-
-#endif

Source/ThirdParty/Box2D/Box2D/Common/b2Timer.h

@@ -1,50 +0,0 @@
-/*
-* Copyright (c) 2011 Erin Catto http://box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef B2_TIMER_H
-#define B2_TIMER_H
-
-#include "Box2D/Common/b2Settings.h"
-
-/// Timer for profiling. This has platform specific code and may
-/// not work on every platform.
-class b2Timer
-{
-public:
-
-	/// Constructor
-	b2Timer();
-
-	/// Reset the timer.
-	void Reset();
-
-	/// Get the time since construction or the last reset.
-	float32 GetMilliseconds() const;
-
-private:
-
-#if defined(_WIN32)
-	float64 m_start;
-	static float64 s_invFrequency;
-#elif defined(__linux__) || defined (__APPLE__)
-	unsigned long long m_start_sec;
-	unsigned long long m_start_usec;
-#endif
-};
-
-#endif

Source/ThirdParty/Box2D/Box2D/Dynamics/Contacts/b2ChainAndCircleContact.cpp

@@ -1,53 +0,0 @@
-/*
-* Copyright (c) 2006-2010 Erin Catto http://www.box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
-
-#include "Box2D/Dynamics/Contacts/b2ChainAndCircleContact.h"
-#include "Box2D/Common/b2BlockAllocator.h"
-#include "Box2D/Dynamics/b2Fixture.h"
-#include "Box2D/Collision/Shapes/b2ChainShape.h"
-#include "Box2D/Collision/Shapes/b2EdgeShape.h"
-
-#include <new>
-
-b2Contact* b2ChainAndCircleContact::Create(b2Fixture* fixtureA, int32 indexA, b2Fixture* fixtureB, int32 indexB, b2BlockAllocator* allocator)
-{
-	void* mem = allocator->Allocate(sizeof(b2ChainAndCircleContact));
-	return new (mem) b2ChainAndCircleContact(fixtureA, indexA, fixtureB, indexB);
-}
-
-void b2ChainAndCircleContact::Destroy(b2Contact* contact, b2BlockAllocator* allocator)
-{
-	((b2ChainAndCircleContact*)contact)->~b2ChainAndCircleContact();
-	allocator->Free(contact, sizeof(b2ChainAndCircleContact));
-}
-
-b2ChainAndCircleContact::b2ChainAndCircleContact(b2Fixture* fixtureA, int32 indexA, b2Fixture* fixtureB, int32 indexB)
-: b2Contact(fixtureA, indexA, fixtureB, indexB)
-{
-	b2Assert(m_fixtureA->GetType() == b2Shape::e_chain);
-	b2Assert(m_fixtureB->GetType() == b2Shape::e_circle);
-}
-
-void b2ChainAndCircleContact::Evaluate(b2Manifold* manifold, const b2Transform& xfA, const b2Transform& xfB)
-{
-	b2ChainShape* chain = (b2ChainShape*)m_fixtureA->GetShape();
-	b2EdgeShape edge;
-	chain->GetChildEdge(&edge, m_indexA);
-	b2CollideEdgeAndCircle(	manifold, &edge, xfA,
-							(b2CircleShape*)m_fixtureB->GetShape(), xfB);
-}

Source/ThirdParty/Box2D/Box2D/Dynamics/Contacts/b2ChainAndCircleContact.h

@@ -1,39 +0,0 @@
-/*
-* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef B2_CHAIN_AND_CIRCLE_CONTACT_H
-#define B2_CHAIN_AND_CIRCLE_CONTACT_H
-
-#include "Box2D/Dynamics/Contacts/b2Contact.h"
-
-class b2BlockAllocator;
-
-class b2ChainAndCircleContact : public b2Contact
-{
-public:
-	static b2Contact* Create(	b2Fixture* fixtureA, int32 indexA,
-								b2Fixture* fixtureB, int32 indexB, b2BlockAllocator* allocator);
-	static void Destroy(b2Contact* contact, b2BlockAllocator* allocator);
-
-	b2ChainAndCircleContact(b2Fixture* fixtureA, int32 indexA, b2Fixture* fixtureB, int32 indexB);
-	~b2ChainAndCircleContact() {}
-
-	void Evaluate(b2Manifold* manifold, const b2Transform& xfA, const b2Transform& xfB) override;
-};
-
-#endif

Source/ThirdParty/Box2D/Box2D/Dynamics/Contacts/b2ChainAndPolygonContact.cpp

@@ -1,53 +0,0 @@
-/*
-* Copyright (c) 2006-2010 Erin Catto http://www.box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
-
-#include "Box2D/Dynamics/Contacts/b2ChainAndPolygonContact.h"
-#include "Box2D/Common/b2BlockAllocator.h"
-#include "Box2D/Dynamics/b2Fixture.h"
-#include "Box2D/Collision/Shapes/b2ChainShape.h"
-#include "Box2D/Collision/Shapes/b2EdgeShape.h"
-
-#include <new>
-
-b2Contact* b2ChainAndPolygonContact::Create(b2Fixture* fixtureA, int32 indexA, b2Fixture* fixtureB, int32 indexB, b2BlockAllocator* allocator)
-{
-	void* mem = allocator->Allocate(sizeof(b2ChainAndPolygonContact));
-	return new (mem) b2ChainAndPolygonContact(fixtureA, indexA, fixtureB, indexB);
-}
-
-void b2ChainAndPolygonContact::Destroy(b2Contact* contact, b2BlockAllocator* allocator)
-{
-	((b2ChainAndPolygonContact*)contact)->~b2ChainAndPolygonContact();
-	allocator->Free(contact, sizeof(b2ChainAndPolygonContact));
-}
-
-b2ChainAndPolygonContact::b2ChainAndPolygonContact(b2Fixture* fixtureA, int32 indexA, b2Fixture* fixtureB, int32 indexB)
-: b2Contact(fixtureA, indexA, fixtureB, indexB)
-{
-	b2Assert(m_fixtureA->GetType() == b2Shape::e_chain);
-	b2Assert(m_fixtureB->GetType() == b2Shape::e_polygon);
-}
-
-void b2ChainAndPolygonContact::Evaluate(b2Manifold* manifold, const b2Transform& xfA, const b2Transform& xfB)
-{
-	b2ChainShape* chain = (b2ChainShape*)m_fixtureA->GetShape();
-	b2EdgeShape edge;
-	chain->GetChildEdge(&edge, m_indexA);
-	b2CollideEdgeAndPolygon(	manifold, &edge, xfA,
-								(b2PolygonShape*)m_fixtureB->GetShape(), xfB);
-}

Source/ThirdParty/Box2D/Box2D/Dynamics/Contacts/b2ChainAndPolygonContact.h

@@ -1,39 +0,0 @@
-/*
-* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef B2_CHAIN_AND_POLYGON_CONTACT_H
-#define B2_CHAIN_AND_POLYGON_CONTACT_H
-
-#include "Box2D/Dynamics/Contacts/b2Contact.h"
-
-class b2BlockAllocator;
-
-class b2ChainAndPolygonContact : public b2Contact
-{
-public:
-	static b2Contact* Create(	b2Fixture* fixtureA, int32 indexA,
-								b2Fixture* fixtureB, int32 indexB, b2BlockAllocator* allocator);
-	static void Destroy(b2Contact* contact, b2BlockAllocator* allocator);
-
-	b2ChainAndPolygonContact(b2Fixture* fixtureA, int32 indexA, b2Fixture* fixtureB, int32 indexB);
-	~b2ChainAndPolygonContact() {}
-
-	void Evaluate(b2Manifold* manifold, const b2Transform& xfA, const b2Transform& xfB) override;
-};
-
-#endif

Source/ThirdParty/Box2D/Box2D/Dynamics/Contacts/b2CircleContact.cpp

@@ -1,52 +0,0 @@
-/*
-* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
-
-#include "Box2D/Dynamics/Contacts/b2CircleContact.h"
-#include "Box2D/Dynamics/b2Body.h"
-#include "Box2D/Dynamics/b2Fixture.h"
-#include "Box2D/Dynamics/b2WorldCallbacks.h"
-#include "Box2D/Common/b2BlockAllocator.h"
-#include "Box2D/Collision/b2TimeOfImpact.h"
-
-#include <new>
-
-b2Contact* b2CircleContact::Create(b2Fixture* fixtureA, int32, b2Fixture* fixtureB, int32, b2BlockAllocator* allocator)
-{
-	void* mem = allocator->Allocate(sizeof(b2CircleContact));
-	return new (mem) b2CircleContact(fixtureA, fixtureB);
-}
-
-void b2CircleContact::Destroy(b2Contact* contact, b2BlockAllocator* allocator)
-{
-	((b2CircleContact*)contact)->~b2CircleContact();
-	allocator->Free(contact, sizeof(b2CircleContact));
-}
-
-b2CircleContact::b2CircleContact(b2Fixture* fixtureA, b2Fixture* fixtureB)
-	: b2Contact(fixtureA, 0, fixtureB, 0)
-{
-	b2Assert(m_fixtureA->GetType() == b2Shape::e_circle);
-	b2Assert(m_fixtureB->GetType() == b2Shape::e_circle);
-}
-
-void b2CircleContact::Evaluate(b2Manifold* manifold, const b2Transform& xfA, const b2Transform& xfB)
-{
-	b2CollideCircles(manifold,
-					(b2CircleShape*)m_fixtureA->GetShape(), xfA,
-					(b2CircleShape*)m_fixtureB->GetShape(), xfB);
-}

Source/ThirdParty/Box2D/Box2D/Dynamics/Contacts/b2CircleContact.h

@@ -1,39 +0,0 @@
-/*
-* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef B2_CIRCLE_CONTACT_H
-#define B2_CIRCLE_CONTACT_H
-
-#include "Box2D/Dynamics/Contacts/b2Contact.h"
-
-class b2BlockAllocator;
-
-class b2CircleContact : public b2Contact
-{
-public:
-	static b2Contact* Create(	b2Fixture* fixtureA, int32 indexA,
-								b2Fixture* fixtureB, int32 indexB, b2BlockAllocator* allocator);
-	static void Destroy(b2Contact* contact, b2BlockAllocator* allocator);
-
-	b2CircleContact(b2Fixture* fixtureA, b2Fixture* fixtureB);
-	~b2CircleContact() {}
-
-	void Evaluate(b2Manifold* manifold, const b2Transform& xfA, const b2Transform& xfB) override;
-};
-
-#endif

Source/ThirdParty/Box2D/Box2D/Dynamics/Contacts/b2ContactSolver.h

@@ -1,95 +0,0 @@
-/*
-* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef B2_CONTACT_SOLVER_H
-#define B2_CONTACT_SOLVER_H
-
-#include "Box2D/Common/b2Math.h"
-#include "Box2D/Collision/b2Collision.h"
-#include "Box2D/Dynamics/b2TimeStep.h"
-
-class b2Contact;
-class b2Body;
-class b2StackAllocator;
-struct b2ContactPositionConstraint;
-
-struct b2VelocityConstraintPoint
-{
-	b2Vec2 rA;
-	b2Vec2 rB;
-	float32 normalImpulse;
-	float32 tangentImpulse;
-	float32 normalMass;
-	float32 tangentMass;
-	float32 velocityBias;
-};
-
-struct b2ContactVelocityConstraint
-{
-	b2VelocityConstraintPoint points[b2_maxManifoldPoints];
-	b2Vec2 normal;
-	b2Mat22 normalMass;
-	b2Mat22 K;
-	int32 indexA;
-	int32 indexB;
-	float32 invMassA, invMassB;
-	float32 invIA, invIB;
-	float32 friction;
-	float32 restitution;
-	float32 tangentSpeed;
-	int32 pointCount;
-	int32 contactIndex;
-};
-
-struct b2ContactSolverDef
-{
-	b2TimeStep step;
-	b2Contact** contacts;
-	int32 count;
-	b2Position* positions;
-	b2Velocity* velocities;
-	b2StackAllocator* allocator;
-};
-
-class b2ContactSolver
-{
-public:
-	b2ContactSolver(b2ContactSolverDef* def);
-	~b2ContactSolver();
-
-	void InitializeVelocityConstraints();
-
-	void WarmStart();
-	void SolveVelocityConstraints();
-	void StoreImpulses();
-
-	bool SolvePositionConstraints();
-	bool SolveTOIPositionConstraints(int32 toiIndexA, int32 toiIndexB);
-
-	b2TimeStep m_step;
-	b2Position* m_positions;
-	b2Velocity* m_velocities;
-	b2StackAllocator* m_allocator;
-	b2ContactPositionConstraint* m_positionConstraints;
-	b2ContactVelocityConstraint* m_velocityConstraints;
-	b2Contact** m_contacts;
-	int m_count;
-};
-
-#endif
-

Source/ThirdParty/Box2D/Box2D/Dynamics/Contacts/b2EdgeAndCircleContact.cpp

@@ -1,49 +0,0 @@
-/*
-* Copyright (c) 2006-2010 Erin Catto http://www.box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
-
-#include "Box2D/Dynamics/Contacts/b2EdgeAndCircleContact.h"
-#include "Box2D/Common/b2BlockAllocator.h"
-#include "Box2D/Dynamics/b2Fixture.h"
-
-#include <new>
-
-b2Contact* b2EdgeAndCircleContact::Create(b2Fixture* fixtureA, int32, b2Fixture* fixtureB, int32, b2BlockAllocator* allocator)
-{
-	void* mem = allocator->Allocate(sizeof(b2EdgeAndCircleContact));
-	return new (mem) b2EdgeAndCircleContact(fixtureA, fixtureB);
-}
-
-void b2EdgeAndCircleContact::Destroy(b2Contact* contact, b2BlockAllocator* allocator)
-{
-	((b2EdgeAndCircleContact*)contact)->~b2EdgeAndCircleContact();
-	allocator->Free(contact, sizeof(b2EdgeAndCircleContact));
-}
-
-b2EdgeAndCircleContact::b2EdgeAndCircleContact(b2Fixture* fixtureA, b2Fixture* fixtureB)
-: b2Contact(fixtureA, 0, fixtureB, 0)
-{
-	b2Assert(m_fixtureA->GetType() == b2Shape::e_edge);
-	b2Assert(m_fixtureB->GetType() == b2Shape::e_circle);
-}
-
-void b2EdgeAndCircleContact::Evaluate(b2Manifold* manifold, const b2Transform& xfA, const b2Transform& xfB)
-{
-	b2CollideEdgeAndCircle(	manifold,
-								(b2EdgeShape*)m_fixtureA->GetShape(), xfA,
-								(b2CircleShape*)m_fixtureB->GetShape(), xfB);
-}

Source/ThirdParty/Box2D/Box2D/Dynamics/Contacts/b2EdgeAndCircleContact.h

@@ -1,39 +0,0 @@
-/*
-* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef B2_EDGE_AND_CIRCLE_CONTACT_H
-#define B2_EDGE_AND_CIRCLE_CONTACT_H
-
-#include "Box2D/Dynamics/Contacts/b2Contact.h"
-
-class b2BlockAllocator;
-
-class b2EdgeAndCircleContact : public b2Contact
-{
-public:
-	static b2Contact* Create(	b2Fixture* fixtureA, int32 indexA,
-								b2Fixture* fixtureB, int32 indexB, b2BlockAllocator* allocator);
-	static void Destroy(b2Contact* contact, b2BlockAllocator* allocator);
-
-	b2EdgeAndCircleContact(b2Fixture* fixtureA, b2Fixture* fixtureB);
-	~b2EdgeAndCircleContact() {}
-
-	void Evaluate(b2Manifold* manifold, const b2Transform& xfA, const b2Transform& xfB) override;
-};
-
-#endif

Source/ThirdParty/Box2D/Box2D/Dynamics/Contacts/b2EdgeAndPolygonContact.cpp

@@ -1,49 +0,0 @@
-/*
-* Copyright (c) 2006-2010 Erin Catto http://www.box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
-
-#include "Box2D/Dynamics/Contacts/b2EdgeAndPolygonContact.h"
-#include "Box2D/Common/b2BlockAllocator.h"
-#include "Box2D/Dynamics/b2Fixture.h"
-
-#include <new>
-
-b2Contact* b2EdgeAndPolygonContact::Create(b2Fixture* fixtureA, int32, b2Fixture* fixtureB, int32, b2BlockAllocator* allocator)
-{
-	void* mem = allocator->Allocate(sizeof(b2EdgeAndPolygonContact));
-	return new (mem) b2EdgeAndPolygonContact(fixtureA, fixtureB);
-}
-
-void b2EdgeAndPolygonContact::Destroy(b2Contact* contact, b2BlockAllocator* allocator)
-{
-	((b2EdgeAndPolygonContact*)contact)->~b2EdgeAndPolygonContact();
-	allocator->Free(contact, sizeof(b2EdgeAndPolygonContact));
-}
-
-b2EdgeAndPolygonContact::b2EdgeAndPolygonContact(b2Fixture* fixtureA, b2Fixture* fixtureB)
-: b2Contact(fixtureA, 0, fixtureB, 0)
-{
-	b2Assert(m_fixtureA->GetType() == b2Shape::e_edge);
-	b2Assert(m_fixtureB->GetType() == b2Shape::e_polygon);
-}
-
-void b2EdgeAndPolygonContact::Evaluate(b2Manifold* manifold, const b2Transform& xfA, const b2Transform& xfB)
-{
-	b2CollideEdgeAndPolygon(	manifold,
-								(b2EdgeShape*)m_fixtureA->GetShape(), xfA,
-								(b2PolygonShape*)m_fixtureB->GetShape(), xfB);
-}

Source/ThirdParty/Box2D/Box2D/Dynamics/Contacts/b2EdgeAndPolygonContact.h

@@ -1,39 +0,0 @@
-/*
-* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef B2_EDGE_AND_POLYGON_CONTACT_H
-#define B2_EDGE_AND_POLYGON_CONTACT_H
-
-#include "Box2D/Dynamics/Contacts/b2Contact.h"
-
-class b2BlockAllocator;
-
-class b2EdgeAndPolygonContact : public b2Contact
-{
-public:
-	static b2Contact* Create(	b2Fixture* fixtureA, int32 indexA,
-								b2Fixture* fixtureB, int32 indexB, b2BlockAllocator* allocator);
-	static void Destroy(b2Contact* contact, b2BlockAllocator* allocator);
-
-	b2EdgeAndPolygonContact(b2Fixture* fixtureA, b2Fixture* fixtureB);
-	~b2EdgeAndPolygonContact() {}
-
-	void Evaluate(b2Manifold* manifold, const b2Transform& xfA, const b2Transform& xfB) override;
-};
-
-#endif

Source/ThirdParty/Box2D/Box2D/Dynamics/Contacts/b2PolygonAndCircleContact.cpp

@@ -1,49 +0,0 @@
-/*
-* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
-
-#include "Box2D/Dynamics/Contacts/b2PolygonAndCircleContact.h"
-#include "Box2D/Common/b2BlockAllocator.h"
-#include "Box2D/Dynamics/b2Fixture.h"
-
-#include <new>
-
-b2Contact* b2PolygonAndCircleContact::Create(b2Fixture* fixtureA, int32, b2Fixture* fixtureB, int32, b2BlockAllocator* allocator)
-{
-	void* mem = allocator->Allocate(sizeof(b2PolygonAndCircleContact));
-	return new (mem) b2PolygonAndCircleContact(fixtureA, fixtureB);
-}
-
-void b2PolygonAndCircleContact::Destroy(b2Contact* contact, b2BlockAllocator* allocator)
-{
-	((b2PolygonAndCircleContact*)contact)->~b2PolygonAndCircleContact();
-	allocator->Free(contact, sizeof(b2PolygonAndCircleContact));
-}
-
-b2PolygonAndCircleContact::b2PolygonAndCircleContact(b2Fixture* fixtureA, b2Fixture* fixtureB)
-: b2Contact(fixtureA, 0, fixtureB, 0)
-{
-	b2Assert(m_fixtureA->GetType() == b2Shape::e_polygon);
-	b2Assert(m_fixtureB->GetType() == b2Shape::e_circle);
-}
-
-void b2PolygonAndCircleContact::Evaluate(b2Manifold* manifold, const b2Transform& xfA, const b2Transform& xfB)
-{
-	b2CollidePolygonAndCircle(	manifold,
-								(b2PolygonShape*)m_fixtureA->GetShape(), xfA,
-								(b2CircleShape*)m_fixtureB->GetShape(), xfB);
-}

Source/ThirdParty/Box2D/Box2D/Dynamics/Contacts/b2PolygonAndCircleContact.h

@@ -1,38 +0,0 @@
-/*
-* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef B2_POLYGON_AND_CIRCLE_CONTACT_H
-#define B2_POLYGON_AND_CIRCLE_CONTACT_H
-
-#include "Box2D/Dynamics/Contacts/b2Contact.h"
-
-class b2BlockAllocator;
-
-class b2PolygonAndCircleContact : public b2Contact
-{
-public:
-	static b2Contact* Create(b2Fixture* fixtureA, int32 indexA, b2Fixture* fixtureB, int32 indexB, b2BlockAllocator* allocator);
-	static void Destroy(b2Contact* contact, b2BlockAllocator* allocator);
-
-	b2PolygonAndCircleContact(b2Fixture* fixtureA, b2Fixture* fixtureB);
-	~b2PolygonAndCircleContact() {}
-
-	void Evaluate(b2Manifold* manifold, const b2Transform& xfA, const b2Transform& xfB) override;
-};
-
-#endif

Source/ThirdParty/Box2D/Box2D/Dynamics/Contacts/b2PolygonContact.cpp

@@ -1,52 +0,0 @@
-/*
-* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
-
-#include "Box2D/Dynamics/Contacts/b2PolygonContact.h"
-#include "Box2D/Common/b2BlockAllocator.h"
-#include "Box2D/Collision/b2TimeOfImpact.h"
-#include "Box2D/Dynamics/b2Body.h"
-#include "Box2D/Dynamics/b2Fixture.h"
-#include "Box2D/Dynamics/b2WorldCallbacks.h"
-
-#include <new>
-
-b2Contact* b2PolygonContact::Create(b2Fixture* fixtureA, int32, b2Fixture* fixtureB, int32, b2BlockAllocator* allocator)
-{
-	void* mem = allocator->Allocate(sizeof(b2PolygonContact));
-	return new (mem) b2PolygonContact(fixtureA, fixtureB);
-}
-
-void b2PolygonContact::Destroy(b2Contact* contact, b2BlockAllocator* allocator)
-{
-	((b2PolygonContact*)contact)->~b2PolygonContact();
-	allocator->Free(contact, sizeof(b2PolygonContact));
-}
-
-b2PolygonContact::b2PolygonContact(b2Fixture* fixtureA, b2Fixture* fixtureB)
-	: b2Contact(fixtureA, 0, fixtureB, 0)
-{
-	b2Assert(m_fixtureA->GetType() == b2Shape::e_polygon);
-	b2Assert(m_fixtureB->GetType() == b2Shape::e_polygon);
-}
-
-void b2PolygonContact::Evaluate(b2Manifold* manifold, const b2Transform& xfA, const b2Transform& xfB)
-{
-	b2CollidePolygons(	manifold,
-						(b2PolygonShape*)m_fixtureA->GetShape(), xfA,
-						(b2PolygonShape*)m_fixtureB->GetShape(), xfB);
-}

Source/ThirdParty/Box2D/Box2D/Dynamics/Contacts/b2PolygonContact.h

@@ -1,39 +0,0 @@
-/*
-* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef B2_POLYGON_CONTACT_H
-#define B2_POLYGON_CONTACT_H
-
-#include "Box2D/Dynamics/Contacts/b2Contact.h"
-
-class b2BlockAllocator;
-
-class b2PolygonContact : public b2Contact
-{
-public:
-	static b2Contact* Create(	b2Fixture* fixtureA, int32 indexA,
-								b2Fixture* fixtureB, int32 indexB, b2BlockAllocator* allocator);
-	static void Destroy(b2Contact* contact, b2BlockAllocator* allocator);
-
-	b2PolygonContact(b2Fixture* fixtureA, b2Fixture* fixtureB);
-	~b2PolygonContact() {}
-
-	void Evaluate(b2Manifold* manifold, const b2Transform& xfA, const b2Transform& xfB) override;
-};
-
-#endif

Source/ThirdParty/Box2D/Box2D/Dynamics/Joints/b2DistanceJoint.cpp

@@ -1,260 +0,0 @@
-/*
-* Copyright (c) 2006-2011 Erin Catto http://www.box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
-
-#include "Box2D/Dynamics/Joints/b2DistanceJoint.h"
-#include "Box2D/Dynamics/b2Body.h"
-#include "Box2D/Dynamics/b2TimeStep.h"
-
-// 1-D constrained system
-// m (v2 - v1) = lambda
-// v2 + (beta/h) * x1 + gamma * lambda = 0, gamma has units of inverse mass.
-// x2 = x1 + h * v2
-
-// 1-D mass-damper-spring system
-// m (v2 - v1) + h * d * v2 + h * k * 
-
-// C = norm(p2 - p1) - L
-// u = (p2 - p1) / norm(p2 - p1)
-// Cdot = dot(u, v2 + cross(w2, r2) - v1 - cross(w1, r1))
-// J = [-u -cross(r1, u) u cross(r2, u)]
-// K = J * invM * JT
-//   = invMass1 + invI1 * cross(r1, u)^2 + invMass2 + invI2 * cross(r2, u)^2
-
-void b2DistanceJointDef::Initialize(b2Body* b1, b2Body* b2,
-									const b2Vec2& anchor1, const b2Vec2& anchor2)
-{
-	bodyA = b1;
-	bodyB = b2;
-	localAnchorA = bodyA->GetLocalPoint(anchor1);
-	localAnchorB = bodyB->GetLocalPoint(anchor2);
-	b2Vec2 d = anchor2 - anchor1;
-	length = d.Length();
-}
-
-b2DistanceJoint::b2DistanceJoint(const b2DistanceJointDef* def)
-: b2Joint(def)
-{
-	m_localAnchorA = def->localAnchorA;
-	m_localAnchorB = def->localAnchorB;
-	m_length = def->length;
-	m_frequencyHz = def->frequencyHz;
-	m_dampingRatio = def->dampingRatio;
-	m_impulse = 0.0f;
-	m_gamma = 0.0f;
-	m_bias = 0.0f;
-}
-
-void b2DistanceJoint::InitVelocityConstraints(const b2SolverData& data)
-{
-	m_indexA = m_bodyA->m_islandIndex;
-	m_indexB = m_bodyB->m_islandIndex;
-	m_localCenterA = m_bodyA->m_sweep.localCenter;
-	m_localCenterB = m_bodyB->m_sweep.localCenter;
-	m_invMassA = m_bodyA->m_invMass;
-	m_invMassB = m_bodyB->m_invMass;
-	m_invIA = m_bodyA->m_invI;
-	m_invIB = m_bodyB->m_invI;
-
-	b2Vec2 cA = data.positions[m_indexA].c;
-	float32 aA = data.positions[m_indexA].a;
-	b2Vec2 vA = data.velocities[m_indexA].v;
-	float32 wA = data.velocities[m_indexA].w;
-
-	b2Vec2 cB = data.positions[m_indexB].c;
-	float32 aB = data.positions[m_indexB].a;
-	b2Vec2 vB = data.velocities[m_indexB].v;
-	float32 wB = data.velocities[m_indexB].w;
-
-	b2Rot qA(aA), qB(aB);
-
-	m_rA = b2Mul(qA, m_localAnchorA - m_localCenterA);
-	m_rB = b2Mul(qB, m_localAnchorB - m_localCenterB);
-	m_u = cB + m_rB - cA - m_rA;
-
-	// Handle singularity.
-	float32 length = m_u.Length();
-	if (length > b2_linearSlop)
-	{
-		m_u *= 1.0f / length;
-	}
-	else
-	{
-		m_u.Set(0.0f, 0.0f);
-	}
-
-	float32 crAu = b2Cross(m_rA, m_u);
-	float32 crBu = b2Cross(m_rB, m_u);
-	float32 invMass = m_invMassA + m_invIA * crAu * crAu + m_invMassB + m_invIB * crBu * crBu;
-
-	// Compute the effective mass matrix.
-	m_mass = invMass != 0.0f ? 1.0f / invMass : 0.0f;
-
-	if (m_frequencyHz > 0.0f)
-	{
-		float32 C = length - m_length;
-
-		// Frequency
-		float32 omega = 2.0f * b2_pi * m_frequencyHz;
-
-		// Damping coefficient
-		float32 d = 2.0f * m_mass * m_dampingRatio * omega;
-
-		// Spring stiffness
-		float32 k = m_mass * omega * omega;
-
-		// magic formulas
-		float32 h = data.step.dt;
-		m_gamma = h * (d + h * k);
-		m_gamma = m_gamma != 0.0f ? 1.0f / m_gamma : 0.0f;
-		m_bias = C * h * k * m_gamma;
-
-		invMass += m_gamma;
-		m_mass = invMass != 0.0f ? 1.0f / invMass : 0.0f;
-	}
-	else
-	{
-		m_gamma = 0.0f;
-		m_bias = 0.0f;
-	}
-
-	if (data.step.warmStarting)
-	{
-		// Scale the impulse to support a variable time step.
-		m_impulse *= data.step.dtRatio;
-
-		b2Vec2 P = m_impulse * m_u;
-		vA -= m_invMassA * P;
-		wA -= m_invIA * b2Cross(m_rA, P);
-		vB += m_invMassB * P;
-		wB += m_invIB * b2Cross(m_rB, P);
-	}
-	else
-	{
-		m_impulse = 0.0f;
-	}
-
-	data.velocities[m_indexA].v = vA;
-	data.velocities[m_indexA].w = wA;
-	data.velocities[m_indexB].v = vB;
-	data.velocities[m_indexB].w = wB;
-}
-
-void b2DistanceJoint::SolveVelocityConstraints(const b2SolverData& data)
-{
-	b2Vec2 vA = data.velocities[m_indexA].v;
-	float32 wA = data.velocities[m_indexA].w;
-	b2Vec2 vB = data.velocities[m_indexB].v;
-	float32 wB = data.velocities[m_indexB].w;
-
-	// Cdot = dot(u, v + cross(w, r))
-	b2Vec2 vpA = vA + b2Cross(wA, m_rA);
-	b2Vec2 vpB = vB + b2Cross(wB, m_rB);
-	float32 Cdot = b2Dot(m_u, vpB - vpA);
-
-	float32 impulse = -m_mass * (Cdot + m_bias + m_gamma * m_impulse);
-	m_impulse += impulse;
-
-	b2Vec2 P = impulse * m_u;
-	vA -= m_invMassA * P;
-	wA -= m_invIA * b2Cross(m_rA, P);
-	vB += m_invMassB * P;
-	wB += m_invIB * b2Cross(m_rB, P);
-
-	data.velocities[m_indexA].v = vA;
-	data.velocities[m_indexA].w = wA;
-	data.velocities[m_indexB].v = vB;
-	data.velocities[m_indexB].w = wB;
-}
-
-bool b2DistanceJoint::SolvePositionConstraints(const b2SolverData& data)
-{
-	if (m_frequencyHz > 0.0f)
-	{
-		// There is no position correction for soft distance constraints.
-		return true;
-	}
-
-	b2Vec2 cA = data.positions[m_indexA].c;
-	float32 aA = data.positions[m_indexA].a;
-	b2Vec2 cB = data.positions[m_indexB].c;
-	float32 aB = data.positions[m_indexB].a;
-
-	b2Rot qA(aA), qB(aB);
-
-	b2Vec2 rA = b2Mul(qA, m_localAnchorA - m_localCenterA);
-	b2Vec2 rB = b2Mul(qB, m_localAnchorB - m_localCenterB);
-	b2Vec2 u = cB + rB - cA - rA;
-
-	float32 length = u.Normalize();
-	float32 C = length - m_length;
-	C = b2Clamp(C, -b2_maxLinearCorrection, b2_maxLinearCorrection);
-
-	float32 impulse = -m_mass * C;
-	b2Vec2 P = impulse * u;
-
-	cA -= m_invMassA * P;
-	aA -= m_invIA * b2Cross(rA, P);
-	cB += m_invMassB * P;
-	aB += m_invIB * b2Cross(rB, P);
-
-	data.positions[m_indexA].c = cA;
-	data.positions[m_indexA].a = aA;
-	data.positions[m_indexB].c = cB;
-	data.positions[m_indexB].a = aB;
-
-	return b2Abs(C) < b2_linearSlop;
-}
-
-b2Vec2 b2DistanceJoint::GetAnchorA() const
-{
-	return m_bodyA->GetWorldPoint(m_localAnchorA);
-}
-
-b2Vec2 b2DistanceJoint::GetAnchorB() const
-{
-	return m_bodyB->GetWorldPoint(m_localAnchorB);
-}
-
-b2Vec2 b2DistanceJoint::GetReactionForce(float32 inv_dt) const
-{
-	b2Vec2 F = (inv_dt * m_impulse) * m_u;
-	return F;
-}
-
-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);
-	b2Log("  joints[%d] = m_world->CreateJoint(&jd);\n", m_index);
-}

Source/ThirdParty/Box2D/Box2D/Dynamics/Joints/b2DistanceJoint.h

@@ -1,169 +0,0 @@
-/*
-* Copyright (c) 2006-2007 Erin Catto http://www.box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef B2_DISTANCE_JOINT_H
-#define B2_DISTANCE_JOINT_H
-
-#include "Box2D/Dynamics/Joints/b2Joint.h"
-
-/// Distance joint definition. This requires defining an
-/// anchor point on both bodies and the non-zero length of the
-/// distance joint. The definition uses local anchor points
-/// so that the initial configuration can violate the constraint
-/// slightly. This helps when saving and loading a game.
-/// @warning Do not use a zero or short length.
-struct b2DistanceJointDef : public b2JointDef
-{
-	b2DistanceJointDef()
-	{
-		type = e_distanceJoint;
-		localAnchorA.Set(0.0f, 0.0f);
-		localAnchorB.Set(0.0f, 0.0f);
-		length = 1.0f;
-		frequencyHz = 0.0f;
-		dampingRatio = 0.0f;
-	}
-
-	/// Initialize the bodies, anchors, and length using the world
-	/// anchors.
-	void Initialize(b2Body* bodyA, b2Body* bodyB,
-					const b2Vec2& anchorA, const b2Vec2& anchorB);
-
-	/// The local anchor point relative to bodyA's origin.
-	b2Vec2 localAnchorA;
-
-	/// The local anchor point relative to bodyB's origin.
-	b2Vec2 localAnchorB;
-
-	/// The natural length between the anchor points.
-	float32 length;
-
-	/// The mass-spring-damper frequency in Hertz. A value of 0
-	/// disables softness.
-	float32 frequencyHz;
-
-	/// The damping ratio. 0 = no damping, 1 = critical damping.
-	float32 dampingRatio;
-};
-
-/// A distance joint constrains two points on two bodies
-/// to remain at a fixed distance from each other. You can view
-/// this as a massless, rigid rod.
-class b2DistanceJoint : public b2Joint
-{
-public:
-
-	b2Vec2 GetAnchorA() const override;
-	b2Vec2 GetAnchorB() const override;
-
-	/// Get the reaction force given the inverse time step.
-	/// Unit is N.
-	b2Vec2 GetReactionForce(float32 inv_dt) const override;
-
-	/// Get the reaction torque given the inverse time step.
-	/// Unit is N*m. This is always zero for a distance joint.
-	float32 GetReactionTorque(float32 inv_dt) const override;
-
-	/// The local anchor point relative to bodyA's origin.
-	const b2Vec2& GetLocalAnchorA() const { return m_localAnchorA; }
-
-	/// The local anchor point relative to bodyB's origin.
-	const b2Vec2& GetLocalAnchorB() const  { return m_localAnchorB; }
-
-	/// Set/get the natural length.
-	/// Manipulating the length can lead to non-physical behavior when the frequency is zero.
-	void SetLength(float32 length);
-	float32 GetLength() const;
-
-	/// Set/get frequency in Hz.
-	void SetFrequency(float32 hz);
-	float32 GetFrequency() const;
-
-	/// Set/get damping ratio.
-	void SetDampingRatio(float32 ratio);
-	float32 GetDampingRatio() const;
-
-	/// Dump joint to dmLog
-	void Dump() override;
-
-protected:
-
-	friend class b2Joint;
-	b2DistanceJoint(const b2DistanceJointDef* data);
-
-	void InitVelocityConstraints(const b2SolverData& data) override;
-	void SolveVelocityConstraints(const b2SolverData& data) override;
-	bool SolvePositionConstraints(const b2SolverData& data) override;
-
-	float32 m_frequencyHz;
-	float32 m_dampingRatio;
-	float32 m_bias;
-
-	// Solver shared
-	b2Vec2 m_localAnchorA;
-	b2Vec2 m_localAnchorB;
-	float32 m_gamma;
-	float32 m_impulse;
-	float32 m_length;
-
-	// Solver temp
-	int32 m_indexA;
-	int32 m_indexB;
-	b2Vec2 m_u;
-	b2Vec2 m_rA;
-	b2Vec2 m_rB;
-	b2Vec2 m_localCenterA;
-	b2Vec2 m_localCenterB;
-	float32 m_invMassA;
-	float32 m_invMassB;
-	float32 m_invIA;
-	float32 m_invIB;
-	float32 m_mass;
-};
-
-inline void b2DistanceJoint::SetLength(float32 length)
-{
-	m_length = length;
-}
-
-inline float32 b2DistanceJoint::GetLength() const
-{
-	return m_length;
-}
-
-inline void b2DistanceJoint::SetFrequency(float32 hz)
-{
-	m_frequencyHz = hz;
-}
-
-inline float32 b2DistanceJoint::GetFrequency() const
-{
-	return m_frequencyHz;
-}
-
-inline void b2DistanceJoint::SetDampingRatio(float32 ratio)
-{
-	m_dampingRatio = ratio;
-}
-
-inline float32 b2DistanceJoint::GetDampingRatio() const
-{
-	return m_dampingRatio;
-}
-
-#endif

Source/ThirdParty/Box2D/Box2D/Dynamics/Joints/b2Joint.cpp

@@ -1,211 +0,0 @@
-/*
-* Copyright (c) 2006-2007 Erin Catto http://www.box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
-
-#include "Box2D/Dynamics/Joints/b2Joint.h"
-#include "Box2D/Dynamics/Joints/b2DistanceJoint.h"
-#include "Box2D/Dynamics/Joints/b2WheelJoint.h"
-#include "Box2D/Dynamics/Joints/b2MouseJoint.h"
-#include "Box2D/Dynamics/Joints/b2RevoluteJoint.h"
-#include "Box2D/Dynamics/Joints/b2PrismaticJoint.h"
-#include "Box2D/Dynamics/Joints/b2PulleyJoint.h"
-#include "Box2D/Dynamics/Joints/b2GearJoint.h"
-#include "Box2D/Dynamics/Joints/b2WeldJoint.h"
-#include "Box2D/Dynamics/Joints/b2FrictionJoint.h"
-#include "Box2D/Dynamics/Joints/b2RopeJoint.h"
-#include "Box2D/Dynamics/Joints/b2MotorJoint.h"
-#include "Box2D/Dynamics/b2Body.h"
-#include "Box2D/Dynamics/b2World.h"
-#include "Box2D/Common/b2BlockAllocator.h"
-
-#include <new>
-
-b2Joint* b2Joint::Create(const b2JointDef* def, b2BlockAllocator* allocator)
-{
-	b2Joint* joint = nullptr;
-
-	switch (def->type)
-	{
-	case e_distanceJoint:
-		{
-			void* mem = allocator->Allocate(sizeof(b2DistanceJoint));
-			joint = new (mem) b2DistanceJoint(static_cast<const b2DistanceJointDef*>(def));
-		}
-		break;
-
-	case e_mouseJoint:
-		{
-			void* mem = allocator->Allocate(sizeof(b2MouseJoint));
-			joint = new (mem) b2MouseJoint(static_cast<const b2MouseJointDef*>(def));
-		}
-		break;
-
-	case e_prismaticJoint:
-		{
-			void* mem = allocator->Allocate(sizeof(b2PrismaticJoint));
-			joint = new (mem) b2PrismaticJoint(static_cast<const b2PrismaticJointDef*>(def));
-		}
-		break;
-
-	case e_revoluteJoint:
-		{
-			void* mem = allocator->Allocate(sizeof(b2RevoluteJoint));
-			joint = new (mem) b2RevoluteJoint(static_cast<const b2RevoluteJointDef*>(def));
-		}
-		break;
-
-	case e_pulleyJoint:
-		{
-			void* mem = allocator->Allocate(sizeof(b2PulleyJoint));
-			joint = new (mem) b2PulleyJoint(static_cast<const b2PulleyJointDef*>(def));
-		}
-		break;
-
-	case e_gearJoint:
-		{
-			void* mem = allocator->Allocate(sizeof(b2GearJoint));
-			joint = new (mem) b2GearJoint(static_cast<const b2GearJointDef*>(def));
-		}
-		break;
-
-	case e_wheelJoint:
-		{
-			void* mem = allocator->Allocate(sizeof(b2WheelJoint));
-			joint = new (mem) b2WheelJoint(static_cast<const b2WheelJointDef*>(def));
-		}
-		break;
-
-	case e_weldJoint:
-		{
-			void* mem = allocator->Allocate(sizeof(b2WeldJoint));
-			joint = new (mem) b2WeldJoint(static_cast<const b2WeldJointDef*>(def));
-		}
-		break;
-        
-	case e_frictionJoint:
-		{
-			void* mem = allocator->Allocate(sizeof(b2FrictionJoint));
-			joint = new (mem) b2FrictionJoint(static_cast<const b2FrictionJointDef*>(def));
-		}
-		break;
-
-	case e_ropeJoint:
-		{
-			void* mem = allocator->Allocate(sizeof(b2RopeJoint));
-			joint = new (mem) b2RopeJoint(static_cast<const b2RopeJointDef*>(def));
-		}
-		break;
-
-	case e_motorJoint:
-		{
-			void* mem = allocator->Allocate(sizeof(b2MotorJoint));
-			joint = new (mem) b2MotorJoint(static_cast<const b2MotorJointDef*>(def));
-		}
-		break;
-
-	default:
-		b2Assert(false);
-		break;
-	}
-
-	return joint;
-}
-
-void b2Joint::Destroy(b2Joint* joint, b2BlockAllocator* allocator)
-{
-	joint->~b2Joint();
-	switch (joint->m_type)
-	{
-	case e_distanceJoint:
-		allocator->Free(joint, sizeof(b2DistanceJoint));
-		break;
-
-	case e_mouseJoint:
-		allocator->Free(joint, sizeof(b2MouseJoint));
-		break;
-
-	case e_prismaticJoint:
-		allocator->Free(joint, sizeof(b2PrismaticJoint));
-		break;
-
-	case e_revoluteJoint:
-		allocator->Free(joint, sizeof(b2RevoluteJoint));
-		break;
-
-	case e_pulleyJoint:
-		allocator->Free(joint, sizeof(b2PulleyJoint));
-		break;
-
-	case e_gearJoint:
-		allocator->Free(joint, sizeof(b2GearJoint));
-		break;
-
-	case e_wheelJoint:
-		allocator->Free(joint, sizeof(b2WheelJoint));
-		break;
-    
-	case e_weldJoint:
-		allocator->Free(joint, sizeof(b2WeldJoint));
-		break;
-
-	case e_frictionJoint:
-		allocator->Free(joint, sizeof(b2FrictionJoint));
-		break;
-
-	case e_ropeJoint:
-		allocator->Free(joint, sizeof(b2RopeJoint));
-		break;
-
-	case e_motorJoint:
-		allocator->Free(joint, sizeof(b2MotorJoint));
-		break;
-
-	default:
-		b2Assert(false);
-		break;
-	}
-}
-
-b2Joint::b2Joint(const b2JointDef* def)
-{
-	b2Assert(def->bodyA != def->bodyB);
-
-	m_type = def->type;
-	m_prev = nullptr;
-	m_next = nullptr;
-	m_bodyA = def->bodyA;
-	m_bodyB = def->bodyB;
-	m_index = 0;
-	m_collideConnected = def->collideConnected;
-	m_islandFlag = false;
-	m_userData = def->userData;
-
-	m_edgeA.joint = nullptr;
-	m_edgeA.other = nullptr;
-	m_edgeA.prev = nullptr;
-	m_edgeA.next = nullptr;
-
-	m_edgeB.joint = nullptr;
-	m_edgeB.other = nullptr;
-	m_edgeB.prev = nullptr;
-	m_edgeB.next = nullptr;
-}
-
-bool b2Joint::IsActive() const
-{
-	return m_bodyA->IsActive() && m_bodyB->IsActive();
-}

Source/ThirdParty/Box2D/Box2D/Dynamics/Joints/b2PrismaticJoint.cpp

@@ -1,642 +0,0 @@
-/*
-* Copyright (c) 2006-2011 Erin Catto http://www.box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
-
-#include "Box2D/Dynamics/Joints/b2PrismaticJoint.h"
-#include "Box2D/Dynamics/b2Body.h"
-#include "Box2D/Dynamics/b2TimeStep.h"
-
-// Linear constraint (point-to-line)
-// d = p2 - p1 = x2 + r2 - x1 - r1
-// C = dot(perp, d)
-// Cdot = dot(d, cross(w1, perp)) + dot(perp, v2 + cross(w2, r2) - v1 - cross(w1, r1))
-//      = -dot(perp, v1) - dot(cross(d + r1, perp), w1) + dot(perp, v2) + dot(cross(r2, perp), v2)
-// J = [-perp, -cross(d + r1, perp), perp, cross(r2,perp)]
-//
-// Angular constraint
-// C = a2 - a1 + a_initial
-// Cdot = w2 - w1
-// J = [0 0 -1 0 0 1]
-//
-// K = J * invM * JT
-//
-// J = [-a -s1 a s2]
-//     [0  -1  0  1]
-// a = perp
-// s1 = cross(d + r1, a) = cross(p2 - x1, a)
-// s2 = cross(r2, a) = cross(p2 - x2, a)
-
-
-// Motor/Limit linear constraint
-// C = dot(ax1, d)
-// Cdot = = -dot(ax1, v1) - dot(cross(d + r1, ax1), w1) + dot(ax1, v2) + dot(cross(r2, ax1), v2)
-// J = [-ax1 -cross(d+r1,ax1) ax1 cross(r2,ax1)]
-
-// Block Solver
-// We develop a block solver that includes the joint limit. This makes the limit stiff (inelastic) even
-// when the mass has poor distribution (leading to large torques about the joint anchor points).
-//
-// The Jacobian has 3 rows:
-// J = [-uT -s1 uT s2] // linear
-//     [0   -1   0  1] // angular
-//     [-vT -a1 vT a2] // limit
-//
-// u = perp
-// v = axis
-// s1 = cross(d + r1, u), s2 = cross(r2, u)
-// a1 = cross(d + r1, v), a2 = cross(r2, v)
-
-// M * (v2 - v1) = JT * df
-// J * v2 = bias
-//
-// v2 = v1 + invM * JT * df
-// J * (v1 + invM * JT * df) = bias
-// K * df = bias - J * v1 = -Cdot
-// K = J * invM * JT
-// Cdot = J * v1 - bias
-//
-// Now solve for f2.
-// df = f2 - f1
-// K * (f2 - f1) = -Cdot
-// f2 = invK * (-Cdot) + f1
-//
-// Clamp accumulated limit impulse.
-// lower: f2(3) = max(f2(3), 0)
-// upper: f2(3) = min(f2(3), 0)
-//
-// Solve for correct f2(1:2)
-// K(1:2, 1:2) * f2(1:2) = -Cdot(1:2) - K(1:2,3) * f2(3) + K(1:2,1:3) * f1
-//                       = -Cdot(1:2) - K(1:2,3) * f2(3) + K(1:2,1:2) * f1(1:2) + K(1:2,3) * f1(3)
-// K(1:2, 1:2) * f2(1:2) = -Cdot(1:2) - K(1:2,3) * (f2(3) - f1(3)) + K(1:2,1:2) * f1(1:2)
-// f2(1:2) = invK(1:2,1:2) * (-Cdot(1:2) - K(1:2,3) * (f2(3) - f1(3))) + f1(1:2)
-//
-// Now compute impulse to be applied:
-// df = f2 - f1
-
-void b2PrismaticJointDef::Initialize(b2Body* bA, b2Body* bB, const b2Vec2& anchor, const b2Vec2& axis)
-{
-	bodyA = bA;
-	bodyB = bB;
-	localAnchorA = bodyA->GetLocalPoint(anchor);
-	localAnchorB = bodyB->GetLocalPoint(anchor);
-	localAxisA = bodyA->GetLocalVector(axis);
-	referenceAngle = bodyB->GetAngle() - bodyA->GetAngle();
-}
-
-b2PrismaticJoint::b2PrismaticJoint(const b2PrismaticJointDef* def)
-: b2Joint(def)
-{
-	m_localAnchorA = def->localAnchorA;
-	m_localAnchorB = def->localAnchorB;
-	m_localXAxisA = def->localAxisA;
-	m_localXAxisA.Normalize();
-	m_localYAxisA = b2Cross(1.0f, m_localXAxisA);
-	m_referenceAngle = def->referenceAngle;
-
-	m_impulse.SetZero();
-	m_motorMass = 0.0f;
-	m_motorImpulse = 0.0f;
-
-	m_lowerTranslation = def->lowerTranslation;
-	m_upperTranslation = def->upperTranslation;
-	m_maxMotorForce = def->maxMotorForce;
-	m_motorSpeed = def->motorSpeed;
-	m_enableLimit = def->enableLimit;
-	m_enableMotor = def->enableMotor;
-	m_limitState = e_inactiveLimit;
-
-	m_axis.SetZero();
-	m_perp.SetZero();
-}
-
-void b2PrismaticJoint::InitVelocityConstraints(const b2SolverData& data)
-{
-	m_indexA = m_bodyA->m_islandIndex;
-	m_indexB = m_bodyB->m_islandIndex;
-	m_localCenterA = m_bodyA->m_sweep.localCenter;
-	m_localCenterB = m_bodyB->m_sweep.localCenter;
-	m_invMassA = m_bodyA->m_invMass;
-	m_invMassB = m_bodyB->m_invMass;
-	m_invIA = m_bodyA->m_invI;
-	m_invIB = m_bodyB->m_invI;
-
-	b2Vec2 cA = data.positions[m_indexA].c;
-	float32 aA = data.positions[m_indexA].a;
-	b2Vec2 vA = data.velocities[m_indexA].v;
-	float32 wA = data.velocities[m_indexA].w;
-
-	b2Vec2 cB = data.positions[m_indexB].c;
-	float32 aB = data.positions[m_indexB].a;
-	b2Vec2 vB = data.velocities[m_indexB].v;
-	float32 wB = data.velocities[m_indexB].w;
-
-	b2Rot qA(aA), qB(aB);
-
-	// Compute the effective masses.
-	b2Vec2 rA = b2Mul(qA, m_localAnchorA - m_localCenterA);
-	b2Vec2 rB = b2Mul(qB, m_localAnchorB - m_localCenterB);
-	b2Vec2 d = (cB - cA) + rB - rA;
-
-	float32 mA = m_invMassA, mB = m_invMassB;
-	float32 iA = m_invIA, iB = m_invIB;
-
-	// Compute motor Jacobian and effective mass.
-	{
-		m_axis = b2Mul(qA, m_localXAxisA);
-		m_a1 = b2Cross(d + rA, m_axis);
-		m_a2 = b2Cross(rB, m_axis);
-
-		m_motorMass = mA + mB + iA * m_a1 * m_a1 + iB * m_a2 * m_a2;
-		if (m_motorMass > 0.0f)
-		{
-			m_motorMass = 1.0f / m_motorMass;
-		}
-	}
-
-	// Prismatic constraint.
-	{
-		m_perp = b2Mul(qA, m_localYAxisA);
-
-		m_s1 = b2Cross(d + rA, m_perp);
-		m_s2 = b2Cross(rB, m_perp);
-
-		float32 k11 = mA + mB + iA * m_s1 * m_s1 + iB * m_s2 * m_s2;
-		float32 k12 = iA * m_s1 + iB * m_s2;
-		float32 k13 = iA * m_s1 * m_a1 + iB * m_s2 * m_a2;
-		float32 k22 = iA + iB;
-		if (k22 == 0.0f)
-		{
-			// For bodies with fixed rotation.
-			k22 = 1.0f;
-		}
-		float32 k23 = iA * m_a1 + iB * m_a2;
-		float32 k33 = mA + mB + iA * m_a1 * m_a1 + iB * m_a2 * m_a2;
-
-		m_K.ex.Set(k11, k12, k13);
-		m_K.ey.Set(k12, k22, k23);
-		m_K.ez.Set(k13, k23, k33);
-	}
-
-	// Compute motor and limit terms.
-	if (m_enableLimit)
-	{
-		float32 jointTranslation = b2Dot(m_axis, d);
-		if (b2Abs(m_upperTranslation - m_lowerTranslation) < 2.0f * b2_linearSlop)
-		{
-			m_limitState = e_equalLimits;
-		}
-		else if (jointTranslation <= m_lowerTranslation)
-		{
-			if (m_limitState != e_atLowerLimit)
-			{
-				m_limitState = e_atLowerLimit;
-				m_impulse.z = 0.0f;
-			}
-		}
-		else if (jointTranslation >= m_upperTranslation)
-		{
-			if (m_limitState != e_atUpperLimit)
-			{
-				m_limitState = e_atUpperLimit;
-				m_impulse.z = 0.0f;
-			}
-		}
-		else
-		{
-			m_limitState = e_inactiveLimit;
-			m_impulse.z = 0.0f;
-		}
-	}
-	else
-	{
-		m_limitState = e_inactiveLimit;
-		m_impulse.z = 0.0f;
-	}
-
-	if (m_enableMotor == false)
-	{
-		m_motorImpulse = 0.0f;
-	}
-
-	if (data.step.warmStarting)
-	{
-		// Account for variable time step.
-		m_impulse *= data.step.dtRatio;
-		m_motorImpulse *= data.step.dtRatio;
-
-		b2Vec2 P = m_impulse.x * m_perp + (m_motorImpulse + m_impulse.z) * m_axis;
-		float32 LA = m_impulse.x * m_s1 + m_impulse.y + (m_motorImpulse + m_impulse.z) * m_a1;
-		float32 LB = m_impulse.x * m_s2 + m_impulse.y + (m_motorImpulse + m_impulse.z) * m_a2;
-
-		vA -= mA * P;
-		wA -= iA * LA;
-
-		vB += mB * P;
-		wB += iB * LB;
-	}
-	else
-	{
-		m_impulse.SetZero();
-		m_motorImpulse = 0.0f;
-	}
-
-	data.velocities[m_indexA].v = vA;
-	data.velocities[m_indexA].w = wA;
-	data.velocities[m_indexB].v = vB;
-	data.velocities[m_indexB].w = wB;
-}
-
-void b2PrismaticJoint::SolveVelocityConstraints(const b2SolverData& data)
-{
-	b2Vec2 vA = data.velocities[m_indexA].v;
-	float32 wA = data.velocities[m_indexA].w;
-	b2Vec2 vB = data.velocities[m_indexB].v;
-	float32 wB = data.velocities[m_indexB].w;
-
-	float32 mA = m_invMassA, mB = m_invMassB;
-	float32 iA = m_invIA, iB = m_invIB;
-
-	// Solve linear motor constraint.
-	if (m_enableMotor && m_limitState != e_equalLimits)
-	{
-		float32 Cdot = b2Dot(m_axis, vB - vA) + m_a2 * wB - m_a1 * wA;
-		float32 impulse = m_motorMass * (m_motorSpeed - Cdot);
-		float32 oldImpulse = m_motorImpulse;
-		float32 maxImpulse = data.step.dt * m_maxMotorForce;
-		m_motorImpulse = b2Clamp(m_motorImpulse + impulse, -maxImpulse, maxImpulse);
-		impulse = m_motorImpulse - oldImpulse;
-
-		b2Vec2 P = impulse * m_axis;
-		float32 LA = impulse * m_a1;
-		float32 LB = impulse * m_a2;
-
-		vA -= mA * P;
-		wA -= iA * LA;
-
-		vB += mB * P;
-		wB += iB * LB;
-	}
-
-	b2Vec2 Cdot1;
-	Cdot1.x = b2Dot(m_perp, vB - vA) + m_s2 * wB - m_s1 * wA;
-	Cdot1.y = wB - wA;
-
-	if (m_enableLimit && m_limitState != e_inactiveLimit)
-	{
-		// Solve prismatic and limit constraint in block form.
-		float32 Cdot2;
-		Cdot2 = b2Dot(m_axis, vB - vA) + m_a2 * wB - m_a1 * wA;
-		b2Vec3 Cdot(Cdot1.x, Cdot1.y, Cdot2);
-
-		b2Vec3 f1 = m_impulse;
-		b2Vec3 df =  m_K.Solve33(-Cdot);
-		m_impulse += df;
-
-		if (m_limitState == e_atLowerLimit)
-		{
-			m_impulse.z = b2Max(m_impulse.z, 0.0f);
-		}
-		else if (m_limitState == e_atUpperLimit)
-		{
-			m_impulse.z = b2Min(m_impulse.z, 0.0f);
-		}
-
-		// f2(1:2) = invK(1:2,1:2) * (-Cdot(1:2) - K(1:2,3) * (f2(3) - f1(3))) + f1(1:2)
-		b2Vec2 b = -Cdot1 - (m_impulse.z - f1.z) * b2Vec2(m_K.ez.x, m_K.ez.y);
-		b2Vec2 f2r = m_K.Solve22(b) + b2Vec2(f1.x, f1.y);
-		m_impulse.x = f2r.x;
-		m_impulse.y = f2r.y;
-
-		df = m_impulse - f1;
-
-		b2Vec2 P = df.x * m_perp + df.z * m_axis;
-		float32 LA = df.x * m_s1 + df.y + df.z * m_a1;
-		float32 LB = df.x * m_s2 + df.y + df.z * m_a2;
-
-		vA -= mA * P;
-		wA -= iA * LA;
-
-		vB += mB * P;
-		wB += iB * LB;
-	}
-	else
-	{
-		// Limit is inactive, just solve the prismatic constraint in block form.
-		b2Vec2 df = m_K.Solve22(-Cdot1);
-		m_impulse.x += df.x;
-		m_impulse.y += df.y;
-
-		b2Vec2 P = df.x * m_perp;
-		float32 LA = df.x * m_s1 + df.y;
-		float32 LB = df.x * m_s2 + df.y;
-
-		vA -= mA * P;
-		wA -= iA * LA;
-
-		vB += mB * P;
-		wB += iB * LB;
-	}
-
-	data.velocities[m_indexA].v = vA;
-	data.velocities[m_indexA].w = wA;
-	data.velocities[m_indexB].v = vB;
-	data.velocities[m_indexB].w = wB;
-}
-
-// A velocity based solver computes reaction forces(impulses) using the velocity constraint solver.Under this context,
-// the position solver is not there to resolve forces.It is only there to cope with integration error.
-//
-// Therefore, the pseudo impulses in the position solver do not have any physical meaning.Thus it is okay if they suck.
-//
-// We could take the active state from the velocity solver.However, the joint might push past the limit when the velocity
-// solver indicates the limit is inactive.
-bool b2PrismaticJoint::SolvePositionConstraints(const b2SolverData& data)
-{
-	b2Vec2 cA = data.positions[m_indexA].c;
-	float32 aA = data.positions[m_indexA].a;
-	b2Vec2 cB = data.positions[m_indexB].c;
-	float32 aB = data.positions[m_indexB].a;
-
-	b2Rot qA(aA), qB(aB);
-
-	float32 mA = m_invMassA, mB = m_invMassB;
-	float32 iA = m_invIA, iB = m_invIB;
-
-	// Compute fresh Jacobians
-	b2Vec2 rA = b2Mul(qA, m_localAnchorA - m_localCenterA);
-	b2Vec2 rB = b2Mul(qB, m_localAnchorB - m_localCenterB);
-	b2Vec2 d = cB + rB - cA - rA;
-
-	b2Vec2 axis = b2Mul(qA, m_localXAxisA);
-	float32 a1 = b2Cross(d + rA, axis);
-	float32 a2 = b2Cross(rB, axis);
-	b2Vec2 perp = b2Mul(qA, m_localYAxisA);
-
-	float32 s1 = b2Cross(d + rA, perp);
-	float32 s2 = b2Cross(rB, perp);
-
-	b2Vec3 impulse;
-	b2Vec2 C1;
-	C1.x = b2Dot(perp, d);
-	C1.y = aB - aA - m_referenceAngle;
-
-	float32 linearError = b2Abs(C1.x);
-	float32 angularError = b2Abs(C1.y);
-
-	bool active = false;
-	float32 C2 = 0.0f;
-	if (m_enableLimit)
-	{
-		float32 translation = b2Dot(axis, d);
-		if (b2Abs(m_upperTranslation - m_lowerTranslation) < 2.0f * b2_linearSlop)
-		{
-			// Prevent large angular corrections
-			C2 = b2Clamp(translation, -b2_maxLinearCorrection, b2_maxLinearCorrection);
-			linearError = b2Max(linearError, b2Abs(translation));
-			active = true;
-		}
-		else if (translation <= m_lowerTranslation)
-		{
-			// Prevent large linear corrections and allow some slop.
-			C2 = b2Clamp(translation - m_lowerTranslation + b2_linearSlop, -b2_maxLinearCorrection, 0.0f);
-			linearError = b2Max(linearError, m_lowerTranslation - translation);
-			active = true;
-		}
-		else if (translation >= m_upperTranslation)
-		{
-			// Prevent large linear corrections and allow some slop.
-			C2 = b2Clamp(translation - m_upperTranslation - b2_linearSlop, 0.0f, b2_maxLinearCorrection);
-			linearError = b2Max(linearError, translation - m_upperTranslation);
-			active = true;
-		}
-	}
-
-	if (active)
-	{
-		float32 k11 = mA + mB + iA * s1 * s1 + iB * s2 * s2;
-		float32 k12 = iA * s1 + iB * s2;
-		float32 k13 = iA * s1 * a1 + iB * s2 * a2;
-		float32 k22 = iA + iB;
-		if (k22 == 0.0f)
-		{
-			// For fixed rotation
-			k22 = 1.0f;
-		}
-		float32 k23 = iA * a1 + iB * a2;
-		float32 k33 = mA + mB + iA * a1 * a1 + iB * a2 * a2;
-
-		b2Mat33 K;
-		K.ex.Set(k11, k12, k13);
-		K.ey.Set(k12, k22, k23);
-		K.ez.Set(k13, k23, k33);
-
-		b2Vec3 C;
-		C.x = C1.x;
-		C.y = C1.y;
-		C.z = C2;
-
-		impulse = K.Solve33(-C);
-	}
-	else
-	{
-		float32 k11 = mA + mB + iA * s1 * s1 + iB * s2 * s2;
-		float32 k12 = iA * s1 + iB * s2;
-		float32 k22 = iA + iB;
-		if (k22 == 0.0f)
-		{
-			k22 = 1.0f;
-		}
-
-		b2Mat22 K;
-		K.ex.Set(k11, k12);
-		K.ey.Set(k12, k22);
-
-		b2Vec2 impulse1 = K.Solve(-C1);
-		impulse.x = impulse1.x;
-		impulse.y = impulse1.y;
-		impulse.z = 0.0f;
-	}
-
-	b2Vec2 P = impulse.x * perp + impulse.z * axis;
-	float32 LA = impulse.x * s1 + impulse.y + impulse.z * a1;
-	float32 LB = impulse.x * s2 + impulse.y + impulse.z * a2;
-
-	cA -= mA * P;
-	aA -= iA * LA;
-	cB += mB * P;
-	aB += iB * LB;
-
-	data.positions[m_indexA].c = cA;
-	data.positions[m_indexA].a = aA;
-	data.positions[m_indexB].c = cB;
-	data.positions[m_indexB].a = aB;
-
-	return linearError <= b2_linearSlop && angularError <= b2_angularSlop;
-}
-
-b2Vec2 b2PrismaticJoint::GetAnchorA() const
-{
-	return m_bodyA->GetWorldPoint(m_localAnchorA);
-}
-
-b2Vec2 b2PrismaticJoint::GetAnchorB() const
-{
-	return m_bodyB->GetWorldPoint(m_localAnchorB);
-}
-
-b2Vec2 b2PrismaticJoint::GetReactionForce(float32 inv_dt) const
-{
-	return inv_dt * (m_impulse.x * m_perp + (m_motorImpulse + m_impulse.z) * m_axis);
-}
-
-float32 b2PrismaticJoint::GetReactionTorque(float32 inv_dt) const
-{
-	return inv_dt * m_impulse.y;
-}
-
-float32 b2PrismaticJoint::GetJointTranslation() const
-{
-	b2Vec2 pA = m_bodyA->GetWorldPoint(m_localAnchorA);
-	b2Vec2 pB = m_bodyB->GetWorldPoint(m_localAnchorB);
-	b2Vec2 d = pB - pA;
-	b2Vec2 axis = m_bodyA->GetWorldVector(m_localXAxisA);
-
-	float32 translation = b2Dot(d, axis);
-	return translation;
-}
-
-float32 b2PrismaticJoint::GetJointSpeed() const
-{
-	b2Body* bA = m_bodyA;
-	b2Body* bB = m_bodyB;
-
-	b2Vec2 rA = b2Mul(bA->m_xf.q, m_localAnchorA - bA->m_sweep.localCenter);
-	b2Vec2 rB = b2Mul(bB->m_xf.q, m_localAnchorB - bB->m_sweep.localCenter);
-	b2Vec2 p1 = bA->m_sweep.c + rA;
-	b2Vec2 p2 = bB->m_sweep.c + rB;
-	b2Vec2 d = p2 - p1;
-	b2Vec2 axis = b2Mul(bA->m_xf.q, m_localXAxisA);
-
-	b2Vec2 vA = bA->m_linearVelocity;
-	b2Vec2 vB = bB->m_linearVelocity;
-	float32 wA = bA->m_angularVelocity;
-	float32 wB = bB->m_angularVelocity;
-
-	float32 speed = b2Dot(d, b2Cross(wA, axis)) + b2Dot(axis, vB + b2Cross(wB, rB) - vA - b2Cross(wA, rA));
-	return speed;
-}
-
-bool b2PrismaticJoint::IsLimitEnabled() const
-{
-	return m_enableLimit;
-}
-
-void b2PrismaticJoint::EnableLimit(bool flag)
-{
-	if (flag != m_enableLimit)
-	{
-		m_bodyA->SetAwake(true);
-		m_bodyB->SetAwake(true);
-		m_enableLimit = flag;
-		m_impulse.z = 0.0f;
-	}
-}
-
-float32 b2PrismaticJoint::GetLowerLimit() const
-{
-	return m_lowerTranslation;
-}
-
-float32 b2PrismaticJoint::GetUpperLimit() const
-{
-	return m_upperTranslation;
-}
-
-void b2PrismaticJoint::SetLimits(float32 lower, float32 upper)
-{
-	b2Assert(lower <= upper);
-	if (lower != m_lowerTranslation || upper != m_upperTranslation)
-	{
-		m_bodyA->SetAwake(true);
-		m_bodyB->SetAwake(true);
-		m_lowerTranslation = lower;
-		m_upperTranslation = upper;
-		m_impulse.z = 0.0f;
-	}
-}
-
-bool b2PrismaticJoint::IsMotorEnabled() const
-{
-	return m_enableMotor;
-}
-
-void b2PrismaticJoint::EnableMotor(bool flag)
-{
-	if (flag != m_enableMotor)
-	{
-		m_bodyA->SetAwake(true);
-		m_bodyB->SetAwake(true);
-		m_enableMotor = flag;
-	}
-}
-
-void b2PrismaticJoint::SetMotorSpeed(float32 speed)
-{
-	if (speed != m_motorSpeed)
-	{
-		m_bodyA->SetAwake(true);
-		m_bodyB->SetAwake(true);
-		m_motorSpeed = speed;
-	}
-}
-
-void b2PrismaticJoint::SetMaxMotorForce(float32 force)
-{
-	if (force != m_maxMotorForce)
-	{
-		m_bodyA->SetAwake(true);
-		m_bodyB->SetAwake(true);
-		m_maxMotorForce = force;
-	}
-}
-
-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("  joints[%d] = m_world->CreateJoint(&jd);\n", m_index);
-}

Source/ThirdParty/Box2D/Box2D/Dynamics/Joints/b2RevoluteJoint.cpp

@@ -1,511 +0,0 @@
-/*
-* Copyright (c) 2006-2011 Erin Catto http://www.box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
-
-#include "Box2D/Dynamics/Joints/b2RevoluteJoint.h"
-#include "Box2D/Dynamics/b2Body.h"
-#include "Box2D/Dynamics/b2TimeStep.h"
-
-// Point-to-point constraint
-// C = p2 - p1
-// Cdot = v2 - v1
-//      = v2 + cross(w2, r2) - v1 - cross(w1, r1)
-// J = [-I -r1_skew I r2_skew ]
-// Identity used:
-// w k % (rx i + ry j) = w * (-ry i + rx j)
-
-// Motor constraint
-// Cdot = w2 - w1
-// J = [0 0 -1 0 0 1]
-// K = invI1 + invI2
-
-void b2RevoluteJointDef::Initialize(b2Body* bA, b2Body* bB, const b2Vec2& anchor)
-{
-	bodyA = bA;
-	bodyB = bB;
-	localAnchorA = bodyA->GetLocalPoint(anchor);
-	localAnchorB = bodyB->GetLocalPoint(anchor);
-	referenceAngle = bodyB->GetAngle() - bodyA->GetAngle();
-}
-
-b2RevoluteJoint::b2RevoluteJoint(const b2RevoluteJointDef* def)
-: b2Joint(def)
-{
-	m_localAnchorA = def->localAnchorA;
-	m_localAnchorB = def->localAnchorB;
-	m_referenceAngle = def->referenceAngle;
-
-	m_impulse.SetZero();
-	m_motorImpulse = 0.0f;
-
-	m_lowerAngle = def->lowerAngle;
-	m_upperAngle = def->upperAngle;
-	m_maxMotorTorque = def->maxMotorTorque;
-	m_motorSpeed = def->motorSpeed;
-	m_enableLimit = def->enableLimit;
-	m_enableMotor = def->enableMotor;
-	m_limitState = e_inactiveLimit;
-}
-
-void b2RevoluteJoint::InitVelocityConstraints(const b2SolverData& data)
-{
-	m_indexA = m_bodyA->m_islandIndex;
-	m_indexB = m_bodyB->m_islandIndex;
-	m_localCenterA = m_bodyA->m_sweep.localCenter;
-	m_localCenterB = m_bodyB->m_sweep.localCenter;
-	m_invMassA = m_bodyA->m_invMass;
-	m_invMassB = m_bodyB->m_invMass;
-	m_invIA = m_bodyA->m_invI;
-	m_invIB = m_bodyB->m_invI;
-
-	float32 aA = data.positions[m_indexA].a;
-	b2Vec2 vA = data.velocities[m_indexA].v;
-	float32 wA = data.velocities[m_indexA].w;
-
-	float32 aB = data.positions[m_indexB].a;
-	b2Vec2 vB = data.velocities[m_indexB].v;
-	float32 wB = data.velocities[m_indexB].w;
-
-	b2Rot qA(aA), qB(aB);
-
-	m_rA = b2Mul(qA, m_localAnchorA - m_localCenterA);
-	m_rB = b2Mul(qB, m_localAnchorB - m_localCenterB);
-
-	// J = [-I -r1_skew I r2_skew]
-	//     [ 0       -1 0       1]
-	// r_skew = [-ry; rx]
-
-	// Matlab
-	// K = [ mA+r1y^2*iA+mB+r2y^2*iB,  -r1y*iA*r1x-r2y*iB*r2x,          -r1y*iA-r2y*iB]
-	//     [  -r1y*iA*r1x-r2y*iB*r2x, mA+r1x^2*iA+mB+r2x^2*iB,           r1x*iA+r2x*iB]
-	//     [          -r1y*iA-r2y*iB,           r1x*iA+r2x*iB,                   iA+iB]
-
-	float32 mA = m_invMassA, mB = m_invMassB;
-	float32 iA = m_invIA, iB = m_invIB;
-
-	bool fixedRotation = (iA + iB == 0.0f);
-
-	m_mass.ex.x = mA + mB + m_rA.y * m_rA.y * iA + m_rB.y * m_rB.y * iB;
-	m_mass.ey.x = -m_rA.y * m_rA.x * iA - m_rB.y * m_rB.x * iB;
-	m_mass.ez.x = -m_rA.y * iA - m_rB.y * iB;
-	m_mass.ex.y = m_mass.ey.x;
-	m_mass.ey.y = mA + mB + m_rA.x * m_rA.x * iA + m_rB.x * m_rB.x * iB;
-	m_mass.ez.y = m_rA.x * iA + m_rB.x * iB;
-	m_mass.ex.z = m_mass.ez.x;
-	m_mass.ey.z = m_mass.ez.y;
-	m_mass.ez.z = iA + iB;
-
-	m_motorMass = iA + iB;
-	if (m_motorMass > 0.0f)
-	{
-		m_motorMass = 1.0f / m_motorMass;
-	}
-
-	if (m_enableMotor == false || fixedRotation)
-	{
-		m_motorImpulse = 0.0f;
-	}
-
-	if (m_enableLimit && fixedRotation == false)
-	{
-		float32 jointAngle = aB - aA - m_referenceAngle;
-		if (b2Abs(m_upperAngle - m_lowerAngle) < 2.0f * b2_angularSlop)
-		{
-			m_limitState = e_equalLimits;
-		}
-		else if (jointAngle <= m_lowerAngle)
-		{
-			if (m_limitState != e_atLowerLimit)
-			{
-				m_impulse.z = 0.0f;
-			}
-			m_limitState = e_atLowerLimit;
-		}
-		else if (jointAngle >= m_upperAngle)
-		{
-			if (m_limitState != e_atUpperLimit)
-			{
-				m_impulse.z = 0.0f;
-			}
-			m_limitState = e_atUpperLimit;
-		}
-		else
-		{
-			m_limitState = e_inactiveLimit;
-			m_impulse.z = 0.0f;
-		}
-	}
-	else
-	{
-		m_limitState = e_inactiveLimit;
-	}
-
-	if (data.step.warmStarting)
-	{
-		// Scale impulses to support a variable time step.
-		m_impulse *= data.step.dtRatio;
-		m_motorImpulse *= data.step.dtRatio;
-
-		b2Vec2 P(m_impulse.x, m_impulse.y);
-
-		vA -= mA * P;
-		wA -= iA * (b2Cross(m_rA, P) + m_motorImpulse + m_impulse.z);
-
-		vB += mB * P;
-		wB += iB * (b2Cross(m_rB, P) + m_motorImpulse + m_impulse.z);
-	}
-	else
-	{
-		m_impulse.SetZero();
-		m_motorImpulse = 0.0f;
-	}
-
-	data.velocities[m_indexA].v = vA;
-	data.velocities[m_indexA].w = wA;
-	data.velocities[m_indexB].v = vB;
-	data.velocities[m_indexB].w = wB;
-}
-
-void b2RevoluteJoint::SolveVelocityConstraints(const b2SolverData& data)
-{
-	b2Vec2 vA = data.velocities[m_indexA].v;
-	float32 wA = data.velocities[m_indexA].w;
-	b2Vec2 vB = data.velocities[m_indexB].v;
-	float32 wB = data.velocities[m_indexB].w;
-
-	float32 mA = m_invMassA, mB = m_invMassB;
-	float32 iA = m_invIA, iB = m_invIB;
-
-	bool fixedRotation = (iA + iB == 0.0f);
-
-	// Solve motor constraint.
-	if (m_enableMotor && m_limitState != e_equalLimits && fixedRotation == false)
-	{
-		float32 Cdot = wB - wA - m_motorSpeed;
-		float32 impulse = -m_motorMass * Cdot;
-		float32 oldImpulse = m_motorImpulse;
-		float32 maxImpulse = data.step.dt * m_maxMotorTorque;
-		m_motorImpulse = b2Clamp(m_motorImpulse + impulse, -maxImpulse, maxImpulse);
-		impulse = m_motorImpulse - oldImpulse;
-
-		wA -= iA * impulse;
-		wB += iB * impulse;
-	}
-
-	// Solve limit constraint.
-	if (m_enableLimit && m_limitState != e_inactiveLimit && fixedRotation == false)
-	{
-		b2Vec2 Cdot1 = vB + b2Cross(wB, m_rB) - vA - b2Cross(wA, m_rA);
-		float32 Cdot2 = wB - wA;
-		b2Vec3 Cdot(Cdot1.x, Cdot1.y, Cdot2);
-
-		b2Vec3 impulse = -m_mass.Solve33(Cdot);
-
-		if (m_limitState == e_equalLimits)
-		{
-			m_impulse += impulse;
-		}
-		else if (m_limitState == e_atLowerLimit)
-		{
-			float32 newImpulse = m_impulse.z + impulse.z;
-			if (newImpulse < 0.0f)
-			{
-				b2Vec2 rhs = -Cdot1 + m_impulse.z * b2Vec2(m_mass.ez.x, m_mass.ez.y);
-				b2Vec2 reduced = m_mass.Solve22(rhs);
-				impulse.x = reduced.x;
-				impulse.y = reduced.y;
-				impulse.z = -m_impulse.z;
-				m_impulse.x += reduced.x;
-				m_impulse.y += reduced.y;
-				m_impulse.z = 0.0f;
-			}
-			else
-			{
-				m_impulse += impulse;
-			}
-		}
-		else if (m_limitState == e_atUpperLimit)
-		{
-			float32 newImpulse = m_impulse.z + impulse.z;
-			if (newImpulse > 0.0f)
-			{
-				b2Vec2 rhs = -Cdot1 + m_impulse.z * b2Vec2(m_mass.ez.x, m_mass.ez.y);
-				b2Vec2 reduced = m_mass.Solve22(rhs);
-				impulse.x = reduced.x;
-				impulse.y = reduced.y;
-				impulse.z = -m_impulse.z;
-				m_impulse.x += reduced.x;
-				m_impulse.y += reduced.y;
-				m_impulse.z = 0.0f;
-			}
-			else
-			{
-				m_impulse += impulse;
-			}
-		}
-
-		b2Vec2 P(impulse.x, impulse.y);
-
-		vA -= mA * P;
-		wA -= iA * (b2Cross(m_rA, P) + impulse.z);
-
-		vB += mB * P;
-		wB += iB * (b2Cross(m_rB, P) + impulse.z);
-	}
-	else
-	{
-		// Solve point-to-point constraint
-		b2Vec2 Cdot = vB + b2Cross(wB, m_rB) - vA - b2Cross(wA, m_rA);
-		b2Vec2 impulse = m_mass.Solve22(-Cdot);
-
-		m_impulse.x += impulse.x;
-		m_impulse.y += impulse.y;
-
-		vA -= mA * impulse;
-		wA -= iA * b2Cross(m_rA, impulse);
-
-		vB += mB * impulse;
-		wB += iB * b2Cross(m_rB, impulse);
-	}
-
-	data.velocities[m_indexA].v = vA;
-	data.velocities[m_indexA].w = wA;
-	data.velocities[m_indexB].v = vB;
-	data.velocities[m_indexB].w = wB;
-}
-
-bool b2RevoluteJoint::SolvePositionConstraints(const b2SolverData& data)
-{
-	b2Vec2 cA = data.positions[m_indexA].c;
-	float32 aA = data.positions[m_indexA].a;
-	b2Vec2 cB = data.positions[m_indexB].c;
-	float32 aB = data.positions[m_indexB].a;
-
-	b2Rot qA(aA), qB(aB);
-
-	float32 angularError = 0.0f;
-	float32 positionError = 0.0f;
-
-	bool fixedRotation = (m_invIA + m_invIB == 0.0f);
-
-	// Solve angular limit constraint.
-	if (m_enableLimit && m_limitState != e_inactiveLimit && fixedRotation == false)
-	{
-		float32 angle = aB - aA - m_referenceAngle;
-		float32 limitImpulse = 0.0f;
-
-		if (m_limitState == e_equalLimits)
-		{
-			// Prevent large angular corrections
-			float32 C = b2Clamp(angle - m_lowerAngle, -b2_maxAngularCorrection, b2_maxAngularCorrection);
-			limitImpulse = -m_motorMass * C;
-			angularError = b2Abs(C);
-		}
-		else if (m_limitState == e_atLowerLimit)
-		{
-			float32 C = angle - m_lowerAngle;
-			angularError = -C;
-
-			// Prevent large angular corrections and allow some slop.
-			C = b2Clamp(C + b2_angularSlop, -b2_maxAngularCorrection, 0.0f);
-			limitImpulse = -m_motorMass * C;
-		}
-		else if (m_limitState == e_atUpperLimit)
-		{
-			float32 C = angle - m_upperAngle;
-			angularError = C;
-
-			// Prevent large angular corrections and allow some slop.
-			C = b2Clamp(C - b2_angularSlop, 0.0f, b2_maxAngularCorrection);
-			limitImpulse = -m_motorMass * C;
-		}
-
-		aA -= m_invIA * limitImpulse;
-		aB += m_invIB * limitImpulse;
-	}
-
-	// Solve point-to-point constraint.
-	{
-		qA.Set(aA);
-		qB.Set(aB);
-		b2Vec2 rA = b2Mul(qA, m_localAnchorA - m_localCenterA);
-		b2Vec2 rB = b2Mul(qB, m_localAnchorB - m_localCenterB);
-
-		b2Vec2 C = cB + rB - cA - rA;
-		positionError = C.Length();
-
-		float32 mA = m_invMassA, mB = m_invMassB;
-		float32 iA = m_invIA, iB = m_invIB;
-
-		b2Mat22 K;
-		K.ex.x = mA + mB + iA * rA.y * rA.y + iB * rB.y * rB.y;
-		K.ex.y = -iA * rA.x * rA.y - iB * rB.x * rB.y;
-		K.ey.x = K.ex.y;
-		K.ey.y = mA + mB + iA * rA.x * rA.x + iB * rB.x * rB.x;
-
-		b2Vec2 impulse = -K.Solve(C);
-
-		cA -= mA * impulse;
-		aA -= iA * b2Cross(rA, impulse);
-
-		cB += mB * impulse;
-		aB += iB * b2Cross(rB, impulse);
-	}
-
-	data.positions[m_indexA].c = cA;
-	data.positions[m_indexA].a = aA;
-	data.positions[m_indexB].c = cB;
-	data.positions[m_indexB].a = aB;
-	
-	return positionError <= b2_linearSlop && angularError <= b2_angularSlop;
-}
-
-b2Vec2 b2RevoluteJoint::GetAnchorA() const
-{
-	return m_bodyA->GetWorldPoint(m_localAnchorA);
-}
-
-b2Vec2 b2RevoluteJoint::GetAnchorB() const
-{
-	return m_bodyB->GetWorldPoint(m_localAnchorB);
-}
-
-b2Vec2 b2RevoluteJoint::GetReactionForce(float32 inv_dt) const
-{
-	b2Vec2 P(m_impulse.x, m_impulse.y);
-	return inv_dt * P;
-}
-
-float32 b2RevoluteJoint::GetReactionTorque(float32 inv_dt) const
-{
-	return inv_dt * m_impulse.z;
-}
-
-float32 b2RevoluteJoint::GetJointAngle() const
-{
-	b2Body* bA = m_bodyA;
-	b2Body* bB = m_bodyB;
-	return bB->m_sweep.a - bA->m_sweep.a - m_referenceAngle;
-}
-
-float32 b2RevoluteJoint::GetJointSpeed() const
-{
-	b2Body* bA = m_bodyA;
-	b2Body* bB = m_bodyB;
-	return bB->m_angularVelocity - bA->m_angularVelocity;
-}
-
-bool b2RevoluteJoint::IsMotorEnabled() const
-{
-	return m_enableMotor;
-}
-
-void b2RevoluteJoint::EnableMotor(bool flag)
-{
-	if (flag != m_enableMotor)
-	{
-		m_bodyA->SetAwake(true);
-		m_bodyB->SetAwake(true);
-		m_enableMotor = flag;
-	}
-}
-
-float32 b2RevoluteJoint::GetMotorTorque(float32 inv_dt) const
-{
-	return inv_dt * m_motorImpulse;
-}
-
-void b2RevoluteJoint::SetMotorSpeed(float32 speed)
-{
-	if (speed != m_motorSpeed)
-	{
-		m_bodyA->SetAwake(true);
-		m_bodyB->SetAwake(true);
-		m_motorSpeed = speed;
-	}
-}
-
-void b2RevoluteJoint::SetMaxMotorTorque(float32 torque)
-{
-	if (torque != m_maxMotorTorque)
-	{
-		m_bodyA->SetAwake(true);
-		m_bodyB->SetAwake(true);
-		m_maxMotorTorque = torque;
-	}
-}
-
-bool b2RevoluteJoint::IsLimitEnabled() const
-{
-	return m_enableLimit;
-}
-
-void b2RevoluteJoint::EnableLimit(bool flag)
-{
-	if (flag != m_enableLimit)
-	{
-		m_bodyA->SetAwake(true);
-		m_bodyB->SetAwake(true);
-		m_enableLimit = flag;
-		m_impulse.z = 0.0f;
-	}
-}
-
-float32 b2RevoluteJoint::GetLowerLimit() const
-{
-	return m_lowerAngle;
-}
-
-float32 b2RevoluteJoint::GetUpperLimit() const
-{
-	return m_upperAngle;
-}
-
-void b2RevoluteJoint::SetLimits(float32 lower, float32 upper)
-{
-	b2Assert(lower <= upper);
-	
-	if (lower != m_lowerAngle || upper != m_upperAngle)
-	{
-		m_bodyA->SetAwake(true);
-		m_bodyB->SetAwake(true);
-		m_impulse.z = 0.0f;
-		m_lowerAngle = lower;
-		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("  joints[%d] = m_world->CreateJoint(&jd);\n", m_index);
-}

Source/ThirdParty/Box2D/Box2D/Dynamics/Joints/b2RopeJoint.cpp

@@ -1,241 +0,0 @@
-/*
-* Copyright (c) 2007-2011 Erin Catto http://www.box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
-
-#include "Box2D/Dynamics/Joints/b2RopeJoint.h"
-#include "Box2D/Dynamics/b2Body.h"
-#include "Box2D/Dynamics/b2TimeStep.h"
-
-
-// Limit:
-// C = norm(pB - pA) - L
-// u = (pB - pA) / norm(pB - pA)
-// Cdot = dot(u, vB + cross(wB, rB) - vA - cross(wA, rA))
-// J = [-u -cross(rA, u) u cross(rB, u)]
-// K = J * invM * JT
-//   = invMassA + invIA * cross(rA, u)^2 + invMassB + invIB * cross(rB, u)^2
-
-b2RopeJoint::b2RopeJoint(const b2RopeJointDef* def)
-: b2Joint(def)
-{
-	m_localAnchorA = def->localAnchorA;
-	m_localAnchorB = def->localAnchorB;
-
-	m_maxLength = def->maxLength;
-
-	m_mass = 0.0f;
-	m_impulse = 0.0f;
-	m_state = e_inactiveLimit;
-	m_length = 0.0f;
-}
-
-void b2RopeJoint::InitVelocityConstraints(const b2SolverData& data)
-{
-	m_indexA = m_bodyA->m_islandIndex;
-	m_indexB = m_bodyB->m_islandIndex;
-	m_localCenterA = m_bodyA->m_sweep.localCenter;
-	m_localCenterB = m_bodyB->m_sweep.localCenter;
-	m_invMassA = m_bodyA->m_invMass;
-	m_invMassB = m_bodyB->m_invMass;
-	m_invIA = m_bodyA->m_invI;
-	m_invIB = m_bodyB->m_invI;
-
-	b2Vec2 cA = data.positions[m_indexA].c;
-	float32 aA = data.positions[m_indexA].a;
-	b2Vec2 vA = data.velocities[m_indexA].v;
-	float32 wA = data.velocities[m_indexA].w;
-
-	b2Vec2 cB = data.positions[m_indexB].c;
-	float32 aB = data.positions[m_indexB].a;
-	b2Vec2 vB = data.velocities[m_indexB].v;
-	float32 wB = data.velocities[m_indexB].w;
-
-	b2Rot qA(aA), qB(aB);
-
-	m_rA = b2Mul(qA, m_localAnchorA - m_localCenterA);
-	m_rB = b2Mul(qB, m_localAnchorB - m_localCenterB);
-	m_u = cB + m_rB - cA - m_rA;
-
-	m_length = m_u.Length();
-
-	float32 C = m_length - m_maxLength;
-	if (C > 0.0f)
-	{
-		m_state = e_atUpperLimit;
-	}
-	else
-	{
-		m_state = e_inactiveLimit;
-	}
-
-	if (m_length > b2_linearSlop)
-	{
-		m_u *= 1.0f / m_length;
-	}
-	else
-	{
-		m_u.SetZero();
-		m_mass = 0.0f;
-		m_impulse = 0.0f;
-		return;
-	}
-
-	// Compute effective mass.
-	float32 crA = b2Cross(m_rA, m_u);
-	float32 crB = b2Cross(m_rB, m_u);
-	float32 invMass = m_invMassA + m_invIA * crA * crA + m_invMassB + m_invIB * crB * crB;
-
-	m_mass = invMass != 0.0f ? 1.0f / invMass : 0.0f;
-
-	if (data.step.warmStarting)
-	{
-		// Scale the impulse to support a variable time step.
-		m_impulse *= data.step.dtRatio;
-
-		b2Vec2 P = m_impulse * m_u;
-		vA -= m_invMassA * P;
-		wA -= m_invIA * b2Cross(m_rA, P);
-		vB += m_invMassB * P;
-		wB += m_invIB * b2Cross(m_rB, P);
-	}
-	else
-	{
-		m_impulse = 0.0f;
-	}
-
-	data.velocities[m_indexA].v = vA;
-	data.velocities[m_indexA].w = wA;
-	data.velocities[m_indexB].v = vB;
-	data.velocities[m_indexB].w = wB;
-}
-
-void b2RopeJoint::SolveVelocityConstraints(const b2SolverData& data)
-{
-	b2Vec2 vA = data.velocities[m_indexA].v;
-	float32 wA = data.velocities[m_indexA].w;
-	b2Vec2 vB = data.velocities[m_indexB].v;
-	float32 wB = data.velocities[m_indexB].w;
-
-	// Cdot = dot(u, v + cross(w, r))
-	b2Vec2 vpA = vA + b2Cross(wA, m_rA);
-	b2Vec2 vpB = vB + b2Cross(wB, m_rB);
-	float32 C = m_length - m_maxLength;
-	float32 Cdot = b2Dot(m_u, vpB - vpA);
-
-	// Predictive constraint.
-	if (C < 0.0f)
-	{
-		Cdot += data.step.inv_dt * C;
-	}
-
-	float32 impulse = -m_mass * Cdot;
-	float32 oldImpulse = m_impulse;
-	m_impulse = b2Min(0.0f, m_impulse + impulse);
-	impulse = m_impulse - oldImpulse;
-
-	b2Vec2 P = impulse * m_u;
-	vA -= m_invMassA * P;
-	wA -= m_invIA * b2Cross(m_rA, P);
-	vB += m_invMassB * P;
-	wB += m_invIB * b2Cross(m_rB, P);
-
-	data.velocities[m_indexA].v = vA;
-	data.velocities[m_indexA].w = wA;
-	data.velocities[m_indexB].v = vB;
-	data.velocities[m_indexB].w = wB;
-}
-
-bool b2RopeJoint::SolvePositionConstraints(const b2SolverData& data)
-{
-	b2Vec2 cA = data.positions[m_indexA].c;
-	float32 aA = data.positions[m_indexA].a;
-	b2Vec2 cB = data.positions[m_indexB].c;
-	float32 aB = data.positions[m_indexB].a;
-
-	b2Rot qA(aA), qB(aB);
-
-	b2Vec2 rA = b2Mul(qA, m_localAnchorA - m_localCenterA);
-	b2Vec2 rB = b2Mul(qB, m_localAnchorB - m_localCenterB);
-	b2Vec2 u = cB + rB - cA - rA;
-
-	float32 length = u.Normalize();
-	float32 C = length - m_maxLength;
-
-	C = b2Clamp(C, 0.0f, b2_maxLinearCorrection);
-
-	float32 impulse = -m_mass * C;
-	b2Vec2 P = impulse * u;
-
-	cA -= m_invMassA * P;
-	aA -= m_invIA * b2Cross(rA, P);
-	cB += m_invMassB * P;
-	aB += m_invIB * b2Cross(rB, P);
-
-	data.positions[m_indexA].c = cA;
-	data.positions[m_indexA].a = aA;
-	data.positions[m_indexB].c = cB;
-	data.positions[m_indexB].a = aB;
-
-	return length - m_maxLength < b2_linearSlop;
-}
-
-b2Vec2 b2RopeJoint::GetAnchorA() const
-{
-	return m_bodyA->GetWorldPoint(m_localAnchorA);
-}
-
-b2Vec2 b2RopeJoint::GetAnchorB() const
-{
-	return m_bodyB->GetWorldPoint(m_localAnchorB);
-}
-
-b2Vec2 b2RopeJoint::GetReactionForce(float32 inv_dt) const
-{
-	b2Vec2 F = (inv_dt * m_impulse) * m_u;
-	return F;
-}
-
-float32 b2RopeJoint::GetReactionTorque(float32 inv_dt) const
-{
-	B2_NOT_USED(inv_dt);
-	return 0.0f;
-}
-
-float32 b2RopeJoint::GetMaxLength() const
-{
-	return m_maxLength;
-}
-
-b2LimitState b2RopeJoint::GetLimitState() const
-{
-	return m_state;
-}
-
-void b2RopeJoint::Dump()
-{
-	int32 indexA = m_bodyA->m_islandIndex;
-	int32 indexB = m_bodyB->m_islandIndex;
-
-	b2Log("  b2RopeJointDef 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.maxLength = %.15lef;\n", m_maxLength);
-	b2Log("  joints[%d] = m_world->CreateJoint(&jd);\n", m_index);
-}

Source/ThirdParty/Box2D/Box2D/Dynamics/Joints/b2RopeJoint.h

@@ -1,114 +0,0 @@
-/*
-* Copyright (c) 2006-2011 Erin Catto http://www.box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef B2_ROPE_JOINT_H
-#define B2_ROPE_JOINT_H
-
-#include "Box2D/Dynamics/Joints/b2Joint.h"
-
-/// Rope joint definition. This requires two body anchor points and
-/// a maximum lengths.
-/// Note: by default the connected objects will not collide.
-/// see collideConnected in b2JointDef.
-struct b2RopeJointDef : public b2JointDef
-{
-	b2RopeJointDef()
-	{
-		type = e_ropeJoint;
-		localAnchorA.Set(-1.0f, 0.0f);
-		localAnchorB.Set(1.0f, 0.0f);
-		maxLength = 0.0f;
-	}
-
-	/// The local anchor point relative to bodyA's origin.
-	b2Vec2 localAnchorA;
-
-	/// The local anchor point relative to bodyB's origin.
-	b2Vec2 localAnchorB;
-
-	/// The maximum length of the rope.
-	/// Warning: this must be larger than b2_linearSlop or
-	/// the joint will have no effect.
-	float32 maxLength;
-};
-
-/// A rope joint enforces a maximum distance between two points
-/// on two bodies. It has no other effect.
-/// Warning: if you attempt to change the maximum length during
-/// the simulation you will get some non-physical behavior.
-/// A model that would allow you to dynamically modify the length
-/// would have some sponginess, so I chose not to implement it
-/// that way. See b2DistanceJoint if you want to dynamically
-/// control length.
-class b2RopeJoint : public b2Joint
-{
-public:
-	b2Vec2 GetAnchorA() const override;
-	b2Vec2 GetAnchorB() const override;
-
-	b2Vec2 GetReactionForce(float32 inv_dt) const override;
-	float32 GetReactionTorque(float32 inv_dt) const override;
-
-	/// The local anchor point relative to bodyA's origin.
-	const b2Vec2& GetLocalAnchorA() const { return m_localAnchorA; }
-
-	/// The local anchor point relative to bodyB's origin.
-	const b2Vec2& GetLocalAnchorB() const  { return m_localAnchorB; }
-
-	/// Set/Get the maximum length of the rope.
-	void SetMaxLength(float32 length) { m_maxLength = length; }
-	float32 GetMaxLength() const;
-
-	b2LimitState GetLimitState() const;
-
-	/// Dump joint to dmLog
-	void Dump() override;
-
-protected:
-
-	friend class b2Joint;
-	b2RopeJoint(const b2RopeJointDef* data);
-
-	void InitVelocityConstraints(const b2SolverData& data) override;
-	void SolveVelocityConstraints(const b2SolverData& data) override;
-	bool SolvePositionConstraints(const b2SolverData& data) override;
-
-	// Solver shared
-	b2Vec2 m_localAnchorA;
-	b2Vec2 m_localAnchorB;
-	float32 m_maxLength;
-	float32 m_length;
-	float32 m_impulse;
-
-	// Solver temp
-	int32 m_indexA;
-	int32 m_indexB;
-	b2Vec2 m_u;
-	b2Vec2 m_rA;
-	b2Vec2 m_rB;
-	b2Vec2 m_localCenterA;
-	b2Vec2 m_localCenterB;
-	float32 m_invMassA;
-	float32 m_invMassB;
-	float32 m_invIA;
-	float32 m_invIB;
-	float32 m_mass;
-	b2LimitState m_state;
-};
-
-#endif

Source/ThirdParty/Box2D/Box2D/Dynamics/Joints/b2WeldJoint.h

@@ -1,126 +0,0 @@
-/*
-* Copyright (c) 2006-2011 Erin Catto http://www.box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef B2_WELD_JOINT_H
-#define B2_WELD_JOINT_H
-
-#include "Box2D/Dynamics/Joints/b2Joint.h"
-
-/// Weld joint definition. You need to specify local anchor points
-/// where they are attached and the relative body angle. The position
-/// of the anchor points is important for computing the reaction torque.
-struct b2WeldJointDef : public b2JointDef
-{
-	b2WeldJointDef()
-	{
-		type = e_weldJoint;
-		localAnchorA.Set(0.0f, 0.0f);
-		localAnchorB.Set(0.0f, 0.0f);
-		referenceAngle = 0.0f;
-		frequencyHz = 0.0f;
-		dampingRatio = 0.0f;
-	}
-
-	/// Initialize the bodies, anchors, and reference angle using a world
-	/// anchor point.
-	void Initialize(b2Body* bodyA, b2Body* bodyB, const b2Vec2& anchor);
-
-	/// The local anchor point relative to bodyA's origin.
-	b2Vec2 localAnchorA;
-
-	/// The local anchor point relative to bodyB's origin.
-	b2Vec2 localAnchorB;
-
-	/// The bodyB angle minus bodyA angle in the reference state (radians).
-	float32 referenceAngle;
-	
-	/// The mass-spring-damper frequency in Hertz. Rotation only.
-	/// Disable softness with a value of 0.
-	float32 frequencyHz;
-
-	/// The damping ratio. 0 = no damping, 1 = critical damping.
-	float32 dampingRatio;
-};
-
-/// A weld joint essentially glues two bodies together. A weld joint may
-/// distort somewhat because the island constraint solver is approximate.
-class b2WeldJoint : public b2Joint
-{
-public:
-	b2Vec2 GetAnchorA() const override;
-	b2Vec2 GetAnchorB() const override;
-
-	b2Vec2 GetReactionForce(float32 inv_dt) const override;
-	float32 GetReactionTorque(float32 inv_dt) const override;
-
-	/// The local anchor point relative to bodyA's origin.
-	const b2Vec2& GetLocalAnchorA() const { return m_localAnchorA; }
-
-	/// The local anchor point relative to bodyB's origin.
-	const b2Vec2& GetLocalAnchorB() const  { return m_localAnchorB; }
-
-	/// Get the reference angle.
-	float32 GetReferenceAngle() const { return m_referenceAngle; }
-
-	/// Set/get frequency in Hz.
-	void SetFrequency(float32 hz) { m_frequencyHz = hz; }
-	float32 GetFrequency() const { return m_frequencyHz; }
-
-	/// Set/get damping ratio.
-	void SetDampingRatio(float32 ratio) { m_dampingRatio = ratio; }
-	float32 GetDampingRatio() const { return m_dampingRatio; }
-
-	/// Dump to b2Log
-	void Dump() override;
-
-protected:
-
-	friend class b2Joint;
-
-	b2WeldJoint(const b2WeldJointDef* def);
-
-	void InitVelocityConstraints(const b2SolverData& data) override;
-	void SolveVelocityConstraints(const b2SolverData& data) override;
-	bool SolvePositionConstraints(const b2SolverData& data) override;
-
-	float32 m_frequencyHz;
-	float32 m_dampingRatio;
-	float32 m_bias;
-
-	// Solver shared
-	b2Vec2 m_localAnchorA;
-	b2Vec2 m_localAnchorB;
-	float32 m_referenceAngle;
-	float32 m_gamma;
-	b2Vec3 m_impulse;
-
-	// Solver temp
-	int32 m_indexA;
-	int32 m_indexB;
-	b2Vec2 m_rA;
-	b2Vec2 m_rB;
-	b2Vec2 m_localCenterA;
-	b2Vec2 m_localCenterB;
-	float32 m_invMassA;
-	float32 m_invMassB;
-	float32 m_invIA;
-	float32 m_invIB;
-	b2Mat33 m_mass;
-};
-
-#endif

Source/ThirdParty/Box2D/Box2D/Dynamics/Joints/b2WheelJoint.cpp

@@ -1,456 +0,0 @@
-/*
-* Copyright (c) 2006-2007 Erin Catto http://www.box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
-
-#include "Box2D/Dynamics/Joints/b2WheelJoint.h"
-#include "Box2D/Dynamics/b2Body.h"
-#include "Box2D/Dynamics/b2TimeStep.h"
-
-// Linear constraint (point-to-line)
-// d = pB - pA = xB + rB - xA - rA
-// C = dot(ay, d)
-// Cdot = dot(d, cross(wA, ay)) + dot(ay, vB + cross(wB, rB) - vA - cross(wA, rA))
-//      = -dot(ay, vA) - dot(cross(d + rA, ay), wA) + dot(ay, vB) + dot(cross(rB, ay), vB)
-// J = [-ay, -cross(d + rA, ay), ay, cross(rB, ay)]
-
-// Spring linear constraint
-// C = dot(ax, d)
-// Cdot = = -dot(ax, vA) - dot(cross(d + rA, ax), wA) + dot(ax, vB) + dot(cross(rB, ax), vB)
-// J = [-ax -cross(d+rA, ax) ax cross(rB, ax)]
-
-// Motor rotational constraint
-// Cdot = wB - wA
-// J = [0 0 -1 0 0 1]
-
-void b2WheelJointDef::Initialize(b2Body* bA, b2Body* bB, const b2Vec2& anchor, const b2Vec2& axis)
-{
-	bodyA = bA;
-	bodyB = bB;
-	localAnchorA = bodyA->GetLocalPoint(anchor);
-	localAnchorB = bodyB->GetLocalPoint(anchor);
-	localAxisA = bodyA->GetLocalVector(axis);
-}
-
-b2WheelJoint::b2WheelJoint(const b2WheelJointDef* def)
-: b2Joint(def)
-{
-	m_localAnchorA = def->localAnchorA;
-	m_localAnchorB = def->localAnchorB;
-	m_localXAxisA = def->localAxisA;
-	m_localYAxisA = b2Cross(1.0f, m_localXAxisA);
-
-	m_mass = 0.0f;
-	m_impulse = 0.0f;
-	m_motorMass = 0.0f;
-	m_motorImpulse = 0.0f;
-	m_springMass = 0.0f;
-	m_springImpulse = 0.0f;
-
-	m_maxMotorTorque = def->maxMotorTorque;
-	m_motorSpeed = def->motorSpeed;
-	m_enableMotor = def->enableMotor;
-
-	m_frequencyHz = def->frequencyHz;
-	m_dampingRatio = def->dampingRatio;
-
-	m_bias = 0.0f;
-	m_gamma = 0.0f;
-
-	m_ax.SetZero();
-	m_ay.SetZero();
-}
-
-void b2WheelJoint::InitVelocityConstraints(const b2SolverData& data)
-{
-	m_indexA = m_bodyA->m_islandIndex;
-	m_indexB = m_bodyB->m_islandIndex;
-	m_localCenterA = m_bodyA->m_sweep.localCenter;
-	m_localCenterB = m_bodyB->m_sweep.localCenter;
-	m_invMassA = m_bodyA->m_invMass;
-	m_invMassB = m_bodyB->m_invMass;
-	m_invIA = m_bodyA->m_invI;
-	m_invIB = m_bodyB->m_invI;
-
-	float32 mA = m_invMassA, mB = m_invMassB;
-	float32 iA = m_invIA, iB = m_invIB;
-
-	b2Vec2 cA = data.positions[m_indexA].c;
-	float32 aA = data.positions[m_indexA].a;
-	b2Vec2 vA = data.velocities[m_indexA].v;
-	float32 wA = data.velocities[m_indexA].w;
-
-	b2Vec2 cB = data.positions[m_indexB].c;
-	float32 aB = data.positions[m_indexB].a;
-	b2Vec2 vB = data.velocities[m_indexB].v;
-	float32 wB = data.velocities[m_indexB].w;
-
-	b2Rot qA(aA), qB(aB);
-
-	// Compute the effective masses.
-	b2Vec2 rA = b2Mul(qA, m_localAnchorA - m_localCenterA);
-	b2Vec2 rB = b2Mul(qB, m_localAnchorB - m_localCenterB);
-	b2Vec2 d = cB + rB - cA - rA;
-
-	// Point to line constraint
-	{
-		m_ay = b2Mul(qA, m_localYAxisA);
-		m_sAy = b2Cross(d + rA, m_ay);
-		m_sBy = b2Cross(rB, m_ay);
-
-		m_mass = mA + mB + iA * m_sAy * m_sAy + iB * m_sBy * m_sBy;
-
-		if (m_mass > 0.0f)
-		{
-			m_mass = 1.0f / m_mass;
-		}
-	}
-
-	// Spring constraint
-	m_springMass = 0.0f;
-	m_bias = 0.0f;
-	m_gamma = 0.0f;
-	if (m_frequencyHz > 0.0f)
-	{
-		m_ax = b2Mul(qA, m_localXAxisA);
-		m_sAx = b2Cross(d + rA, m_ax);
-		m_sBx = b2Cross(rB, m_ax);
-
-		float32 invMass = mA + mB + iA * m_sAx * m_sAx + iB * m_sBx * m_sBx;
-
-		if (invMass > 0.0f)
-		{
-			m_springMass = 1.0f / invMass;
-
-			float32 C = b2Dot(d, m_ax);
-
-			// Frequency
-			float32 omega = 2.0f * b2_pi * m_frequencyHz;
-
-			// Damping coefficient
-			float32 damp = 2.0f * m_springMass * m_dampingRatio * omega;
-
-			// Spring stiffness
-			float32 k = m_springMass * omega * omega;
-
-			// magic formulas
-			float32 h = data.step.dt;
-			m_gamma = h * (damp + h * k);
-			if (m_gamma > 0.0f)
-			{
-				m_gamma = 1.0f / m_gamma;
-			}
-
-			m_bias = C * h * k * m_gamma;
-
-			m_springMass = invMass + m_gamma;
-			if (m_springMass > 0.0f)
-			{
-				m_springMass = 1.0f / m_springMass;
-			}
-		}
-	}
-	else
-	{
-		m_springImpulse = 0.0f;
-	}
-
-	// Rotational motor
-	if (m_enableMotor)
-	{
-		m_motorMass = iA + iB;
-		if (m_motorMass > 0.0f)
-		{
-			m_motorMass = 1.0f / m_motorMass;
-		}
-	}
-	else
-	{
-		m_motorMass = 0.0f;
-		m_motorImpulse = 0.0f;
-	}
-
-	if (data.step.warmStarting)
-	{
-		// Account for variable time step.
-		m_impulse *= data.step.dtRatio;
-		m_springImpulse *= data.step.dtRatio;
-		m_motorImpulse *= data.step.dtRatio;
-
-		b2Vec2 P = m_impulse * m_ay + m_springImpulse * m_ax;
-		float32 LA = m_impulse * m_sAy + m_springImpulse * m_sAx + m_motorImpulse;
-		float32 LB = m_impulse * m_sBy + m_springImpulse * m_sBx + m_motorImpulse;
-
-		vA -= m_invMassA * P;
-		wA -= m_invIA * LA;
-
-		vB += m_invMassB * P;
-		wB += m_invIB * LB;
-	}
-	else
-	{
-		m_impulse = 0.0f;
-		m_springImpulse = 0.0f;
-		m_motorImpulse = 0.0f;
-	}
-
-	data.velocities[m_indexA].v = vA;
-	data.velocities[m_indexA].w = wA;
-	data.velocities[m_indexB].v = vB;
-	data.velocities[m_indexB].w = wB;
-}
-
-void b2WheelJoint::SolveVelocityConstraints(const b2SolverData& data)
-{
-	float32 mA = m_invMassA, mB = m_invMassB;
-	float32 iA = m_invIA, iB = m_invIB;
-
-	b2Vec2 vA = data.velocities[m_indexA].v;
-	float32 wA = data.velocities[m_indexA].w;
-	b2Vec2 vB = data.velocities[m_indexB].v;
-	float32 wB = data.velocities[m_indexB].w;
-
-	// Solve spring constraint
-	{
-		float32 Cdot = b2Dot(m_ax, vB - vA) + m_sBx * wB - m_sAx * wA;
-		float32 impulse = -m_springMass * (Cdot + m_bias + m_gamma * m_springImpulse);
-		m_springImpulse += impulse;
-
-		b2Vec2 P = impulse * m_ax;
-		float32 LA = impulse * m_sAx;
-		float32 LB = impulse * m_sBx;
-
-		vA -= mA * P;
-		wA -= iA * LA;
-
-		vB += mB * P;
-		wB += iB * LB;
-	}
-
-	// Solve rotational motor constraint
-	{
-		float32 Cdot = wB - wA - m_motorSpeed;
-		float32 impulse = -m_motorMass * Cdot;
-
-		float32 oldImpulse = m_motorImpulse;
-		float32 maxImpulse = data.step.dt * m_maxMotorTorque;
-		m_motorImpulse = b2Clamp(m_motorImpulse + impulse, -maxImpulse, maxImpulse);
-		impulse = m_motorImpulse - oldImpulse;
-
-		wA -= iA * impulse;
-		wB += iB * impulse;
-	}
-
-	// Solve point to line constraint
-	{
-		float32 Cdot = b2Dot(m_ay, vB - vA) + m_sBy * wB - m_sAy * wA;
-		float32 impulse = -m_mass * Cdot;
-		m_impulse += impulse;
-
-		b2Vec2 P = impulse * m_ay;
-		float32 LA = impulse * m_sAy;
-		float32 LB = impulse * m_sBy;
-
-		vA -= mA * P;
-		wA -= iA * LA;
-
-		vB += mB * P;
-		wB += iB * LB;
-	}
-
-	data.velocities[m_indexA].v = vA;
-	data.velocities[m_indexA].w = wA;
-	data.velocities[m_indexB].v = vB;
-	data.velocities[m_indexB].w = wB;
-}
-
-bool b2WheelJoint::SolvePositionConstraints(const b2SolverData& data)
-{
-	b2Vec2 cA = data.positions[m_indexA].c;
-	float32 aA = data.positions[m_indexA].a;
-	b2Vec2 cB = data.positions[m_indexB].c;
-	float32 aB = data.positions[m_indexB].a;
-
-	b2Rot qA(aA), qB(aB);
-
-	b2Vec2 rA = b2Mul(qA, m_localAnchorA - m_localCenterA);
-	b2Vec2 rB = b2Mul(qB, m_localAnchorB - m_localCenterB);
-	b2Vec2 d = (cB - cA) + rB - rA;
-
-	b2Vec2 ay = b2Mul(qA, m_localYAxisA);
-
-	float32 sAy = b2Cross(d + rA, ay);
-	float32 sBy = b2Cross(rB, ay);
-
-	float32 C = b2Dot(d, ay);
-
-	float32 k = m_invMassA + m_invMassB + m_invIA * m_sAy * m_sAy + m_invIB * m_sBy * m_sBy;
-
-	float32 impulse;
-	if (k != 0.0f)
-	{
-		impulse = - C / k;
-	}
-	else
-	{
-		impulse = 0.0f;
-	}
-
-	b2Vec2 P = impulse * ay;
-	float32 LA = impulse * sAy;
-	float32 LB = impulse * sBy;
-
-	cA -= m_invMassA * P;
-	aA -= m_invIA * LA;
-	cB += m_invMassB * P;
-	aB += m_invIB * LB;
-
-	data.positions[m_indexA].c = cA;
-	data.positions[m_indexA].a = aA;
-	data.positions[m_indexB].c = cB;
-	data.positions[m_indexB].a = aB;
-
-	return b2Abs(C) <= b2_linearSlop;
-}
-
-b2Vec2 b2WheelJoint::GetAnchorA() const
-{
-	return m_bodyA->GetWorldPoint(m_localAnchorA);
-}
-
-b2Vec2 b2WheelJoint::GetAnchorB() const
-{
-	return m_bodyB->GetWorldPoint(m_localAnchorB);
-}
-
-b2Vec2 b2WheelJoint::GetReactionForce(float32 inv_dt) const
-{
-	return inv_dt * (m_impulse * m_ay + m_springImpulse * m_ax);
-}
-
-float32 b2WheelJoint::GetReactionTorque(float32 inv_dt) const
-{
-	return inv_dt * m_motorImpulse;
-}
-
-float32 b2WheelJoint::GetJointTranslation() const
-{
-	b2Body* bA = m_bodyA;
-	b2Body* bB = m_bodyB;
-
-	b2Vec2 pA = bA->GetWorldPoint(m_localAnchorA);
-	b2Vec2 pB = bB->GetWorldPoint(m_localAnchorB);
-	b2Vec2 d = pB - pA;
-	b2Vec2 axis = bA->GetWorldVector(m_localXAxisA);
-
-	float32 translation = b2Dot(d, axis);
-	return translation;
-}
-
-float32 b2WheelJoint::GetJointLinearSpeed() const
-{
-	b2Body* bA = m_bodyA;
-	b2Body* bB = m_bodyB;
-
-	b2Vec2 rA = b2Mul(bA->m_xf.q, m_localAnchorA - bA->m_sweep.localCenter);
-	b2Vec2 rB = b2Mul(bB->m_xf.q, m_localAnchorB - bB->m_sweep.localCenter);
-	b2Vec2 p1 = bA->m_sweep.c + rA;
-	b2Vec2 p2 = bB->m_sweep.c + rB;
-	b2Vec2 d = p2 - p1;
-	b2Vec2 axis = b2Mul(bA->m_xf.q, m_localXAxisA);
-
-	b2Vec2 vA = bA->m_linearVelocity;
-	b2Vec2 vB = bB->m_linearVelocity;
-	float32 wA = bA->m_angularVelocity;
-	float32 wB = bB->m_angularVelocity;
-
-	float32 speed = b2Dot(d, b2Cross(wA, axis)) + b2Dot(axis, vB + b2Cross(wB, rB) - vA - b2Cross(wA, rA));
-	return speed;
-}
-
-float32 b2WheelJoint::GetJointAngle() const
-{
-	b2Body* bA = m_bodyA;
-	b2Body* bB = m_bodyB;
-	return bB->m_sweep.a - bA->m_sweep.a;
-}
-
-float32 b2WheelJoint::GetJointAngularSpeed() const
-{
-	float32 wA = m_bodyA->m_angularVelocity;
-	float32 wB = m_bodyB->m_angularVelocity;
-	return wB - wA;
-}
-
-bool b2WheelJoint::IsMotorEnabled() const
-{
-	return m_enableMotor;
-}
-
-void b2WheelJoint::EnableMotor(bool flag)
-{
-	if (flag != m_enableMotor)
-	{
-		m_bodyA->SetAwake(true);
-		m_bodyB->SetAwake(true);
-		m_enableMotor = flag;
-	}
-}
-
-void b2WheelJoint::SetMotorSpeed(float32 speed)
-{
-	if (speed != m_motorSpeed)
-	{
-		m_bodyA->SetAwake(true);
-		m_bodyB->SetAwake(true);
-		m_motorSpeed = speed;
-	}
-}
-
-void b2WheelJoint::SetMaxMotorTorque(float32 torque)
-{
-	if (torque != m_maxMotorTorque)
-	{
-		m_bodyA->SetAwake(true);
-		m_bodyB->SetAwake(true);
-		m_maxMotorTorque = torque;
-	}
-}
-
-float32 b2WheelJoint::GetMotorTorque(float32 inv_dt) const
-{
-	return inv_dt * m_motorImpulse;
-}
-
-void b2WheelJoint::Dump()
-{
-	int32 indexA = m_bodyA->m_islandIndex;
-	int32 indexB = m_bodyB->m_islandIndex;
-
-	b2Log("  b2WheelJointDef 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.enableMotor = bool(%d);\n", m_enableMotor);
-	b2Log("  jd.motorSpeed = %.15lef;\n", m_motorSpeed);
-	b2Log("  jd.maxMotorTorque = %.15lef;\n", m_maxMotorTorque);
-	b2Log("  jd.frequencyHz = %.15lef;\n", m_frequencyHz);
-	b2Log("  jd.dampingRatio = %.15lef;\n", m_dampingRatio);
-	b2Log("  joints[%d] = m_world->CreateJoint(&jd);\n", m_index);
-}

Source/ThirdParty/Box2D/Box2D/Dynamics/Joints/b2WheelJoint.h

@@ -1,216 +0,0 @@
-/*
-* Copyright (c) 2006-2011 Erin Catto http://www.box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef B2_WHEEL_JOINT_H
-#define B2_WHEEL_JOINT_H
-
-#include "Box2D/Dynamics/Joints/b2Joint.h"
-
-/// Wheel joint definition. This requires defining a line of
-/// motion using an axis and an anchor point. The definition uses local
-/// anchor points and a local axis so that the initial configuration
-/// can violate the constraint slightly. The joint translation is zero
-/// when the local anchor points coincide in world space. Using local
-/// anchors and a local axis helps when saving and loading a game.
-struct b2WheelJointDef : public b2JointDef
-{
-	b2WheelJointDef()
-	{
-		type = e_wheelJoint;
-		localAnchorA.SetZero();
-		localAnchorB.SetZero();
-		localAxisA.Set(1.0f, 0.0f);
-		enableMotor = false;
-		maxMotorTorque = 0.0f;
-		motorSpeed = 0.0f;
-		frequencyHz = 2.0f;
-		dampingRatio = 0.7f;
-	}
-
-	/// Initialize the bodies, anchors, axis, and reference angle using the world
-	/// anchor and world axis.
-	void Initialize(b2Body* bodyA, b2Body* bodyB, const b2Vec2& anchor, const b2Vec2& axis);
-
-	/// The local anchor point relative to bodyA's origin.
-	b2Vec2 localAnchorA;
-
-	/// The local anchor point relative to bodyB's origin.
-	b2Vec2 localAnchorB;
-
-	/// The local translation axis in bodyA.
-	b2Vec2 localAxisA;
-
-	/// Enable/disable the joint motor.
-	bool enableMotor;
-
-	/// The maximum motor torque, usually in N-m.
-	float32 maxMotorTorque;
-
-	/// The desired motor speed in radians per second.
-	float32 motorSpeed;
-
-	/// Suspension frequency, zero indicates no suspension
-	float32 frequencyHz;
-
-	/// Suspension damping ratio, one indicates critical damping
-	float32 dampingRatio;
-};
-
-/// A wheel joint. This joint provides two degrees of freedom: translation
-/// along an axis fixed in bodyA and rotation in the plane. In other words, it is a point to
-/// line constraint with a rotational motor and a linear spring/damper.
-/// This joint is designed for vehicle suspensions.
-class b2WheelJoint : public b2Joint
-{
-public:
-	b2Vec2 GetAnchorA() const override;
-	b2Vec2 GetAnchorB() const override;
-
-	b2Vec2 GetReactionForce(float32 inv_dt) const override;
-	float32 GetReactionTorque(float32 inv_dt) const override;
-
-	/// The local anchor point relative to bodyA's origin.
-	const b2Vec2& GetLocalAnchorA() const { return m_localAnchorA; }
-
-	/// The local anchor point relative to bodyB's origin.
-	const b2Vec2& GetLocalAnchorB() const  { return m_localAnchorB; }
-
-	/// The local joint axis relative to bodyA.
-	const b2Vec2& GetLocalAxisA() const { return m_localXAxisA; }
-
-	/// Get the current joint translation, usually in meters.
-	float32 GetJointTranslation() const;
-
-	/// Get the current joint linear speed, usually in meters per second.
-	float32 GetJointLinearSpeed() const;
-
-	/// Get the current joint angle in radians.
-	float32 GetJointAngle() const;
-
-	/// Get the current joint angular speed in radians per second.
-	float32 GetJointAngularSpeed() const;
-
-	/// Is the joint motor enabled?
-	bool IsMotorEnabled() const;
-
-	/// Enable/disable the joint motor.
-	void EnableMotor(bool flag);
-
-	/// Set the motor speed, usually in radians per second.
-	void SetMotorSpeed(float32 speed);
-
-	/// Get the motor speed, usually in radians per second.
-	float32 GetMotorSpeed() const;
-
-	/// Set/Get the maximum motor force, usually in N-m.
-	void SetMaxMotorTorque(float32 torque);
-	float32 GetMaxMotorTorque() const;
-
-	/// Get the current motor torque given the inverse time step, usually in N-m.
-	float32 GetMotorTorque(float32 inv_dt) const;
-
-	/// Set/Get the spring frequency in hertz. Setting the frequency to zero disables the spring.
-	void SetSpringFrequencyHz(float32 hz);
-	float32 GetSpringFrequencyHz() const;
-
-	/// Set/Get the spring damping ratio
-	void SetSpringDampingRatio(float32 ratio);
-	float32 GetSpringDampingRatio() const;
-
-	/// Dump to b2Log
-	void Dump() override;
-
-protected:
-
-	friend class b2Joint;
-	b2WheelJoint(const b2WheelJointDef* def);
-
-	void InitVelocityConstraints(const b2SolverData& data) override;
-	void SolveVelocityConstraints(const b2SolverData& data) override;
-	bool SolvePositionConstraints(const b2SolverData& data) override;
-
-	float32 m_frequencyHz;
-	float32 m_dampingRatio;
-
-	// Solver shared
-	b2Vec2 m_localAnchorA;
-	b2Vec2 m_localAnchorB;
-	b2Vec2 m_localXAxisA;
-	b2Vec2 m_localYAxisA;
-
-	float32 m_impulse;
-	float32 m_motorImpulse;
-	float32 m_springImpulse;
-
-	float32 m_maxMotorTorque;
-	float32 m_motorSpeed;
-	bool m_enableMotor;
-
-	// Solver temp
-	int32 m_indexA;
-	int32 m_indexB;
-	b2Vec2 m_localCenterA;
-	b2Vec2 m_localCenterB;
-	float32 m_invMassA;
-	float32 m_invMassB;
-	float32 m_invIA;
-	float32 m_invIB;
-
-	b2Vec2 m_ax, m_ay;
-	float32 m_sAx, m_sBx;
-	float32 m_sAy, m_sBy;
-
-	float32 m_mass;
-	float32 m_motorMass;
-	float32 m_springMass;
-
-	float32 m_bias;
-	float32 m_gamma;
-};
-
-inline float32 b2WheelJoint::GetMotorSpeed() const
-{
-	return m_motorSpeed;
-}
-
-inline float32 b2WheelJoint::GetMaxMotorTorque() const
-{
-	return m_maxMotorTorque;
-}
-
-inline void b2WheelJoint::SetSpringFrequencyHz(float32 hz)
-{
-	m_frequencyHz = hz;
-}
-
-inline float32 b2WheelJoint::GetSpringFrequencyHz() const
-{
-	return m_frequencyHz;
-}
-
-inline void b2WheelJoint::SetSpringDampingRatio(float32 ratio)
-{
-	m_dampingRatio = ratio;
-}
-
-inline float32 b2WheelJoint::GetSpringDampingRatio() const
-{
-	return m_dampingRatio;
-}
-
-#endif

Source/ThirdParty/Box2D/Box2D/Dynamics/b2ContactManager.h

@@ -1,52 +0,0 @@
-/*
-* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef B2_CONTACT_MANAGER_H
-#define B2_CONTACT_MANAGER_H
-
-#include "Box2D/Collision/b2BroadPhase.h"
-
-class b2Contact;
-class b2ContactFilter;
-class b2ContactListener;
-class b2BlockAllocator;
-
-// Delegate of b2World.
-class b2ContactManager
-{
-public:
-	b2ContactManager();
-
-	// Broad-phase callback.
-	void AddPair(void* proxyUserDataA, void* proxyUserDataB);
-
-	void FindNewContacts();
-
-	void Destroy(b2Contact* c);
-
-	void Collide();
-            
-	b2BroadPhase m_broadPhase;
-	b2Contact* m_contactList;
-	int32 m_contactCount;
-	b2ContactFilter* m_contactFilter;
-	b2ContactListener* m_contactListener;
-	b2BlockAllocator* m_allocator;
-};
-
-#endif

Source/ThirdParty/Box2D/Box2D/Dynamics/b2TimeStep.h

@@ -1,70 +0,0 @@
-/*
-* Copyright (c) 2006-2011 Erin Catto http://www.box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef B2_TIME_STEP_H
-#define B2_TIME_STEP_H
-
-#include "Box2D/Common/b2Math.h"
-
-/// Profiling data. Times are in milliseconds.
-struct b2Profile
-{
-	float32 step;
-	float32 collide;
-	float32 solve;
-	float32 solveInit;
-	float32 solveVelocity;
-	float32 solvePosition;
-	float32 broadphase;
-	float32 solveTOI;
-};
-
-/// This is an internal structure.
-struct b2TimeStep
-{
-	float32 dt;			// time step
-	float32 inv_dt;		// inverse time step (0 if dt == 0).
-	float32 dtRatio;	// dt * inv_dt0
-	int32 velocityIterations;
-	int32 positionIterations;
-	bool warmStarting;
-};
-
-/// This is an internal structure.
-struct b2Position
-{
-	b2Vec2 c;
-	float32 a;
-};
-
-/// This is an internal structure.
-struct b2Velocity
-{
-	b2Vec2 v;
-	float32 w;
-};
-
-/// Solver Data
-struct b2SolverData
-{
-	b2TimeStep step;
-	b2Position* positions;
-	b2Velocity* velocities;
-};
-
-#endif

Source/ThirdParty/Box2D/Box2D/Dynamics/b2WorldCallbacks.cpp

@@ -1,36 +0,0 @@
-/*
-* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
-
-#include "Box2D/Dynamics/b2WorldCallbacks.h"
-#include "Box2D/Dynamics/b2Fixture.h"
-
-// Return true if contact calculations should be performed between these two shapes.
-// If you implement your own collision filter you may want to build from this implementation.
-bool b2ContactFilter::ShouldCollide(b2Fixture* fixtureA, b2Fixture* fixtureB)
-{
-	const b2Filter& filterA = fixtureA->GetFilterData();
-	const b2Filter& filterB = fixtureB->GetFilterData();
-
-	if (filterA.groupIndex == filterB.groupIndex && filterA.groupIndex != 0)
-	{
-		return filterA.groupIndex > 0;
-	}
-
-	bool collide = (filterA.maskBits & filterB.categoryBits) != 0 && (filterA.categoryBits & filterB.maskBits) != 0;
-	return collide;
-}

Source/ThirdParty/Box2D/Box2D/Rope/b2Rope.cpp

@@ -1,259 +0,0 @@
-/*
-* Copyright (c) 2011 Erin Catto http://box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
-
-#include "Box2D/Rope/b2Rope.h"
-#include "Box2D/Common/b2Draw.h"
-
-b2Rope::b2Rope()
-{
-	m_count = 0;
-	m_ps = nullptr;
-	m_p0s = nullptr;
-	m_vs = nullptr;
-	m_ims = nullptr;
-	m_Ls = nullptr;
-	m_as = nullptr;
-	m_gravity.SetZero();
-	m_k2 = 1.0f;
-	m_k3 = 0.1f;
-}
-
-b2Rope::~b2Rope()
-{
-	b2Free(m_ps);
-	b2Free(m_p0s);
-	b2Free(m_vs);
-	b2Free(m_ims);
-	b2Free(m_Ls);
-	b2Free(m_as);
-}
-
-void b2Rope::Initialize(const b2RopeDef* def)
-{
-	b2Assert(def->count >= 3);
-	m_count = def->count;
-	m_ps = (b2Vec2*)b2Alloc(m_count * sizeof(b2Vec2));
-	m_p0s = (b2Vec2*)b2Alloc(m_count * sizeof(b2Vec2));
-	m_vs = (b2Vec2*)b2Alloc(m_count * sizeof(b2Vec2));
-	m_ims = (float32*)b2Alloc(m_count * sizeof(float32));
-
-	for (int32 i = 0; i < m_count; ++i)
-	{
-		m_ps[i] = def->vertices[i];
-		m_p0s[i] = def->vertices[i];
-		m_vs[i].SetZero();
-
-		float32 m = def->masses[i];
-		if (m > 0.0f)
-		{
-			m_ims[i] = 1.0f / m;
-		}
-		else
-		{
-			m_ims[i] = 0.0f;
-		}
-	}
-
-	int32 count2 = m_count - 1;
-	int32 count3 = m_count - 2;
-	m_Ls = (float32*)b2Alloc(count2 * sizeof(float32));
-	m_as = (float32*)b2Alloc(count3 * sizeof(float32));
-
-	for (int32 i = 0; i < count2; ++i)
-	{
-		b2Vec2 p1 = m_ps[i];
-		b2Vec2 p2 = m_ps[i+1];
-		m_Ls[i] = b2Distance(p1, p2);
-	}
-
-	for (int32 i = 0; i < count3; ++i)
-	{
-		b2Vec2 p1 = m_ps[i];
-		b2Vec2 p2 = m_ps[i + 1];
-		b2Vec2 p3 = m_ps[i + 2];
-
-		b2Vec2 d1 = p2 - p1;
-		b2Vec2 d2 = p3 - p2;
-
-		float32 a = b2Cross(d1, d2);
-		float32 b = b2Dot(d1, d2);
-
-		m_as[i] = b2Atan2(a, b);
-	}
-
-	m_gravity = def->gravity;
-	m_damping = def->damping;
-	m_k2 = def->k2;
-	m_k3 = def->k3;
-}
-
-void b2Rope::Step(float32 h, int32 iterations)
-{
-	if (h == 0.0)
-	{
-		return;
-	}
-
-	float32 d = expf(- h * m_damping);
-
-	for (int32 i = 0; i < m_count; ++i)
-	{
-		m_p0s[i] = m_ps[i];
-		if (m_ims[i] > 0.0f)
-		{
-			m_vs[i] += h * m_gravity;
-		}
-		m_vs[i] *= d;
-		m_ps[i] += h * m_vs[i];
-
-	}
-
-	for (int32 i = 0; i < iterations; ++i)
-	{
-		SolveC2();
-		SolveC3();
-		SolveC2();
-	}
-
-	float32 inv_h = 1.0f / h;
-	for (int32 i = 0; i < m_count; ++i)
-	{
-		m_vs[i] = inv_h * (m_ps[i] - m_p0s[i]);
-	}
-}
-
-void b2Rope::SolveC2()
-{
-	int32 count2 = m_count - 1;
-
-	for (int32 i = 0; i < count2; ++i)
-	{
-		b2Vec2 p1 = m_ps[i];
-		b2Vec2 p2 = m_ps[i + 1];
-
-		b2Vec2 d = p2 - p1;
-		float32 L = d.Normalize();
-
-		float32 im1 = m_ims[i];
-		float32 im2 = m_ims[i + 1];
-
-		if (im1 + im2 == 0.0f)
-		{
-			continue;
-		}
-
-		float32 s1 = im1 / (im1 + im2);
-		float32 s2 = im2 / (im1 + im2);
-
-		p1 -= m_k2 * s1 * (m_Ls[i] - L) * d;
-		p2 += m_k2 * s2 * (m_Ls[i] - L) * d;
-
-		m_ps[i] = p1;
-		m_ps[i + 1] = p2;
-	}
-}
-
-void b2Rope::SetAngle(float32 angle)
-{
-	int32 count3 = m_count - 2;
-	for (int32 i = 0; i < count3; ++i)
-	{
-		m_as[i] = angle;
-	}
-}
-
-void b2Rope::SolveC3()
-{
-	int32 count3 = m_count - 2;
-
-	for (int32 i = 0; i < count3; ++i)
-	{
-		b2Vec2 p1 = m_ps[i];
-		b2Vec2 p2 = m_ps[i + 1];
-		b2Vec2 p3 = m_ps[i + 2];
-
-		float32 m1 = m_ims[i];
-		float32 m2 = m_ims[i + 1];
-		float32 m3 = m_ims[i + 2];
-
-		b2Vec2 d1 = p2 - p1;
-		b2Vec2 d2 = p3 - p2;
-
-		float32 L1sqr = d1.LengthSquared();
-		float32 L2sqr = d2.LengthSquared();
-
-		if (L1sqr * L2sqr == 0.0f)
-		{
-			continue;
-		}
-
-		float32 a = b2Cross(d1, d2);
-		float32 b = b2Dot(d1, d2);
-
-		float32 angle = b2Atan2(a, b);
-
-		b2Vec2 Jd1 = (-1.0f / L1sqr) * d1.Skew();
-		b2Vec2 Jd2 = (1.0f / L2sqr) * d2.Skew();
-
-		b2Vec2 J1 = -Jd1;
-		b2Vec2 J2 = Jd1 - Jd2;
-		b2Vec2 J3 = Jd2;
-
-		float32 mass = m1 * b2Dot(J1, J1) + m2 * b2Dot(J2, J2) + m3 * b2Dot(J3, J3);
-		if (mass == 0.0f)
-		{
-			continue;
-		}
-
-		mass = 1.0f / mass;
-
-		float32 C = angle - m_as[i];
-
-		while (C > b2_pi)
-		{
-			angle -= 2 * b2_pi;
-			C = angle - m_as[i];
-		}
-
-		while (C < -b2_pi)
-		{
-			angle += 2.0f * b2_pi;
-			C = angle - m_as[i];
-		}
-
-		float32 impulse = - m_k3 * mass * C;
-
-		p1 += (m1 * impulse) * J1;
-		p2 += (m2 * impulse) * J2;
-		p3 += (m3 * impulse) * J3;
-
-		m_ps[i] = p1;
-		m_ps[i + 1] = p2;
-		m_ps[i + 2] = p3;
-	}
-}
-
-void b2Rope::Draw(b2Draw* draw) const
-{
-	b2Color c(0.4f, 0.5f, 0.7f);
-
-	for (int32 i = 0; i < m_count - 1; ++i)
-	{
-		draw->DrawSegment(m_ps[i], m_ps[i+1], c);
-	}
-}

Source/ThirdParty/Box2D/Box2D/Rope/b2Rope.h

@@ -1,115 +0,0 @@
-/*
-* Copyright (c) 2011 Erin Catto http://www.box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef B2_ROPE_H
-#define B2_ROPE_H
-
-#include "Box2D/Common/b2Math.h"
-
-class b2Draw;
-
-/// 
-struct b2RopeDef
-{
-	b2RopeDef()
-	{
-		vertices = nullptr;
-		count = 0;
-		masses = nullptr;
-		gravity.SetZero();
-		damping = 0.1f;
-		k2 = 0.9f;
-		k3 = 0.1f;
-	}
-
-	///
-	b2Vec2* vertices;
-
-	///
-	int32 count;
-
-	///
-	float32* masses;
-
-	///
-	b2Vec2 gravity;
-
-	///
-	float32 damping;
-
-	/// Stretching stiffness
-	float32 k2;
-
-	/// Bending stiffness. Values above 0.5 can make the simulation blow up.
-	float32 k3;
-};
-
-/// 
-class b2Rope
-{
-public:
-	b2Rope();
-	~b2Rope();
-
-	///
-	void Initialize(const b2RopeDef* def);
-
-	///
-	void Step(float32 timeStep, int32 iterations);
-
-	///
-	int32 GetVertexCount() const
-	{
-		return m_count;
-	}
-
-	///
-	const b2Vec2* GetVertices() const
-	{
-		return m_ps;
-	}
-
-	///
-	void Draw(b2Draw* draw) const;
-
-	///
-	void SetAngle(float32 angle);
-
-private:
-
-	void SolveC2();
-	void SolveC3();
-
-	int32 m_count;
-	b2Vec2* m_ps;
-	b2Vec2* m_p0s;
-	b2Vec2* m_vs;
-
-	float32* m_ims;
-
-	float32* m_Ls;
-	float32* m_as;
-
-	b2Vec2 m_gravity;
-	float32 m_damping;
-
-	float32 m_k2;
-	float32 m_k3;
-};
-
-#endif

Source/ThirdParty/Box2D/CMakeLists.txt

@@ -23,167 +23,16 @@
 # Define target name
 set (TARGET_NAME Box2D)
 
-set(BOX2D_Collision_SRCS
-    Box2D/Collision/b2BroadPhase.cpp
-    Box2D/Collision/b2CollideCircle.cpp
-    Box2D/Collision/b2CollideEdge.cpp
-    Box2D/Collision/b2CollidePolygon.cpp
-    Box2D/Collision/b2Collision.cpp
-    Box2D/Collision/b2Distance.cpp
-    Box2D/Collision/b2DynamicTree.cpp
-    Box2D/Collision/b2TimeOfImpact.cpp
-)
-set(BOX2D_Collision_HDRS
-    Box2D/Collision/b2BroadPhase.h
-    Box2D/Collision/b2Collision.h
-    Box2D/Collision/b2Distance.h
-    Box2D/Collision/b2DynamicTree.h
-    Box2D/Collision/b2TimeOfImpact.h
-)
-set(BOX2D_Shapes_SRCS
-    Box2D/Collision/Shapes/b2CircleShape.cpp
-    Box2D/Collision/Shapes/b2EdgeShape.cpp
-    Box2D/Collision/Shapes/b2ChainShape.cpp
-    Box2D/Collision/Shapes/b2PolygonShape.cpp
-)
-set(BOX2D_Shapes_HDRS
-    Box2D/Collision/Shapes/b2CircleShape.h
-    Box2D/Collision/Shapes/b2EdgeShape.h
-    Box2D/Collision/Shapes/b2ChainShape.h
-    Box2D/Collision/Shapes/b2PolygonShape.h
-    Box2D/Collision/Shapes/b2Shape.h
-)
-set(BOX2D_Common_SRCS
-    Box2D/Common/b2BlockAllocator.cpp
-    Box2D/Common/b2Draw.cpp
-    Box2D/Common/b2Math.cpp
-    Box2D/Common/b2Settings.cpp
-    Box2D/Common/b2StackAllocator.cpp
-    Box2D/Common/b2Timer.cpp
-)
-set(BOX2D_Common_HDRS
-    Box2D/Common/b2BlockAllocator.h
-    Box2D/Common/b2Draw.h
-    Box2D/Common/b2GrowableStack.h
-    Box2D/Common/b2Math.h
-    Box2D/Common/b2Settings.h
-    Box2D/Common/b2StackAllocator.h
-    Box2D/Common/b2Timer.h
-)
-set(BOX2D_Dynamics_SRCS
-    Box2D/Dynamics/b2Body.cpp
-    Box2D/Dynamics/b2ContactManager.cpp
-    Box2D/Dynamics/b2Fixture.cpp
-    Box2D/Dynamics/b2Island.cpp
-    Box2D/Dynamics/b2World.cpp
-    Box2D/Dynamics/b2WorldCallbacks.cpp
-)
-set(BOX2D_Dynamics_HDRS
-    Box2D/Dynamics/b2Body.h
-    Box2D/Dynamics/b2ContactManager.h
-    Box2D/Dynamics/b2Fixture.h
-    Box2D/Dynamics/b2Island.h
-    Box2D/Dynamics/b2TimeStep.h
-    Box2D/Dynamics/b2World.h
-    Box2D/Dynamics/b2WorldCallbacks.h
-)
-set(BOX2D_Contacts_SRCS
-    Box2D/Dynamics/Contacts/b2CircleContact.cpp
-    Box2D/Dynamics/Contacts/b2Contact.cpp
-    Box2D/Dynamics/Contacts/b2ContactSolver.cpp
-    Box2D/Dynamics/Contacts/b2PolygonAndCircleContact.cpp
-    Box2D/Dynamics/Contacts/b2EdgeAndCircleContact.cpp
-    Box2D/Dynamics/Contacts/b2EdgeAndPolygonContact.cpp
-    Box2D/Dynamics/Contacts/b2ChainAndCircleContact.cpp
-    Box2D/Dynamics/Contacts/b2ChainAndPolygonContact.cpp
-    Box2D/Dynamics/Contacts/b2PolygonContact.cpp
-)
-set(BOX2D_Contacts_HDRS
-    Box2D/Dynamics/Contacts/b2CircleContact.h
-    Box2D/Dynamics/Contacts/b2Contact.h
-    Box2D/Dynamics/Contacts/b2ContactSolver.h
-    Box2D/Dynamics/Contacts/b2PolygonAndCircleContact.h
-    Box2D/Dynamics/Contacts/b2EdgeAndCircleContact.h
-    Box2D/Dynamics/Contacts/b2EdgeAndPolygonContact.h
-    Box2D/Dynamics/Contacts/b2ChainAndCircleContact.h
-    Box2D/Dynamics/Contacts/b2ChainAndPolygonContact.h
-    Box2D/Dynamics/Contacts/b2PolygonContact.h
-)
-set(BOX2D_Joints_SRCS
-    Box2D/Dynamics/Joints/b2DistanceJoint.cpp
-    Box2D/Dynamics/Joints/b2FrictionJoint.cpp
-    Box2D/Dynamics/Joints/b2GearJoint.cpp
-    Box2D/Dynamics/Joints/b2Joint.cpp
-    Box2D/Dynamics/Joints/b2MotorJoint.cpp
-    Box2D/Dynamics/Joints/b2MouseJoint.cpp
-    Box2D/Dynamics/Joints/b2PrismaticJoint.cpp
-    Box2D/Dynamics/Joints/b2PulleyJoint.cpp
-    Box2D/Dynamics/Joints/b2RevoluteJoint.cpp
-    Box2D/Dynamics/Joints/b2RopeJoint.cpp
-    Box2D/Dynamics/Joints/b2WeldJoint.cpp
-    Box2D/Dynamics/Joints/b2WheelJoint.cpp
-)
-set(BOX2D_Joints_HDRS
-    Box2D/Dynamics/Joints/b2DistanceJoint.h
-    Box2D/Dynamics/Joints/b2FrictionJoint.h
-    Box2D/Dynamics/Joints/b2GearJoint.h
-    Box2D/Dynamics/Joints/b2Joint.h
-    Box2D/Dynamics/Joints/b2MotorJoint.h
-    Box2D/Dynamics/Joints/b2MouseJoint.h
-    Box2D/Dynamics/Joints/b2PrismaticJoint.h
-    Box2D/Dynamics/Joints/b2PulleyJoint.h
-    Box2D/Dynamics/Joints/b2RevoluteJoint.h
-    Box2D/Dynamics/Joints/b2RopeJoint.h
-    Box2D/Dynamics/Joints/b2WeldJoint.h
-    Box2D/Dynamics/Joints/b2WheelJoint.h
-)
-set(BOX2D_Rope_SRCS
-    Box2D/Rope/b2Rope.cpp
-)
-set(BOX2D_Rope_HDRS
-    Box2D/Rope/b2Rope.h
-)
-set(BOX2D_General_HDRS
-    Box2D/Box2D.h
-)
-
 # Define source files
-file (GLOB CPP_FILES 
-    ${BOX2D_Collision_SRCS}
-    ${BOX2D_Shapes_SRCS}
-    ${BOX2D_Common_SRCS}
-    ${BOX2D_Dynamics_SRCS}
-    ${BOX2D_Contacts_SRCS}
-    ${BOX2D_Joints_SRCS}
-    ${BOX2D_Rope_SRCS})
-
-file (GLOB H_FILES 
-    ${BOX2D_Collision_HDRS}
-    ${BOX2D_Shapes_HDRS}
-    ${BOX2D_Common_HDRS}
-    ${BOX2D_Dynamics_HDRS}
-    ${BOX2D_Contacts_HDRS}
-    ${BOX2D_Joints_HDRS}
-    ${BOX2D_Rope_HDRS}
-    ${BOX2D_General_HDRS})
+define_source_files (RECURSE GLOB_CPP_PATTERNS src/*.cpp src/*.h GLOB_H_PATTERNS include/*.h GROUP)
 
 set (SOURCE_FILES ${CPP_FILES} ${H_FILES})
 
-# These are used to create visual studio folders.
-source_group(Collision FILES ${BOX2D_Collision_SRCS} ${BOX2D_Collision_HDRS})
-source_group(Collision\\Shapes FILES ${BOX2D_Shapes_SRCS} ${BOX2D_Shapes_HDRS})
-source_group(Common FILES ${BOX2D_Common_SRCS} ${BOX2D_Common_HDRS})
-source_group(Dynamics FILES ${BOX2D_Dynamics_SRCS} ${BOX2D_Dynamics_HDRS})
-source_group(Dynamics\\Contacts FILES ${BOX2D_Contacts_SRCS} ${BOX2D_Contacts_HDRS})
-source_group(Dynamics\\Joints FILES ${BOX2D_Joints_SRCS} ${BOX2D_Joints_HDRS})
-source_group(Include FILES ${BOX2D_General_HDRS})
-source_group(Rope FILES ${BOX2D_Rope_SRCS} ${BOX2D_Rope_HDRS})
-
 # Define dependency libs
-set (INCLUDE_DIRS .)
+set (INCLUDE_DIRS include)
 
 # Setup target
 setup_library ()
 
 # Install headers for building and using the Urho3D library (install dependency for Urho3D/Physics2D/PhysicsWorld2D.h and Urho3D/Physics2D/RigidBody2D.h)
-install_header_files (DIRECTORY Box2D DESTINATION ${DEST_INCLUDE_DIR}/ThirdParty FILES_MATCHING PATTERN *.h)
+install_header_files (DIRECTORY include/box2d DESTINATION ${DEST_INCLUDE_DIR}/ThirdParty)

Source/ThirdParty/Box2D/LICENSE

@@ -1,17 +1,21 @@
-Copyright (c) 2006-2017 Erin Catto http://www.box2d.org
+MIT License
 
-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.
+Copyright (c) 2019 Erin Catto
 
-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:
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
 
-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 as such, and must not be
-   misrepresented as being the original software.
-3. This notice may not be removed or altered from any source distribution.
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

Source/ThirdParty/Box2D/Urho3DNotes.txt

@@ -0,0 +1,3 @@
+URL: https://github.com/erincatto/box2d
+Date: 22.04.2022
+Latest commit: https://github.com/erincatto/box2d/commit/9dc24a6fd4f32442c4bcf80791de47a0a7d25afb

Source/ThirdParty/Box2D/include/box2d/b2_api.h

@@ -0,0 +1,52 @@
+// MIT License
+
+// Copyright (c) 2019 Erin Catto
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#ifndef B2_API_H
+#define B2_API_H
+
+#ifdef B2_SHARED
+  #if defined _WIN32 || defined __CYGWIN__
+    #ifdef box2d_EXPORTS
+      #ifdef __GNUC__
+        #define B2_API __attribute__ ((dllexport))
+      #else
+        #define B2_API __declspec(dllexport)
+      #endif
+    #else
+      #ifdef __GNUC__
+        #define B2_API __attribute__ ((dllimport))
+      #else
+        #define B2_API __declspec(dllimport)
+      #endif
+    #endif
+  #else
+    #if __GNUC__ >= 4
+      #define B2_API __attribute__ ((visibility ("default")))
+    #else
+      #define B2_API
+    #endif
+  #endif
+#else
+  #define B2_API
+#endif
+
+#endif

Source/ThirdParty/Box2D/include/box2d/b2_block_allocator.h

@@ -0,0 +1,60 @@
+// MIT License
+
+// Copyright (c) 2019 Erin Catto
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#ifndef B2_BLOCK_ALLOCATOR_H
+#define B2_BLOCK_ALLOCATOR_H
+
+#include "b2_api.h"
+#include "b2_settings.h"
+
+const int32 b2_blockSizeCount = 14;
+
+struct b2Block;
+struct b2Chunk;
+
+/// This is a small object allocator used for allocating small
+/// objects that persist for more than one time step.
+/// See: http://www.codeproject.com/useritems/Small_Block_Allocator.asp
+class B2_API b2BlockAllocator
+{
+public:
+	b2BlockAllocator();
+	~b2BlockAllocator();
+
+	/// Allocate memory. This will use b2Alloc if the size is larger than b2_maxBlockSize.
+	void* Allocate(int32 size);
+
+	/// Free memory. This will use b2Free if the size is larger than b2_maxBlockSize.
+	void Free(void* p, int32 size);
+
+	void Clear();
+
+private:
+
+	b2Chunk* m_chunks;
+	int32 m_chunkCount;
+	int32 m_chunkSpace;
+
+	b2Block* m_freeLists[b2_blockSizeCount];
+};
+
+#endif

Source/ThirdParty/Box2D/Box2D/Dynamics/b2Body.h → Source/ThirdParty/Box2D/include/box2d/b2_body.h

@@ -1,27 +1,31 @@
-/*
-* Copyright (c) 2006-2011 Erin Catto http://www.box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
+// MIT License
+
+// Copyright (c) 2019 Erin Catto
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
 
 #ifndef B2_BODY_H
 #define B2_BODY_H
 
-#include "Box2D/Common/b2Math.h"
-#include "Box2D/Collision/Shapes/b2Shape.h"
-#include <memory>
+#include "b2_api.h"
+#include "b2_math.h"
+#include "b2_shape.h"
 
 class b2Fixture;
 class b2Joint;
@@ -41,19 +45,15 @@ enum b2BodyType
 	b2_staticBody = 0,
 	b2_kinematicBody,
 	b2_dynamicBody
-
-	// TODO_ERIN
-	//b2_bulletBody,
 };
 
 /// A body definition holds all the data needed to construct a rigid body.
 /// You can safely re-use body definitions. Shapes are added to a body after construction.
-struct b2BodyDef
+struct B2_API b2BodyDef
 {
 	/// This constructor sets the body definition default values.
 	b2BodyDef()
 	{
-		userData = nullptr;
 		position.Set(0.0f, 0.0f);
 		angle = 0.0f;
 		linearVelocity.Set(0.0f, 0.0f);
@@ -65,7 +65,7 @@ struct b2BodyDef
 		fixedRotation = false;
 		bullet = false;
 		type = b2_staticBody;
-		active = true;
+		enabled = true;
 		gravityScale = 1.0f;
 	}
 
@@ -78,25 +78,25 @@ struct b2BodyDef
 	b2Vec2 position;
 
 	/// The world angle of the body in radians.
-	float32 angle;
+	float angle;
 
 	/// The linear velocity of the body's origin in world co-ordinates.
 	b2Vec2 linearVelocity;
 
 	/// The angular velocity of the body.
-	float32 angularVelocity;
+	float angularVelocity;
 
 	/// Linear damping is use to reduce the linear velocity. The damping parameter
 	/// can be larger than 1.0f but the damping effect becomes sensitive to the
 	/// time step when the damping parameter is large.
 	/// Units are 1/time
-	float32 linearDamping;
+	float linearDamping;
 
 	/// Angular damping is use to reduce the angular velocity. The damping parameter
 	/// can be larger than 1.0f but the damping effect becomes sensitive to the
 	/// time step when the damping parameter is large.
 	/// Units are 1/time
-	float32 angularDamping;
+	float angularDamping;
 
 	/// Set this flag to false if this body should never fall asleep. Note that
 	/// this increases CPU usage.
@@ -114,18 +114,18 @@ struct b2BodyDef
 	/// @warning You should use this flag sparingly since it increases processing time.
 	bool bullet;
 
-	/// Does this body start out active?
-	bool active;
+	/// Does this body start out enabled?
+	bool enabled;
 
 	/// Use this to store application specific body data.
-	void* userData;
+	b2BodyUserData userData;
 
 	/// Scale the gravity applied to this body.
-	float32 gravityScale;
+	float gravityScale;
 };
 
 /// A rigid body. These are created via b2World::CreateBody.
-class b2Body
+class B2_API b2Body
 {
 public:
 	/// Creates a fixture and attach it to this body. Use this function if you need
@@ -144,7 +144,7 @@ public:
 	/// @param shape the shape to be cloned.
 	/// @param density the shape density (set to zero for static bodies).
 	/// @warning This function is locked during callbacks.
-	b2Fixture* CreateFixture(const b2Shape* shape, float32 density);
+	b2Fixture* CreateFixture(const b2Shape* shape, float density);
 
 	/// Destroy a fixture. This removes the fixture from the broad-phase and
 	/// destroys all contacts associated with this fixture. This will
@@ -160,7 +160,7 @@ public:
 	/// Note: contacts are updated on the next call to b2World::Step.
 	/// @param position the world position of the body's local origin.
 	/// @param angle the world rotation in radians.
-	void SetTransform(const b2Vec2& position, float32 angle);
+	void SetTransform(const b2Vec2& position, float angle);
 
 	/// Get the body transform for the body's origin.
 	/// @return the world transform of the body's origin.
@@ -172,7 +172,7 @@ public:
 
 	/// Get the angle in radians.
 	/// @return the current world rotation angle in radians.
-	float32 GetAngle() const;
+	float GetAngle() const;
 
 	/// Get the world position of the center of mass.
 	const b2Vec2& GetWorldCenter() const;
@@ -190,11 +190,11 @@ public:
 
 	/// Set the angular velocity.
 	/// @param omega the new angular velocity in radians/second.
-	void SetAngularVelocity(float32 omega);
+	void SetAngularVelocity(float omega);
 
 	/// Get the angular velocity.
 	/// @return the angular velocity in radians/second.
-	float32 GetAngularVelocity() const;
+	float GetAngularVelocity() const;
 
 	/// Apply a force at a world point. If the force is not
 	/// applied at the center of mass, it will generate a torque and
@@ -213,7 +213,7 @@ public:
 	/// without affecting the linear velocity of the center of mass.
 	/// @param torque about the z-axis (out of the screen), usually in N-m.
 	/// @param wake also wake up the body
-	void ApplyTorque(float32 torque, bool wake);
+	void ApplyTorque(float torque, bool wake);
 
 	/// Apply an impulse at a point. This immediately modifies the velocity.
 	/// It also modifies the angular velocity if the point of application
@@ -231,25 +231,25 @@ public:
 	/// Apply an angular impulse.
 	/// @param impulse the angular impulse in units of kg*m*m/s
 	/// @param wake also wake up the body
-	void ApplyAngularImpulse(float32 impulse, bool wake);
+	void ApplyAngularImpulse(float impulse, bool wake);
 
 	/// Get the total mass of the body.
 	/// @return the mass, usually in kilograms (kg).
-	float32 GetMass() const;
+	float GetMass() const;
 
 	/// Get the rotational inertia of the body about the local origin.
 	/// @return the rotational inertia, usually in kg-m^2.
-	float32 GetInertia() const;
+	float GetInertia() const;
 
 	/// Get the mass data of the body.
 	/// @return a struct containing the mass, inertia and center of the body.
-	void GetMassData(b2MassData* data) const;
+	b2MassData GetMassData() const;
 
 	/// Set the mass properties to override the mass properties of the fixtures.
 	/// Note that this changes the center of mass position.
 	/// Note that creating or destroying fixtures can also alter the mass.
 	/// This function has no effect if the body isn't dynamic.
-	/// @param massData the mass properties.
+	/// @param data the mass properties.
 	void SetMassData(const b2MassData* data);
 
 	/// This resets the mass properties to the sum of the mass properties of the fixtures.
@@ -268,42 +268,42 @@ public:
 	b2Vec2 GetWorldVector(const b2Vec2& localVector) const;
 
 	/// Gets a local point relative to the body's origin given a world point.
-	/// @param a point in world coordinates.
+	/// @param worldPoint a point in world coordinates.
 	/// @return the corresponding local point relative to the body's origin.
 	b2Vec2 GetLocalPoint(const b2Vec2& worldPoint) const;
 
 	/// Gets a local vector given a world vector.
-	/// @param a vector in world coordinates.
+	/// @param worldVector a vector in world coordinates.
 	/// @return the corresponding local vector.
 	b2Vec2 GetLocalVector(const b2Vec2& worldVector) const;
 
 	/// Get the world linear velocity of a world point attached to this body.
-	/// @param a point in world coordinates.
+	/// @param worldPoint a point in world coordinates.
 	/// @return the world velocity of a point.
 	b2Vec2 GetLinearVelocityFromWorldPoint(const b2Vec2& worldPoint) const;
 
 	/// Get the world velocity of a local point.
-	/// @param a point in local coordinates.
+	/// @param localPoint a point in local coordinates.
 	/// @return the world velocity of a point.
 	b2Vec2 GetLinearVelocityFromLocalPoint(const b2Vec2& localPoint) const;
 
 	/// Get the linear damping of the body.
-	float32 GetLinearDamping() const;
+	float GetLinearDamping() const;
 
 	/// Set the linear damping of the body.
-	void SetLinearDamping(float32 linearDamping);
+	void SetLinearDamping(float linearDamping);
 
 	/// Get the angular damping of the body.
-	float32 GetAngularDamping() const;
+	float GetAngularDamping() const;
 
 	/// Set the angular damping of the body.
-	void SetAngularDamping(float32 angularDamping);
+	void SetAngularDamping(float angularDamping);
 
 	/// Get the gravity scale of the body.
-	float32 GetGravityScale() const;
+	float GetGravityScale() const;
 
 	/// Set the gravity scale of the body.
-	void SetGravityScale(float32 scale);
+	void SetGravityScale(float scale);
 
 	/// Set the type of this body. This may alter the mass and velocity.
 	void SetType(b2BodyType type);
@@ -333,23 +333,22 @@ public:
 	/// @return true if the body is awake.
 	bool IsAwake() const;
 
-	/// Set the active state of the body. An inactive body is not
-	/// simulated and cannot be collided with or woken up.
-	/// If you pass a flag of true, all fixtures will be added to the
-	/// broad-phase.
-	/// If you pass a flag of false, all fixtures will be removed from
-	/// the broad-phase and all contacts will be destroyed.
+	/// Allow a body to be disabled. A disabled body is not simulated and cannot
+	/// be collided with or woken up.
+	/// If you pass a flag of true, all fixtures will be added to the broad-phase.
+	/// If you pass a flag of false, all fixtures will be removed from the
+	/// broad-phase and all contacts will be destroyed.
 	/// Fixtures and joints are otherwise unaffected. You may continue
-	/// to create/destroy fixtures and joints on inactive bodies.
-	/// Fixtures on an inactive body are implicitly inactive and will
+	/// to create/destroy fixtures and joints on disabled bodies.
+	/// Fixtures on a disabled body are implicitly disabled and will
 	/// not participate in collisions, ray-casts, or queries.
-	/// Joints connected to an inactive body are implicitly inactive.
-	/// An inactive body is still owned by a b2World object and remains
+	/// Joints connected to a disabled body are implicitly disabled.
+	/// An diabled body is still owned by a b2World object and remains
 	/// in the body list.
-	void SetActive(bool flag);
+	void SetEnabled(bool flag);
 
 	/// Get the active state of the body.
-	bool IsActive() const;
+	bool IsEnabled() const;
 
 	/// Set this body to have fixed rotation. This causes the mass
 	/// to be reset.
@@ -377,16 +376,14 @@ public:
 	const b2Body* GetNext() const;
 
 	/// Get the user data pointer that was provided in the body definition.
-	void* GetUserData() const;
-
-	/// Set the user data. Use this to store your application specific data.
-	void SetUserData(void* data);
+	b2BodyUserData& GetUserData();
+	const b2BodyUserData& GetUserData() const;
 
 	/// Get the parent world of this body.
 	b2World* GetWorld();
 	const b2World* GetWorld() const;
 
-	/// Dump this body to a log file
+	/// Dump this body to a file
 	void Dump();
 
 private:
@@ -396,7 +393,7 @@ private:
 	friend class b2ContactManager;
 	friend class b2ContactSolver;
 	friend class b2Contact;
-	
+
 	friend class b2DistanceJoint;
 	friend class b2FrictionJoint;
 	friend class b2GearJoint;
@@ -405,7 +402,6 @@ private:
 	friend class b2PrismaticJoint;
 	friend class b2PulleyJoint;
 	friend class b2RevoluteJoint;
-	friend class b2RopeJoint;
 	friend class b2WeldJoint;
 	friend class b2WheelJoint;
 
@@ -417,7 +413,7 @@ private:
 		e_autoSleepFlag		= 0x0004,
 		e_bulletFlag		= 0x0008,
 		e_fixedRotationFlag	= 0x0010,
-		e_activeFlag		= 0x0020,
+		e_enabledFlag		= 0x0020,
 		e_toiFlag			= 0x0040
 	};
 
@@ -431,7 +427,7 @@ private:
 	// It may lie, depending on the collideConnected flag.
 	bool ShouldCollide(const b2Body* other) const;
 
-	void Advance(float32 t);
+	void Advance(float t);
 
 	b2BodyType m_type;
 
@@ -443,10 +439,10 @@ private:
 	b2Sweep m_sweep;		// the swept motion for CCD
 
 	b2Vec2 m_linearVelocity;
-	float32 m_angularVelocity;
+	float m_angularVelocity;
 
 	b2Vec2 m_force;
-	float32 m_torque;
+	float m_torque;
 
 	b2World* m_world;
 	b2Body* m_prev;
@@ -458,18 +454,18 @@ private:
 	b2JointEdge* m_jointList;
 	b2ContactEdge* m_contactList;
 
-	float32 m_mass, m_invMass;
+	float m_mass, m_invMass;
 
 	// Rotational inertia about the center of mass.
-	float32 m_I, m_invI;
+	float m_I, m_invI;
 
-	float32 m_linearDamping;
-	float32 m_angularDamping;
-	float32 m_gravityScale;
+	float m_linearDamping;
+	float m_angularDamping;
+	float m_gravityScale;
 
-	float32 m_sleepTime;
+	float m_sleepTime;
 
-	void* m_userData;
+	b2BodyUserData m_userData;
 };
 
 inline b2BodyType b2Body::GetType() const
@@ -487,7 +483,7 @@ inline const b2Vec2& b2Body::GetPosition() const
 	return m_xf.p;
 }
 
-inline float32 b2Body::GetAngle() const
+inline float b2Body::GetAngle() const
 {
 	return m_sweep.a;
 }
@@ -522,7 +518,7 @@ inline const b2Vec2& b2Body::GetLinearVelocity() const
 	return m_linearVelocity;
 }
 
-inline void b2Body::SetAngularVelocity(float32 w)
+inline void b2Body::SetAngularVelocity(float w)
 {
 	if (m_type == b2_staticBody)
 	{
@@ -537,26 +533,28 @@ inline void b2Body::SetAngularVelocity(float32 w)
 	m_angularVelocity = w;
 }
 
-inline float32 b2Body::GetAngularVelocity() const
+inline float b2Body::GetAngularVelocity() const
 {
 	return m_angularVelocity;
 }
 
-inline float32 b2Body::GetMass() const
+inline float b2Body::GetMass() const
 {
 	return m_mass;
 }
 
-inline float32 b2Body::GetInertia() const
+inline float b2Body::GetInertia() const
 {
 	return m_I + m_mass * b2Dot(m_sweep.localCenter, m_sweep.localCenter);
 }
 
-inline void b2Body::GetMassData(b2MassData* data) const
+inline b2MassData b2Body::GetMassData() const
 {
-	data->mass = m_mass;
-	data->I = m_I + m_mass * b2Dot(m_sweep.localCenter, m_sweep.localCenter);
-	data->center = m_sweep.localCenter;
+	b2MassData data;
+	data.mass = m_mass;
+	data.I = m_I + m_mass * b2Dot(m_sweep.localCenter, m_sweep.localCenter);
+	data.center = m_sweep.localCenter;
+	return data;
 }
 
 inline b2Vec2 b2Body::GetWorldPoint(const b2Vec2& localPoint) const
@@ -589,32 +587,32 @@ inline b2Vec2 b2Body::GetLinearVelocityFromLocalPoint(const b2Vec2& localPoint)
 	return GetLinearVelocityFromWorldPoint(GetWorldPoint(localPoint));
 }
 
-inline float32 b2Body::GetLinearDamping() const
+inline float b2Body::GetLinearDamping() const
 {
 	return m_linearDamping;
 }
 
-inline void b2Body::SetLinearDamping(float32 linearDamping)
+inline void b2Body::SetLinearDamping(float linearDamping)
 {
 	m_linearDamping = linearDamping;
 }
 
-inline float32 b2Body::GetAngularDamping() const
+inline float b2Body::GetAngularDamping() const
 {
 	return m_angularDamping;
 }
 
-inline void b2Body::SetAngularDamping(float32 angularDamping)
+inline void b2Body::SetAngularDamping(float angularDamping)
 {
 	m_angularDamping = angularDamping;
 }
 
-inline float32 b2Body::GetGravityScale() const
+inline float b2Body::GetGravityScale() const
 {
 	return m_gravityScale;
 }
 
-inline void b2Body::SetGravityScale(float32 scale)
+inline void b2Body::SetGravityScale(float scale)
 {
 	m_gravityScale = scale;
 }
@@ -638,6 +636,11 @@ inline bool b2Body::IsBullet() const
 
 inline void b2Body::SetAwake(bool flag)
 {
+	if (m_type == b2_staticBody)
+	{
+		return;
+	}
+
 	if (flag)
 	{
 		m_flags |= e_awakeFlag;
@@ -659,9 +662,9 @@ inline bool b2Body::IsAwake() const
 	return (m_flags & e_awakeFlag) == e_awakeFlag;
 }
 
-inline bool b2Body::IsActive() const
+inline bool b2Body::IsEnabled() const
 {
-	return (m_flags & e_activeFlag) == e_activeFlag;
+	return (m_flags & e_enabledFlag) == e_enabledFlag;
 }
 
 inline bool b2Body::IsFixedRotation() const
@@ -727,12 +730,12 @@ inline const b2Body* b2Body::GetNext() const
 	return m_next;
 }
 
-inline void b2Body::SetUserData(void* data)
+inline b2BodyUserData& b2Body::GetUserData()
 {
-	m_userData = data;
+	return m_userData;
 }
 
-inline void* b2Body::GetUserData() const
+inline const b2BodyUserData& b2Body::GetUserData() const
 {
 	return m_userData;
 }
@@ -776,7 +779,7 @@ inline void b2Body::ApplyForceToCenter(const b2Vec2& force, bool wake)
 	}
 }
 
-inline void b2Body::ApplyTorque(float32 torque, bool wake)
+inline void b2Body::ApplyTorque(float torque, bool wake)
 {
 	if (m_type != b2_dynamicBody)
 	{
@@ -834,7 +837,7 @@ inline void b2Body::ApplyLinearImpulseToCenter(const b2Vec2& impulse, bool wake)
 	}
 }
 
-inline void b2Body::ApplyAngularImpulse(float32 impulse, bool wake)
+inline void b2Body::ApplyAngularImpulse(float impulse, bool wake)
 {
 	if (m_type != b2_dynamicBody)
 	{
@@ -859,7 +862,7 @@ inline void b2Body::SynchronizeTransform()
 	m_xf.p = m_sweep.c - b2Mul(m_xf.q, m_sweep.localCenter);
 }
 
-inline void b2Body::Advance(float32 alpha)
+inline void b2Body::Advance(float alpha)
 {
 	// Advance to the new safe time. This doesn't sync the broad-phase.
 	m_sweep.Advance(alpha);

Source/ThirdParty/Box2D/Box2D/Collision/b2BroadPhase.h → Source/ThirdParty/Box2D/include/box2d/b2_broad_phase.h

@@ -1,30 +1,34 @@
-/*
-* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
+// MIT License
+
+// Copyright (c) 2019 Erin Catto
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
 
 #ifndef B2_BROAD_PHASE_H
 #define B2_BROAD_PHASE_H
 
-#include "Box2D/Common/b2Settings.h"
-#include "Box2D/Collision/b2Collision.h"
-#include "Box2D/Collision/b2DynamicTree.h"
-#include <algorithm>
+#include "b2_api.h"
+#include "b2_settings.h"
+#include "b2_collision.h"
+#include "b2_dynamic_tree.h"
 
-struct b2Pair
+struct B2_API b2Pair
 {
 	int32 proxyIdA;
 	int32 proxyIdB;
@@ -33,7 +37,7 @@ struct b2Pair
 /// The broad-phase is used for computing pairs and performing volume queries and ray casts.
 /// This broad-phase does not persist pairs. Instead, this reports potentially new pairs.
 /// It is up to the client to consume the new pairs and to track subsequent overlap.
-class b2BroadPhase
+class B2_API b2BroadPhase
 {
 public:
 
@@ -97,7 +101,7 @@ public:
 	int32 GetTreeBalance() const;
 
 	/// Get the quality metric of the embedded tree.
-	float32 GetTreeQuality() const;
+	float GetTreeQuality() const;
 
 	/// Shift the world origin. Useful for large worlds.
 	/// The shift formula is: position -= newOrigin
@@ -128,22 +132,6 @@ private:
 	int32 m_queryProxyId;
 };
 
-/// This is used to sort pairs.
-inline bool b2PairLessThan(const b2Pair& pair1, const b2Pair& pair2)
-{
-	if (pair1.proxyIdA < pair2.proxyIdA)
-	{
-		return true;
-	}
-
-	if (pair1.proxyIdA == pair2.proxyIdA)
-	{
-		return pair1.proxyIdB < pair2.proxyIdB;
-	}
-
-	return false;
-}
-
 inline void* b2BroadPhase::GetUserData(int32 proxyId) const
 {
 	return m_tree.GetUserData(proxyId);
@@ -176,7 +164,7 @@ inline int32 b2BroadPhase::GetTreeBalance() const
 	return m_tree.GetMaxBalance();
 }
 
-inline float32 b2BroadPhase::GetTreeQuality() const
+inline float b2BroadPhase::GetTreeQuality() const
 {
 	return m_tree.GetAreaRatio();
 }
@@ -204,37 +192,30 @@ void b2BroadPhase::UpdatePairs(T* callback)
 		m_tree.Query(this, fatAABB);
 	}
 
-	// Reset move buffer
-	m_moveCount = 0;
-
-	// Sort the pair buffer to expose duplicates.
-	std::sort(m_pairBuffer, m_pairBuffer + m_pairCount, b2PairLessThan);
-
-	// Send the pairs back to the client.
-	int32 i = 0;
-	while (i < m_pairCount)
+	// Send pairs to caller
+	for (int32 i = 0; i < m_pairCount; ++i)
 	{
 		b2Pair* primaryPair = m_pairBuffer + i;
 		void* userDataA = m_tree.GetUserData(primaryPair->proxyIdA);
 		void* userDataB = m_tree.GetUserData(primaryPair->proxyIdB);
 
 		callback->AddPair(userDataA, userDataB);
-		++i;
+	}
 
-		// Skip any duplicate pairs.
-		while (i < m_pairCount)
+	// Clear move flags
+	for (int32 i = 0; i < m_moveCount; ++i)
+	{
+		int32 proxyId = m_moveBuffer[i];
+		if (proxyId == e_nullProxy)
 		{
-			b2Pair* pair = m_pairBuffer + i;
-			if (pair->proxyIdA != primaryPair->proxyIdA || pair->proxyIdB != primaryPair->proxyIdB)
-			{
-				break;
-			}
-			++i;
+			continue;
 		}
+
+		m_tree.ClearMoved(proxyId);
 	}
 
-	// Try to keep the tree balanced.
-	//m_tree.Rebalance(4);
+	// Reset move buffer
+	m_moveCount = 0;
 }
 
 template <typename T>

Source/ThirdParty/Box2D/include/box2d/b2_chain_shape.h

@@ -0,0 +1,101 @@
+// MIT License
+
+// Copyright (c) 2019 Erin Catto
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#ifndef B2_CHAIN_SHAPE_H
+#define B2_CHAIN_SHAPE_H
+
+#include "b2_api.h"
+#include "b2_shape.h"
+
+class b2EdgeShape;
+
+/// A chain shape is a free form sequence of line segments.
+/// The chain has one-sided collision, with the surface normal pointing to the right of the edge.
+/// This provides a counter-clockwise winding like the polygon shape.
+/// Connectivity information is used to create smooth collisions.
+/// @warning the chain will not collide properly if there are self-intersections.
+class B2_API b2ChainShape : public b2Shape
+{
+public:
+	b2ChainShape();
+
+	/// The destructor frees the vertices using b2Free.
+	~b2ChainShape();
+
+	/// Clear all data.
+	void Clear();
+
+	/// Create a loop. This automatically adjusts connectivity.
+	/// @param vertices an array of vertices, these are copied
+	/// @param count the vertex count
+	void CreateLoop(const b2Vec2* vertices, int32 count);
+
+	/// Create a chain with ghost vertices to connect multiple chains together.
+	/// @param vertices an array of vertices, these are copied
+	/// @param count the vertex count
+	/// @param prevVertex previous vertex from chain that connects to the start
+	/// @param nextVertex next vertex from chain that connects to the end
+	void CreateChain(const b2Vec2* vertices, int32 count,
+		const b2Vec2& prevVertex, const b2Vec2& nextVertex);
+
+	/// Implement b2Shape. Vertices are cloned using b2Alloc.
+	b2Shape* Clone(b2BlockAllocator* allocator) const override;
+
+	/// @see b2Shape::GetChildCount
+	int32 GetChildCount() const override;
+
+	/// Get a child edge.
+	void GetChildEdge(b2EdgeShape* edge, int32 index) const;
+
+	/// This always return false.
+	/// @see b2Shape::TestPoint
+	bool TestPoint(const b2Transform& transform, const b2Vec2& p) const override;
+
+	/// Implement b2Shape.
+	bool RayCast(b2RayCastOutput* output, const b2RayCastInput& input,
+					const b2Transform& transform, int32 childIndex) const override;
+
+	/// @see b2Shape::ComputeAABB
+	void ComputeAABB(b2AABB* aabb, const b2Transform& transform, int32 childIndex) const override;
+
+	/// Chains have zero mass.
+	/// @see b2Shape::ComputeMass
+	void ComputeMass(b2MassData* massData, float density) const override;
+
+	/// The vertices. Owned by this class.
+	b2Vec2* m_vertices;
+
+	/// The vertex count.
+	int32 m_count;
+
+	b2Vec2 m_prevVertex, m_nextVertex;
+};
+
+inline b2ChainShape::b2ChainShape()
+{
+	m_type = e_chain;
+	m_radius = b2_polygonRadius;
+	m_vertices = nullptr;
+	m_count = 0;
+}
+
+#endif

Source/ThirdParty/Box2D/include/box2d/b2_circle_shape.h

@@ -0,0 +1,67 @@
+// MIT License
+
+// Copyright (c) 2019 Erin Catto
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#ifndef B2_CIRCLE_SHAPE_H
+#define B2_CIRCLE_SHAPE_H
+
+#include "b2_api.h"
+#include "b2_shape.h"
+
+/// A solid circle shape
+class B2_API b2CircleShape : public b2Shape
+{
+public:
+	b2CircleShape();
+
+	/// Implement b2Shape.
+	b2Shape* Clone(b2BlockAllocator* allocator) const override;
+
+	/// @see b2Shape::GetChildCount
+	int32 GetChildCount() const override;
+
+	/// Implement b2Shape.
+	bool TestPoint(const b2Transform& transform, const b2Vec2& p) const override;
+
+	/// Implement b2Shape.
+	/// @note because the circle is solid, rays that start inside do not hit because the normal is
+	/// not defined.
+	bool RayCast(b2RayCastOutput* output, const b2RayCastInput& input,
+				const b2Transform& transform, int32 childIndex) const override;
+
+	/// @see b2Shape::ComputeAABB
+	void ComputeAABB(b2AABB* aabb, const b2Transform& transform, int32 childIndex) const override;
+
+	/// @see b2Shape::ComputeMass
+	void ComputeMass(b2MassData* massData, float density) const override;
+
+	/// Position
+	b2Vec2 m_p;
+};
+
+inline b2CircleShape::b2CircleShape()
+{
+	m_type = e_circle;
+	m_radius = 0.0f;
+	m_p.SetZero();
+}
+
+#endif

Source/ThirdParty/Box2D/Box2D/Collision/b2Collision.h → Source/ThirdParty/Box2D/include/box2d/b2_collision.h

@@ -1,27 +1,33 @@
-/*
-* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
+// MIT License
+
+// Copyright (c) 2019 Erin Catto
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
 
 #ifndef B2_COLLISION_H
 #define B2_COLLISION_H
 
-#include "Box2D/Common/b2Math.h"
 #include <limits.h>
 
+#include "b2_api.h"
+#include "b2_math.h"
+
 /// @file
 /// Structures and functions used for computing contact points, distance
 /// queries, and TOI queries.
@@ -35,7 +41,7 @@ const uint8 b2_nullFeature = UCHAR_MAX;
 
 /// The features that intersect to form the contact point
 /// This must be 4 bytes or less.
-struct b2ContactFeature
+struct B2_API b2ContactFeature
 {
 	enum Type
 	{
@@ -50,7 +56,7 @@ struct b2ContactFeature
 };
 
 /// Contact ids to facilitate warm starting.
-union b2ContactID
+union B2_API b2ContactID
 {
 	b2ContactFeature cf;
 	uint32 key;					///< Used to quickly compare contact ids.
@@ -66,11 +72,11 @@ union b2ContactID
 /// This structure is stored across time steps, so we keep it small.
 /// Note: the impulses are used for internal caching and may not
 /// provide reliable contact forces, especially for high speed collisions.
-struct b2ManifoldPoint
+struct B2_API b2ManifoldPoint
 {
 	b2Vec2 localPoint;		///< usage depends on manifold type
-	float32 normalImpulse;	///< the non-penetration impulse
-	float32 tangentImpulse;	///< the friction impulse
+	float normalImpulse;	///< the non-penetration impulse
+	float tangentImpulse;	///< the friction impulse
 	b2ContactID id;			///< uniquely identifies a contact point between two shapes
 };
 
@@ -90,7 +96,7 @@ struct b2ManifoldPoint
 /// account for movement, which is critical for continuous physics.
 /// All contact scenarios must be expressed in one of these types.
 /// This structure is stored across time steps, so we keep it small.
-struct b2Manifold
+struct B2_API b2Manifold
 {
 	enum Type
 	{
@@ -107,19 +113,19 @@ struct b2Manifold
 };
 
 /// This is used to compute the current state of a contact manifold.
-struct b2WorldManifold
+struct B2_API b2WorldManifold
 {
 	/// Evaluate the manifold with supplied transforms. This assumes
 	/// modest motion from the original state. This does not change the
 	/// point count, impulses, etc. The radii must come from the shapes
 	/// that generated the manifold.
 	void Initialize(const b2Manifold* manifold,
-					const b2Transform& xfA, float32 radiusA,
-					const b2Transform& xfB, float32 radiusB);
+					const b2Transform& xfA, float radiusA,
+					const b2Transform& xfB, float radiusB);
 
 	b2Vec2 normal;								///< world vector pointing from A to B
 	b2Vec2 points[b2_maxManifoldPoints];		///< world contact point (point of intersection)
-	float32 separations[b2_maxManifoldPoints];	///< a negative value indicates overlap, in meters
+	float separations[b2_maxManifoldPoints];	///< a negative value indicates overlap, in meters
 };
 
 /// This is used for determining the state of contact points.
@@ -133,33 +139,33 @@ enum b2PointState
 
 /// Compute the point states given two manifolds. The states pertain to the transition from manifold1
 /// to manifold2. So state1 is either persist or remove while state2 is either add or persist.
-void b2GetPointStates(b2PointState state1[b2_maxManifoldPoints], b2PointState state2[b2_maxManifoldPoints],
+B2_API void b2GetPointStates(b2PointState state1[b2_maxManifoldPoints], b2PointState state2[b2_maxManifoldPoints],
 					  const b2Manifold* manifold1, const b2Manifold* manifold2);
 
 /// Used for computing contact manifolds.
-struct b2ClipVertex
+struct B2_API b2ClipVertex
 {
 	b2Vec2 v;
 	b2ContactID id;
 };
 
 /// Ray-cast input data. The ray extends from p1 to p1 + maxFraction * (p2 - p1).
-struct b2RayCastInput
+struct B2_API b2RayCastInput
 {
 	b2Vec2 p1, p2;
-	float32 maxFraction;
+	float maxFraction;
 };
 
 /// Ray-cast output data. The ray hits at p1 + fraction * (p2 - p1), where p1 and p2
 /// come from b2RayCastInput.
-struct b2RayCastOutput
+struct B2_API b2RayCastOutput
 {
 	b2Vec2 normal;
-	float32 fraction;
+	float fraction;
 };
 
 /// An axis aligned bounding box.
-struct b2AABB
+struct B2_API b2AABB
 {
 	/// Verify that the bounds are sorted.
 	bool IsValid() const;
@@ -177,10 +183,10 @@ struct b2AABB
 	}
 
 	/// Get the perimeter length
-	float32 GetPerimeter() const
+	float GetPerimeter() const
 	{
-		float32 wx = upperBound.x - lowerBound.x;
-		float32 wy = upperBound.y - lowerBound.y;
+		float wx = upperBound.x - lowerBound.x;
+		float wy = upperBound.y - lowerBound.y;
 		return 2.0f * (wx + wy);
 	}
 
@@ -216,36 +222,36 @@ struct b2AABB
 };
 
 /// Compute the collision manifold between two circles.
-void b2CollideCircles(b2Manifold* manifold,
+B2_API void b2CollideCircles(b2Manifold* manifold,
 					  const b2CircleShape* circleA, const b2Transform& xfA,
 					  const b2CircleShape* circleB, const b2Transform& xfB);
 
 /// Compute the collision manifold between a polygon and a circle.
-void b2CollidePolygonAndCircle(b2Manifold* manifold,
+B2_API void b2CollidePolygonAndCircle(b2Manifold* manifold,
 							   const b2PolygonShape* polygonA, const b2Transform& xfA,
 							   const b2CircleShape* circleB, const b2Transform& xfB);
 
 /// Compute the collision manifold between two polygons.
-void b2CollidePolygons(b2Manifold* manifold,
+B2_API void b2CollidePolygons(b2Manifold* manifold,
 					   const b2PolygonShape* polygonA, const b2Transform& xfA,
 					   const b2PolygonShape* polygonB, const b2Transform& xfB);
 
 /// Compute the collision manifold between an edge and a circle.
-void b2CollideEdgeAndCircle(b2Manifold* manifold,
+B2_API void b2CollideEdgeAndCircle(b2Manifold* manifold,
 							   const b2EdgeShape* polygonA, const b2Transform& xfA,
 							   const b2CircleShape* circleB, const b2Transform& xfB);
 
-/// Compute the collision manifold between an edge and a circle.
-void b2CollideEdgeAndPolygon(b2Manifold* manifold,
+/// Compute the collision manifold between an edge and a polygon.
+B2_API void b2CollideEdgeAndPolygon(b2Manifold* manifold,
 							   const b2EdgeShape* edgeA, const b2Transform& xfA,
 							   const b2PolygonShape* circleB, const b2Transform& xfB);
 
 /// Clipping for contact manifolds.
-int32 b2ClipSegmentToLine(b2ClipVertex vOut[2], const b2ClipVertex vIn[2],
-							const b2Vec2& normal, float32 offset, int32 vertexIndexA);
+B2_API int32 b2ClipSegmentToLine(b2ClipVertex vOut[2], const b2ClipVertex vIn[2],
+							const b2Vec2& normal, float offset, int32 vertexIndexA);
 
 /// Determine if two generic shapes overlap.
-bool b2TestOverlap(	const b2Shape* shapeA, int32 indexA,
+B2_API bool b2TestOverlap(	const b2Shape* shapeA, int32 indexA,
 					const b2Shape* shapeB, int32 indexB,
 					const b2Transform& xfA, const b2Transform& xfB);
 

Source/ThirdParty/Box2D/Box2D/Common/b2Settings.h → Source/ThirdParty/Box2D/include/box2d/b2_common.h

@@ -1,23 +1,29 @@
-/*
-* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef B2_SETTINGS_H
-#define B2_SETTINGS_H
+// MIT License
+
+// Copyright (c) 2019 Erin Catto
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#ifndef B2_COMMON_H
+#define B2_COMMON_H
+
+#include "b2_settings.h"
 
 #include <stddef.h>
 #include <assert.h>
@@ -30,15 +36,6 @@
 #define B2_NOT_USED(x) ((void)(x))
 #define b2Assert(A) assert(A)
 
-typedef signed char	int8;
-typedef signed short int16;
-typedef signed int int32;
-typedef unsigned char uint8;
-typedef unsigned short uint16;
-typedef unsigned int uint32;
-typedef float float32;
-typedef double float64;
-
 #define	b2_maxFloat		FLT_MAX
 #define	b2_epsilon		FLT_EPSILON
 #define b2_pi			3.14159265359f
@@ -53,23 +50,19 @@ typedef double float64;
 /// not change this value.
 #define b2_maxManifoldPoints	2
 
-/// The maximum number of vertices on a convex polygon. You cannot increase
-/// this too much because b2BlockAllocator has a maximum object size.
-#define b2_maxPolygonVertices	8
-
 /// This is used to fatten AABBs in the dynamic tree. This allows proxies
 /// to move by a small amount without triggering a tree adjustment.
 /// This is in meters.
-#define b2_aabbExtension		0.1f
+#define b2_aabbExtension		(0.1f * b2_lengthUnitsPerMeter)
 
 /// This is used to fatten AABBs in the dynamic tree. This is used to predict
 /// the future position based on the current displacement.
 /// This is a dimensionless multiplier.
-#define b2_aabbMultiplier		2.0f
+#define b2_aabbMultiplier		4.0f
 
 /// A small length used as a collision and constraint tolerance. Usually it is
-/// chosen to be numerically significant, but visually insignificant.
-#define b2_linearSlop			0.005f
+/// chosen to be numerically significant, but visually insignificant. In meters.
+#define b2_linearSlop			(0.005f * b2_lengthUnitsPerMeter)
 
 /// A small angle used as a collision and constraint tolerance. Usually it is
 /// chosen to be numerically significant, but visually insignificant.
@@ -89,21 +82,17 @@ typedef double float64;
 /// Maximum number of contacts to be handled to solve a TOI impact.
 #define b2_maxTOIContacts			32
 
-/// A velocity threshold for elastic collisions. Any collision with a relative linear
-/// velocity below this threshold will be treated as inelastic.
-#define b2_velocityThreshold		1.0f
-
 /// The maximum linear position correction used when solving constraints. This helps to
-/// prevent overshoot.
-#define b2_maxLinearCorrection		0.2f
+/// prevent overshoot. Meters.
+#define b2_maxLinearCorrection		(0.2f * b2_lengthUnitsPerMeter)
 
 /// The maximum angular position correction used when solving constraints. This helps to
 /// prevent overshoot.
 #define b2_maxAngularCorrection		(8.0f / 180.0f * b2_pi)
 
-/// The maximum linear velocity of a body. This limit is very large and is used
-/// to prevent numerical problems. You shouldn't need to adjust this.
-#define b2_maxTranslation			2.0f
+/// The maximum linear translation of a body per step. This limit is very large and is used
+/// to prevent numerical problems. You shouldn't need to adjust this. Meters.
+#define b2_maxTranslation			(2.0f * b2_lengthUnitsPerMeter)
 #define b2_maxTranslationSquared	(b2_maxTranslation * b2_maxTranslation)
 
 /// The maximum angular velocity of a body. This limit is very large and is used
@@ -115,7 +104,7 @@ typedef double float64;
 /// that overlap is removed in one time step. However using values close to 1 often lead
 /// to overshoot.
 #define b2_baumgarte				0.2f
-#define b2_toiBaugarte				0.75f
+#define b2_toiBaumgarte				0.75f
 
 
 // Sleep
@@ -124,21 +113,15 @@ typedef double float64;
 #define b2_timeToSleep				0.5f
 
 /// A body cannot sleep if its linear velocity is above this tolerance.
-#define b2_linearSleepTolerance		0.01f
+#define b2_linearSleepTolerance		(0.01f * b2_lengthUnitsPerMeter)
 
 /// A body cannot sleep if its angular velocity is above this tolerance.
 #define b2_angularSleepTolerance	(2.0f / 180.0f * b2_pi)
 
-// Memory Allocation
-
-/// Implement this function to use your own memory allocator.
-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, ...);
+/// Dump to a file. Only one dump file allowed at a time.
+void b2OpenDump(const char* fileName);
+void b2Dump(const char* string, ...);
+void b2CloseDump();
 
 /// Version numbering scheme.
 /// See http://en.wikipedia.org/wiki/Software_versioning
@@ -150,6 +133,6 @@ struct b2Version
 };
 
 /// Current version.
-extern b2Version b2_version;
+extern B2_API b2Version b2_version;
 
 #endif

Source/ThirdParty/Box2D/Box2D/Dynamics/Contacts/b2Contact.h → Source/ThirdParty/Box2D/include/box2d/b2_contact.h

@@ -1,28 +1,33 @@
-/*
-* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
+// MIT License
+
+// Copyright (c) 2019 Erin Catto
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
 
 #ifndef B2_CONTACT_H
 #define B2_CONTACT_H
 
-#include "Box2D/Common/b2Math.h"
-#include "Box2D/Collision/b2Collision.h"
-#include "Box2D/Collision/Shapes/b2Shape.h"
-#include "Box2D/Dynamics/b2Fixture.h"
+#include "b2_api.h"
+#include "b2_collision.h"
+#include "b2_fixture.h"
+#include "b2_math.h"
+#include "b2_shape.h"
 
 class b2Body;
 class b2Contact;
@@ -34,24 +39,30 @@ class b2ContactListener;
 
 /// Friction mixing law. The idea is to allow either fixture to drive the friction to zero.
 /// For example, anything slides on ice.
-inline float32 b2MixFriction(float32 friction1, float32 friction2)
+inline float b2MixFriction(float friction1, float friction2)
 {
 	return b2Sqrt(friction1 * friction2);
 }
 
 /// Restitution mixing law. The idea is allow for anything to bounce off an inelastic surface.
 /// For example, a superball bounces on anything.
-inline float32 b2MixRestitution(float32 restitution1, float32 restitution2)
+inline float b2MixRestitution(float restitution1, float restitution2)
 {
 	return restitution1 > restitution2 ? restitution1 : restitution2;
 }
 
+/// Restitution mixing law. This picks the lowest value.
+inline float b2MixRestitutionThreshold(float threshold1, float threshold2)
+{
+	return threshold1 < threshold2 ? threshold1 : threshold2;
+}
+
 typedef b2Contact* b2ContactCreateFcn(	b2Fixture* fixtureA, int32 indexA,
 										b2Fixture* fixtureB, int32 indexB,
 										b2BlockAllocator* allocator);
 typedef void b2ContactDestroyFcn(b2Contact* contact, b2BlockAllocator* allocator);
 
-struct b2ContactRegister
+struct B2_API b2ContactRegister
 {
 	b2ContactCreateFcn* createFcn;
 	b2ContactDestroyFcn* destroyFcn;
@@ -63,7 +74,7 @@ struct b2ContactRegister
 /// is an edge. A contact edge belongs to a doubly linked list
 /// maintained in each attached body. Each contact has two contact
 /// nodes, one for each attached body.
-struct b2ContactEdge
+struct B2_API b2ContactEdge
 {
 	b2Body* other;			///< provides quick access to the other body attached.
 	b2Contact* contact;		///< the contact
@@ -74,7 +85,7 @@ struct b2ContactEdge
 /// The class manages contact between two shapes. A contact exists for each overlapping
 /// AABB in the broad-phase (except if filtered). Therefore a contact object may exist
 /// that has no contact points.
-class b2Contact
+class B2_API b2Contact
 {
 public:
 
@@ -117,29 +128,39 @@ public:
 
 	/// Override the default friction mixture. You can call this in b2ContactListener::PreSolve.
 	/// This value persists until set or reset.
-	void SetFriction(float32 friction);
+	void SetFriction(float friction);
 
 	/// Get the friction.
-	float32 GetFriction() const;
+	float GetFriction() const;
 
 	/// Reset the friction mixture to the default value.
 	void ResetFriction();
 
 	/// Override the default restitution mixture. You can call this in b2ContactListener::PreSolve.
 	/// The value persists until you set or reset.
-	void SetRestitution(float32 restitution);
+	void SetRestitution(float restitution);
 
 	/// Get the restitution.
-	float32 GetRestitution() const;
+	float GetRestitution() const;
 
 	/// Reset the restitution to the default value.
 	void ResetRestitution();
 
+	/// Override the default restitution velocity threshold mixture. You can call this in b2ContactListener::PreSolve.
+	/// The value persists until you set or reset.
+	void SetRestitutionThreshold(float threshold);
+
+	/// Get the restitution threshold.
+	float GetRestitutionThreshold() const;
+
+	/// Reset the restitution threshold to the default value.
+	void ResetRestitutionThreshold();
+
 	/// Set the desired tangent speed for a conveyor belt behavior. In meters per second.
-	void SetTangentSpeed(float32 speed);
+	void SetTangentSpeed(float speed);
 
 	/// Get the desired tangent speed. In meters per second.
-	float32 GetTangentSpeed() const;
+	float GetTangentSpeed() const;
 
 	/// Evaluate this contact with your own manifold and transforms.
 	virtual void Evaluate(b2Manifold* manifold, const b2Transform& xfA, const b2Transform& xfB) = 0;
@@ -211,12 +232,13 @@ protected:
 	b2Manifold m_manifold;
 
 	int32 m_toiCount;
-	float32 m_toi;
+	float m_toi;
 
-	float32 m_friction;
-	float32 m_restitution;
+	float m_friction;
+	float m_restitution;
+	float m_restitutionThreshold;
 
-	float32 m_tangentSpeed;
+	float m_tangentSpeed;
 };
 
 inline b2Manifold* b2Contact::GetManifold()
@@ -306,12 +328,12 @@ inline void b2Contact::FlagForFiltering()
 	m_flags |= e_filterFlag;
 }
 
-inline void b2Contact::SetFriction(float32 friction)
+inline void b2Contact::SetFriction(float friction)
 {
 	m_friction = friction;
 }
 
-inline float32 b2Contact::GetFriction() const
+inline float b2Contact::GetFriction() const
 {
 	return m_friction;
 }
@@ -321,12 +343,12 @@ inline void b2Contact::ResetFriction()
 	m_friction = b2MixFriction(m_fixtureA->m_friction, m_fixtureB->m_friction);
 }
 
-inline void b2Contact::SetRestitution(float32 restitution)
+inline void b2Contact::SetRestitution(float restitution)
 {
 	m_restitution = restitution;
 }
 
-inline float32 b2Contact::GetRestitution() const
+inline float b2Contact::GetRestitution() const
 {
 	return m_restitution;
 }
@@ -336,12 +358,27 @@ inline void b2Contact::ResetRestitution()
 	m_restitution = b2MixRestitution(m_fixtureA->m_restitution, m_fixtureB->m_restitution);
 }
 
-inline void b2Contact::SetTangentSpeed(float32 speed)
+inline void b2Contact::SetRestitutionThreshold(float threshold)
+{
+	m_restitutionThreshold = threshold;
+}
+
+inline float b2Contact::GetRestitutionThreshold() const
+{
+	return m_restitutionThreshold;
+}
+
+inline void b2Contact::ResetRestitutionThreshold()
+{
+	m_restitutionThreshold = b2MixRestitutionThreshold(m_fixtureA->m_restitutionThreshold, m_fixtureB->m_restitutionThreshold);
+}
+
+inline void b2Contact::SetTangentSpeed(float speed)
 {
 	m_tangentSpeed = speed;
 }
 
-inline float32 b2Contact::GetTangentSpeed() const
+inline float b2Contact::GetTangentSpeed() const
 {
 	return m_tangentSpeed;
 }

Source/ThirdParty/Box2D/include/box2d/b2_contact_manager.h

@@ -0,0 +1,57 @@
+// MIT License
+
+// Copyright (c) 2019 Erin Catto
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#ifndef B2_CONTACT_MANAGER_H
+#define B2_CONTACT_MANAGER_H
+
+#include "b2_api.h"
+#include "b2_broad_phase.h"
+
+class b2Contact;
+class b2ContactFilter;
+class b2ContactListener;
+class b2BlockAllocator;
+
+// Delegate of b2World.
+class B2_API b2ContactManager
+{
+public:
+	b2ContactManager();
+
+	// Broad-phase callback.
+	void AddPair(void* proxyUserDataA, void* proxyUserDataB);
+
+	void FindNewContacts();
+
+	void Destroy(b2Contact* c);
+
+	void Collide();
+
+	b2BroadPhase m_broadPhase;
+	b2Contact* m_contactList;
+	int32 m_contactCount;
+	b2ContactFilter* m_contactFilter;
+	b2ContactListener* m_contactListener;
+	b2BlockAllocator* m_allocator;
+};
+
+#endif

Source/ThirdParty/Box2D/Box2D/Collision/b2Distance.h → Source/ThirdParty/Box2D/include/box2d/b2_distance.h

@@ -1,32 +1,36 @@
+// MIT License
 
-/*
-* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
+// Copyright (c) 2019 Erin Catto
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
 
 #ifndef B2_DISTANCE_H
 #define B2_DISTANCE_H
 
-#include "Box2D/Common/b2Math.h"
+#include "b2_api.h"
+#include "b2_math.h"
 
 class b2Shape;
 
 /// A distance proxy is used by the GJK algorithm.
 /// It encapsulates any shape.
-struct b2DistanceProxy
+struct B2_API b2DistanceProxy
 {
 	b2DistanceProxy() : m_vertices(nullptr), m_count(0), m_radius(0.0f) {}
 
@@ -36,7 +40,7 @@ struct b2DistanceProxy
 
     /// Initialize the proxy using a vertex cloud and radius. The vertices
     /// must remain in scope while the proxy is in use.
-    void Set(const b2Vec2* vertices, int32 count, float32 radius);
+    void Set(const b2Vec2* vertices, int32 count, float radius);
 
 	/// Get the supporting vertex index in the given direction.
 	int32 GetSupport(const b2Vec2& d) const;
@@ -53,14 +57,14 @@ struct b2DistanceProxy
 	b2Vec2 m_buffer[2];
 	const b2Vec2* m_vertices;
 	int32 m_count;
-	float32 m_radius;
+	float m_radius;
 };
 
 /// Used to warm start b2Distance.
 /// Set count to zero on first call.
-struct b2SimplexCache
+struct B2_API b2SimplexCache
 {
-	float32 metric;		///< length or area
+	float metric;		///< length or area
 	uint16 count;
 	uint8 indexA[3];	///< vertices on shape A
 	uint8 indexB[3];	///< vertices on shape B
@@ -68,8 +72,8 @@ struct b2SimplexCache
 
 /// Input for b2Distance.
 /// You have to option to use the shape radii
-/// in the computation. Even 
-struct b2DistanceInput
+/// in the computation. Even
+struct B2_API b2DistanceInput
 {
 	b2DistanceProxy proxyA;
 	b2DistanceProxy proxyB;
@@ -79,23 +83,23 @@ struct b2DistanceInput
 };
 
 /// Output for b2Distance.
-struct b2DistanceOutput
+struct B2_API b2DistanceOutput
 {
 	b2Vec2 pointA;		///< closest point on shapeA
 	b2Vec2 pointB;		///< closest point on shapeB
-	float32 distance;
+	float distance;
 	int32 iterations;	///< number of GJK iterations used
 };
 
 /// Compute the closest points between two shapes. Supports any combination of:
 /// b2CircleShape, b2PolygonShape, b2EdgeShape. The simplex cache is input/output.
 /// On the first call set b2SimplexCache.count to zero.
-void b2Distance(b2DistanceOutput* output,
-				b2SimplexCache* cache, 
+B2_API void b2Distance(b2DistanceOutput* output,
+				b2SimplexCache* cache,
 				const b2DistanceInput* input);
 
 /// Input parameters for b2ShapeCast
-struct b2ShapeCastInput
+struct B2_API b2ShapeCastInput
 {
 	b2DistanceProxy proxyA;
 	b2DistanceProxy proxyB;
@@ -105,16 +109,17 @@ struct b2ShapeCastInput
 };
 
 /// Output results for b2ShapeCast
-struct b2ShapeCastOutput
+struct B2_API b2ShapeCastOutput
 {
 	b2Vec2 point;
 	b2Vec2 normal;
-	float32 lambda;
+	float lambda;
 	int32 iterations;
 };
 
 /// Perform a linear shape cast of shape B moving and shape A fixed. Determines the hit point, normal, and translation fraction.
-bool b2ShapeCast(b2ShapeCastOutput* output, const b2ShapeCastInput* input);
+/// @returns true if hit, false if there is no hit or an initial overlap
+B2_API bool b2ShapeCast(b2ShapeCastOutput* output, const b2ShapeCastInput* input);
 
 //////////////////////////////////////////////////////////////////////////
 
@@ -132,10 +137,10 @@ inline const b2Vec2& b2DistanceProxy::GetVertex(int32 index) const
 inline int32 b2DistanceProxy::GetSupport(const b2Vec2& d) const
 {
 	int32 bestIndex = 0;
-	float32 bestValue = b2Dot(m_vertices[0], d);
+	float bestValue = b2Dot(m_vertices[0], d);
 	for (int32 i = 1; i < m_count; ++i)
 	{
-		float32 value = b2Dot(m_vertices[i], d);
+		float value = b2Dot(m_vertices[i], d);
 		if (value > bestValue)
 		{
 			bestIndex = i;
@@ -149,10 +154,10 @@ inline int32 b2DistanceProxy::GetSupport(const b2Vec2& d) const
 inline const b2Vec2& b2DistanceProxy::GetSupportVertex(const b2Vec2& d) const
 {
 	int32 bestIndex = 0;
-	float32 bestValue = b2Dot(m_vertices[0], d);
+	float bestValue = b2Dot(m_vertices[0], d);
 	for (int32 i = 1; i < m_count; ++i)
 	{
-		float32 value = b2Dot(m_vertices[i], d);
+		float value = b2Dot(m_vertices[i], d);
 		if (value > bestValue)
 		{
 			bestIndex = i;

Source/ThirdParty/Box2D/include/box2d/b2_distance_joint.h

@@ -0,0 +1,176 @@
+// MIT License
+
+// Copyright (c) 2019 Erin Catto
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#ifndef B2_DISTANCE_JOINT_H
+#define B2_DISTANCE_JOINT_H
+
+#include "b2_api.h"
+#include "b2_joint.h"
+
+/// Distance joint definition. This requires defining an anchor point on both
+/// bodies and the non-zero distance of the distance joint. The definition uses
+/// local anchor points so that the initial configuration can violate the
+/// constraint slightly. This helps when saving and loading a game.
+struct B2_API b2DistanceJointDef : public b2JointDef
+{
+	b2DistanceJointDef()
+	{
+		type = e_distanceJoint;
+		localAnchorA.Set(0.0f, 0.0f);
+		localAnchorB.Set(0.0f, 0.0f);
+		length = 1.0f;
+		minLength = 0.0f;
+		maxLength = FLT_MAX;
+		stiffness = 0.0f;
+		damping = 0.0f;
+	}
+
+	/// Initialize the bodies, anchors, and rest length using world space anchors.
+	/// The minimum and maximum lengths are set to the rest length.
+	void Initialize(b2Body* bodyA, b2Body* bodyB,
+					const b2Vec2& anchorA, const b2Vec2& anchorB);
+
+	/// The local anchor point relative to bodyA's origin.
+	b2Vec2 localAnchorA;
+
+	/// The local anchor point relative to bodyB's origin.
+	b2Vec2 localAnchorB;
+
+	/// The rest length of this joint. Clamped to a stable minimum value.
+	float length;
+
+	/// Minimum length. Clamped to a stable minimum value.
+	float minLength;
+
+	/// Maximum length. Must be greater than or equal to the minimum length.
+	float maxLength;
+
+	/// The linear stiffness in N/m.
+	float stiffness;
+
+	/// The linear damping in N*s/m.
+	float damping;
+};
+
+/// A distance joint constrains two points on two bodies to remain at a fixed
+/// distance from each other. You can view this as a massless, rigid rod.
+class B2_API b2DistanceJoint : public b2Joint
+{
+public:
+
+	b2Vec2 GetAnchorA() const override;
+	b2Vec2 GetAnchorB() const override;
+
+	/// Get the reaction force given the inverse time step.
+	/// Unit is N.
+	b2Vec2 GetReactionForce(float inv_dt) const override;
+
+	/// Get the reaction torque given the inverse time step.
+	/// Unit is N*m. This is always zero for a distance joint.
+	float GetReactionTorque(float inv_dt) const override;
+
+	/// The local anchor point relative to bodyA's origin.
+	const b2Vec2& GetLocalAnchorA() const { return m_localAnchorA; }
+
+	/// The local anchor point relative to bodyB's origin.
+	const b2Vec2& GetLocalAnchorB() const  { return m_localAnchorB; }
+
+	/// Get the rest length
+	float GetLength() const { return m_length; }
+
+	/// Set the rest length
+	/// @returns clamped rest length
+	float SetLength(float length);
+
+	/// Get the minimum length
+	float GetMinLength() const { return m_minLength; }
+
+	/// Set the minimum length
+	/// @returns the clamped minimum length
+	float SetMinLength(float minLength);
+
+	/// Get the maximum length
+	float GetMaxLength() const { return m_maxLength; }
+
+	/// Set the maximum length
+	/// @returns the clamped maximum length
+	float SetMaxLength(float maxLength);
+
+	/// Get the current length
+	float GetCurrentLength() const;
+
+	/// Set/get the linear stiffness in N/m
+	void SetStiffness(float stiffness) { m_stiffness = stiffness; }
+	float GetStiffness() const { return m_stiffness; }
+
+	/// Set/get linear damping in N*s/m
+	void SetDamping(float damping) { m_damping = damping; }
+	float GetDamping() const { return m_damping; }
+
+	/// Dump joint to dmLog
+	void Dump() override;
+
+	///
+	void Draw(b2Draw* draw) const override;
+
+protected:
+
+	friend class b2Joint;
+	b2DistanceJoint(const b2DistanceJointDef* data);
+
+	void InitVelocityConstraints(const b2SolverData& data) override;
+	void SolveVelocityConstraints(const b2SolverData& data) override;
+	bool SolvePositionConstraints(const b2SolverData& data) override;
+
+	float m_stiffness;
+	float m_damping;
+	float m_bias;
+	float m_length;
+	float m_minLength;
+	float m_maxLength;
+
+	// Solver shared
+	b2Vec2 m_localAnchorA;
+	b2Vec2 m_localAnchorB;
+	float m_gamma;
+	float m_impulse;
+	float m_lowerImpulse;
+	float m_upperImpulse;
+
+	// Solver temp
+	int32 m_indexA;
+	int32 m_indexB;
+	b2Vec2 m_u;
+	b2Vec2 m_rA;
+	b2Vec2 m_rB;
+	b2Vec2 m_localCenterA;
+	b2Vec2 m_localCenterB;
+	float m_currentLength;
+	float m_invMassA;
+	float m_invMassB;
+	float m_invIA;
+	float m_invIB;
+	float m_softMass;
+	float m_mass;
+};
+
+#endif

Source/ThirdParty/Box2D/include/box2d/b2_draw.h

@@ -0,0 +1,102 @@
+// MIT License
+
+// Copyright (c) 2019 Erin Catto
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#ifndef B2_DRAW_H
+#define B2_DRAW_H
+
+#include "b2_api.h"
+#include "b2_math.h"
+
+/// Color for debug drawing. Each value has the range [0,1].
+struct B2_API b2Color
+{
+	b2Color() {}
+	b2Color(float rIn, float gIn, float bIn, float aIn = 1.0f)
+	{
+		r = rIn; g = gIn; b = bIn; a = aIn;
+	}
+
+	void Set(float rIn, float gIn, float bIn, float aIn = 1.0f)
+	{
+		r = rIn; g = gIn; b = bIn; a = aIn;
+	}
+
+	float r, g, b, a;
+};
+
+/// Implement and register this class with a b2World to provide debug drawing of physics
+/// entities in your game.
+class B2_API b2Draw
+{
+public:
+	b2Draw();
+
+	virtual ~b2Draw() {}
+
+	enum
+	{
+		e_shapeBit				= 0x0001,	///< draw shapes
+		e_jointBit				= 0x0002,	///< draw joint connections
+		e_aabbBit				= 0x0004,	///< draw axis aligned bounding boxes
+		e_pairBit				= 0x0008,	///< draw broad-phase pairs
+		e_centerOfMassBit		= 0x0010	///< draw center of mass frame
+	};
+
+	/// Set the drawing flags.
+	void SetFlags(uint32 flags);
+
+	/// Get the drawing flags.
+	uint32 GetFlags() const;
+
+	/// Append flags to the current flags.
+	void AppendFlags(uint32 flags);
+
+	/// Clear flags from the current flags.
+	void ClearFlags(uint32 flags);
+
+	/// Draw a closed polygon provided in CCW order.
+	virtual void DrawPolygon(const b2Vec2* vertices, int32 vertexCount, const b2Color& color) = 0;
+
+	/// Draw a solid closed polygon provided in CCW order.
+	virtual void DrawSolidPolygon(const b2Vec2* vertices, int32 vertexCount, const b2Color& color) = 0;
+
+	/// Draw a circle.
+	virtual void DrawCircle(const b2Vec2& center, float radius, const b2Color& color) = 0;
+
+	/// Draw a solid circle.
+	virtual void DrawSolidCircle(const b2Vec2& center, float radius, const b2Vec2& axis, const b2Color& color) = 0;
+
+	/// Draw a line segment.
+	virtual void DrawSegment(const b2Vec2& p1, const b2Vec2& p2, const b2Color& color) = 0;
+
+	/// Draw a transform. Choose your own length scale.
+	/// @param xf a transform.
+	virtual void DrawTransform(const b2Transform& xf) = 0;
+
+	/// Draw a point.
+	virtual void DrawPoint(const b2Vec2& p, float size, const b2Color& color) = 0;
+
+protected:
+	uint32 m_drawFlags;
+};
+
+#endif

Source/ThirdParty/Box2D/Box2D/Collision/b2DynamicTree.h → Source/ThirdParty/Box2D/include/box2d/b2_dynamic_tree.h

@@ -1,31 +1,36 @@
-/*
-* Copyright (c) 2009 Erin Catto http://www.box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
+// MIT License
+
+// Copyright (c) 2019 Erin Catto
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
 
 #ifndef B2_DYNAMIC_TREE_H
 #define B2_DYNAMIC_TREE_H
 
-#include "Box2D/Collision/b2Collision.h"
-#include "Box2D/Common/b2GrowableStack.h"
+#include "b2_api.h"
+#include "b2_collision.h"
+#include "b2_growable_stack.h"
 
 #define b2_nullNode (-1)
 
 /// A node in the dynamic tree. The client does not interact with this directly.
-struct b2TreeNode
+struct B2_API b2TreeNode
 {
 	bool IsLeaf() const
 	{
@@ -48,6 +53,8 @@ struct b2TreeNode
 
 	// leaf = 0, free node = -1
 	int32 height;
+
+	bool moved;
 };
 
 /// A dynamic AABB tree broad-phase, inspired by Nathanael Presson's btDbvt.
@@ -58,7 +65,7 @@ struct b2TreeNode
 /// object to move by small amounts without triggering a tree update.
 ///
 /// Nodes are pooled and relocatable, so we use node indices rather than pointers.
-class b2DynamicTree
+class B2_API b2DynamicTree
 {
 public:
 	/// Constructing the tree initializes the node pool.
@@ -83,6 +90,9 @@ public:
 	/// @return the proxy user data or 0 if the id is invalid.
 	void* GetUserData(int32 proxyId) const;
 
+	bool WasMoved(int32 proxyId) const;
+	void ClearMoved(int32 proxyId);
+
 	/// Get the fat AABB for a proxy.
 	const b2AABB& GetFatAABB(int32 proxyId) const;
 
@@ -113,7 +123,7 @@ public:
 	int32 GetMaxBalance() const;
 
 	/// Get the ratio of the sum of the node areas to the root area.
-	float32 GetAreaRatio() const;
+	float GetAreaRatio() const;
 
 	/// Build an optimal tree. Very expensive. For testing.
 	void RebuildBottomUp();
@@ -147,9 +157,6 @@ private:
 
 	int32 m_freeList;
 
-	/// This is used to incrementally traverse the tree for re-balancing.
-	uint32 m_path;
-
 	int32 m_insertionCount;
 };
 
@@ -159,6 +166,18 @@ inline void* b2DynamicTree::GetUserData(int32 proxyId) const
 	return m_nodes[proxyId].userData;
 }
 
+inline bool b2DynamicTree::WasMoved(int32 proxyId) const
+{
+	b2Assert(0 <= proxyId && proxyId < m_nodeCapacity);
+	return m_nodes[proxyId].moved;
+}
+
+inline void b2DynamicTree::ClearMoved(int32 proxyId)
+{
+	b2Assert(0 <= proxyId && proxyId < m_nodeCapacity);
+	m_nodes[proxyId].moved = false;
+}
+
 inline const b2AABB& b2DynamicTree::GetFatAABB(int32 proxyId) const
 {
 	b2Assert(0 <= proxyId && proxyId < m_nodeCapacity);
@@ -216,7 +235,7 @@ inline void b2DynamicTree::RayCast(T* callback, const b2RayCastInput& input) con
 	// Separating axis for segment (Gino, p80).
 	// |dot(v, p1 - c)| > dot(|v|, h)
 
-	float32 maxFraction = input.maxFraction;
+	float maxFraction = input.maxFraction;
 
 	// Build a bounding box for the segment.
 	b2AABB segmentAABB;
@@ -248,7 +267,7 @@ inline void b2DynamicTree::RayCast(T* callback, const b2RayCastInput& input) con
 		// |dot(v, p1 - c)| > dot(|v|, h)
 		b2Vec2 c = node->aabb.GetCenter();
 		b2Vec2 h = node->aabb.GetExtents();
-		float32 separation = b2Abs(b2Dot(v, p1 - c)) - b2Dot(abs_v, h);
+		float separation = b2Abs(b2Dot(v, p1 - c)) - b2Dot(abs_v, h);
 		if (separation > 0.0f)
 		{
 			continue;
@@ -261,7 +280,7 @@ inline void b2DynamicTree::RayCast(T* callback, const b2RayCastInput& input) con
 			subInput.p2 = input.p2;
 			subInput.maxFraction = maxFraction;
 
-			float32 value = callback->RayCastCallback(subInput, nodeId);
+			float value = callback->RayCastCallback(subInput, nodeId);
 
 			if (value == 0.0f)
 			{

Source/ThirdParty/Box2D/include/box2d/b2_edge_shape.h

@@ -0,0 +1,86 @@
+// MIT License
+
+// Copyright (c) 2019 Erin Catto
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#ifndef B2_EDGE_SHAPE_H
+#define B2_EDGE_SHAPE_H
+
+#include "b2_api.h"
+#include "b2_shape.h"
+
+/// A line segment (edge) shape. These can be connected in chains or loops
+/// to other edge shapes. Edges created independently are two-sided and do
+/// no provide smooth movement across junctions.
+class B2_API b2EdgeShape : public b2Shape
+{
+public:
+	b2EdgeShape();
+
+	/// Set this as a part of a sequence. Vertex v0 precedes the edge and vertex v3
+	/// follows. These extra vertices are used to provide smooth movement
+	/// across junctions. This also makes the collision one-sided. The edge
+	/// normal points to the right looking from v1 to v2.
+	void SetOneSided(const b2Vec2& v0, const b2Vec2& v1,const b2Vec2& v2, const b2Vec2& v3);
+
+	/// Set this as an isolated edge. Collision is two-sided.
+	void SetTwoSided(const b2Vec2& v1, const b2Vec2& v2);
+
+	/// Implement b2Shape.
+	b2Shape* Clone(b2BlockAllocator* allocator) const override;
+
+	/// @see b2Shape::GetChildCount
+	int32 GetChildCount() const override;
+
+	/// @see b2Shape::TestPoint
+	bool TestPoint(const b2Transform& transform, const b2Vec2& p) const override;
+
+	/// Implement b2Shape.
+	bool RayCast(b2RayCastOutput* output, const b2RayCastInput& input,
+				const b2Transform& transform, int32 childIndex) const override;
+
+	/// @see b2Shape::ComputeAABB
+	void ComputeAABB(b2AABB* aabb, const b2Transform& transform, int32 childIndex) const override;
+
+	/// @see b2Shape::ComputeMass
+	void ComputeMass(b2MassData* massData, float density) const override;
+
+	/// These are the edge vertices
+	b2Vec2 m_vertex1, m_vertex2;
+
+	/// Optional adjacent vertices. These are used for smooth collision.
+	b2Vec2 m_vertex0, m_vertex3;
+
+	/// Uses m_vertex0 and m_vertex3 to create smooth collision.
+	bool m_oneSided;
+};
+
+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_oneSided = false;
+}
+
+#endif

Source/ThirdParty/Box2D/Box2D/Dynamics/b2Fixture.h → Source/ThirdParty/Box2D/include/box2d/b2_fixture.h

@@ -1,27 +1,32 @@
-/*
-* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
+// MIT License
+
+// Copyright (c) 2019 Erin Catto
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
 
 #ifndef B2_FIXTURE_H
 #define B2_FIXTURE_H
 
-#include "Box2D/Dynamics/b2Body.h"
-#include "Box2D/Collision/b2Collision.h"
-#include "Box2D/Collision/Shapes/b2Shape.h"
+#include "b2_api.h"
+#include "b2_body.h"
+#include "b2_collision.h"
+#include "b2_shape.h"
 
 class b2BlockAllocator;
 class b2Body;
@@ -29,7 +34,7 @@ class b2BroadPhase;
 class b2Fixture;
 
 /// This holds contact filtering data.
-struct b2Filter
+struct B2_API b2Filter
 {
 	b2Filter()
 	{
@@ -53,15 +58,15 @@ struct b2Filter
 
 /// A fixture definition is used to create a fixture. This class defines an
 /// abstract fixture definition. You can reuse fixture definitions safely.
-struct b2FixtureDef
+struct B2_API b2FixtureDef
 {
 	/// The constructor sets the default fixture definition values.
 	b2FixtureDef()
 	{
 		shape = nullptr;
-		userData = nullptr;
 		friction = 0.2f;
 		restitution = 0.0f;
+		restitutionThreshold = 1.0f * b2_lengthUnitsPerMeter;
 		density = 0.0f;
 		isSensor = false;
 	}
@@ -71,16 +76,20 @@ struct b2FixtureDef
 	const b2Shape* shape;
 
 	/// Use this to store application specific fixture data.
-	void* userData;
+	b2FixtureUserData userData;
 
 	/// The friction coefficient, usually in the range [0,1].
-	float32 friction;
+	float friction;
 
 	/// The restitution (elasticity) usually in the range [0,1].
-	float32 restitution;
+	float restitution;
+
+	/// Restitution velocity threshold, usually in m/s. Collisions above this
+	/// speed have restitution applied (will bounce).
+	float restitutionThreshold;
 
 	/// The density, usually in kg/m^2.
-	float32 density;
+	float density;
 
 	/// A sensor shape collects contact information but never generates a collision
 	/// response.
@@ -91,7 +100,7 @@ struct b2FixtureDef
 };
 
 /// This proxy is used internally to connect fixtures to the broad-phase.
-struct b2FixtureProxy
+struct B2_API b2FixtureProxy
 {
 	b2AABB aabb;
 	b2Fixture* fixture;
@@ -104,7 +113,7 @@ struct b2FixtureProxy
 /// such as friction, collision filters, etc.
 /// Fixtures are created via b2Body::CreateFixture.
 /// @warning you cannot reuse fixtures.
-class b2Fixture
+class B2_API b2Fixture
 {
 public:
 	/// Get the type of the child shape. You can use this to down cast to the concrete shape.
@@ -147,10 +156,8 @@ public:
 
 	/// Get the user data that was assigned in the fixture definition. Use this to
 	/// store your application specific data.
-	void* GetUserData() const;
-
-	/// Set the user data. Use this to store your application specific data.
-	void SetUserData(void* data);
+	b2FixtureUserData& GetUserData();
+	const b2FixtureUserData& GetUserData() const;
 
 	/// Test a point for containment in this fixture.
 	/// @param p a point in world coordinates.
@@ -159,6 +166,7 @@ public:
 	/// Cast a ray against this shape.
 	/// @param output the ray-cast results.
 	/// @param input the ray-cast input parameters.
+	/// @param childIndex the child shape index (e.g. edge index)
 	bool RayCast(b2RayCastOutput* output, const b2RayCastInput& input, int32 childIndex) const;
 
 	/// Get the mass data for this fixture. The mass data is based on the density and
@@ -168,24 +176,31 @@ public:
 
 	/// Set the density of this fixture. This will _not_ automatically adjust the mass
 	/// of the body. You must call b2Body::ResetMassData to update the body's mass.
-	void SetDensity(float32 density);
+	void SetDensity(float density);
 
 	/// Get the density of this fixture.
-	float32 GetDensity() const;
+	float GetDensity() const;
 
 	/// Get the coefficient of friction.
-	float32 GetFriction() const;
+	float GetFriction() const;
 
 	/// Set the coefficient of friction. This will _not_ change the friction of
 	/// existing contacts.
-	void SetFriction(float32 friction);
+	void SetFriction(float friction);
 
 	/// Get the coefficient of restitution.
-	float32 GetRestitution() const;
+	float GetRestitution() const;
 
 	/// Set the coefficient of restitution. This will _not_ change the restitution of
 	/// existing contacts.
-	void SetRestitution(float32 restitution);
+	void SetRestitution(float restitution);
+
+	/// Get the restitution velocity threshold.
+	float GetRestitutionThreshold() const;
+
+	/// Set the restitution threshold. This will _not_ change the restitution threshold of
+	/// existing contacts.
+	void SetRestitutionThreshold(float threshold);
 
 	/// Get the fixture's AABB. This AABB may be enlarge and/or stale.
 	/// If you need a more accurate AABB, compute it using the shape and
@@ -215,15 +230,16 @@ protected:
 
 	void Synchronize(b2BroadPhase* broadPhase, const b2Transform& xf1, const b2Transform& xf2);
 
-	float32 m_density;
+	float m_density;
 
 	b2Fixture* m_next;
 	b2Body* m_body;
 
 	b2Shape* m_shape;
 
-	float32 m_friction;
-	float32 m_restitution;
+	float m_friction;
+	float m_restitution;
+	float m_restitutionThreshold;
 
 	b2FixtureProxy* m_proxies;
 	int32 m_proxyCount;
@@ -232,7 +248,7 @@ protected:
 
 	bool m_isSensor;
 
-	void* m_userData;
+	b2FixtureUserData m_userData;
 };
 
 inline b2Shape::Type b2Fixture::GetType() const
@@ -260,14 +276,14 @@ inline const b2Filter& b2Fixture::GetFilterData() const
 	return m_filter;
 }
 
-inline void* b2Fixture::GetUserData() const
+inline b2FixtureUserData& b2Fixture::GetUserData()
 {
 	return m_userData;
 }
 
-inline void b2Fixture::SetUserData(void* data)
+inline const b2FixtureUserData& b2Fixture::GetUserData() const
 {
-	m_userData = data;
+	return m_userData;
 }
 
 inline b2Body* b2Fixture::GetBody()
@@ -290,37 +306,47 @@ inline const b2Fixture* b2Fixture::GetNext() const
 	return m_next;
 }
 
-inline void b2Fixture::SetDensity(float32 density)
+inline void b2Fixture::SetDensity(float density)
 {
 	b2Assert(b2IsValid(density) && density >= 0.0f);
 	m_density = density;
 }
 
-inline float32 b2Fixture::GetDensity() const
+inline float b2Fixture::GetDensity() const
 {
 	return m_density;
 }
 
-inline float32 b2Fixture::GetFriction() const
+inline float b2Fixture::GetFriction() const
 {
 	return m_friction;
 }
 
-inline void b2Fixture::SetFriction(float32 friction)
+inline void b2Fixture::SetFriction(float friction)
 {
 	m_friction = friction;
 }
 
-inline float32 b2Fixture::GetRestitution() const
+inline float b2Fixture::GetRestitution() const
 {
 	return m_restitution;
 }
 
-inline void b2Fixture::SetRestitution(float32 restitution)
+inline void b2Fixture::SetRestitution(float restitution)
 {
 	m_restitution = restitution;
 }
 
+inline float b2Fixture::GetRestitutionThreshold() const
+{
+	return m_restitutionThreshold;
+}
+
+inline void b2Fixture::SetRestitutionThreshold(float threshold)
+{
+	m_restitutionThreshold = threshold;
+}
+
 inline bool b2Fixture::TestPoint(const b2Vec2& p) const
 {
 	return m_shape->TestPoint(m_body->GetTransform(), p);

Source/ThirdParty/Box2D/Box2D/Dynamics/Joints/b2FrictionJoint.h → Source/ThirdParty/Box2D/include/box2d/b2_friction_joint.h

@@ -1,28 +1,33 @@
-/*
-* Copyright (c) 2006-2007 Erin Catto http://www.box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
+// MIT License
+
+// Copyright (c) 2019 Erin Catto
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
 
 #ifndef B2_FRICTION_JOINT_H
 #define B2_FRICTION_JOINT_H
 
-#include "Box2D/Dynamics/Joints/b2Joint.h"
+#include "b2_api.h"
+#include "b2_joint.h"
 
 /// Friction joint definition.
-struct b2FrictionJointDef : public b2JointDef
+struct B2_API b2FrictionJointDef : public b2JointDef
 {
 	b2FrictionJointDef()
 	{
@@ -44,22 +49,22 @@ struct b2FrictionJointDef : public b2JointDef
 	b2Vec2 localAnchorB;
 
 	/// The maximum friction force in N.
-	float32 maxForce;
+	float maxForce;
 
 	/// The maximum friction torque in N-m.
-	float32 maxTorque;
+	float maxTorque;
 };
 
 /// Friction joint. This is used for top-down friction.
 /// It provides 2D translational friction and angular friction.
-class b2FrictionJoint : public b2Joint
+class B2_API b2FrictionJoint : public b2Joint
 {
 public:
 	b2Vec2 GetAnchorA() const override;
 	b2Vec2 GetAnchorB() const override;
 
-	b2Vec2 GetReactionForce(float32 inv_dt) const override;
-	float32 GetReactionTorque(float32 inv_dt) const override;
+	b2Vec2 GetReactionForce(float inv_dt) const override;
+	float GetReactionTorque(float inv_dt) const override;
 
 	/// The local anchor point relative to bodyA's origin.
 	const b2Vec2& GetLocalAnchorA() const { return m_localAnchorA; }
@@ -68,16 +73,16 @@ public:
 	const b2Vec2& GetLocalAnchorB() const  { return m_localAnchorB; }
 
 	/// Set the maximum friction force in N.
-	void SetMaxForce(float32 force);
+	void SetMaxForce(float force);
 
 	/// Get the maximum friction force in N.
-	float32 GetMaxForce() const;
+	float GetMaxForce() const;
 
 	/// Set the maximum friction torque in N*m.
-	void SetMaxTorque(float32 torque);
+	void SetMaxTorque(float torque);
 
 	/// Get the maximum friction torque in N*m.
-	float32 GetMaxTorque() const;
+	float GetMaxTorque() const;
 
 	/// Dump joint to dmLog
 	void Dump() override;
@@ -97,9 +102,9 @@ protected:
 
 	// Solver shared
 	b2Vec2 m_linearImpulse;
-	float32 m_angularImpulse;
-	float32 m_maxForce;
-	float32 m_maxTorque;
+	float m_angularImpulse;
+	float m_maxForce;
+	float m_maxTorque;
 
 	// Solver temp
 	int32 m_indexA;
@@ -108,12 +113,12 @@ protected:
 	b2Vec2 m_rB;
 	b2Vec2 m_localCenterA;
 	b2Vec2 m_localCenterB;
-	float32 m_invMassA;
-	float32 m_invMassB;
-	float32 m_invIA;
-	float32 m_invIB;
+	float m_invMassA;
+	float m_invMassB;
+	float m_invIA;
+	float m_invIB;
 	b2Mat22 m_linearMass;
-	float32 m_angularMass;
+	float m_angularMass;
 };
 
 #endif

Source/ThirdParty/Box2D/Box2D/Dynamics/Joints/b2GearJoint.h → Source/ThirdParty/Box2D/include/box2d/b2_gear_joint.h

@@ -1,29 +1,34 @@
-/*
-* Copyright (c) 2006-2011 Erin Catto http://www.box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
+// MIT License
+
+// Copyright (c) 2019 Erin Catto
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
 
 #ifndef B2_GEAR_JOINT_H
 #define B2_GEAR_JOINT_H
 
-#include "Box2D/Dynamics/Joints/b2Joint.h"
+#include "b2_joint.h"
 
 /// Gear joint definition. This definition requires two existing
 /// revolute or prismatic joints (any combination will work).
-struct b2GearJointDef : public b2JointDef
+/// @warning bodyB on the input joints must both be dynamic
+struct B2_API b2GearJointDef : public b2JointDef
 {
 	b2GearJointDef()
 	{
@@ -41,7 +46,7 @@ struct b2GearJointDef : public b2JointDef
 
 	/// The gear ratio.
 	/// @see b2GearJoint for explanation.
-	float32 ratio;
+	float ratio;
 };
 
 /// A gear joint is used to connect two joints together. Either joint
@@ -53,14 +58,14 @@ struct b2GearJointDef : public b2JointDef
 /// of length or units of 1/length.
 /// @warning You have to manually destroy the gear joint if joint1 or joint2
 /// is destroyed.
-class b2GearJoint : public b2Joint
+class B2_API b2GearJoint : public b2Joint
 {
 public:
 	b2Vec2 GetAnchorA() const override;
 	b2Vec2 GetAnchorB() const override;
 
-	b2Vec2 GetReactionForce(float32 inv_dt) const override;
-	float32 GetReactionTorque(float32 inv_dt) const override;
+	b2Vec2 GetReactionForce(float inv_dt) const override;
+	float GetReactionTorque(float inv_dt) const override;
 
 	/// Get the first joint.
 	b2Joint* GetJoint1() { return m_joint1; }
@@ -69,8 +74,8 @@ public:
 	b2Joint* GetJoint2() { return m_joint2; }
 
 	/// Set/Get the gear ratio.
-	void SetRatio(float32 ratio);
-	float32 GetRatio() const;
+	void SetRatio(float ratio);
+	float GetRatio() const;
 
 	/// Dump joint to dmLog
 	void Dump() override;
@@ -104,22 +109,23 @@ protected:
 	b2Vec2 m_localAxisC;
 	b2Vec2 m_localAxisD;
 
-	float32 m_referenceAngleA;
-	float32 m_referenceAngleB;
+	float m_referenceAngleA;
+	float m_referenceAngleB;
 
-	float32 m_constant;
-	float32 m_ratio;
+	float m_constant;
+	float m_ratio;
+	float m_tolerance;
 
-	float32 m_impulse;
+	float m_impulse;
 
 	// Solver temp
 	int32 m_indexA, m_indexB, m_indexC, m_indexD;
 	b2Vec2 m_lcA, m_lcB, m_lcC, m_lcD;
-	float32 m_mA, m_mB, m_mC, m_mD;
-	float32 m_iA, m_iB, m_iC, m_iD;
+	float m_mA, m_mB, m_mC, m_mD;
+	float m_iA, m_iB, m_iC, m_iD;
 	b2Vec2 m_JvAC, m_JvBD;
-	float32 m_JwA, m_JwB, m_JwC, m_JwD;
-	float32 m_mass;
+	float m_JwA, m_JwB, m_JwC, m_JwD;
+	float m_mass;
 };
 
 #endif

Source/ThirdParty/Box2D/include/box2d/b2_growable_stack.h

@@ -0,0 +1,91 @@
+// MIT License
+
+// Copyright (c) 2019 Erin Catto
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#ifndef B2_GROWABLE_STACK_H
+#define B2_GROWABLE_STACK_H
+
+#include <string.h>
+
+#include "b2_settings.h"
+
+/// This is a growable LIFO stack with an initial capacity of N.
+/// If the stack size exceeds the initial capacity, the heap is used
+/// to increase the size of the stack.
+template <typename T, int32 N>
+class b2GrowableStack
+{
+public:
+	b2GrowableStack()
+	{
+		m_stack = m_array;
+		m_count = 0;
+		m_capacity = N;
+	}
+
+	~b2GrowableStack()
+	{
+		if (m_stack != m_array)
+		{
+			b2Free(m_stack);
+			m_stack = nullptr;
+		}
+	}
+
+	void Push(const T& element)
+	{
+		if (m_count == m_capacity)
+		{
+			T* old = m_stack;
+			m_capacity *= 2;
+			m_stack = (T*)b2Alloc(m_capacity * sizeof(T));
+			memcpy(m_stack, old, m_count * sizeof(T));
+			if (old != m_array)
+			{
+				b2Free(old);
+			}
+		}
+
+		m_stack[m_count] = element;
+		++m_count;
+	}
+
+	T Pop()
+	{
+		b2Assert(m_count > 0);
+		--m_count;
+		return m_stack[m_count];
+	}
+
+	int32 GetCount()
+	{
+		return m_count;
+	}
+
+private:
+	T* m_stack;
+	T m_array[N];
+	int32 m_count;
+	int32 m_capacity;
+};
+
+
+#endif

Source/ThirdParty/Box2D/Box2D/Dynamics/Joints/b2Joint.h → Source/ThirdParty/Box2D/include/box2d/b2_joint.h

@@ -1,27 +1,33 @@
-/*
-* Copyright (c) 2006-2007 Erin Catto http://www.box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
+// MIT License
+
+// Copyright (c) 2019 Erin Catto
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
 
 #ifndef B2_JOINT_H
 #define B2_JOINT_H
 
-#include "Box2D/Common/b2Math.h"
+#include "b2_api.h"
+#include "b2_math.h"
 
 class b2Body;
+class b2Draw;
 class b2Joint;
 struct b2SolverData;
 class b2BlockAllocator;
@@ -38,23 +44,14 @@ enum b2JointType
 	e_wheelJoint,
     e_weldJoint,
 	e_frictionJoint,
-	e_ropeJoint,
 	e_motorJoint
 };
 
-enum b2LimitState
-{
-	e_inactiveLimit,
-	e_atLowerLimit,
-	e_atUpperLimit,
-	e_equalLimits
-};
-
-struct b2Jacobian
+struct B2_API b2Jacobian
 {
 	b2Vec2 linear;
-	float32 angularA;
-	float32 angularB;
+	float angularA;
+	float angularB;
 };
 
 /// A joint edge is used to connect bodies and joints together
@@ -62,7 +59,7 @@ struct b2Jacobian
 /// is an edge. A joint edge belongs to a doubly linked list
 /// maintained in each attached body. Each joint has two joint
 /// nodes, one for each attached body.
-struct b2JointEdge
+struct B2_API b2JointEdge
 {
 	b2Body* other;			///< provides quick access to the other body attached.
 	b2Joint* joint;			///< the joint
@@ -71,12 +68,11 @@ struct b2JointEdge
 };
 
 /// Joint definitions are used to construct joints.
-struct b2JointDef
+struct B2_API b2JointDef
 {
 	b2JointDef()
 	{
 		type = e_unknownJoint;
-		userData = nullptr;
 		bodyA = nullptr;
 		bodyB = nullptr;
 		collideConnected = false;
@@ -86,7 +82,7 @@ struct b2JointDef
 	b2JointType type;
 
 	/// Use this to attach application specific data to your joints.
-	void* userData;
+	b2JointUserData userData;
 
 	/// The first attached body.
 	b2Body* bodyA;
@@ -98,9 +94,19 @@ struct b2JointDef
 	bool collideConnected;
 };
 
+/// Utility to compute linear stiffness values from frequency and damping ratio
+B2_API void b2LinearStiffness(float& stiffness, float& damping,
+	float frequencyHertz, float dampingRatio,
+	const b2Body* bodyA, const b2Body* bodyB);
+
+/// Utility to compute rotational stiffness values frequency and damping ratio
+B2_API void b2AngularStiffness(float& stiffness, float& damping,
+	float frequencyHertz, float dampingRatio,
+	const b2Body* bodyA, const b2Body* bodyB);
+
 /// The base joint class. Joints are used to constraint two bodies together in
 /// various fashions. Some joints also feature limits and motors.
-class b2Joint
+class B2_API b2Joint
 {
 public:
 
@@ -120,23 +126,21 @@ public:
 	virtual b2Vec2 GetAnchorB() const = 0;
 
 	/// Get the reaction force on bodyB at the joint anchor in Newtons.
-	virtual b2Vec2 GetReactionForce(float32 inv_dt) const = 0;
+	virtual b2Vec2 GetReactionForce(float inv_dt) const = 0;
 
 	/// Get the reaction torque on bodyB in N*m.
-	virtual float32 GetReactionTorque(float32 inv_dt) const = 0;
+	virtual float GetReactionTorque(float inv_dt) const = 0;
 
 	/// Get the next joint the world joint list.
 	b2Joint* GetNext();
 	const b2Joint* GetNext() const;
 
 	/// Get the user data pointer.
-	void* GetUserData() const;
+	b2JointUserData& GetUserData();
+	const b2JointUserData& GetUserData() const;
 
-	/// Set the user data pointer.
-	void SetUserData(void* data);
-
-	/// Short-cut function to determine if either body is inactive.
-	bool IsActive() const;
+	/// Short-cut function to determine if either body is enabled.
+	bool IsEnabled() const;
 
 	/// Get collide connected.
 	/// Note: modifying the collide connect flag won't work correctly because
@@ -144,11 +148,14 @@ public:
 	bool GetCollideConnected() const;
 
 	/// Dump this joint to the log file.
-	virtual void Dump() { b2Log("// Dump is not supported for this joint type.\n"); }
+	virtual void Dump() { b2Dump("// Dump is not supported for this joint type.\n"); }
 
 	/// Shift the origin for any points stored in world coordinates.
 	virtual void ShiftOrigin(const b2Vec2& newOrigin) { B2_NOT_USED(newOrigin);  }
 
+	/// Debug draw this joint
+	virtual void Draw(b2Draw* draw) const;
+
 protected:
 	friend class b2World;
 	friend class b2Body;
@@ -180,7 +187,7 @@ protected:
 	bool m_islandFlag;
 	bool m_collideConnected;
 
-	void* m_userData;
+	b2JointUserData m_userData;
 };
 
 inline b2JointType b2Joint::GetType() const
@@ -208,14 +215,14 @@ inline const b2Joint* b2Joint::GetNext() const
 	return m_next;
 }
 
-inline void* b2Joint::GetUserData() const
+inline b2JointUserData& b2Joint::GetUserData()
 {
 	return m_userData;
 }
 
-inline void b2Joint::SetUserData(void* data)
+inline const b2JointUserData& b2Joint::GetUserData() const
 {
-	m_userData = data;
+	return m_userData;
 }
 
 inline bool b2Joint::GetCollideConnected() const

Source/ThirdParty/Box2D/Box2D/Common/b2Math.h → Source/ThirdParty/Box2D/include/box2d/b2_math.h

@@ -1,66 +1,68 @@
-/*
-* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
-
-// Modified by Yao Wei Tjong for Urho3D
+// MIT License
+
+// Copyright (c) 2019 Erin Catto
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
 
 #ifndef B2_MATH_H
 #define B2_MATH_H
 
-#include "Box2D/Common/b2Settings.h"
-// Urho3D - use C++11 std function
-#include <cmath>
+#include <math.h>
+
+#include "b2_api.h"
+#include "b2_settings.h"
 
 /// This function is used to ensure that a floating point number is not a NaN or infinity.
-inline bool b2IsValid(float32 x)
+inline bool b2IsValid(float x)
 {
-    // Urho3D - use C++11 std function
-	return std::isfinite(x);
+	return isfinite(x);
 }
 
 #define	b2Sqrt(x)	sqrtf(x)
 #define	b2Atan2(y, x)	atan2f(y, x)
 
 /// A 2D column vector.
-struct b2Vec2
+struct B2_API b2Vec2
 {
 	/// Default constructor does nothing (for performance).
-	b2Vec2() {}
+	b2Vec2() = default;
 
 	/// Construct using coordinates.
-	b2Vec2(float32 xIn, float32 yIn) : x(xIn), y(yIn) {}
+	b2Vec2(float xIn, float yIn) : x(xIn), y(yIn) {}
 
 	/// Set this vector to all zeros.
 	void SetZero() { x = 0.0f; y = 0.0f; }
 
 	/// Set this vector to some specified coordinates.
-	void Set(float32 x_, float32 y_) { x = x_; y = y_; }
+	void Set(float x_, float y_) { x = x_; y = y_; }
 
 	/// Negate this vector.
 	b2Vec2 operator -() const { b2Vec2 v; v.Set(-x, -y); return v; }
-	
+
 	/// Read from and indexed element.
-	float32 operator () (int32 i) const
+	float operator () (int32 i) const
 	{
 		return (&x)[i];
 	}
 
 	/// Write to an indexed element.
-	float32& operator () (int32 i)
+	float& operator () (int32 i)
 	{
 		return (&x)[i];
 	}
@@ -70,7 +72,7 @@ struct b2Vec2
 	{
 		x += v.x; y += v.y;
 	}
-	
+
 	/// Subtract a vector from this vector.
 	void operator -= (const b2Vec2& v)
 	{
@@ -78,33 +80,33 @@ struct b2Vec2
 	}
 
 	/// Multiply this vector by a scalar.
-	void operator *= (float32 a)
+	void operator *= (float a)
 	{
 		x *= a; y *= a;
 	}
 
 	/// Get the length of this vector (the norm).
-	float32 Length() const
+	float Length() const
 	{
 		return b2Sqrt(x * x + y * y);
 	}
 
 	/// Get the length squared. For performance, use this instead of
 	/// b2Vec2::Length (if possible).
-	float32 LengthSquared() const
+	float LengthSquared() const
 	{
 		return x * x + y * y;
 	}
 
 	/// Convert this vector into a unit vector. Returns the length.
-	float32 Normalize()
+	float Normalize()
 	{
-		float32 length = Length();
+		float length = Length();
 		if (length < b2_epsilon)
 		{
 			return 0.0f;
 		}
-		float32 invLength = 1.0f / length;
+		float invLength = 1.0f / length;
 		x *= invLength;
 		y *= invLength;
 
@@ -123,23 +125,23 @@ struct b2Vec2
 		return b2Vec2(-y, x);
 	}
 
-	float32 x, y;
+	float x, y;
 };
 
 /// A 2D column vector with 3 elements.
-struct b2Vec3
+struct B2_API b2Vec3
 {
 	/// Default constructor does nothing (for performance).
-	b2Vec3() {}
+	b2Vec3() = default;
 
 	/// Construct using coordinates.
-	b2Vec3(float32 xIn, float32 yIn, float32 zIn) : x(xIn), y(yIn), z(zIn) {}
+	b2Vec3(float xIn, float yIn, float zIn) : x(xIn), y(yIn), z(zIn) {}
 
 	/// Set this vector to all zeros.
 	void SetZero() { x = 0.0f; y = 0.0f; z = 0.0f; }
 
 	/// Set this vector to some specified coordinates.
-	void Set(float32 x_, float32 y_, float32 z_) { x = x_; y = y_; z = z_; }
+	void Set(float x_, float y_, float z_) { x = x_; y = y_; z = z_; }
 
 	/// Negate this vector.
 	b2Vec3 operator -() const { b2Vec3 v; v.Set(-x, -y, -z); return v; }
@@ -157,19 +159,19 @@ struct b2Vec3
 	}
 
 	/// Multiply this vector by a scalar.
-	void operator *= (float32 s)
+	void operator *= (float s)
 	{
 		x *= s; y *= s; z *= s;
 	}
 
-	float32 x, y, z;
+	float x, y, z;
 };
 
 /// A 2-by-2 matrix. Stored in column-major order.
-struct b2Mat22
+struct B2_API b2Mat22
 {
 	/// The default constructor does nothing (for performance).
-	b2Mat22() {}
+	b2Mat22() = default;
 
 	/// Construct this matrix using columns.
 	b2Mat22(const b2Vec2& c1, const b2Vec2& c2)
@@ -179,7 +181,7 @@ struct b2Mat22
 	}
 
 	/// Construct this matrix using scalars.
-	b2Mat22(float32 a11, float32 a12, float32 a21, float32 a22)
+	b2Mat22(float a11, float a12, float a21, float a22)
 	{
 		ex.x = a11; ex.y = a21;
 		ey.x = a12; ey.y = a22;
@@ -208,9 +210,9 @@ struct b2Mat22
 
 	b2Mat22 GetInverse() const
 	{
-		float32 a = ex.x, b = ey.x, c = ex.y, d = ey.y;
+		float a = ex.x, b = ey.x, c = ex.y, d = ey.y;
 		b2Mat22 B;
-		float32 det = a * d - b * c;
+		float det = a * d - b * c;
 		if (det != 0.0f)
 		{
 			det = 1.0f / det;
@@ -224,8 +226,8 @@ struct b2Mat22
 	/// than computing the inverse in one-shot cases.
 	b2Vec2 Solve(const b2Vec2& b) const
 	{
-		float32 a11 = ex.x, a12 = ey.x, a21 = ex.y, a22 = ey.y;
-		float32 det = a11 * a22 - a12 * a21;
+		float a11 = ex.x, a12 = ey.x, a21 = ex.y, a22 = ey.y;
+		float det = a11 * a22 - a12 * a21;
 		if (det != 0.0f)
 		{
 			det = 1.0f / det;
@@ -240,10 +242,10 @@ struct b2Mat22
 };
 
 /// A 3-by-3 matrix. Stored in column-major order.
-struct b2Mat33
+struct B2_API b2Mat33
 {
 	/// The default constructor does nothing (for performance).
-	b2Mat33() {}
+	b2Mat33() = default;
 
 	/// Construct this matrix using columns.
 	b2Mat33(const b2Vec3& c1, const b2Vec3& c2, const b2Vec3& c3)
@@ -282,12 +284,12 @@ struct b2Mat33
 };
 
 /// Rotation
-struct b2Rot
+struct B2_API b2Rot
 {
-	b2Rot() {}
+	b2Rot() = default;
 
 	/// Initialize from an angle in radians
-	explicit b2Rot(float32 angle)
+	explicit b2Rot(float angle)
 	{
 		/// TODO_ERIN optimize
 		s = sinf(angle);
@@ -295,7 +297,7 @@ struct b2Rot
 	}
 
 	/// Set using an angle in radians.
-	void Set(float32 angle)
+	void Set(float angle)
 	{
 		/// TODO_ERIN optimize
 		s = sinf(angle);
@@ -310,7 +312,7 @@ struct b2Rot
 	}
 
 	/// Get the angle in radians
-	float32 GetAngle() const
+	float GetAngle() const
 	{
 		return b2Atan2(s, c);
 	}
@@ -328,15 +330,15 @@ struct b2Rot
 	}
 
 	/// Sine and cosine
-	float32 s, c;
+	float s, c;
 };
 
 /// A transform contains translation and rotation. It is used to represent
 /// the position and orientation of rigid frames.
-struct b2Transform
+struct B2_API b2Transform
 {
 	/// The default constructor does nothing.
-	b2Transform() {}
+	b2Transform() = default;
 
 	/// Initialize using a position vector and a rotation.
 	b2Transform(const b2Vec2& position, const b2Rot& rotation) : p(position), q(rotation) {}
@@ -349,7 +351,7 @@ struct b2Transform
 	}
 
 	/// Set this based on the position and angle.
-	void Set(const b2Vec2& position, float32 angle)
+	void Set(const b2Vec2& position, float angle)
 	{
 		p = position;
 		q.Set(angle);
@@ -363,53 +365,56 @@ struct b2Transform
 /// Shapes are defined with respect to the body origin, which may
 /// no coincide with the center of mass. However, to support dynamics
 /// we must interpolate the center of mass position.
-struct b2Sweep
+struct B2_API b2Sweep
 {
+	b2Sweep() = default;
+
 	/// Get the interpolated transform at a specific time.
+	/// @param transform the output transform
 	/// @param beta is a factor in [0,1], where 0 indicates alpha0.
-	void GetTransform(b2Transform* xfb, float32 beta) const;
+	void GetTransform(b2Transform* transform, float beta) const;
 
 	/// Advance the sweep forward, yielding a new initial state.
 	/// @param alpha the new initial time.
-	void Advance(float32 alpha);
+	void Advance(float alpha);
 
 	/// Normalize the angles.
 	void Normalize();
 
 	b2Vec2 localCenter;	///< local center of mass position
 	b2Vec2 c0, c;		///< center world positions
-	float32 a0, a;		///< world angles
+	float a0, a;		///< world angles
 
 	/// Fraction of the current time step in the range [0,1]
 	/// c0 and a0 are the positions at alpha0.
-	float32 alpha0;
+	float alpha0;
 };
 
 /// Useful constant
-extern const b2Vec2 b2Vec2_zero;
+extern B2_API const b2Vec2 b2Vec2_zero;
 
 /// Perform the dot product on two vectors.
-inline float32 b2Dot(const b2Vec2& a, const b2Vec2& b)
+inline float b2Dot(const b2Vec2& a, const b2Vec2& b)
 {
 	return a.x * b.x + a.y * b.y;
 }
 
 /// Perform the cross product on two vectors. In 2D this produces a scalar.
-inline float32 b2Cross(const b2Vec2& a, const b2Vec2& b)
+inline float b2Cross(const b2Vec2& a, const b2Vec2& b)
 {
 	return a.x * b.y - a.y * b.x;
 }
 
 /// Perform the cross product on a vector and a scalar. In 2D this produces
 /// a vector.
-inline b2Vec2 b2Cross(const b2Vec2& a, float32 s)
+inline b2Vec2 b2Cross(const b2Vec2& a, float s)
 {
 	return b2Vec2(s * a.y, -s * a.x);
 }
 
 /// Perform the cross product on a scalar and a vector. In 2D this produces
 /// a vector.
-inline b2Vec2 b2Cross(float32 s, const b2Vec2& a)
+inline b2Vec2 b2Cross(float s, const b2Vec2& a)
 {
 	return b2Vec2(-s * a.y, s * a.x);
 }
@@ -440,7 +445,7 @@ inline b2Vec2 operator - (const b2Vec2& a, const b2Vec2& b)
 	return b2Vec2(a.x - b.x, a.y - b.y);
 }
 
-inline b2Vec2 operator * (float32 s, const b2Vec2& a)
+inline b2Vec2 operator * (float s, const b2Vec2& a)
 {
 	return b2Vec2(s * a.x, s * a.y);
 }
@@ -455,19 +460,19 @@ inline bool operator != (const b2Vec2& a, const b2Vec2& b)
 	return a.x != b.x || a.y != b.y;
 }
 
-inline float32 b2Distance(const b2Vec2& a, const b2Vec2& b)
+inline float b2Distance(const b2Vec2& a, const b2Vec2& b)
 {
 	b2Vec2 c = a - b;
 	return c.Length();
 }
 
-inline float32 b2DistanceSquared(const b2Vec2& a, const b2Vec2& b)
+inline float b2DistanceSquared(const b2Vec2& a, const b2Vec2& b)
 {
 	b2Vec2 c = a - b;
 	return b2Dot(c, c);
 }
 
-inline b2Vec3 operator * (float32 s, const b2Vec3& a)
+inline b2Vec3 operator * (float s, const b2Vec3& a)
 {
 	return b2Vec3(s * a.x, s * a.y, s * a.z);
 }
@@ -485,7 +490,7 @@ inline b2Vec3 operator - (const b2Vec3& a, const b2Vec3& b)
 }
 
 /// Perform the dot product on two vectors.
-inline float32 b2Dot(const b2Vec3& a, const b2Vec3& b)
+inline float b2Dot(const b2Vec3& a, const b2Vec3& b)
 {
 	return a.x * b.x + a.y * b.y + a.z * b.z;
 }
@@ -567,18 +572,18 @@ inline b2Vec2 b2MulT(const b2Rot& q, const b2Vec2& v)
 
 inline b2Vec2 b2Mul(const b2Transform& T, const b2Vec2& v)
 {
-	float32 x = (T.q.c * v.x - T.q.s * v.y) + T.p.x;
-	float32 y = (T.q.s * v.x + T.q.c * v.y) + T.p.y;
+	float x = (T.q.c * v.x - T.q.s * v.y) + T.p.x;
+	float y = (T.q.s * v.x + T.q.c * v.y) + T.p.y;
 
 	return b2Vec2(x, y);
 }
 
 inline b2Vec2 b2MulT(const b2Transform& T, const b2Vec2& v)
 {
-	float32 px = v.x - T.p.x;
-	float32 py = v.y - T.p.y;
-	float32 x = (T.q.c * px + T.q.s * py);
-	float32 y = (-T.q.s * px + T.q.c * py);
+	float px = v.x - T.p.x;
+	float py = v.y - T.p.y;
+	float x = (T.q.c * px + T.q.s * py);
+	float y = (-T.q.s * px + T.q.c * py);
 
 	return b2Vec2(x, y);
 }
@@ -680,20 +685,21 @@ inline bool b2IsPowerOfTwo(uint32 x)
 	return result;
 }
 
-inline void b2Sweep::GetTransform(b2Transform* xf, float32 beta) const
+// https://fgiesen.wordpress.com/2012/08/15/linear-interpolation-past-present-and-future/
+inline void b2Sweep::GetTransform(b2Transform* xf, float beta) const
 {
 	xf->p = (1.0f - beta) * c0 + beta * c;
-	float32 angle = (1.0f - beta) * a0 + beta * a;
+	float angle = (1.0f - beta) * a0 + beta * a;
 	xf->q.Set(angle);
 
 	// Shift to origin
 	xf->p -= b2Mul(xf->q, localCenter);
 }
 
-inline void b2Sweep::Advance(float32 alpha)
+inline void b2Sweep::Advance(float alpha)
 {
 	b2Assert(alpha0 < 1.0f);
-	float32 beta = (alpha - alpha0) / (1.0f - alpha0);
+	float beta = (alpha - alpha0) / (1.0f - alpha0);
 	c0 += beta * (c - c0);
 	a0 += beta * (a - a0);
 	alpha0 = alpha;
@@ -702,8 +708,8 @@ inline void b2Sweep::Advance(float32 alpha)
 /// Normalize an angle in radians to be between -pi and pi
 inline void b2Sweep::Normalize()
 {
-	float32 twoPi = 2.0f * b2_pi;
-	float32 d =  twoPi * floorf(a0 / twoPi);
+	float twoPi = 2.0f * b2_pi;
+	float d =  twoPi * floorf(a0 / twoPi);
 	a0 -= d;
 	a -= d;
 }

Source/ThirdParty/Box2D/Box2D/Dynamics/Joints/b2MotorJoint.h → Source/ThirdParty/Box2D/include/box2d/b2_motor_joint.h

@@ -1,28 +1,33 @@
-/*
-* Copyright (c) 2006-2012 Erin Catto http://www.box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
+// MIT License
+
+// Copyright (c) 2019 Erin Catto
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
 
 #ifndef B2_MOTOR_JOINT_H
 #define B2_MOTOR_JOINT_H
 
-#include "Box2D/Dynamics/Joints/b2Joint.h"
+#include "b2_api.h"
+#include "b2_joint.h"
 
 /// Motor joint definition.
-struct b2MotorJointDef : public b2JointDef
+struct B2_API b2MotorJointDef : public b2JointDef
 {
 	b2MotorJointDef()
 	{
@@ -41,55 +46,55 @@ struct b2MotorJointDef : public b2JointDef
 	b2Vec2 linearOffset;
 
 	/// The bodyB angle minus bodyA angle in radians.
-	float32 angularOffset;
-	
+	float angularOffset;
+
 	/// The maximum motor force in N.
-	float32 maxForce;
+	float maxForce;
 
 	/// The maximum motor torque in N-m.
-	float32 maxTorque;
+	float maxTorque;
 
 	/// Position correction factor in the range [0,1].
-	float32 correctionFactor;
+	float correctionFactor;
 };
 
 /// A motor joint is used to control the relative motion
 /// between two bodies. A typical usage is to control the movement
 /// of a dynamic body with respect to the ground.
-class b2MotorJoint : public b2Joint
+class B2_API b2MotorJoint : public b2Joint
 {
 public:
 	b2Vec2 GetAnchorA() const override;
 	b2Vec2 GetAnchorB() const override;
 
-	b2Vec2 GetReactionForce(float32 inv_dt) const override;
-	float32 GetReactionTorque(float32 inv_dt) const override;
+	b2Vec2 GetReactionForce(float inv_dt) const override;
+	float GetReactionTorque(float inv_dt) const override;
 
 	/// Set/get the target linear offset, in frame A, in meters.
 	void SetLinearOffset(const b2Vec2& linearOffset);
 	const b2Vec2& GetLinearOffset() const;
 
 	/// Set/get the target angular offset, in radians.
-	void SetAngularOffset(float32 angularOffset);
-	float32 GetAngularOffset() const;
+	void SetAngularOffset(float angularOffset);
+	float GetAngularOffset() const;
 
 	/// Set the maximum friction force in N.
-	void SetMaxForce(float32 force);
+	void SetMaxForce(float force);
 
 	/// Get the maximum friction force in N.
-	float32 GetMaxForce() const;
+	float GetMaxForce() const;
 
 	/// Set the maximum friction torque in N*m.
-	void SetMaxTorque(float32 torque);
+	void SetMaxTorque(float torque);
 
 	/// Get the maximum friction torque in N*m.
-	float32 GetMaxTorque() const;
+	float GetMaxTorque() const;
 
 	/// Set the position correction factor in the range [0,1].
-	void SetCorrectionFactor(float32 factor);
+	void SetCorrectionFactor(float factor);
 
 	/// Get the position correction factor in the range [0,1].
-	float32 GetCorrectionFactor() const;
+	float GetCorrectionFactor() const;
 
 	/// Dump to b2Log
 	void Dump() override;
@@ -106,12 +111,12 @@ protected:
 
 	// Solver shared
 	b2Vec2 m_linearOffset;
-	float32 m_angularOffset;
+	float m_angularOffset;
 	b2Vec2 m_linearImpulse;
-	float32 m_angularImpulse;
-	float32 m_maxForce;
-	float32 m_maxTorque;
-	float32 m_correctionFactor;
+	float m_angularImpulse;
+	float m_maxForce;
+	float m_maxTorque;
+	float m_correctionFactor;
 
 	// Solver temp
 	int32 m_indexA;
@@ -121,13 +126,13 @@ protected:
 	b2Vec2 m_localCenterA;
 	b2Vec2 m_localCenterB;
 	b2Vec2 m_linearError;
-	float32 m_angularError;
-	float32 m_invMassA;
-	float32 m_invMassB;
-	float32 m_invIA;
-	float32 m_invIB;
+	float m_angularError;
+	float m_invMassA;
+	float m_invMassB;
+	float m_invIA;
+	float m_invIB;
 	b2Mat22 m_linearMass;
-	float32 m_angularMass;
+	float m_angularMass;
 };
 
 #endif

Source/ThirdParty/Box2D/Box2D/Dynamics/Joints/b2MouseJoint.h → Source/ThirdParty/Box2D/include/box2d/b2_mouse_joint.h

@@ -1,37 +1,42 @@
-/*
-* Copyright (c) 2006-2007 Erin Catto http://www.box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
+// MIT License
+
+// Copyright (c) 2019 Erin Catto
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
 
 #ifndef B2_MOUSE_JOINT_H
 #define B2_MOUSE_JOINT_H
 
-#include "Box2D/Dynamics/Joints/b2Joint.h"
+#include "b2_api.h"
+#include "b2_joint.h"
 
 /// Mouse joint definition. This requires a world target point,
 /// tuning parameters, and the time step.
-struct b2MouseJointDef : public b2JointDef
+struct B2_API b2MouseJointDef : public b2JointDef
 {
 	b2MouseJointDef()
 	{
 		type = e_mouseJoint;
 		target.Set(0.0f, 0.0f);
 		maxForce = 0.0f;
-		frequencyHz = 5.0f;
-		dampingRatio = 0.7f;
+		stiffness = 0.0f;
+		damping = 0.0f;
 	}
 
 	/// The initial world target point. This is assumed
@@ -41,13 +46,13 @@ struct b2MouseJointDef : public b2JointDef
 	/// The maximum constraint force that can be exerted
 	/// to move the candidate body. Usually you will express
 	/// as some multiple of the weight (multiplier * mass * gravity).
-	float32 maxForce;
+	float maxForce;
 
-	/// The response speed.
-	float32 frequencyHz;
+	/// The linear stiffness in N/m
+	float stiffness;
 
-	/// The damping ratio. 0 = no damping, 1 = critical damping.
-	float32 dampingRatio;
+	/// The linear damping in N*s/m
+	float damping;
 };
 
 /// A mouse joint is used to make a point on a body track a
@@ -57,7 +62,7 @@ struct b2MouseJointDef : public b2JointDef
 /// NOTE: this joint is not documented in the manual because it was
 /// developed to be used in the testbed. If you want to learn how to
 /// use the mouse joint, look at the testbed.
-class b2MouseJoint : public b2Joint
+class B2_API b2MouseJoint : public b2Joint
 {
 public:
 
@@ -68,26 +73,26 @@ public:
 	b2Vec2 GetAnchorB() const override;
 
 	/// Implements b2Joint.
-	b2Vec2 GetReactionForce(float32 inv_dt) const override;
+	b2Vec2 GetReactionForce(float inv_dt) const override;
 
 	/// Implements b2Joint.
-	float32 GetReactionTorque(float32 inv_dt) const override;
+	float GetReactionTorque(float inv_dt) const override;
 
 	/// Use this to update the target point.
 	void SetTarget(const b2Vec2& target);
 	const b2Vec2& GetTarget() const;
 
 	/// Set/get the maximum force in Newtons.
-	void SetMaxForce(float32 force);
-	float32 GetMaxForce() const;
+	void SetMaxForce(float force);
+	float GetMaxForce() const;
 
-	/// Set/get the frequency in Hertz.
-	void SetFrequency(float32 hz);
-	float32 GetFrequency() const;
+	/// Set/get the linear stiffness in N/m
+	void SetStiffness(float stiffness) { m_stiffness = stiffness; }
+	float GetStiffness() const { return m_stiffness; }
 
-	/// Set/get the damping ratio (dimensionless).
-	void SetDampingRatio(float32 ratio);
-	float32 GetDampingRatio() const;
+	/// Set/get linear damping in N*s/m
+	void SetDamping(float damping) { m_damping = damping; }
+	float GetDamping() const { return m_damping; }
 
 	/// The mouse joint does not support dumping.
 	void Dump() override { b2Log("Mouse joint dumping is not supported.\n"); }
@@ -106,22 +111,22 @@ protected:
 
 	b2Vec2 m_localAnchorB;
 	b2Vec2 m_targetA;
-	float32 m_frequencyHz;
-	float32 m_dampingRatio;
-	float32 m_beta;
-	
+	float m_stiffness;
+	float m_damping;
+	float m_beta;
+
 	// Solver shared
 	b2Vec2 m_impulse;
-	float32 m_maxForce;
-	float32 m_gamma;
+	float m_maxForce;
+	float m_gamma;
 
 	// Solver temp
 	int32 m_indexA;
 	int32 m_indexB;
 	b2Vec2 m_rB;
 	b2Vec2 m_localCenterB;
-	float32 m_invMassB;
-	float32 m_invIB;
+	float m_invMassB;
+	float m_invIB;
 	b2Mat22 m_mass;
 	b2Vec2 m_C;
 };

Source/ThirdParty/Box2D/Box2D/Collision/Shapes/b2PolygonShape.h → Source/ThirdParty/Box2D/include/box2d/b2_polygon_shape.h

@@ -1,31 +1,35 @@
-/*
-* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
-
+// MIT License
+
+// Copyright (c) 2019 Erin Catto
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
 #ifndef B2_POLYGON_SHAPE_H
 #define B2_POLYGON_SHAPE_H
 
-#include "Box2D/Collision/Shapes/b2Shape.h"
+#include "b2_api.h"
+#include "b2_shape.h"
 
-/// A convex polygon. It is assumed that the interior of the polygon is to
+/// A solid convex polygon. It is assumed that the interior of the polygon is to
 /// the left of each edge.
 /// Polygons have a maximum number of vertices equal to b2_maxPolygonVertices.
 /// In most cases you should not need many vertices for a convex polygon.
-class b2PolygonShape : public b2Shape
+class B2_API b2PolygonShape : public b2Shape
 {
 public:
 	b2PolygonShape();
@@ -46,19 +50,21 @@ public:
 	/// Build vertices to represent an axis-aligned box centered on the local origin.
 	/// @param hx the half-width.
 	/// @param hy the half-height.
-	void SetAsBox(float32 hx, float32 hy);
+	void SetAsBox(float hx, float hy);
 
 	/// Build vertices to represent an oriented box.
 	/// @param hx the half-width.
 	/// @param hy the half-height.
 	/// @param center the center of the box in local coordinates.
 	/// @param angle the rotation of the box in local coordinates.
-	void SetAsBox(float32 hx, float32 hy, const b2Vec2& center, float32 angle);
+	void SetAsBox(float hx, float hy, const b2Vec2& center, float angle);
 
 	/// @see b2Shape::TestPoint
 	bool TestPoint(const b2Transform& transform, const b2Vec2& p) const override;
 
 	/// Implement b2Shape.
+	/// @note because the polygon is solid, rays that start inside do not hit because the normal is
+	/// not defined.
 	bool RayCast(b2RayCastOutput* output, const b2RayCastInput& input,
 					const b2Transform& transform, int32 childIndex) const override;
 
@@ -66,7 +72,7 @@ public:
 	void ComputeAABB(b2AABB* aabb, const b2Transform& transform, int32 childIndex) const override;
 
 	/// @see b2Shape::ComputeMass
-	void ComputeMass(b2MassData* massData, float32 density) const override;
+	void ComputeMass(b2MassData* massData, float density) const override;
 
 	/// Validate convexity. This is a very time consuming operation.
 	/// @returns true if valid

Source/ThirdParty/Box2D/Box2D/Dynamics/Joints/b2PrismaticJoint.h → Source/ThirdParty/Box2D/include/box2d/b2_prismatic_joint.h

@@ -1,25 +1,30 @@
-/*
-* Copyright (c) 2006-2011 Erin Catto http://www.box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
+// MIT License
+
+// Copyright (c) 2019 Erin Catto
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
 
 #ifndef B2_PRISMATIC_JOINT_H
 #define B2_PRISMATIC_JOINT_H
 
-#include "Box2D/Dynamics/Joints/b2Joint.h"
+#include "b2_api.h"
+#include "b2_joint.h"
 
 /// Prismatic joint definition. This requires defining a line of
 /// motion using an axis and an anchor point. The definition uses local
@@ -27,7 +32,7 @@
 /// can violate the constraint slightly. The joint translation is zero
 /// when the local anchor points coincide in world space. Using local
 /// anchors and a local axis helps when saving and loading a game.
-struct b2PrismaticJointDef : public b2JointDef
+struct B2_API b2PrismaticJointDef : public b2JointDef
 {
 	b2PrismaticJointDef()
 	{
@@ -58,39 +63,39 @@ struct b2PrismaticJointDef : public b2JointDef
 	b2Vec2 localAxisA;
 
 	/// The constrained angle between the bodies: bodyB_angle - bodyA_angle.
-	float32 referenceAngle;
+	float referenceAngle;
 
 	/// Enable/disable the joint limit.
 	bool enableLimit;
 
 	/// The lower translation limit, usually in meters.
-	float32 lowerTranslation;
+	float lowerTranslation;
 
 	/// The upper translation limit, usually in meters.
-	float32 upperTranslation;
+	float upperTranslation;
 
 	/// Enable/disable the joint motor.
 	bool enableMotor;
 
 	/// The maximum motor torque, usually in N-m.
-	float32 maxMotorForce;
+	float maxMotorForce;
 
 	/// The desired motor speed in radians per second.
-	float32 motorSpeed;
+	float motorSpeed;
 };
 
 /// A prismatic joint. This joint provides one degree of freedom: translation
 /// along an axis fixed in bodyA. Relative rotation is prevented. You can
 /// use a joint limit to restrict the range of motion and a joint motor to
 /// drive the motion or to model joint friction.
-class b2PrismaticJoint : public b2Joint
+class B2_API b2PrismaticJoint : public b2Joint
 {
 public:
 	b2Vec2 GetAnchorA() const override;
 	b2Vec2 GetAnchorB() const override;
 
-	b2Vec2 GetReactionForce(float32 inv_dt) const override;
-	float32 GetReactionTorque(float32 inv_dt) const override;
+	b2Vec2 GetReactionForce(float inv_dt) const override;
+	float GetReactionTorque(float inv_dt) const override;
 
 	/// The local anchor point relative to bodyA's origin.
 	const b2Vec2& GetLocalAnchorA() const { return m_localAnchorA; }
@@ -102,13 +107,13 @@ public:
 	const b2Vec2& GetLocalAxisA() const { return m_localXAxisA; }
 
 	/// Get the reference angle.
-	float32 GetReferenceAngle() const { return m_referenceAngle; }
+	float GetReferenceAngle() const { return m_referenceAngle; }
 
 	/// Get the current joint translation, usually in meters.
-	float32 GetJointTranslation() const;
+	float GetJointTranslation() const;
 
 	/// Get the current joint translation speed, usually in meters per second.
-	float32 GetJointSpeed() const;
+	float GetJointSpeed() const;
 
 	/// Is the joint limit enabled?
 	bool IsLimitEnabled() const;
@@ -117,13 +122,13 @@ public:
 	void EnableLimit(bool flag);
 
 	/// Get the lower joint limit, usually in meters.
-	float32 GetLowerLimit() const;
+	float GetLowerLimit() const;
 
 	/// Get the upper joint limit, usually in meters.
-	float32 GetUpperLimit() const;
+	float GetUpperLimit() const;
 
 	/// Set the joint limits, usually in meters.
-	void SetLimits(float32 lower, float32 upper);
+	void SetLimits(float lower, float upper);
 
 	/// Is the joint motor enabled?
 	bool IsMotorEnabled() const;
@@ -132,21 +137,24 @@ public:
 	void EnableMotor(bool flag);
 
 	/// Set the motor speed, usually in meters per second.
-	void SetMotorSpeed(float32 speed);
+	void SetMotorSpeed(float speed);
 
 	/// Get the motor speed, usually in meters per second.
-	float32 GetMotorSpeed() const;
+	float GetMotorSpeed() const;
 
 	/// Set the maximum motor force, usually in N.
-	void SetMaxMotorForce(float32 force);
-	float32 GetMaxMotorForce() const { return m_maxMotorForce; }
+	void SetMaxMotorForce(float force);
+	float GetMaxMotorForce() const { return m_maxMotorForce; }
 
 	/// Get the current motor force given the inverse time step, usually in N.
-	float32 GetMotorForce(float32 inv_dt) const;
+	float GetMotorForce(float inv_dt) const;
 
 	/// Dump to b2Log
 	void Dump() override;
 
+	///
+	void Draw(b2Draw* draw) const override;
+
 protected:
 	friend class b2Joint;
 	friend class b2GearJoint;
@@ -156,39 +164,40 @@ protected:
 	void SolveVelocityConstraints(const b2SolverData& data) override;
 	bool SolvePositionConstraints(const b2SolverData& data) override;
 
-	// Solver shared
 	b2Vec2 m_localAnchorA;
 	b2Vec2 m_localAnchorB;
 	b2Vec2 m_localXAxisA;
 	b2Vec2 m_localYAxisA;
-	float32 m_referenceAngle;
-	b2Vec3 m_impulse;
-	float32 m_motorImpulse;
-	float32 m_lowerTranslation;
-	float32 m_upperTranslation;
-	float32 m_maxMotorForce;
-	float32 m_motorSpeed;
+	float m_referenceAngle;
+	b2Vec2 m_impulse;
+	float m_motorImpulse;
+	float m_lowerImpulse;
+	float m_upperImpulse;
+	float m_lowerTranslation;
+	float m_upperTranslation;
+	float m_maxMotorForce;
+	float m_motorSpeed;
 	bool m_enableLimit;
 	bool m_enableMotor;
-	b2LimitState m_limitState;
 
 	// Solver temp
 	int32 m_indexA;
 	int32 m_indexB;
 	b2Vec2 m_localCenterA;
 	b2Vec2 m_localCenterB;
-	float32 m_invMassA;
-	float32 m_invMassB;
-	float32 m_invIA;
-	float32 m_invIB;
+	float m_invMassA;
+	float m_invMassB;
+	float m_invIA;
+	float m_invIB;
 	b2Vec2 m_axis, m_perp;
-	float32 m_s1, m_s2;
-	float32 m_a1, m_a2;
-	b2Mat33 m_K;
-	float32 m_motorMass;
+	float m_s1, m_s2;
+	float m_a1, m_a2;
+	b2Mat22 m_K;
+	float m_translation;
+	float m_axialMass;
 };
 
-inline float32 b2PrismaticJoint::GetMotorSpeed() const
+inline float b2PrismaticJoint::GetMotorSpeed() const
 {
 	return m_motorSpeed;
 }

Source/ThirdParty/Box2D/Box2D/Dynamics/Joints/b2PulleyJoint.h → Source/ThirdParty/Box2D/include/box2d/b2_pulley_joint.h

@@ -1,31 +1,36 @@
-/*
-* Copyright (c) 2006-2011 Erin Catto http://www.box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
+// MIT License
+
+// Copyright (c) 2019 Erin Catto
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
 
 #ifndef B2_PULLEY_JOINT_H
 #define B2_PULLEY_JOINT_H
 
-#include "Box2D/Dynamics/Joints/b2Joint.h"
+#include "b2_api.h"
+#include "b2_joint.h"
 
-const float32 b2_minPulleyLength = 2.0f;
+const float b2_minPulleyLength = 2.0f;
 
 /// Pulley joint definition. This requires two ground anchors,
 /// two dynamic body anchor points, and a pulley ratio.
-struct b2PulleyJointDef : public b2JointDef
+struct B2_API b2PulleyJointDef : public b2JointDef
 {
 	b2PulleyJointDef()
 	{
@@ -44,7 +49,7 @@ struct b2PulleyJointDef : public b2JointDef
 	void Initialize(b2Body* bodyA, b2Body* bodyB,
 					const b2Vec2& groundAnchorA, const b2Vec2& groundAnchorB,
 					const b2Vec2& anchorA, const b2Vec2& anchorB,
-					float32 ratio);
+					float ratio);
 
 	/// The first ground anchor in world coordinates. This point never moves.
 	b2Vec2 groundAnchorA;
@@ -59,13 +64,13 @@ struct b2PulleyJointDef : public b2JointDef
 	b2Vec2 localAnchorB;
 
 	/// The a reference length for the segment attached to bodyA.
-	float32 lengthA;
+	float lengthA;
 
 	/// The a reference length for the segment attached to bodyB.
-	float32 lengthB;
+	float lengthB;
 
 	/// The pulley ratio, used to simulate a block-and-tackle.
-	float32 ratio;
+	float ratio;
 };
 
 /// The pulley joint is connected to two bodies and two fixed ground points.
@@ -76,14 +81,14 @@ struct b2PulleyJointDef : public b2JointDef
 /// work better when combined with prismatic joints. You should also cover the
 /// the anchor points with static shapes to prevent one side from going to
 /// zero length.
-class b2PulleyJoint : public b2Joint
+class B2_API b2PulleyJoint : public b2Joint
 {
 public:
 	b2Vec2 GetAnchorA() const override;
 	b2Vec2 GetAnchorB() const override;
 
-	b2Vec2 GetReactionForce(float32 inv_dt) const override;
-	float32 GetReactionTorque(float32 inv_dt) const override;
+	b2Vec2 GetReactionForce(float inv_dt) const override;
+	float GetReactionTorque(float inv_dt) const override;
 
 	/// Get the first ground anchor.
 	b2Vec2 GetGroundAnchorA() const;
@@ -92,19 +97,19 @@ public:
 	b2Vec2 GetGroundAnchorB() const;
 
 	/// Get the current length of the segment attached to bodyA.
-	float32 GetLengthA() const;
+	float GetLengthA() const;
 
 	/// Get the current length of the segment attached to bodyB.
-	float32 GetLengthB() const;
+	float GetLengthB() const;
 
 	/// Get the pulley ratio.
-	float32 GetRatio() const;
+	float GetRatio() const;
 
 	/// Get the current length of the segment attached to bodyA.
-	float32 GetCurrentLengthA() const;
+	float GetCurrentLengthA() const;
 
 	/// Get the current length of the segment attached to bodyB.
-	float32 GetCurrentLengthB() const;
+	float GetCurrentLengthB() const;
 
 	/// Dump joint to dmLog
 	void Dump() override;
@@ -123,15 +128,15 @@ protected:
 
 	b2Vec2 m_groundAnchorA;
 	b2Vec2 m_groundAnchorB;
-	float32 m_lengthA;
-	float32 m_lengthB;
-	
+	float m_lengthA;
+	float m_lengthB;
+
 	// Solver shared
 	b2Vec2 m_localAnchorA;
 	b2Vec2 m_localAnchorB;
-	float32 m_constant;
-	float32 m_ratio;
-	float32 m_impulse;
+	float m_constant;
+	float m_ratio;
+	float m_impulse;
 
 	// Solver temp
 	int32 m_indexA;
@@ -142,11 +147,11 @@ protected:
 	b2Vec2 m_rB;
 	b2Vec2 m_localCenterA;
 	b2Vec2 m_localCenterB;
-	float32 m_invMassA;
-	float32 m_invMassB;
-	float32 m_invIA;
-	float32 m_invIB;
-	float32 m_mass;
+	float m_invMassA;
+	float m_invMassB;
+	float m_invIA;
+	float m_invIB;
+	float m_mass;
 };
 
 #endif

Source/ThirdParty/Box2D/Box2D/Dynamics/Joints/b2RevoluteJoint.h → Source/ThirdParty/Box2D/include/box2d/b2_revolute_joint.h

@@ -1,38 +1,42 @@
-/*
-* Copyright (c) 2006-2011 Erin Catto http://www.box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
+// MIT License
+
+// Copyright (c) 2019 Erin Catto
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
 
 #ifndef B2_REVOLUTE_JOINT_H
 #define B2_REVOLUTE_JOINT_H
 
-#include "Box2D/Dynamics/Joints/b2Joint.h"
+#include "b2_api.h"
+#include "b2_joint.h"
 
-/// Revolute joint definition. This requires defining an
-/// anchor point where the bodies are joined. The definition
-/// uses local anchor points so that the initial configuration
-/// can violate the constraint slightly. You also need to
-/// specify the initial relative angle for joint limits. This
-/// helps when saving and loading a game.
+/// Revolute joint definition. This requires defining an anchor point where the
+/// bodies are joined. The definition uses local anchor points so that the
+/// initial configuration can violate the constraint slightly. You also need to
+/// specify the initial relative angle for joint limits. This helps when saving
+/// and loading a game.
 /// The local anchor points are measured from the body's origin
 /// rather than the center of mass because:
 /// 1. you might not know where the center of mass will be.
 /// 2. if you add/remove shapes from a body and recompute the mass,
 ///    the joints will be broken.
-struct b2RevoluteJointDef : public b2JointDef
+struct B2_API b2RevoluteJointDef : public b2JointDef
 {
 	b2RevoluteJointDef()
 	{
@@ -59,26 +63,26 @@ struct b2RevoluteJointDef : public b2JointDef
 	b2Vec2 localAnchorB;
 
 	/// The bodyB angle minus bodyA angle in the reference state (radians).
-	float32 referenceAngle;
+	float referenceAngle;
 
 	/// A flag to enable joint limits.
 	bool enableLimit;
 
 	/// The lower angle for the joint limit (radians).
-	float32 lowerAngle;
+	float lowerAngle;
 
 	/// The upper angle for the joint limit (radians).
-	float32 upperAngle;
+	float upperAngle;
 
 	/// A flag to enable the joint motor.
 	bool enableMotor;
 
 	/// The desired motor speed. Usually in radians per second.
-	float32 motorSpeed;
+	float motorSpeed;
 
 	/// The maximum motor torque used to achieve the desired motor speed.
 	/// Usually in N-m.
-	float32 maxMotorTorque;
+	float maxMotorTorque;
 };
 
 /// A revolute joint constrains two bodies to share a common point while they
@@ -87,7 +91,7 @@ struct b2RevoluteJointDef : public b2JointDef
 /// a joint limit that specifies a lower and upper angle. You can use a motor
 /// to drive the relative rotation about the shared point. A maximum motor torque
 /// is provided so that infinite forces are not generated.
-class b2RevoluteJoint : public b2Joint
+class B2_API b2RevoluteJoint : public b2Joint
 {
 public:
 	b2Vec2 GetAnchorA() const override;
@@ -100,13 +104,13 @@ public:
 	const b2Vec2& GetLocalAnchorB() const  { return m_localAnchorB; }
 
 	/// Get the reference angle.
-	float32 GetReferenceAngle() const { return m_referenceAngle; }
+	float GetReferenceAngle() const { return m_referenceAngle; }
 
 	/// Get the current joint angle in radians.
-	float32 GetJointAngle() const;
+	float GetJointAngle() const;
 
 	/// Get the current joint angle speed in radians per second.
-	float32 GetJointSpeed() const;
+	float GetJointSpeed() const;
 
 	/// Is the joint limit enabled?
 	bool IsLimitEnabled() const;
@@ -115,13 +119,13 @@ public:
 	void EnableLimit(bool flag);
 
 	/// Get the lower joint limit in radians.
-	float32 GetLowerLimit() const;
+	float GetLowerLimit() const;
 
 	/// Get the upper joint limit in radians.
-	float32 GetUpperLimit() const;
+	float GetUpperLimit() const;
 
 	/// Set the joint limits in radians.
-	void SetLimits(float32 lower, float32 upper);
+	void SetLimits(float lower, float upper);
 
 	/// Is the joint motor enabled?
 	bool IsMotorEnabled() const;
@@ -130,32 +134,35 @@ public:
 	void EnableMotor(bool flag);
 
 	/// Set the motor speed in radians per second.
-	void SetMotorSpeed(float32 speed);
+	void SetMotorSpeed(float speed);
 
 	/// Get the motor speed in radians per second.
-	float32 GetMotorSpeed() const;
+	float GetMotorSpeed() const;
 
 	/// Set the maximum motor torque, usually in N-m.
-	void SetMaxMotorTorque(float32 torque);
-	float32 GetMaxMotorTorque() const { return m_maxMotorTorque; }
+	void SetMaxMotorTorque(float torque);
+	float GetMaxMotorTorque() const { return m_maxMotorTorque; }
 
 	/// Get the reaction force given the inverse time step.
 	/// Unit is N.
-	b2Vec2 GetReactionForce(float32 inv_dt) const override;
+	b2Vec2 GetReactionForce(float inv_dt) const override;
 
 	/// Get the reaction torque due to the joint limit given the inverse time step.
 	/// Unit is N*m.
-	float32 GetReactionTorque(float32 inv_dt) const override;
+	float GetReactionTorque(float inv_dt) const override;
 
 	/// Get the current motor torque given the inverse time step.
 	/// Unit is N*m.
-	float32 GetMotorTorque(float32 inv_dt) const;
+	float GetMotorTorque(float inv_dt) const;
 
 	/// Dump to b2Log.
 	void Dump() override;
 
+	///
+	void Draw(b2Draw* draw) const override;
+
 protected:
-	
+
 	friend class b2Joint;
 	friend class b2GearJoint;
 
@@ -168,17 +175,17 @@ protected:
 	// Solver shared
 	b2Vec2 m_localAnchorA;
 	b2Vec2 m_localAnchorB;
-	b2Vec3 m_impulse;
-	float32 m_motorImpulse;
-
+	b2Vec2 m_impulse;
+	float m_motorImpulse;
+	float m_lowerImpulse;
+	float m_upperImpulse;
 	bool m_enableMotor;
-	float32 m_maxMotorTorque;
-	float32 m_motorSpeed;
-
+	float m_maxMotorTorque;
+	float m_motorSpeed;
 	bool m_enableLimit;
-	float32 m_referenceAngle;
-	float32 m_lowerAngle;
-	float32 m_upperAngle;
+	float m_referenceAngle;
+	float m_lowerAngle;
+	float m_upperAngle;
 
 	// Solver temp
 	int32 m_indexA;
@@ -187,16 +194,16 @@ protected:
 	b2Vec2 m_rB;
 	b2Vec2 m_localCenterA;
 	b2Vec2 m_localCenterB;
-	float32 m_invMassA;
-	float32 m_invMassB;
-	float32 m_invIA;
-	float32 m_invIB;
-	b2Mat33 m_mass;			// effective mass for point-to-point constraint.
-	float32 m_motorMass;	// effective mass for motor/limit angular constraint.
-	b2LimitState m_limitState;
+	float m_invMassA;
+	float m_invMassB;
+	float m_invIA;
+	float m_invIB;
+	b2Mat22 m_K;
+	float m_angle;
+	float m_axialMass;
 };
 
-inline float32 b2RevoluteJoint::GetMotorSpeed() const
+inline float b2RevoluteJoint::GetMotorSpeed() const
 {
 	return m_motorSpeed;
 }

Source/ThirdParty/Box2D/include/box2d/b2_rope.h

@@ -0,0 +1,155 @@
+// MIT License
+
+// Copyright (c) 2019 Erin Catto
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#ifndef B2_ROPE_H
+#define B2_ROPE_H
+
+#include "b2_api.h"
+#include "b2_math.h"
+
+class b2Draw;
+struct b2RopeStretch;
+struct b2RopeBend;
+
+enum b2StretchingModel
+{
+	b2_pbdStretchingModel,
+	b2_xpbdStretchingModel
+};
+
+enum b2BendingModel
+{
+	b2_springAngleBendingModel = 0,
+	b2_pbdAngleBendingModel,
+	b2_xpbdAngleBendingModel,
+	b2_pbdDistanceBendingModel,
+	b2_pbdHeightBendingModel,
+	b2_pbdTriangleBendingModel
+};
+
+///
+struct B2_API b2RopeTuning
+{
+	b2RopeTuning()
+	{
+		stretchingModel = b2_pbdStretchingModel;
+		bendingModel = b2_pbdAngleBendingModel;
+		damping = 0.0f;
+		stretchStiffness = 1.0f;
+		stretchHertz = 1.0f;
+		stretchDamping = 0.0f;
+		bendStiffness = 0.5f;
+		bendHertz = 1.0f;
+		bendDamping = 0.0f;
+		isometric = false;
+		fixedEffectiveMass = false;
+		warmStart = false;
+	}
+
+	b2StretchingModel stretchingModel;
+	b2BendingModel bendingModel;
+	float damping;
+	float stretchStiffness;
+	float stretchHertz;
+	float stretchDamping;
+	float bendStiffness;
+	float bendHertz;
+	float bendDamping;
+	bool isometric;
+	bool fixedEffectiveMass;
+	bool warmStart;
+};
+
+///
+struct B2_API b2RopeDef
+{
+	b2RopeDef()
+	{
+		position.SetZero();
+		vertices = nullptr;
+		count = 0;
+		masses = nullptr;
+		gravity.SetZero();
+	}
+
+	b2Vec2 position;
+	b2Vec2* vertices;
+	int32 count;
+	float* masses;
+	b2Vec2 gravity;
+	b2RopeTuning tuning;
+};
+
+///
+class B2_API b2Rope
+{
+public:
+	b2Rope();
+	~b2Rope();
+
+	///
+	void Create(const b2RopeDef& def);
+
+	///
+	void SetTuning(const b2RopeTuning& tuning);
+
+	///
+	void Step(float timeStep, int32 iterations, const b2Vec2& position);
+
+	///
+	void Reset(const b2Vec2& position);
+
+	///
+	void Draw(b2Draw* draw) const;
+
+private:
+
+	void SolveStretch_PBD();
+	void SolveStretch_XPBD(float dt);
+	void SolveBend_PBD_Angle();
+	void SolveBend_XPBD_Angle(float dt);
+	void SolveBend_PBD_Distance();
+	void SolveBend_PBD_Height();
+	void SolveBend_PBD_Triangle();
+	void ApplyBendForces(float dt);
+
+	b2Vec2 m_position;
+
+	int32 m_count;
+	int32 m_stretchCount;
+	int32 m_bendCount;
+
+	b2RopeStretch* m_stretchConstraints;
+	b2RopeBend* m_bendConstraints;
+
+	b2Vec2* m_bindPositions;
+	b2Vec2* m_ps;
+	b2Vec2* m_p0s;
+	b2Vec2* m_vs;
+
+	float* m_invMasses;
+	b2Vec2 m_gravity;
+
+	b2RopeTuning m_tuning;
+};
+
+#endif

Source/ThirdParty/Box2D/include/box2d/b2_settings.h

@@ -0,0 +1,127 @@
+// MIT License
+
+// Copyright (c) 2019 Erin Catto
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#ifndef B2_SETTINGS_H
+#define B2_SETTINGS_H
+
+#include "b2_types.h"
+#include "b2_api.h"
+
+/// @file
+/// Settings that can be overriden for your application
+///
+
+/// Define this macro in your build if you want to override settings
+#ifdef B2_USER_SETTINGS
+
+/// This is a user file that includes custom definitions of the macros, structs, and functions
+/// defined below.
+#include "b2_user_settings.h"
+
+#else
+
+#include <stdarg.h>
+#include <stdint.h>
+
+// Tunable Constants
+
+/// You can use this to change the length scale used by your game.
+/// For example for inches you could use 39.4.
+#define b2_lengthUnitsPerMeter 1.0f
+
+/// The maximum number of vertices on a convex polygon. You cannot increase
+/// this too much because b2BlockAllocator has a maximum object size.
+#define b2_maxPolygonVertices	8
+
+// User data
+
+/// You can define this to inject whatever data you want in b2Body
+struct B2_API b2BodyUserData
+{
+	b2BodyUserData()
+	{
+		pointer = 0;
+	}
+
+	/// For legacy compatibility
+	uintptr_t pointer;
+};
+
+/// You can define this to inject whatever data you want in b2Fixture
+struct B2_API b2FixtureUserData
+{
+	b2FixtureUserData()
+	{
+		pointer = 0;
+	}
+
+	/// For legacy compatibility
+	uintptr_t pointer;
+};
+
+/// You can define this to inject whatever data you want in b2Joint
+struct B2_API b2JointUserData
+{
+	b2JointUserData()
+	{
+		pointer = 0;
+	}
+
+	/// For legacy compatibility
+	uintptr_t pointer;
+};
+
+// Memory Allocation
+
+/// Default allocation functions
+B2_API void* b2Alloc_Default(int32 size);
+B2_API void b2Free_Default(void* mem);
+
+/// Implement this function to use your own memory allocator.
+inline void* b2Alloc(int32 size)
+{
+	return b2Alloc_Default(size);
+}
+
+/// If you implement b2Alloc, you should also implement this function.
+inline void b2Free(void* mem)
+{
+	b2Free_Default(mem);
+}
+
+/// Default logging function
+B2_API void b2Log_Default(const char* string, va_list args);
+
+/// Implement this to use your own logging.
+inline void b2Log(const char* string, ...)
+{
+	va_list args;
+	va_start(args, string);
+	b2Log_Default(string, args);
+	va_end(args);
+}
+
+#endif // B2_USER_SETTINGS
+
+#include "b2_common.h"
+
+#endif

Source/ThirdParty/Box2D/Box2D/Collision/Shapes/b2Shape.h → Source/ThirdParty/Box2D/include/box2d/b2_shape.h

@@ -1,48 +1,54 @@
-/*
-* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
+// MIT License
+
+// Copyright (c) 2019 Erin Catto
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
 
 #ifndef B2_SHAPE_H
 #define B2_SHAPE_H
 
-#include "Box2D/Common/b2BlockAllocator.h"
-#include "Box2D/Common/b2Math.h"
-#include "Box2D/Collision/b2Collision.h"
+#include "b2_api.h"
+#include "b2_math.h"
+#include "b2_collision.h"
+
+class b2BlockAllocator;
 
 /// This holds the mass data computed for a shape.
-struct b2MassData
+struct B2_API b2MassData
 {
 	/// The mass of the shape, usually in kilograms.
-	float32 mass;
+	float mass;
 
 	/// The position of the shape's centroid relative to the shape's origin.
 	b2Vec2 center;
 
 	/// The rotational inertia of the shape about the local origin.
-	float32 I;
+	float I;
 };
 
 /// A shape is used for collision detection. You can create a shape however you like.
 /// Shapes used for simulation in b2World are created automatically when a b2Fixture
 /// is created. Shapes may encapsulate a one or more child shapes.
-class b2Shape
+class B2_API b2Shape
 {
 public:
-	
+
 	enum Type
 	{
 		e_circle = 0,
@@ -87,13 +93,13 @@ public:
 	/// The inertia tensor is computed about the local origin.
 	/// @param massData returns the mass data for this shape.
 	/// @param density the density in kilograms per meter squared.
-	virtual void ComputeMass(b2MassData* massData, float32 density) const = 0;
+	virtual void ComputeMass(b2MassData* massData, float density) const = 0;
 
 	Type m_type;
 
 	/// Radius of a shape. For polygonal shapes this must be b2_polygonRadius. There is no support for
 	/// making rounded polygons.
-	float32 m_radius;
+	float m_radius;
 };
 
 inline b2Shape::Type b2Shape::GetType() const

Source/ThirdParty/Box2D/include/box2d/b2_stack_allocator.h

@@ -0,0 +1,65 @@
+// MIT License
+
+// Copyright (c) 2019 Erin Catto
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#ifndef B2_STACK_ALLOCATOR_H
+#define B2_STACK_ALLOCATOR_H
+
+#include "b2_api.h"
+#include "b2_settings.h"
+
+const int32 b2_stackSize = 100 * 1024;	// 100k
+const int32 b2_maxStackEntries = 32;
+
+struct B2_API b2StackEntry
+{
+	char* data;
+	int32 size;
+	bool usedMalloc;
+};
+
+// This is a stack allocator used for fast per step allocations.
+// You must nest allocate/free pairs. The code will assert
+// if you try to interleave multiple allocate/free pairs.
+class B2_API b2StackAllocator
+{
+public:
+	b2StackAllocator();
+	~b2StackAllocator();
+
+	void* Allocate(int32 size);
+	void Free(void* p);
+
+	int32 GetMaxAllocation() const;
+
+private:
+
+	char m_data[b2_stackSize];
+	int32 m_index;
+
+	int32 m_allocation;
+	int32 m_maxAllocation;
+
+	b2StackEntry m_entries[b2_maxStackEntries];
+	int32 m_entryCount;
+};
+
+#endif

Source/ThirdParty/Box2D/include/box2d/b2_time_of_impact.h

@@ -0,0 +1,63 @@
+// MIT License
+
+// Copyright (c) 2019 Erin Catto
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#ifndef B2_TIME_OF_IMPACT_H
+#define B2_TIME_OF_IMPACT_H
+
+#include "b2_api.h"
+#include "b2_math.h"
+#include "b2_distance.h"
+
+/// Input parameters for b2TimeOfImpact
+struct B2_API b2TOIInput
+{
+	b2DistanceProxy proxyA;
+	b2DistanceProxy proxyB;
+	b2Sweep sweepA;
+	b2Sweep sweepB;
+	float tMax;		// defines sweep interval [0, tMax]
+};
+
+/// Output parameters for b2TimeOfImpact.
+struct B2_API b2TOIOutput
+{
+	enum State
+	{
+		e_unknown,
+		e_failed,
+		e_overlapped,
+		e_touching,
+		e_separated
+	};
+
+	State state;
+	float t;
+};
+
+/// Compute the upper bound on time before two shapes penetrate. Time is represented as
+/// a fraction between [0,tMax]. This uses a swept separating axis and may miss some intermediate,
+/// non-tunneling collisions. If you change the time interval, you should call this function
+/// again.
+/// Note: use b2Distance to compute the contact point and normal at the time of impact.
+B2_API void b2TimeOfImpact(b2TOIOutput* output, const b2TOIInput* input);
+
+#endif

Source/ThirdParty/Box2D/include/box2d/b2_time_step.h

@@ -0,0 +1,74 @@
+// MIT License
+
+// Copyright (c) 2019 Erin Catto
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+#ifndef B2_TIME_STEP_H
+#define B2_TIME_STEP_H
+
+#include "b2_api.h"
+#include "b2_math.h"
+
+/// Profiling data. Times are in milliseconds.
+struct B2_API b2Profile
+{
+	float step;
+	float collide;
+	float solve;
+	float solveInit;
+	float solveVelocity;
+	float solvePosition;
+	float broadphase;
+	float solveTOI;
+};
+
+/// This is an internal structure.
+struct B2_API b2TimeStep
+{
+	float dt;			// time step
+	float inv_dt;		// inverse time step (0 if dt == 0).
+	float dtRatio;	// dt * inv_dt0
+	int32 velocityIterations;
+	int32 positionIterations;
+	bool warmStarting;
+};
+
+/// This is an internal structure.
+struct B2_API b2Position
+{
+	b2Vec2 c;
+	float a;
+};
+
+/// This is an internal structure.
+struct B2_API b2Velocity
+{
+	b2Vec2 v;
+	float w;
+};
+
+/// Solver Data
+struct B2_API b2SolverData
+{
+	b2TimeStep step;
+	b2Position* positions;
+	b2Velocity* velocities;
+};
+
+#endif

Source/ThirdParty/Box2D/include/box2d/b2_timer.h

@@ -0,0 +1,55 @@
+// MIT License
+
+// Copyright (c) 2019 Erin Catto
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#ifndef B2_TIMER_H
+#define B2_TIMER_H
+
+#include "b2_api.h"
+#include "b2_settings.h"
+
+/// Timer for profiling. This has platform specific code and may
+/// not work on every platform.
+class B2_API b2Timer
+{
+public:
+
+	/// Constructor
+	b2Timer();
+
+	/// Reset the timer.
+	void Reset();
+
+	/// Get the time since construction or the last reset.
+	float GetMilliseconds() const;
+
+private:
+
+#if defined(_WIN32)
+	double m_start;
+	static double s_invFrequency;
+#elif defined(__linux__) || defined (__APPLE__)
+	unsigned long long m_start_sec;
+	unsigned long long m_start_usec;
+#endif
+};
+
+#endif

Source/ThirdParty/Box2D/include/box2d/b2_types.h

@@ -0,0 +1,33 @@
+// MIT License
+
+// Copyright (c) 2020 Erin Catto
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#ifndef B2_TYPES_H
+#define B2_TYPES_H
+
+typedef signed char	int8;
+typedef signed short int16;
+typedef signed int int32;
+typedef unsigned char uint8;
+typedef unsigned short uint16;
+typedef unsigned int uint32;
+
+#endif

Source/ThirdParty/Box2D/include/box2d/b2_weld_joint.h

@@ -0,0 +1,133 @@
+// MIT License
+
+// Copyright (c) 2019 Erin Catto
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#ifndef B2_WELD_JOINT_H
+#define B2_WELD_JOINT_H
+
+#include "b2_api.h"
+#include "b2_joint.h"
+
+/// Weld joint definition. You need to specify local anchor points
+/// where they are attached and the relative body angle. The position
+/// of the anchor points is important for computing the reaction torque.
+struct B2_API b2WeldJointDef : public b2JointDef
+{
+	b2WeldJointDef()
+	{
+		type = e_weldJoint;
+		localAnchorA.Set(0.0f, 0.0f);
+		localAnchorB.Set(0.0f, 0.0f);
+		referenceAngle = 0.0f;
+		stiffness = 0.0f;
+		damping = 0.0f;
+	}
+
+	/// Initialize the bodies, anchors, reference angle, stiffness, and damping.
+	/// @param bodyA the first body connected by this joint
+	/// @param bodyB the second body connected by this joint
+	/// @param anchor the point of connection in world coordinates
+	void Initialize(b2Body* bodyA, b2Body* bodyB, const b2Vec2& anchor);
+
+	/// The local anchor point relative to bodyA's origin.
+	b2Vec2 localAnchorA;
+
+	/// The local anchor point relative to bodyB's origin.
+	b2Vec2 localAnchorB;
+
+	/// The bodyB angle minus bodyA angle in the reference state (radians).
+	float referenceAngle;
+
+	/// The rotational stiffness in N*m
+	/// Disable softness with a value of 0
+	float stiffness;
+
+	/// The rotational damping in N*m*s
+	float damping;
+};
+
+/// A weld joint essentially glues two bodies together. A weld joint may
+/// distort somewhat because the island constraint solver is approximate.
+class B2_API b2WeldJoint : public b2Joint
+{
+public:
+	b2Vec2 GetAnchorA() const override;
+	b2Vec2 GetAnchorB() const override;
+
+	b2Vec2 GetReactionForce(float inv_dt) const override;
+	float GetReactionTorque(float inv_dt) const override;
+
+	/// The local anchor point relative to bodyA's origin.
+	const b2Vec2& GetLocalAnchorA() const { return m_localAnchorA; }
+
+	/// The local anchor point relative to bodyB's origin.
+	const b2Vec2& GetLocalAnchorB() const  { return m_localAnchorB; }
+
+	/// Get the reference angle.
+	float GetReferenceAngle() const { return m_referenceAngle; }
+
+	/// Set/get stiffness in N*m
+	void SetStiffness(float stiffness) { m_stiffness = stiffness; }
+	float GetStiffness() const { return m_stiffness; }
+
+	/// Set/get damping in N*m*s
+	void SetDamping(float damping) { m_damping = damping; }
+	float GetDamping() const { return m_damping; }
+
+	/// Dump to b2Log
+	void Dump() override;
+
+protected:
+
+	friend class b2Joint;
+
+	b2WeldJoint(const b2WeldJointDef* def);
+
+	void InitVelocityConstraints(const b2SolverData& data) override;
+	void SolveVelocityConstraints(const b2SolverData& data) override;
+	bool SolvePositionConstraints(const b2SolverData& data) override;
+
+	float m_stiffness;
+	float m_damping;
+	float m_bias;
+
+	// Solver shared
+	b2Vec2 m_localAnchorA;
+	b2Vec2 m_localAnchorB;
+	float m_referenceAngle;
+	float m_gamma;
+	b2Vec3 m_impulse;
+
+	// Solver temp
+	int32 m_indexA;
+	int32 m_indexB;
+	b2Vec2 m_rA;
+	b2Vec2 m_rB;
+	b2Vec2 m_localCenterA;
+	b2Vec2 m_localCenterB;
+	float m_invMassA;
+	float m_invMassB;
+	float m_invIA;
+	float m_invIB;
+	b2Mat33 m_mass;
+};
+
+#endif

Source/ThirdParty/Box2D/include/box2d/b2_wheel_joint.h

@@ -0,0 +1,240 @@
+// MIT License
+
+// Copyright (c) 2019 Erin Catto
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#ifndef B2_WHEEL_JOINT_H
+#define B2_WHEEL_JOINT_H
+
+#include "b2_api.h"
+#include "b2_joint.h"
+
+/// Wheel joint definition. This requires defining a line of
+/// motion using an axis and an anchor point. The definition uses local
+/// anchor points and a local axis so that the initial configuration
+/// can violate the constraint slightly. The joint translation is zero
+/// when the local anchor points coincide in world space. Using local
+/// anchors and a local axis helps when saving and loading a game.
+struct B2_API b2WheelJointDef : public b2JointDef
+{
+	b2WheelJointDef()
+	{
+		type = e_wheelJoint;
+		localAnchorA.SetZero();
+		localAnchorB.SetZero();
+		localAxisA.Set(1.0f, 0.0f);
+		enableLimit = false;
+		lowerTranslation = 0.0f;
+		upperTranslation = 0.0f;
+		enableMotor = false;
+		maxMotorTorque = 0.0f;
+		motorSpeed = 0.0f;
+		stiffness = 0.0f;
+		damping = 0.0f;
+	}
+
+	/// Initialize the bodies, anchors, axis, and reference angle using the world
+	/// anchor and world axis.
+	void Initialize(b2Body* bodyA, b2Body* bodyB, const b2Vec2& anchor, const b2Vec2& axis);
+
+	/// The local anchor point relative to bodyA's origin.
+	b2Vec2 localAnchorA;
+
+	/// The local anchor point relative to bodyB's origin.
+	b2Vec2 localAnchorB;
+
+	/// The local translation axis in bodyA.
+	b2Vec2 localAxisA;
+
+	/// Enable/disable the joint limit.
+	bool enableLimit;
+
+	/// The lower translation limit, usually in meters.
+	float lowerTranslation;
+
+	/// The upper translation limit, usually in meters.
+	float upperTranslation;
+
+	/// Enable/disable the joint motor.
+	bool enableMotor;
+
+	/// The maximum motor torque, usually in N-m.
+	float maxMotorTorque;
+
+	/// The desired motor speed in radians per second.
+	float motorSpeed;
+
+	/// Suspension stiffness. Typically in units N/m.
+	float stiffness;
+
+	/// Suspension damping. Typically in units of N*s/m.
+	float damping;
+};
+
+/// A wheel joint. This joint provides two degrees of freedom: translation
+/// along an axis fixed in bodyA and rotation in the plane. In other words, it is a point to
+/// line constraint with a rotational motor and a linear spring/damper. The spring/damper is
+/// initialized upon creation. This joint is designed for vehicle suspensions.
+class B2_API b2WheelJoint : public b2Joint
+{
+public:
+	b2Vec2 GetAnchorA() const override;
+	b2Vec2 GetAnchorB() const override;
+
+	b2Vec2 GetReactionForce(float inv_dt) const override;
+	float GetReactionTorque(float inv_dt) const override;
+
+	/// The local anchor point relative to bodyA's origin.
+	const b2Vec2& GetLocalAnchorA() const { return m_localAnchorA; }
+
+	/// The local anchor point relative to bodyB's origin.
+	const b2Vec2& GetLocalAnchorB() const  { return m_localAnchorB; }
+
+	/// The local joint axis relative to bodyA.
+	const b2Vec2& GetLocalAxisA() const { return m_localXAxisA; }
+
+	/// Get the current joint translation, usually in meters.
+	float GetJointTranslation() const;
+
+	/// Get the current joint linear speed, usually in meters per second.
+	float GetJointLinearSpeed() const;
+
+	/// Get the current joint angle in radians.
+	float GetJointAngle() const;
+
+	/// Get the current joint angular speed in radians per second.
+	float GetJointAngularSpeed() const;
+
+	/// Is the joint limit enabled?
+	bool IsLimitEnabled() const;
+
+	/// Enable/disable the joint translation limit.
+	void EnableLimit(bool flag);
+
+	/// Get the lower joint translation limit, usually in meters.
+	float GetLowerLimit() const;
+
+	/// Get the upper joint translation limit, usually in meters.
+	float GetUpperLimit() const;
+
+	/// Set the joint translation limits, usually in meters.
+	void SetLimits(float lower, float upper);
+
+	/// Is the joint motor enabled?
+	bool IsMotorEnabled() const;
+
+	/// Enable/disable the joint motor.
+	void EnableMotor(bool flag);
+
+	/// Set the motor speed, usually in radians per second.
+	void SetMotorSpeed(float speed);
+
+	/// Get the motor speed, usually in radians per second.
+	float GetMotorSpeed() const;
+
+	/// Set/Get the maximum motor force, usually in N-m.
+	void SetMaxMotorTorque(float torque);
+	float GetMaxMotorTorque() const;
+
+	/// Get the current motor torque given the inverse time step, usually in N-m.
+	float GetMotorTorque(float inv_dt) const;
+
+	/// Access spring stiffness
+	void SetStiffness(float stiffness);
+	float GetStiffness() const;
+
+	/// Access damping
+	void SetDamping(float damping);
+	float GetDamping() const;
+
+	/// Dump to b2Log
+	void Dump() override;
+
+	///
+	void Draw(b2Draw* draw) const override;
+
+protected:
+
+	friend class b2Joint;
+	b2WheelJoint(const b2WheelJointDef* def);
+
+	void InitVelocityConstraints(const b2SolverData& data) override;
+	void SolveVelocityConstraints(const b2SolverData& data) override;
+	bool SolvePositionConstraints(const b2SolverData& data) override;
+
+	b2Vec2 m_localAnchorA;
+	b2Vec2 m_localAnchorB;
+	b2Vec2 m_localXAxisA;
+	b2Vec2 m_localYAxisA;
+
+	float m_impulse;
+	float m_motorImpulse;
+	float m_springImpulse;
+
+	float m_lowerImpulse;
+	float m_upperImpulse;
+	float m_translation;
+	float m_lowerTranslation;
+	float m_upperTranslation;
+
+	float m_maxMotorTorque;
+	float m_motorSpeed;
+
+	bool m_enableLimit;
+	bool m_enableMotor;
+
+	float m_stiffness;
+	float m_damping;
+
+	// Solver temp
+	int32 m_indexA;
+	int32 m_indexB;
+	b2Vec2 m_localCenterA;
+	b2Vec2 m_localCenterB;
+	float m_invMassA;
+	float m_invMassB;
+	float m_invIA;
+	float m_invIB;
+
+	b2Vec2 m_ax, m_ay;
+	float m_sAx, m_sBx;
+	float m_sAy, m_sBy;
+
+	float m_mass;
+	float m_motorMass;
+	float m_axialMass;
+	float m_springMass;
+
+	float m_bias;
+	float m_gamma;
+
+};
+
+inline float b2WheelJoint::GetMotorSpeed() const
+{
+	return m_motorSpeed;
+}
+
+inline float b2WheelJoint::GetMaxMotorTorque() const
+{
+	return m_maxMotorTorque;
+}
+
+#endif

Source/ThirdParty/Box2D/Box2D/Dynamics/b2World.h → Source/ThirdParty/Box2D/include/box2d/b2_world.h

@@ -1,30 +1,35 @@
-/*
-* Copyright (c) 2006-2011 Erin Catto http://www.box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
+// MIT License
+
+// Copyright (c) 2019 Erin Catto
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
 
 #ifndef B2_WORLD_H
 #define B2_WORLD_H
 
-#include "Box2D/Common/b2Math.h"
-#include "Box2D/Common/b2BlockAllocator.h"
-#include "Box2D/Common/b2StackAllocator.h"
-#include "Box2D/Dynamics/b2ContactManager.h"
-#include "Box2D/Dynamics/b2WorldCallbacks.h"
-#include "Box2D/Dynamics/b2TimeStep.h"
+#include "b2_api.h"
+#include "b2_block_allocator.h"
+#include "b2_contact_manager.h"
+#include "b2_math.h"
+#include "b2_stack_allocator.h"
+#include "b2_time_step.h"
+#include "b2_world_callbacks.h"
 
 struct b2AABB;
 struct b2BodyDef;
@@ -38,7 +43,7 @@ class b2Joint;
 /// The world class manages all physics entities, dynamic simulation,
 /// and asynchronous queries. The world also contains efficient memory
 /// management facilities.
-class b2World
+class B2_API b2World
 {
 public:
 	/// Construct a world object.
@@ -54,7 +59,7 @@ public:
 
 	/// Register a contact filter to provide specific control over collision.
 	/// Otherwise the default filter is used (b2_defaultFilter). The listener is
-	/// owned by you and must remain in scope. 
+	/// owned by you and must remain in scope.
 	void SetContactFilter(b2ContactFilter* filter);
 
 	/// Register a contact event listener. The listener is owned by you and must
@@ -62,7 +67,7 @@ public:
 	void SetContactListener(b2ContactListener* listener);
 
 	/// Register a routine for debug drawing. The debug draw functions are called
-	/// inside with b2World::DrawDebugData method. The debug draw object is owned
+	/// inside with b2World::DebugDraw method. The debug draw object is owned
 	/// by you and must remain in scope.
 	void SetDebugDraw(b2Draw* debugDraw);
 
@@ -91,7 +96,7 @@ public:
 	/// @param timeStep the amount of time to simulate, this should not vary.
 	/// @param velocityIterations for the velocity constraint solver.
 	/// @param positionIterations for the position constraint solver.
-	void Step(	float32 timeStep,
+	void Step(	float timeStep,
 				int32 velocityIterations,
 				int32 positionIterations);
 
@@ -105,7 +110,7 @@ public:
 	void ClearForces();
 
 	/// Call this to draw shapes and other debug draw data. This is intentionally non-const.
-	void DrawDebugData();
+	void DebugDraw();
 
 	/// Query the world for all fixtures that potentially overlap the
 	/// provided AABB.
@@ -177,11 +182,11 @@ public:
 
 	/// Get the quality metric of the dynamic tree. The smaller the better.
 	/// The minimum is 1.
-	float32 GetTreeQuality() const;
+	float GetTreeQuality() const;
 
 	/// Change the global gravity vector.
 	void SetGravity(const b2Vec2& gravity);
-	
+
 	/// Get the global gravity vector.
 	b2Vec2 GetGravity() const;
 
@@ -211,14 +216,6 @@ public:
 
 private:
 
-	// m_flags
-	enum
-	{
-		e_newFixture	= 0x0001,
-		e_locked		= 0x0002,
-		e_clearForces	= 0x0004
-	};
-
 	friend class b2Body;
 	friend class b2Fixture;
 	friend class b2ContactManager;
@@ -227,14 +224,11 @@ private:
 	void Solve(const b2TimeStep& step);
 	void SolveTOI(const b2TimeStep& step);
 
-	void DrawJoint(b2Joint* joint);
 	void DrawShape(b2Fixture* shape, const b2Transform& xf, const b2Color& color);
 
 	b2BlockAllocator m_blockAllocator;
 	b2StackAllocator m_stackAllocator;
 
-	int32 m_flags;
-
 	b2ContactManager m_contactManager;
 
 	b2Body* m_bodyList;
@@ -251,7 +245,11 @@ private:
 
 	// This is used to compute the time step ratio to
 	// support a variable time step.
-	float32 m_inv_dt0;
+	float m_inv_dt0;
+
+	bool m_newContacts;
+	bool m_locked;
+	bool m_clearForces;
 
 	// These are for debugging the solver.
 	bool m_warmStarting;
@@ -320,25 +318,18 @@ inline b2Vec2 b2World::GetGravity() const
 
 inline bool b2World::IsLocked() const
 {
-	return (m_flags & e_locked) == e_locked;
+	return m_locked;
 }
 
 inline void b2World::SetAutoClearForces(bool flag)
 {
-	if (flag)
-	{
-		m_flags |= e_clearForces;
-	}
-	else
-	{
-		m_flags &= ~e_clearForces;
-	}
+	m_clearForces = flag;
 }
 
 /// Get the flag that controls automatic clearing of forces after each time step.
 inline bool b2World::GetAutoClearForces() const
 {
-	return (m_flags & e_clearForces) == e_clearForces;
+	return m_clearForces;
 }
 
 inline const b2ContactManager& b2World::GetContactManager() const

Source/ThirdParty/Box2D/Box2D/Dynamics/b2WorldCallbacks.h → Source/ThirdParty/Box2D/include/box2d/b2_world_callbacks.h

@@ -1,25 +1,30 @@
-/*
-* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
+// MIT License
+
+// Copyright (c) 2019 Erin Catto
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
 
 #ifndef B2_WORLD_CALLBACKS_H
 #define B2_WORLD_CALLBACKS_H
 
-#include "Box2D/Common/b2Settings.h"
+#include "b2_api.h"
+#include "b2_settings.h"
 
 struct b2Vec2;
 struct b2Transform;
@@ -33,7 +38,7 @@ struct b2Manifold;
 /// Joints and fixtures are destroyed when their associated
 /// body is destroyed. Implement this listener so that you
 /// may nullify references to these joints and shapes.
-class b2DestructionListener
+class B2_API b2DestructionListener
 {
 public:
 	virtual ~b2DestructionListener() {}
@@ -49,7 +54,7 @@ public:
 
 /// Implement this class to provide collision filtering. In other words, you can implement
 /// this class if you want finer control over contact creation.
-class b2ContactFilter
+class B2_API b2ContactFilter
 {
 public:
 	virtual ~b2ContactFilter() {}
@@ -62,10 +67,10 @@ public:
 /// Contact impulses for reporting. Impulses are used instead of forces because
 /// sub-step forces may approach infinity for rigid body collisions. These
 /// match up one-to-one with the contact points in b2Manifold.
-struct b2ContactImpulse
+struct B2_API b2ContactImpulse
 {
-	float32 normalImpulses[b2_maxManifoldPoints];
-	float32 tangentImpulses[b2_maxManifoldPoints];
+	float normalImpulses[b2_maxManifoldPoints];
+	float tangentImpulses[b2_maxManifoldPoints];
 	int32 count;
 };
 
@@ -78,7 +83,7 @@ struct b2ContactImpulse
 /// You should strive to make your callbacks efficient because there may be
 /// many callbacks per time step.
 /// @warning You cannot create/destroy Box2D entities inside these callbacks.
-class b2ContactListener
+class B2_API b2ContactListener
 {
 public:
 	virtual ~b2ContactListener() {}
@@ -120,7 +125,7 @@ public:
 
 /// Callback class for AABB queries.
 /// See b2World::Query
-class b2QueryCallback
+class B2_API b2QueryCallback
 {
 public:
 	virtual ~b2QueryCallback() {}
@@ -132,7 +137,7 @@ public:
 
 /// Callback class for ray casts.
 /// See b2World::RayCast
-class b2RayCastCallback
+class B2_API b2RayCastCallback
 {
 public:
 	virtual ~b2RayCastCallback() {}
@@ -146,10 +151,11 @@ public:
 	/// @param fixture the fixture hit by the ray
 	/// @param point the point of initial intersection
 	/// @param normal the normal vector at the point of intersection
+	/// @param fraction the fraction along the ray at the point of intersection
 	/// @return -1 to filter, 0 to terminate, fraction to clip the ray for
 	/// closest hit, 1 to continue
-	virtual float32 ReportFixture(	b2Fixture* fixture, const b2Vec2& point,
-									const b2Vec2& normal, float32 fraction) = 0;
+	virtual float ReportFixture(	b2Fixture* fixture, const b2Vec2& point,
+									const b2Vec2& normal, float fraction) = 0;
 };
 
 #endif

Source/ThirdParty/Box2D/include/box2d/box2d.h

@@ -0,0 +1,58 @@
+// MIT License
+
+// Copyright (c) 2019 Erin Catto
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#ifndef BOX2D_H
+#define BOX2D_H
+
+// These include files constitute the main Box2D API
+
+#include "b2_settings.h"
+#include "b2_draw.h"
+#include "b2_timer.h"
+
+#include "b2_chain_shape.h"
+#include "b2_circle_shape.h"
+#include "b2_edge_shape.h"
+#include "b2_polygon_shape.h"
+
+#include "b2_broad_phase.h"
+#include "b2_dynamic_tree.h"
+
+#include "b2_body.h"
+#include "b2_contact.h"
+#include "b2_fixture.h"
+#include "b2_time_step.h"
+#include "b2_world.h"
+#include "b2_world_callbacks.h"
+
+#include "b2_distance_joint.h"
+#include "b2_friction_joint.h"
+#include "b2_gear_joint.h"
+#include "b2_motor_joint.h"
+#include "b2_mouse_joint.h"
+#include "b2_prismatic_joint.h"
+#include "b2_pulley_joint.h"
+#include "b2_revolute_joint.h"
+#include "b2_weld_joint.h"
+#include "b2_wheel_joint.h"
+
+#endif

Source/ThirdParty/Box2D/src/CMakeLists.txt

@@ -0,0 +1,163 @@
+set(BOX2D_SOURCE_FILES
+	collision/b2_broad_phase.cpp
+	collision/b2_chain_shape.cpp
+	collision/b2_circle_shape.cpp
+	collision/b2_collide_circle.cpp
+	collision/b2_collide_edge.cpp
+	collision/b2_collide_polygon.cpp
+	collision/b2_collision.cpp
+	collision/b2_distance.cpp
+	collision/b2_dynamic_tree.cpp
+	collision/b2_edge_shape.cpp
+	collision/b2_polygon_shape.cpp
+	collision/b2_time_of_impact.cpp
+	common/b2_block_allocator.cpp
+	common/b2_draw.cpp
+	common/b2_math.cpp
+	common/b2_settings.cpp
+	common/b2_stack_allocator.cpp
+	common/b2_timer.cpp
+	dynamics/b2_body.cpp
+	dynamics/b2_chain_circle_contact.cpp
+	dynamics/b2_chain_circle_contact.h
+	dynamics/b2_chain_polygon_contact.cpp
+	dynamics/b2_chain_polygon_contact.h
+	dynamics/b2_circle_contact.cpp
+	dynamics/b2_circle_contact.h
+	dynamics/b2_contact.cpp
+	dynamics/b2_contact_manager.cpp
+	dynamics/b2_contact_solver.cpp
+	dynamics/b2_contact_solver.h
+	dynamics/b2_distance_joint.cpp
+	dynamics/b2_edge_circle_contact.cpp
+	dynamics/b2_edge_circle_contact.h
+	dynamics/b2_edge_polygon_contact.cpp
+	dynamics/b2_edge_polygon_contact.h
+	dynamics/b2_fixture.cpp
+	dynamics/b2_friction_joint.cpp
+	dynamics/b2_gear_joint.cpp
+	dynamics/b2_island.cpp
+	dynamics/b2_island.h
+	dynamics/b2_joint.cpp
+	dynamics/b2_motor_joint.cpp
+	dynamics/b2_mouse_joint.cpp
+	dynamics/b2_polygon_circle_contact.cpp
+	dynamics/b2_polygon_circle_contact.h
+	dynamics/b2_polygon_contact.cpp
+	dynamics/b2_polygon_contact.h
+	dynamics/b2_prismatic_joint.cpp
+	dynamics/b2_pulley_joint.cpp
+	dynamics/b2_revolute_joint.cpp
+	dynamics/b2_weld_joint.cpp
+	dynamics/b2_wheel_joint.cpp
+	dynamics/b2_world.cpp
+	dynamics/b2_world_callbacks.cpp
+	rope/b2_rope.cpp)
+
+set(BOX2D_HEADER_FILES
+	../include/box2d/b2_api.h
+	../include/box2d/b2_block_allocator.h
+	../include/box2d/b2_body.h
+	../include/box2d/b2_broad_phase.h
+	../include/box2d/b2_chain_shape.h
+	../include/box2d/b2_circle_shape.h
+	../include/box2d/b2_collision.h
+	../include/box2d/b2_common.h
+	../include/box2d/b2_contact.h
+	../include/box2d/b2_contact_manager.h
+	../include/box2d/b2_distance.h
+	../include/box2d/b2_distance_joint.h
+	../include/box2d/b2_draw.h
+	../include/box2d/b2_dynamic_tree.h
+	../include/box2d/b2_edge_shape.h
+	../include/box2d/b2_fixture.h
+	../include/box2d/b2_friction_joint.h
+	../include/box2d/b2_gear_joint.h
+	../include/box2d/b2_growable_stack.h
+	../include/box2d/b2_joint.h
+	../include/box2d/b2_math.h
+	../include/box2d/b2_motor_joint.h
+	../include/box2d/b2_mouse_joint.h
+	../include/box2d/b2_polygon_shape.h
+	../include/box2d/b2_prismatic_joint.h
+	../include/box2d/b2_pulley_joint.h
+	../include/box2d/b2_revolute_joint.h
+	../include/box2d/b2_rope.h
+	../include/box2d/b2_settings.h
+	../include/box2d/b2_shape.h
+	../include/box2d/b2_stack_allocator.h
+	../include/box2d/b2_time_of_impact.h
+	../include/box2d/b2_timer.h
+	../include/box2d/b2_time_step.h
+	../include/box2d/b2_types.h
+	../include/box2d/b2_weld_joint.h
+	../include/box2d/b2_wheel_joint.h
+	../include/box2d/b2_world.h
+	../include/box2d/b2_world_callbacks.h
+	../include/box2d/box2d.h)
+
+add_library(box2d ${BOX2D_SOURCE_FILES} ${BOX2D_HEADER_FILES})
+target_include_directories(box2d
+  PUBLIC
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/../include>
+    $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
+  PRIVATE
+    ${CMAKE_CURRENT_SOURCE_DIR}
+)
+
+set_target_properties(box2d PROPERTIES
+	CXX_STANDARD 11
+    CXX_STANDARD_REQUIRED YES
+    CXX_EXTENSIONS NO
+    VERSION ${PROJECT_VERSION}
+    SOVERSION ${PROJECT_VERSION_MAJOR}
+)
+
+if(MSVC)
+  set_target_properties(box2d PROPERTIES
+    COMPILE_PDB_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}"
+    COMPILE_PDB_NAME box2d
+  )
+
+  install(
+    FILES "${CMAKE_CURRENT_BINARY_DIR}/$<CONFIG>/box2d.pdb"
+    DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    OPTIONAL
+  )
+endif()
+
+if (BUILD_SHARED_LIBS)
+  target_compile_definitions(box2d
+    PUBLIC
+      B2_SHARED
+  )
+endif()
+
+source_group(TREE "${CMAKE_CURRENT_SOURCE_DIR}" PREFIX "src" FILES ${BOX2D_SOURCE_FILES})
+source_group(TREE "${CMAKE_CURRENT_SOURCE_DIR}/../include" PREFIX "include" FILES ${BOX2D_HEADER_FILES})
+
+install(
+  TARGETS box2d
+  EXPORT box2dConfig
+  LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+  ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+  RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+)
+
+install(
+  EXPORT box2dConfig
+  NAMESPACE box2d::
+  DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/box2d"
+)
+
+include(CMakePackageConfigHelpers)
+
+write_basic_package_version_file(
+  "${CMAKE_CURRENT_BINARY_DIR}/box2dConfigVersion.cmake"
+  COMPATIBILITY SameMajorVersion
+)
+
+install(
+  FILES "${CMAKE_CURRENT_BINARY_DIR}/box2dConfigVersion.cmake"
+  DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/box2d"
+)

Source/ThirdParty/Box2D/Box2D/Collision/b2BroadPhase.cpp → Source/ThirdParty/Box2D/src/collision/b2_broad_phase.cpp

@@ -1,22 +1,27 @@
-/*
-* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
-
-#include "Box2D/Collision/b2BroadPhase.h"
+// MIT License
+
+// Copyright (c) 2019 Erin Catto
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#include "box2d/b2_broad_phase.h"
+#include <string.h>
 
 b2BroadPhase::b2BroadPhase()
 {
@@ -101,11 +106,18 @@ bool b2BroadPhase::QueryCallback(int32 proxyId)
 		return true;
 	}
 
+	const bool moved = m_tree.WasMoved(proxyId);
+	if (moved && proxyId > m_queryProxyId)
+	{
+		// Both proxies are moving. Avoid duplicate pairs.
+		return true;
+	}
+
 	// Grow the pair buffer as needed.
 	if (m_pairCount == m_pairCapacity)
 	{
 		b2Pair* oldBuffer = m_pairBuffer;
-		m_pairCapacity *= 2;
+		m_pairCapacity = m_pairCapacity + (m_pairCapacity >> 1);
 		m_pairBuffer = (b2Pair*)b2Alloc(m_pairCapacity * sizeof(b2Pair));
 		memcpy(m_pairBuffer, oldBuffer, m_pairCount * sizeof(b2Pair));
 		b2Free(oldBuffer);

Source/ThirdParty/Box2D/Box2D/Collision/Shapes/b2ChainShape.cpp → Source/ThirdParty/Box2D/src/collision/b2_chain_shape.cpp

@@ -1,23 +1,30 @@
-/*
-* Copyright (c) 2006-2010 Erin Catto http://www.box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
-
-#include "Box2D/Collision/Shapes/b2ChainShape.h"
-#include "Box2D/Collision/Shapes/b2EdgeShape.h"
+// MIT License
+
+// Copyright (c) 2019 Erin Catto
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#include "box2d/b2_chain_shape.h"
+#include "box2d/b2_edge_shape.h"
+
+#include "box2d/b2_block_allocator.h"
+
 #include <new>
 #include <string.h>
 
@@ -56,11 +63,9 @@ void b2ChainShape::CreateLoop(const b2Vec2* vertices, int32 count)
 	m_vertices[count] = m_vertices[0];
 	m_prevVertex = m_vertices[m_count - 2];
 	m_nextVertex = m_vertices[1];
-	m_hasPrevVertex = true;
-	m_hasNextVertex = true;
 }
 
-void b2ChainShape::CreateChain(const b2Vec2* vertices, int32 count)
+void b2ChainShape::CreateChain(const b2Vec2* vertices, int32 count,	const b2Vec2& prevVertex, const b2Vec2& nextVertex)
 {
 	b2Assert(m_vertices == nullptr && m_count == 0);
 	b2Assert(count >= 2);
@@ -74,34 +79,15 @@ void b2ChainShape::CreateChain(const b2Vec2* vertices, int32 count)
 	m_vertices = (b2Vec2*)b2Alloc(count * sizeof(b2Vec2));
 	memcpy(m_vertices, vertices, m_count * sizeof(b2Vec2));
 
-	m_hasPrevVertex = false;
-	m_hasNextVertex = false;
-
-	m_prevVertex.SetZero();
-	m_nextVertex.SetZero();
-}
-
-void b2ChainShape::SetPrevVertex(const b2Vec2& prevVertex)
-{
 	m_prevVertex = prevVertex;
-	m_hasPrevVertex = true;
-}
-
-void b2ChainShape::SetNextVertex(const b2Vec2& nextVertex)
-{
 	m_nextVertex = nextVertex;
-	m_hasNextVertex = true;
 }
 
 b2Shape* b2ChainShape::Clone(b2BlockAllocator* allocator) const
 {
 	void* mem = allocator->Allocate(sizeof(b2ChainShape));
 	b2ChainShape* clone = new (mem) b2ChainShape;
-	clone->CreateChain(m_vertices, m_count);
-	clone->m_prevVertex = m_prevVertex;
-	clone->m_nextVertex = m_nextVertex;
-	clone->m_hasPrevVertex = m_hasPrevVertex;
-	clone->m_hasNextVertex = m_hasNextVertex;
+	clone->CreateChain(m_vertices, m_count, m_prevVertex, m_nextVertex);
 	return clone;
 }
 
@@ -119,27 +105,24 @@ void b2ChainShape::GetChildEdge(b2EdgeShape* edge, int32 index) const
 
 	edge->m_vertex1 = m_vertices[index + 0];
 	edge->m_vertex2 = m_vertices[index + 1];
+	edge->m_oneSided = true;
 
 	if (index > 0)
 	{
 		edge->m_vertex0 = m_vertices[index - 1];
-		edge->m_hasVertex0 = true;
 	}
 	else
 	{
 		edge->m_vertex0 = m_prevVertex;
-		edge->m_hasVertex0 = m_hasPrevVertex;
 	}
 
 	if (index < m_count - 2)
 	{
 		edge->m_vertex3 = m_vertices[index + 2];
-		edge->m_hasVertex3 = true;
 	}
 	else
 	{
 		edge->m_vertex3 = m_nextVertex;
-		edge->m_hasVertex3 = m_hasNextVertex;
 	}
 }
 
@@ -184,11 +167,15 @@ void b2ChainShape::ComputeAABB(b2AABB* aabb, const b2Transform& xf, int32 childI
 	b2Vec2 v1 = b2Mul(xf, m_vertices[i1]);
 	b2Vec2 v2 = b2Mul(xf, m_vertices[i2]);
 
-	aabb->lowerBound = b2Min(v1, v2);
-	aabb->upperBound = b2Max(v1, v2);
+	b2Vec2 lower = b2Min(v1, v2);
+	b2Vec2 upper = b2Max(v1, v2);
+
+	b2Vec2 r(m_radius, m_radius);
+	aabb->lowerBound = lower - r;
+	aabb->upperBound = upper + r;
 }
 
-void b2ChainShape::ComputeMass(b2MassData* massData, float32 density) const
+void b2ChainShape::ComputeMass(b2MassData* massData, float density) const
 {
 	B2_NOT_USED(density);
 

Source/ThirdParty/Box2D/Box2D/Collision/Shapes/b2CircleShape.cpp → Source/ThirdParty/Box2D/src/collision/b2_circle_shape.cpp

@@ -1,22 +1,28 @@
-/*
-* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
-
-#include "Box2D/Collision/Shapes/b2CircleShape.h"
+// MIT License
+
+// Copyright (c) 2019 Erin Catto
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#include "box2d/b2_circle_shape.h"
+#include "box2d/b2_block_allocator.h"
+
 #include <new>
 
 b2Shape* b2CircleShape::Clone(b2BlockAllocator* allocator) const
@@ -50,13 +56,13 @@ bool b2CircleShape::RayCast(b2RayCastOutput* output, const b2RayCastInput& input
 
 	b2Vec2 position = transform.p + b2Mul(transform.q, m_p);
 	b2Vec2 s = input.p1 - position;
-	float32 b = b2Dot(s, s) - m_radius * m_radius;
+	float b = b2Dot(s, s) - m_radius * m_radius;
 
 	// Solve quadratic equation.
 	b2Vec2 r = input.p2 - input.p1;
-	float32 c =  b2Dot(s, r);
-	float32 rr = b2Dot(r, r);
-	float32 sigma = c * c - rr * b;
+	float c =  b2Dot(s, r);
+	float rr = b2Dot(r, r);
+	float sigma = c * c - rr * b;
 
 	// Check for negative discriminant and short segment.
 	if (sigma < 0.0f || rr < b2_epsilon)
@@ -65,7 +71,7 @@ bool b2CircleShape::RayCast(b2RayCastOutput* output, const b2RayCastInput& input
 	}
 
 	// Find the point of intersection of the line with the circle.
-	float32 a = -(c + b2Sqrt(sigma));
+	float a = -(c + b2Sqrt(sigma));
 
 	// Is the intersection point on the segment?
 	if (0.0f <= a && a <= input.maxFraction * rr)
@@ -89,7 +95,7 @@ void b2CircleShape::ComputeAABB(b2AABB* aabb, const b2Transform& transform, int3
 	aabb->upperBound.Set(p.x + m_radius, p.y + m_radius);
 }
 
-void b2CircleShape::ComputeMass(b2MassData* massData, float32 density) const
+void b2CircleShape::ComputeMass(b2MassData* massData, float density) const
 {
 	massData->mass = density * b2_pi * m_radius * m_radius;
 	massData->center = m_p;

Source/ThirdParty/Box2D/Box2D/Collision/b2CollideCircle.cpp → Source/ThirdParty/Box2D/src/collision/b2_collide_circle.cpp

@@ -1,24 +1,28 @@
-/*
-* Copyright (c) 2007-2009 Erin Catto http://www.box2d.org
-*
-* 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 as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*/
-
-#include "Box2D/Collision/b2Collision.h"
-#include "Box2D/Collision/Shapes/b2CircleShape.h"
-#include "Box2D/Collision/Shapes/b2PolygonShape.h"
+// MIT License
+
+// Copyright (c) 2019 Erin Catto
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#include "box2d/b2_collision.h"
+#include "box2d/b2_circle_shape.h"
+#include "box2d/b2_polygon_shape.h"
 
 void b2CollideCircles(
 	b2Manifold* manifold,
@@ -31,9 +35,9 @@ void b2CollideCircles(
 	b2Vec2 pB = b2Mul(xfB, circleB->m_p);
 
 	b2Vec2 d = pB - pA;
-	float32 distSqr = b2Dot(d, d);
-	float32 rA = circleA->m_radius, rB = circleB->m_radius;
-	float32 radius = rA + rB;
+	float distSqr = b2Dot(d, d);
+	float rA = circleA->m_radius, rB = circleB->m_radius;
+	float radius = rA + rB;
 	if (distSqr > radius * radius)
 	{
 		return;
@@ -61,15 +65,15 @@ void b2CollidePolygonAndCircle(
 
 	// Find the min separating edge.
 	int32 normalIndex = 0;
-	float32 separation = -b2_maxFloat;
-	float32 radius = polygonA->m_radius + circleB->m_radius;
+	float separation = -b2_maxFloat;
+	float radius = polygonA->m_radius + circleB->m_radius;
 	int32 vertexCount = polygonA->m_count;
 	const b2Vec2* vertices = polygonA->m_vertices;
 	const b2Vec2* normals = polygonA->m_normals;
 
 	for (int32 i = 0; i < vertexCount; ++i)
 	{
-		float32 s = b2Dot(normals[i], cLocal - vertices[i]);
+		float s = b2Dot(normals[i], cLocal - vertices[i]);
 
 		if (s > radius)
 		{
@@ -103,8 +107,8 @@ void b2CollidePolygonAndCircle(
 	}
 
 	// Compute barycentric coordinates
-	float32 u1 = b2Dot(cLocal - v1, v2 - v1);
-	float32 u2 = b2Dot(cLocal - v2, v1 - v2);
+	float u1 = b2Dot(cLocal - v1, v2 - v1);
+	float u2 = b2Dot(cLocal - v2, v1 - v2);
 	if (u1 <= 0.0f)
 	{
 		if (b2DistanceSquared(cLocal, v1) > radius * radius)
@@ -138,7 +142,7 @@ void b2CollidePolygonAndCircle(
 	else
 	{
 		b2Vec2 faceCenter = 0.5f * (v1 + v2);
-		float32 s = b2Dot(cLocal - faceCenter, normals[vertIndex1]);
+		float s = b2Dot(cLocal - faceCenter, normals[vertIndex1]);
 		if (s > radius)
 		{
 			return;